using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using ValheimFarmerNPC.AI;
using ValheimFarmerNPC.Commands;
using ValheimFarmerNPC.Config;
using ValheimFarmerNPC.Farmer;
using ValheimFarmerNPC.Farming;
using ValheimFarmerNPC.HarmonyPatches;
using ValheimFarmerNPC.Homestead;
using ValheimFarmerNPC.Inventory;
using ValheimFarmerNPC.NPC;
using ValheimFarmerNPC.Networking;
using ValheimFarmerNPC.Persistence;
using ValheimFarmerNPC.Pieces;
using ValheimFarmerNPC.Registration;
using ValheimFarmerNPC.Resolvers;
using ValheimFarmerNPC.UI;
using ValheimFarmerNPC.Utilities;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimFarmerNPC")]
[assembly: AssemblyDescription("Autonomous multiplayer-safe farming NPC for Valheim")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimFarmerNPC")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b7e4c2a1-9f3d-4e8a-a1c5-6d2f0b8e4a71")]
[assembly: AssemblyFileVersion("1.0.13")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.13.0")]
namespace ValheimFarmerNPC
{
	internal static class Constants
	{
		public const int SchemaVersion = 1;

		public const string HomesteadPrefab = "FarmerHomestead";

		public const string BoundaryPostPrefab = "FarmBoundaryPost";

		public const string NpcPrefab = "FarmerNpc";

		public const string HomesteadCloneSource = "piece_workbench";

		public const string BoundaryPostCloneSource = "wood_pole";

		public const string NpcCloneSource = "Goblin";

		public const string ZdoSchemaVersion = "fj_schema";

		public const string ZdoData = "fj_data";

		public const string ZdoNpcId = "fj_npc";

		public const string ZdoPaused = "fj_paused";

		public const string ZdoInitialNpc = "fj_initial_npc";

		public const string RpcTogglePause = "FJ_TogglePause";

		public const string RpcScanField = "FJ_ScanField";

		public const string RpcAssignBoundary = "FJ_AssignBoundary";

		public const string RpcAssignChest = "FJ_AssignChest";

		public const string RpcUpdateCropConfig = "FJ_UpdateCropConfig";

		public const string RpcSetLayoutMode = "FJ_SetLayoutMode";

		public const string RpcSetPaused = "FJ_SetPaused";

		public const string RpcClearChests = "FJ_ClearChests";

		public const string RpcClearField = "FJ_ClearField";

		public const string RpcEnsureNpc = "FJ_EnsureNpc";

		public const float DefaultInteractRange = 3.5f;

		public const float DefaultWorkRange = 2f;

		public const float DefaultThinkInterval = 0.5f;

		public const float DefaultChestAssignRange = 20f;

		public const float ChestMatchRadius = 0.35f;

		public const float FarmScanVerticalExtent = 64f;

		public const float CropMatchRadius = 0.85f;

		public const float DefaultStuckSeconds = 8f;

		public const float InventoryNearlyFullRatio = 0.85f;
	}
	[BepInPlugin("com.farmerjohn.valheimfarmernpc", "ValheimFarmerNPC", "1.0.13")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class Plugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.farmerjohn.valheimfarmernpc";

		public const string PluginName = "ValheimFarmerNPC";

		public const string PluginVersion = "1.0.13";

		public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();

		internal static Plugin Instance { get; private set; }

		internal static PluginConfig ModConfig { get; private set; }

		internal static Harmony Harmony { get; private set; }

		private void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Instance = this;
			ModConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
			SyncedConfig.Init(ModConfig);
			Harmony = new Harmony("com.farmerjohn.valheimfarmernpc");
			try
			{
				PlacementPatches.Apply(Harmony);
				FarmerRemovePatches.Apply(Harmony);
				FarmerAudioPatches.Apply(Harmony);
				Harmony.PatchAll(typeof(GameStartPatch).Assembly);
			}
			catch (Exception ex)
			{
				Log.Warning("Harmony patches failed (plugin will still register pieces): " + ex.Message);
			}
			PrefabManager.OnVanillaPrefabsAvailable += OnVanillaPrefabsAvailable;
			RpcMessages.Register();
			ReservationManager.Init();
			AddLocalizations();
			Log.Info("ValheimFarmerNPC v1.0.13 loaded");
		}

		private void OnDestroy()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
			Harmony harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void OnVanillaPrefabsAvailable()
		{
			PieceRegistrar.Register();
			NpcRegistrar.Register();
			ItemRegistrar.Register();
			PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
		}

		private static void AddLocalizations()
		{
			CustomLocalization localization = Localization;
			string text = "English";
			localization.AddTranslation(ref text, new Dictionary<string, string>
			{
				{ "piece_farmerhomestead", "Farmer Homestead" },
				{ "piece_farmerhomestead_desc", "Homestead for autonomous farmers. Spawns one farmer on place. Admin only." },
				{ "piece_farmboundarypost", "Farm Boundary Post" },
				{ "piece_farmboundarypost_desc", "Place two posts to define a rectangular farm field." },
				{ "fj_npc_name", "Farmer" },
				{ "fj_npc_paused", "Farmer is paused. Talk to resume." },
				{ "fj_npc_working", "Farmer is working. Talk to pause." }
			});
		}
	}
}
namespace ValheimFarmerNPC.Utilities
{
	internal static class AdminUtil
	{
		public static bool IsServer()
		{
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				return ZNet.instance.IsServer();
			}
			return false;
		}

		public static bool LocalPlayerIsAdmin()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (!ZNet.instance.IsDedicated() && ZNet.instance.IsServer())
			{
				return true;
			}
			try
			{
				if (SynchronizationManager.Instance != null && SynchronizationManager.Instance.PlayerIsAdmin)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		public static bool PeerIsAdmin(long peerId)
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (!ZNet.instance.IsDedicated() && (peerId == 0L || peerId == ZNet.GetUID()))
			{
				return true;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(peerId);
			if (peer == null)
			{
				if (ZNet.instance.IsDedicated())
				{
					return LocalPlayerIsAdmin();
				}
				return true;
			}
			string text = null;
			try
			{
				ISocket socket = peer.m_socket;
				text = ((socket != null) ? socket.GetHostName() : null);
			}
			catch
			{
			}
			if (!string.IsNullOrEmpty(text))
			{
				try
				{
					if (ZNet.instance.IsAdmin(text))
					{
						return true;
					}
				}
				catch
				{
				}
				try
				{
					if (ZNet.instance.m_adminList != null && ZNet.instance.ListContainsId(ZNet.instance.m_adminList, text))
					{
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		public static bool CanConfigure(long senderPeerId)
		{
			if (!SyncedConfig.AdminOnlyAccess)
			{
				return true;
			}
			return PeerIsAdmin(senderPeerId);
		}

		public static bool LocalPlayerCanAccess()
		{
			if (!SyncedConfig.AdminOnlyAccess)
			{
				return true;
			}
			return LocalPlayerIsAdmin();
		}

		public static void EnsureServerOwnership(ZNetView view)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid() && IsServer() && !view.IsOwner())
			{
				view.ClaimOwnership();
			}
		}
	}
	internal static class Log
	{
		public static void Info(string message)
		{
			Logger.LogInfo((object)("[FarmerNPC] " + message));
		}

		public static void Warning(string message)
		{
			Logger.LogWarning((object)("[FarmerNPC] " + message));
		}

		public static void Error(string message)
		{
			Logger.LogError((object)("[FarmerNPC] " + message));
		}

		public static void Debug(string message)
		{
			if (SyncedConfig.DebugLogging)
			{
				Logger.LogInfo((object)("[FarmerNPC:DBG] " + message));
			}
		}
	}
	internal static class PhysicsQuery
	{
		public const int BufferSize = 256;

		public static readonly Collider[] Buffer = (Collider[])(object)new Collider[256];

		private static int _cropMask = int.MinValue;

		private static int _defaultMask = int.MinValue;

		public static int CropMask
		{
			get
			{
				if (_cropMask == int.MinValue)
				{
					_cropMask = LayerMask.GetMask(new string[6] { "Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "item" });
					if (_cropMask == 0)
					{
						_cropMask = -1;
					}
				}
				return _cropMask;
			}
		}

		public static int DefaultMask
		{
			get
			{
				if (_defaultMask == int.MinValue)
				{
					_defaultMask = CropMask;
				}
				return _defaultMask;
			}
		}

		public static int OverlapBoxNonAlloc(Vector3 center, Vector3 halfExtents, Quaternion orientation, int layerMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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)
			return Physics.OverlapBoxNonAlloc(center, halfExtents, Buffer, orientation, layerMask, (QueryTriggerInteraction)2);
		}

		public static int OverlapSphereNonAlloc(Vector3 position, float radius, int layerMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Physics.OverlapSphereNonAlloc(position, radius, Buffer, layerMask, (QueryTriggerInteraction)2);
		}
	}
	internal static class PlayerFeedback
	{
		public static void Notify(string message)
		{
			if (!string.IsNullOrEmpty(message))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null);
				}
				AddChat(message);
			}
		}

		public static void Notify(Player user, string message)
		{
			Notify((Humanoid)(object)user, message);
		}

		public static void Notify(Humanoid user, string message)
		{
			if (string.IsNullOrEmpty(message))
			{
				return;
			}
			if ((Object)(object)user != (Object)null)
			{
				((Character)user).Message((MessageType)2, message, 0, (Sprite)null);
			}
			else
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null);
				}
			}
			AddChat(message);
		}

		private static void AddChat(string message)
		{
			if (!SyncedConfig.LogFeedbackToChat || (Object)(object)Chat.instance == (Object)null)
			{
				return;
			}
			try
			{
				((Terminal)Chat.instance).AddString("<color=#EAAE5B>[Farmer]</color> " + message);
			}
			catch
			{
			}
		}
	}
	internal static class ZdoIds
	{
		public static long ZdoKey(ZDO zdo)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null)
			{
				return 0L;
			}
			ZDOID uid = zdo.m_uid;
			return (long)((ulong)((ZDOID)(ref uid)).UserID ^ ((ulong)((ZDOID)(ref uid)).ID << 16) ^ ((ZDOID)(ref uid)).UserKey);
		}
	}
}
namespace ValheimFarmerNPC.UI
{
	internal static class HomesteadCropsPage
	{
		internal static void BuildCropsPage()
		{
			//IL_004a: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_0105: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.CropsPage.transform, "Crop settings", 0f, -22f, 20, 500f, (TextAnchor)3);
			float num = 280f;
			GameObject val = GUIManager.Instance.CreateText("Biome: —", HomesteadUiController.CropsPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(num, -22f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimOrange, true, Color.black, 280f, 24f, false);
			HomesteadUiController.CropsBiomeLabel = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)HomesteadUiController.CropsBiomeLabel != (Object)null)
			{
				HomesteadUiController.CropsBiomeLabel.alignment = (TextAnchor)5;
				RectTransform rectTransform = ((Graphic)HomesteadUiController.CropsBiomeLabel).rectTransform;
				rectTransform.pivot = new Vector2(1f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(420f, -22f);
				rectTransform.sizeDelta = new Vector2(280f, 24f);
			}
			GameObject val2 = (HomesteadUiController.CropsEmptyRoot = GUIManager.Instance.CreateText("No crops grow in this biome.", HomesteadUiController.CropsPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -200f), GUIManager.Instance.AveriaSerifBold, 16, GUIManager.Instance.ValheimOrange, true, Color.black, 600f, 40f, false));
			Text val3 = (((Object)(object)val2 != (Object)null) ? val2.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val3.alignment = (TextAnchor)4;
			}
			if ((Object)(object)HomesteadUiController.CropsEmptyRoot != (Object)null)
			{
				HomesteadUiController.CropsEmptyRoot.SetActive(false);
			}
			float num2 = -85f;
			float num3 = -230f;
			float num4 = 230f;
			float num5 = num2;
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.CropsPage.transform, "Weights", num3, num5, 18, 400f, (TextAnchor)3);
			num5 -= 26f;
			HomesteadUiWidgets.CreateHelpText(HomesteadUiController.CropsPage.transform, "Relative planting ratios — higher values are planted more often. Set a crop to 0 to skip it. Only crops that grow in this biome are shown.", ref num5, 48f, num3);
			HomesteadUiController.CropsRowYStart = num5;
			string[] weightCrops = HomesteadUiController.WeightCrops;
			foreach (string text in weightCrops)
			{
				string iconPrefab = text;
				if (CropRegistry.TryGet(text, out var def))
				{
					iconPrefab = (def.ProducesSeedItem ? def.SeedItem : def.GrownPrefab);
				}
				string cropKey = text;
				HomesteadUiController.WeightRows[text] = HomesteadUiWidgets.CreateSliderRow(HomesteadUiController.CropsPage.transform, text, "weight", num5, 0, 100, HomesteadUiController.WeightSliders, HomesteadUiController.WeightLabels, delegate(float v)
				{
					HomesteadUiController.OnWeightChanged(cropKey, Mathf.RoundToInt(v));
				}, iconPrefab, (int value) => FormatWeightLabel(cropKey, value), num3, 400f);
				num5 -= 62f;
			}
			float num6 = num2;
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.CropsPage.transform, "Reserves", num4, num6, 18, 400f, (TextAnchor)3);
			num6 -= 26f;
			HomesteadUiWidgets.CreateHelpText(HomesteadUiController.CropsPage.transform, "Kept in the farmer's bag. When stock falls below this amount, they prioritize seed-crops until the reserve recovers.", ref num6, 48f, num4);
			weightCrops = HomesteadUiController.ReserveCrops;
			foreach (string text2 in weightCrops)
			{
				CropDefinition def2;
				string iconPrefab2 = (CropRegistry.TryGet(text2, out def2) ? def2.SeedItem : text2);
				string cropKey2 = text2;
				HomesteadUiController.ReserveRows[text2] = HomesteadUiWidgets.CreateSliderRow(HomesteadUiController.CropsPage.transform, text2, "reserve", num6, 0, 100, HomesteadUiController.ReserveSliders, HomesteadUiController.ReserveLabels, delegate(float v)
				{
					HomesteadUiController.OnReserveChanged(cropKey2, Mathf.RoundToInt(v));
				}, iconPrefab2, (int value) => FormatReserveLabel(cropKey2, value), num4, 400f);
				num6 -= 62f;
			}
			float y = -500f;
			HomesteadUiWidgets.AddButton(HomesteadUiController.CropsPage.transform, "Back", ref y, new UnityAction(HomesteadUiController.ShowMainPage));
		}

		internal static string CropDisplayName(string family)
		{
			if (string.Equals(family, "JotunPuffs", StringComparison.OrdinalIgnoreCase))
			{
				return "Jotun Puffs";
			}
			if (string.Equals(family, "Magecap", StringComparison.OrdinalIgnoreCase))
			{
				return "Magecap";
			}
			return family;
		}

		internal static string FormatWeightLabel(string family, int value)
		{
			return $"{CropDisplayName(family)}: {value}";
		}

		internal static string FormatReserveLabel(string family, int value)
		{
			if (string.Equals(family, "Barley", StringComparison.OrdinalIgnoreCase) || string.Equals(family, "Flax", StringComparison.OrdinalIgnoreCase) || string.Equals(family, "JotunPuffs", StringComparison.OrdinalIgnoreCase) || string.Equals(family, "Magecap", StringComparison.OrdinalIgnoreCase))
			{
				return $"{CropDisplayName(family)}: {value}";
			}
			return $"{CropDisplayName(family)} seeds: {value}";
		}
	}
	internal static class HomesteadInventoryPages
	{
		internal static void BuildInventoryPage()
		{
			//IL_0039: 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_0057: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: 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_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Expected O, but got Unknown
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.InvPage.transform, "Farmer inventory", -22f, 20);
			GameObject val = GUIManager.Instance.CreateText("Loading...", HomesteadUiController.InvPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -55f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 70f, false);
			HomesteadUiController.InvStatus = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)HomesteadUiController.InvStatus != (Object)null)
			{
				HomesteadUiController.InvStatus.alignment = (TextAnchor)0;
				HomesteadUiController.InvStatus.horizontalOverflow = (HorizontalWrapMode)0;
				HomesteadUiController.InvStatus.verticalOverflow = (VerticalWrapMode)1;
				RectTransform rectTransform = ((Graphic)HomesteadUiController.InvStatus).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(0f, -55f);
				rectTransform.sizeDelta = new Vector2(400f, 70f);
			}
			else
			{
				Log.Error("HomesteadUI: inventory text control missing");
			}
			GameObject val2 = new GameObject("InvList", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(HomesteadUiController.InvPage.transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			HomesteadUiController.InvListRoot = val2.transform;
			GameObject val3 = GUIManager.Instance.CreateText("", HomesteadUiController.InvPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -560f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 24f, false);
			HomesteadUiController.InvFooter = (((Object)(object)val3 != (Object)null) ? val3.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)HomesteadUiController.InvFooter != (Object)null)
			{
				HomesteadUiController.InvFooter.alignment = (TextAnchor)0;
				RectTransform rectTransform2 = ((Graphic)HomesteadUiController.InvFooter).rectTransform;
				rectTransform2.pivot = new Vector2(0.5f, 1f);
				rectTransform2.anchorMin = new Vector2(0.5f, 1f);
				rectTransform2.anchorMax = new Vector2(0.5f, 1f);
				rectTransform2.anchoredPosition = new Vector2(0f, -560f);
				rectTransform2.sizeDelta = new Vector2(400f, 24f);
			}
			float y = -618f;
			HomesteadUiWidgets.AddButton(HomesteadUiController.InvPage.transform, "Refresh", ref y, new UnityAction(RefreshInventoryPage));
			HomesteadUiWidgets.AddButton(HomesteadUiController.InvPage.transform, "Back", ref y, new UnityAction(HomesteadUiController.ShowMainPage));
		}

		internal static void BuildChestInventoryPage()
		{
			//IL_0039: 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_0057: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: 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_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Expected O, but got Unknown
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.ChestInvPage.transform, "Chest inventory", -22f, 20);
			GameObject val = GUIManager.Instance.CreateText("Loading...", HomesteadUiController.ChestInvPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -55f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 70f, false);
			HomesteadUiController.ChestInvStatus = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)HomesteadUiController.ChestInvStatus != (Object)null)
			{
				HomesteadUiController.ChestInvStatus.alignment = (TextAnchor)0;
				HomesteadUiController.ChestInvStatus.horizontalOverflow = (HorizontalWrapMode)0;
				HomesteadUiController.ChestInvStatus.verticalOverflow = (VerticalWrapMode)1;
				RectTransform rectTransform = ((Graphic)HomesteadUiController.ChestInvStatus).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(0f, -55f);
				rectTransform.sizeDelta = new Vector2(400f, 70f);
			}
			else
			{
				Log.Error("HomesteadUI: chest inventory text control missing");
			}
			GameObject val2 = new GameObject("ChestInvList", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(HomesteadUiController.ChestInvPage.transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			HomesteadUiController.ChestInvListRoot = val2.transform;
			GameObject val3 = GUIManager.Instance.CreateText("", HomesteadUiController.ChestInvPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -560f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 24f, false);
			HomesteadUiController.ChestInvFooter = (((Object)(object)val3 != (Object)null) ? val3.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)HomesteadUiController.ChestInvFooter != (Object)null)
			{
				HomesteadUiController.ChestInvFooter.alignment = (TextAnchor)0;
				RectTransform rectTransform2 = ((Graphic)HomesteadUiController.ChestInvFooter).rectTransform;
				rectTransform2.pivot = new Vector2(0.5f, 1f);
				rectTransform2.anchorMin = new Vector2(0.5f, 1f);
				rectTransform2.anchorMax = new Vector2(0.5f, 1f);
				rectTransform2.anchoredPosition = new Vector2(0f, -560f);
				rectTransform2.sizeDelta = new Vector2(400f, 24f);
			}
			float y = -618f;
			HomesteadUiWidgets.AddButton(HomesteadUiController.ChestInvPage.transform, "Refresh", ref y, new UnityAction(RefreshChestInventoryPage));
			HomesteadUiWidgets.AddButton(HomesteadUiController.ChestInvPage.transform, "Back", ref y, new UnityAction(HomesteadUiController.ShowMainPage));
		}

		internal static void RefreshInventoryPage()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)HomesteadUiController.Current == (Object)null)
			{
				return;
			}
			if ((Object)(object)HomesteadUiController.InvStatus == (Object)null || (Object)(object)HomesteadUiController.InvListRoot == (Object)null)
			{
				Log.Warning("HomesteadUI: inventory page text is null — rebuilding UI");
				if ((Object)(object)HomesteadUiController.Root != (Object)null)
				{
					Object.Destroy((Object)(object)HomesteadUiController.Root);
					HomesteadUiController.Root = null;
					HomesteadUiController.InvPage = null;
					HomesteadUiController.MainPage = null;
					HomesteadUiController.CropsPage = null;
				}
				HomesteadUiShell.EnsureUi();
				HomesteadUiController.ShowInventoryPage();
				return;
			}
			try
			{
				foreach (FarmerNpc item in FarmerRoster.ListNear(((Component)HomesteadUiController.Current).transform.position))
				{
					Humanoid val = (((Object)(object)item != (Object)null) ? ((Component)item).GetComponent<Humanoid>() : null);
					if ((Object)(object)val != (Object)null && item.Inventory != null)
					{
						WorldDropCollector.AbsorbFromHumanoid(item.Inventory, val);
					}
				}
				int num = HomesteadUiController.Current.CountFarmers();
				List<CarriedItem> list = HomesteadUiController.Current.GetAggregatedCarriedItems() ?? new List<CarriedItem>();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine($"Farmers: {num}");
				stringBuilder.AppendLine($"Item types: {list.Count}");
				stringBuilder.Append("(Live farmer bags)");
				HomesteadUiController.InvStatus.text = stringBuilder.ToString();
				ClearInvList(HomesteadUiController.InvListRoot);
				float num2 = -140f;
				int num3 = 0;
				int num4 = 0;
				if (list.Count == 0)
				{
					if ((Object)(object)HomesteadUiController.InvFooter != (Object)null)
					{
						((Graphic)HomesteadUiController.InvFooter).rectTransform.anchoredPosition = new Vector2(0f, -560f);
						HomesteadUiController.InvFooter.text = "Inventory empty.";
					}
					return;
				}
				foreach (CarriedItem item2 in from i in list
					orderby i.Stack descending, i.Prefab
					select i)
				{
					if (item2 != null && !string.IsNullOrEmpty(item2.Prefab))
					{
						num3 += item2.Stack;
						if (num2 < -532f)
						{
							num4++;
							continue;
						}
						CreateInvItemRow(HomesteadUiController.InvListRoot, item2.Prefab, item2.Stack, num2);
						num2 -= 46f;
					}
				}
				if ((Object)(object)HomesteadUiController.InvFooter != (Object)null)
				{
					((Graphic)HomesteadUiController.InvFooter).rectTransform.anchoredPosition = new Vector2(0f, -560f);
					HomesteadUiController.InvFooter.text = ((num4 > 0) ? $"Total items: {num3}  (+{num4} more types)" : $"Total items: {num3}");
				}
			}
			catch (Exception ex)
			{
				Log.Error($"HomesteadUI inventory refresh failed: {ex}");
				ClearInvList(HomesteadUiController.InvListRoot);
				HomesteadUiController.InvStatus.text = "Error loading inventory:\n" + ex.Message;
				if ((Object)(object)HomesteadUiController.InvFooter != (Object)null)
				{
					HomesteadUiController.InvFooter.text = string.Empty;
				}
			}
		}

		internal static void RefreshChestInventoryPage()
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)HomesteadUiController.Current == (Object)null)
			{
				return;
			}
			if ((Object)(object)HomesteadUiController.ChestInvStatus == (Object)null || (Object)(object)HomesteadUiController.ChestInvListRoot == (Object)null)
			{
				Log.Warning("HomesteadUI: chest inventory page missing — rebuilding UI");
				if ((Object)(object)HomesteadUiController.Root != (Object)null)
				{
					Object.Destroy((Object)(object)HomesteadUiController.Root);
					HomesteadUiController.Root = null;
					HomesteadUiController.InvPage = null;
					HomesteadUiController.ChestInvPage = null;
					HomesteadUiController.MainPage = null;
					HomesteadUiController.CropsPage = null;
				}
				HomesteadUiShell.EnsureUi();
				HomesteadUiController.ShowChestInventoryPage();
				return;
			}
			try
			{
				HomesteadUiController.Current.ReloadDataFromZdo();
				HomesteadData data = HomesteadUiController.Current.Data;
				data?.SyncChestListsFromCsv();
				int num = data?.ChestCount ?? 0;
				List<CarriedItem> list = HomesteadUiController.Current.GetAggregatedChestItems() ?? new List<CarriedItem>();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine($"Chests: {num}");
				stringBuilder.AppendLine($"Item types: {list.Count}");
				stringBuilder.Append("(Assigned homestead chests)");
				HomesteadUiController.ChestInvStatus.text = stringBuilder.ToString();
				ClearInvList(HomesteadUiController.ChestInvListRoot);
				float num2 = -140f;
				int num3 = 0;
				int num4 = 0;
				if (num == 0)
				{
					if ((Object)(object)HomesteadUiController.ChestInvFooter != (Object)null)
					{
						((Graphic)HomesteadUiController.ChestInvFooter).rectTransform.anchoredPosition = new Vector2(0f, -560f);
						HomesteadUiController.ChestInvFooter.text = "No chests assigned.";
					}
					return;
				}
				if (list.Count == 0)
				{
					if ((Object)(object)HomesteadUiController.ChestInvFooter != (Object)null)
					{
						((Graphic)HomesteadUiController.ChestInvFooter).rectTransform.anchoredPosition = new Vector2(0f, -560f);
						HomesteadUiController.ChestInvFooter.text = "Chests empty.";
					}
					return;
				}
				foreach (CarriedItem item in from i in list
					orderby i.Stack descending, i.Prefab
					select i)
				{
					if (item != null && !string.IsNullOrEmpty(item.Prefab))
					{
						num3 += item.Stack;
						if (num2 < -532f)
						{
							num4++;
							continue;
						}
						CreateInvItemRow(HomesteadUiController.ChestInvListRoot, item.Prefab, item.Stack, num2);
						num2 -= 46f;
					}
				}
				if ((Object)(object)HomesteadUiController.ChestInvFooter != (Object)null)
				{
					((Graphic)HomesteadUiController.ChestInvFooter).rectTransform.anchoredPosition = new Vector2(0f, -560f);
					HomesteadUiController.ChestInvFooter.text = ((num4 > 0) ? $"Total items: {num3}  (+{num4} more types)" : $"Total items: {num3}");
				}
			}
			catch (Exception ex)
			{
				Log.Error($"HomesteadUI chest inventory refresh failed: {ex}");
				ClearInvList(HomesteadUiController.ChestInvListRoot);
				HomesteadUiController.ChestInvStatus.text = "Error loading chests:\n" + ex.Message;
				if ((Object)(object)HomesteadUiController.ChestInvFooter != (Object)null)
				{
					HomesteadUiController.ChestInvFooter.text = string.Empty;
				}
			}
		}

		internal static void ClearInvList(Transform listRoot)
		{
			if (!((Object)(object)listRoot == (Object)null))
			{
				for (int num = listRoot.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)listRoot.GetChild(num)).gameObject);
				}
			}
		}

		internal static void CreateInvItemRow(Transform parent, string prefab, int stack, float y)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			float num = y - 20f;
			Sprite val = HomesteadUiWidgets.TryGetItemIcon(prefab);
			if ((Object)(object)val != (Object)null)
			{
				GameObject val2 = new GameObject(prefab + "_inv_icon", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val2.transform.SetParent(parent, false);
				RectTransform component = val2.GetComponent<RectTransform>();
				component.pivot = new Vector2(0.5f, 0.5f);
				component.anchorMin = new Vector2(0.5f, 1f);
				component.anchorMax = new Vector2(0.5f, 1f);
				component.sizeDelta = new Vector2(40f, 40f);
				component.anchoredPosition = new Vector2(-175f, num);
				Image component2 = val2.GetComponent<Image>();
				component2.sprite = val;
				component2.preserveAspect = true;
				((Graphic)component2).raycastTarget = false;
			}
			GameObject val3 = GUIManager.Instance.CreateText($"{prefab}: {stack}", parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(20f, num), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimOrange, true, Color.black, 320f, 22f, false);
			Text val4 = (((Object)(object)val3 != (Object)null) ? val3.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)val4 != (Object)null)
			{
				val4.alignment = (TextAnchor)3;
				RectTransform rectTransform = ((Graphic)val4).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(20f, num);
				rectTransform.sizeDelta = new Vector2(320f, 22f);
			}
		}
	}
	internal static class HomesteadMainPage
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__0_0;

			public static UnityAction <>9__0_1;

			public static UnityAction <>9__0_2;

			public static UnityAction <>9__0_3;

			public static UnityAction <>9__0_4;

			public static UnityAction <>9__0_5;

			public static UnityAction <>9__0_6;

			public static UnityAction <>9__0_7;

			public static UnityAction <>9__0_8;

			internal void <BuildMainPage>b__0_0()
			{
				HomesteadUiController.Current?.RequestTogglePause();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_1()
			{
				HomesteadUiController.Current?.RequestAddFarmer();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_2()
			{
				HomesteadUiController.Current?.RequestRemoveFarmer();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_3()
			{
				HomesteadUiController.Current?.RequestForceDepositAll();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_4()
			{
				HomesteadUiController.Current?.RequestScan();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_5()
			{
				HomesteadUiController.Current?.RequestClearField();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_6()
			{
				HomesteadUiController.Current?.RequestAssignBoundary();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_7()
			{
				HomesteadUiController.Current?.RequestAssignChest();
				HomesteadUiController.QueueRefresh();
			}

			internal void <BuildMainPage>b__0_8()
			{
				HomesteadUiController.Current?.RequestClearChests();
				HomesteadUiController.QueueRefresh();
			}
		}

		internal static void BuildMainPage()
		{
			//IL_0039: 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_0057: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Expected O, but got Unknown
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Expected O, but got Unknown
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Expected O, but got Unknown
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.MainPage.transform, "Farmer Homestead", -22f, 22);
			GameObject val = GUIManager.Instance.CreateText("", HomesteadUiController.MainPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -58f), GUIManager.Instance.AveriaSerifBold, 13, GUIManager.Instance.ValheimOrange, true, Color.black, 380f, 100f, false);
			HomesteadUiController.Status = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)HomesteadUiController.Status != (Object)null)
			{
				HomesteadUiController.Status.alignment = (TextAnchor)0;
				HomesteadUiController.Status.horizontalOverflow = (HorizontalWrapMode)1;
				HomesteadUiController.Status.verticalOverflow = (VerticalWrapMode)1;
				RectTransform rectTransform = ((Graphic)HomesteadUiController.Status).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(0f, -58f);
				rectTransform.sizeDelta = new Vector2(380f, 100f);
			}
			float y = -175f;
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Farmers", ref y);
			Transform transform = HomesteadUiController.MainPage.transform;
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					HomesteadUiController.Current?.RequestTogglePause();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_0 = val2;
				obj = (object)val2;
			}
			HomesteadUiWidgets.AddButton(transform, "Toggle Pause", ref y, (UnityAction)obj);
			Transform transform2 = HomesteadUiController.MainPage.transform;
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				UnityAction val3 = delegate
				{
					HomesteadUiController.Current?.RequestAddFarmer();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_1 = val3;
				obj2 = (object)val3;
			}
			HomesteadUiWidgets.AddButton(transform2, "Add Farmer", ref y, (UnityAction)obj2);
			Transform transform3 = HomesteadUiController.MainPage.transform;
			object obj3 = <>c.<>9__0_2;
			if (obj3 == null)
			{
				UnityAction val4 = delegate
				{
					HomesteadUiController.Current?.RequestRemoveFarmer();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_2 = val4;
				obj3 = (object)val4;
			}
			HomesteadUiWidgets.AddButton(transform3, "Remove Farmer", ref y, (UnityAction)obj3);
			Transform transform4 = HomesteadUiController.MainPage.transform;
			object obj4 = <>c.<>9__0_3;
			if (obj4 == null)
			{
				UnityAction val5 = delegate
				{
					HomesteadUiController.Current?.RequestForceDepositAll();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_3 = val5;
				obj4 = (object)val5;
			}
			HomesteadUiWidgets.AddButton(transform4, "Deposit all", ref y, (UnityAction)obj4);
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Farmer inventory", ref y, new UnityAction(HomesteadUiController.ShowInventoryPage));
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Field", ref y);
			Transform transform5 = HomesteadUiController.MainPage.transform;
			object obj5 = <>c.<>9__0_4;
			if (obj5 == null)
			{
				UnityAction val6 = delegate
				{
					HomesteadUiController.Current?.RequestScan();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_4 = val6;
				obj5 = (object)val6;
			}
			HomesteadUiWidgets.AddButton(transform5, "Scan Field", ref y, (UnityAction)obj5);
			Transform transform6 = HomesteadUiController.MainPage.transform;
			object obj6 = <>c.<>9__0_5;
			if (obj6 == null)
			{
				UnityAction val7 = delegate
				{
					HomesteadUiController.Current?.RequestClearField();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_5 = val7;
				obj6 = (object)val7;
			}
			HomesteadUiWidgets.AddButton(transform6, "Clear Field", ref y, (UnityAction)obj6);
			Transform transform7 = HomesteadUiController.MainPage.transform;
			object obj7 = <>c.<>9__0_6;
			if (obj7 == null)
			{
				UnityAction val8 = delegate
				{
					HomesteadUiController.Current?.RequestAssignBoundary();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_6 = val8;
				obj7 = (object)val8;
			}
			HomesteadUiWidgets.AddButton(transform7, "Assign Boundary Posts", ref y, (UnityAction)obj7);
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Storage", ref y);
			Transform transform8 = HomesteadUiController.MainPage.transform;
			object obj8 = <>c.<>9__0_7;
			if (obj8 == null)
			{
				UnityAction val9 = delegate
				{
					HomesteadUiController.Current?.RequestAssignChest();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_7 = val9;
				obj8 = (object)val9;
			}
			HomesteadUiWidgets.AddButton(transform8, "Add chest", ref y, (UnityAction)obj8);
			Transform transform9 = HomesteadUiController.MainPage.transform;
			object obj9 = <>c.<>9__0_8;
			if (obj9 == null)
			{
				UnityAction val10 = delegate
				{
					HomesteadUiController.Current?.RequestClearChests();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_8 = val10;
				obj9 = (object)val10;
			}
			HomesteadUiWidgets.AddButton(transform9, "Clear chests", ref y, (UnityAction)obj9);
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Chest inventory", ref y, new UnityAction(HomesteadUiController.ShowChestInventoryPage));
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Crops", ref y);
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Crop settings", ref y, new UnityAction(HomesteadUiController.ShowCropsPage));
			y -= 8f;
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Close", ref y, new UnityAction(HomesteadUiController.Hide));
		}
	}
	internal static class HomesteadUiController
	{
		internal static readonly string[] WeightCrops = new string[7] { "Carrot", "Turnip", "Onion", "Barley", "Flax", "JotunPuffs", "Magecap" };

		internal static readonly string[] ReserveCrops = new string[7] { "Carrot", "Turnip", "Onion", "Barley", "Flax", "JotunPuffs", "Magecap" };

		internal const int UiLayoutVersion = 24;

		internal const float CropSliderRowStep = 62f;

		internal const float CropIconSize = 49f;

		internal const float InvIconSize = 40f;

		internal const float InvRowStep = 46f;

		internal const float PanelWidth = 460f;

		internal const float MainPanelHeight = 860f;

		internal const float CropsPanelWidth = 920f;

		internal const float CropsPanelHeight = 550f;

		internal const float CropsColumnOffset = 230f;

		internal const float CropsColumnWidth = 400f;

		internal const float InventoryPanelHeight = 700f;

		internal const float InvButtonsYStart = -618f;

		internal const float InvFooterY = -560f;

		internal const float InvListStopY = -532f;

		internal const float SectionGap = 7f;

		internal static int BuiltLayoutVersion;

		internal static GameObject Root;

		internal static GameObject MainPage;

		internal static GameObject CropsPage;

		internal static GameObject InvPage;

		internal static GameObject ChestInvPage;

		internal static FarmerHomestead Current;

		internal static Text Status;

		internal static Text CropsBiomeLabel;

		internal static GameObject CropsEmptyRoot;

		internal static float CropsRowYStart;

		internal static Text InvStatus;

		internal static Text InvFooter;

		internal static Transform InvListRoot;

		internal static Text ChestInvStatus;

		internal static Text ChestInvFooter;

		internal static Transform ChestInvListRoot;

		internal static Coroutine RefreshRoutine;

		internal static readonly Dictionary<string, Slider> WeightSliders = new Dictionary<string, Slider>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, Text> WeightLabels = new Dictionary<string, Text>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, GameObject> WeightRows = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, Slider> ReserveSliders = new Dictionary<string, Slider>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, Text> ReserveLabels = new Dictionary<string, Text>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, GameObject> ReserveRows = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);

		internal static bool SuppressSliderEvents;

		public static void Show(FarmerHomestead homestead)
		{
			if (!((Object)(object)homestead == (Object)null))
			{
				Current = homestead;
				homestead.TryInitialize();
				HomesteadUiShell.EnsureUi();
				Root.SetActive(true);
				ShowMainPage();
				SyncSlidersFromData();
				RefreshStatus();
				GUIManager.BlockInput(true);
			}
		}

		public static void Hide()
		{
			if ((Object)(object)Root != (Object)null)
			{
				Root.SetActive(false);
			}
			Current = null;
			GUIManager.BlockInput(false);
		}

		internal static void ShowMainPage()
		{
			HomesteadUiShell.SetPanelSize(460f, 860f);
			if ((Object)(object)MainPage != (Object)null)
			{
				MainPage.SetActive(true);
			}
			if ((Object)(object)CropsPage != (Object)null)
			{
				CropsPage.SetActive(false);
			}
			if ((Object)(object)InvPage != (Object)null)
			{
				InvPage.SetActive(false);
			}
			if ((Object)(object)ChestInvPage != (Object)null)
			{
				ChestInvPage.SetActive(false);
			}
			RefreshStatus();
		}

		internal static void ShowCropsPage()
		{
			HomesteadUiShell.SetPanelSize(920f, 550f);
			if ((Object)(object)MainPage != (Object)null)
			{
				MainPage.SetActive(false);
			}
			if ((Object)(object)CropsPage != (Object)null)
			{
				CropsPage.SetActive(true);
			}
			if ((Object)(object)InvPage != (Object)null)
			{
				InvPage.SetActive(false);
			}
			if ((Object)(object)ChestInvPage != (Object)null)
			{
				ChestInvPage.SetActive(false);
			}
			ApplyBiomeCropUi();
			SyncSlidersFromData();
		}

		internal static void ShowInventoryPage()
		{
			HomesteadUiShell.SetPanelSize(460f, 700f);
			if ((Object)(object)MainPage != (Object)null)
			{
				MainPage.SetActive(false);
			}
			if ((Object)(object)CropsPage != (Object)null)
			{
				CropsPage.SetActive(false);
			}
			if ((Object)(object)InvPage != (Object)null)
			{
				InvPage.SetActive(true);
			}
			if ((Object)(object)ChestInvPage != (Object)null)
			{
				ChestInvPage.SetActive(false);
			}
			HomesteadInventoryPages.RefreshInventoryPage();
		}

		internal static void ShowChestInventoryPage()
		{
			HomesteadUiShell.SetPanelSize(460f, 700f);
			if ((Object)(object)MainPage != (Object)null)
			{
				MainPage.SetActive(false);
			}
			if ((Object)(object)CropsPage != (Object)null)
			{
				CropsPage.SetActive(false);
			}
			if ((Object)(object)InvPage != (Object)null)
			{
				InvPage.SetActive(false);
			}
			if ((Object)(object)ChestInvPage != (Object)null)
			{
				ChestInvPage.SetActive(true);
			}
			HomesteadInventoryPages.RefreshChestInventoryPage();
		}

		internal static void ApplyBiomeCropUi()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0047: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Current == (Object)null)
			{
				return;
			}
			HomesteadData data = Current.Data;
			if (data == null)
			{
				Current.ReloadDataFromZdo();
				data = Current.Data;
			}
			Vector3 position = ((Component)Current).transform.position;
			Biome biome = BiomeCropRules.GetBiome(position);
			BiomeCropRules.ApplyToData(data, position);
			Current.Persist();
			if ((Object)(object)CropsBiomeLabel != (Object)null)
			{
				CropsBiomeLabel.text = "Biome: " + BiomeCropRules.GetBiomeDisplayName(biome);
			}
			HashSet<string> hashSet = new HashSet<string>(BiomeCropRules.GetAllowedFoodCrops(biome), StringComparer.OrdinalIgnoreCase);
			float y = CropsRowYStart;
			float y2 = CropsRowYStart;
			float columnX = -230f;
			float columnX2 = 230f;
			int num = 0;
			string[] weightCrops = WeightCrops;
			foreach (string text in weightCrops)
			{
				bool flag = hashSet.Contains(text);
				if (WeightRows.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
				{
					SetCropRowVisible(value, flag, columnX, ref y);
					if (flag)
					{
						num++;
					}
				}
				SetActiveSafe(WeightLabels, text, flag);
				SetActiveSafe(WeightSliders, text, flag);
				if (ReserveRows.TryGetValue(text, out var value2) && (Object)(object)value2 != (Object)null)
				{
					SetCropRowVisible(value2, flag, columnX2, ref y2);
				}
				SetActiveSafe(ReserveLabels, text, flag);
				SetActiveSafe(ReserveSliders, text, flag);
			}
			if ((Object)(object)CropsEmptyRoot != (Object)null)
			{
				CropsEmptyRoot.SetActive(num == 0);
			}
		}

		private static void SetActiveSafe(Dictionary<string, Text> map, string crop, bool show)
		{
			if (!map.TryGetValue(crop, out var value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			((Component)value).gameObject.SetActive(show);
			Transform parent = ((Component)value).transform.parent;
			if ((Object)(object)parent != (Object)null)
			{
				GameObject cropsPage = CropsPage;
				if ((Object)(object)parent != (Object)(object)((cropsPage != null) ? cropsPage.transform : null) && ((Object)parent).name.IndexOf("_row", StringComparison.OrdinalIgnoreCase) < 0)
				{
					((Component)parent).gameObject.SetActive(show);
				}
			}
		}

		private static void SetActiveSafe(Dictionary<string, Slider> map, string crop, bool show)
		{
			if (map.TryGetValue(crop, out var value) && (Object)(object)value != (Object)null)
			{
				((Component)value).gameObject.SetActive(show);
			}
		}

		private static void SetCropRowVisible(GameObject row, bool show, float columnX, ref float y)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			row.SetActive(show);
			CanvasGroup component = row.GetComponent<CanvasGroup>();
			if ((Object)(object)component != (Object)null)
			{
				component.alpha = (show ? 1f : 0f);
				component.interactable = show;
				component.blocksRaycasts = show;
			}
			if (show)
			{
				RectTransform component2 = row.GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.anchoredPosition = new Vector2(columnX, y);
				}
				y -= 62f;
			}
		}

		internal static void OnWeightChanged(string family, int weight)
		{
			if (!SuppressSliderEvents && !((Object)(object)Current == (Object)null))
			{
				weight = Mathf.Clamp(weight, 0, 100);
				if (WeightLabels.TryGetValue(family, out var value))
				{
					value.text = HomesteadCropsPage.FormatWeightLabel(family, weight);
				}
				Current.RequestSetLayoutMode("Weighted");
				Current.RequestSetCropWeight(family, weight);
				RefreshStatus();
			}
		}

		internal static void OnReserveChanged(string family, int reserve)
		{
			if (!SuppressSliderEvents && !((Object)(object)Current == (Object)null))
			{
				reserve = Mathf.Clamp(reserve, 0, 100);
				if (ReserveLabels.TryGetValue(family, out var value))
				{
					value.text = HomesteadCropsPage.FormatReserveLabel(family, reserve);
				}
				Current.RequestSetCropReserve(family, reserve);
				RefreshStatus();
			}
		}

		internal static void SyncSlidersFromData()
		{
			if (Current?.Data == null)
			{
				Current?.ReloadDataFromZdo();
			}
			HomesteadData homesteadData = Current?.Data;
			if (homesteadData == null)
			{
				return;
			}
			SuppressSliderEvents = true;
			try
			{
				string[] weightCrops = WeightCrops;
				foreach (string text in weightCrops)
				{
					CropConfigEntry cropConfigEntry = homesteadData.GetCropConfig(text) ?? new CropConfigEntry
					{
						Family = text,
						Weight = 50
					};
					if (WeightSliders.TryGetValue(text, out var value))
					{
						value.value = Mathf.Clamp(cropConfigEntry.Weight, 0, 100);
					}
					if (WeightLabels.TryGetValue(text, out var value2))
					{
						value2.text = HomesteadCropsPage.FormatWeightLabel(text, Mathf.Clamp(cropConfigEntry.Weight, 0, 100));
					}
				}
				weightCrops = ReserveCrops;
				foreach (string text2 in weightCrops)
				{
					CropConfigEntry cropConfigEntry2 = homesteadData.GetCropConfig(text2) ?? new CropConfigEntry
					{
						Family = text2,
						MinimumSeedReserve = 10
					};
					if (ReserveSliders.TryGetValue(text2, out var value3))
					{
						value3.value = Mathf.Clamp(cropConfigEntry2.MinimumSeedReserve, 0, 100);
					}
					if (ReserveLabels.TryGetValue(text2, out var value4))
					{
						value4.text = HomesteadCropsPage.FormatReserveLabel(text2, Mathf.Clamp(cropConfigEntry2.MinimumSeedReserve, 0, 100));
					}
				}
			}
			finally
			{
				SuppressSliderEvents = false;
			}
		}

		internal static void QueueRefresh()
		{
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				RefreshStatus();
				SyncSlidersFromData();
				return;
			}
			if (RefreshRoutine != null)
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(RefreshRoutine);
			}
			RefreshRoutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(RefreshSoon());
		}

		private static IEnumerator RefreshSoon()
		{
			RefreshStatus();
			yield return (object)new WaitForSeconds(0.4f);
			Current?.ReloadDataFromZdo();
			SyncSlidersFromData();
			RefreshStatus();
			RefreshRoutine = null;
		}

		internal static void RefreshStatus()
		{
			if (!((Object)(object)Status == (Object)null) && !((Object)(object)Current == (Object)null))
			{
				HomesteadData data = Current.Data;
				if (data == null)
				{
					Current.ReloadDataFromZdo();
					data = Current.Data;
				}
				if (data == null)
				{
					Status.text = "No data (waiting for network...)";
					return;
				}
				data.SyncChestListsFromCsv();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Status: " + (data.Paused ? "Paused" : "Working"));
				stringBuilder.AppendLine($"Farmers: {Current.CountFarmers()}");
				stringBuilder.AppendLine($"Crops: {data.Slots?.Count ?? 0}");
				stringBuilder.AppendLine($"Chests: {data.ChestCount}");
				stringBuilder.Append("Boundary: " + (data.HasBoundary ? "set" : "missing"));
				Status.text = stringBuilder.ToString();
			}
		}

		internal static void ClearCachedUiState()
		{
			WeightSliders.Clear();
			WeightLabels.Clear();
			WeightRows.Clear();
			ReserveSliders.Clear();
			ReserveLabels.Clear();
			ReserveRows.Clear();
			CropsBiomeLabel = null;
			CropsEmptyRoot = null;
			InvStatus = null;
			InvFooter = null;
			InvListRoot = null;
			ChestInvStatus = null;
			ChestInvFooter = null;
			ChestInvListRoot = null;
			BuiltLayoutVersion = 0;
		}
	}
	internal static class HomesteadUiShell
	{
		private sealed class HomesteadUiInput : MonoBehaviour
		{
			private void Update()
			{
				if (!((Object)(object)HomesteadUiController.Root == (Object)null) && HomesteadUiController.Root.activeInHierarchy && WasEscapePressed())
				{
					if ((Object)(object)HomesteadUiController.CropsPage != (Object)null && HomesteadUiController.CropsPage.activeSelf)
					{
						HomesteadUiController.ShowMainPage();
					}
					else if ((Object)(object)HomesteadUiController.InvPage != (Object)null && HomesteadUiController.InvPage.activeSelf)
					{
						HomesteadUiController.ShowMainPage();
					}
					else if ((Object)(object)HomesteadUiController.ChestInvPage != (Object)null && HomesteadUiController.ChestInvPage.activeSelf)
					{
						HomesteadUiController.ShowMainPage();
					}
					else
					{
						HomesteadUiController.Hide();
					}
				}
			}

			private static bool WasEscapePressed()
			{
				try
				{
					if (ZInput.GetKeyDown((KeyCode)27, true))
					{
						return true;
					}
				}
				catch
				{
				}
				return Input.GetKeyDown((KeyCode)27);
			}
		}

		internal static void EnsureUi()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)HomesteadUiController.Root != (Object)null && ((Object)(object)HomesteadUiController.MainPage == (Object)null || (Object)(object)HomesteadUiController.InvPage == (Object)null || (Object)(object)HomesteadUiController.ChestInvPage == (Object)null || (Object)(object)HomesteadUiController.InvStatus == (Object)null || (Object)(object)HomesteadUiController.ChestInvStatus == (Object)null || HomesteadUiController.BuiltLayoutVersion != 24))
			{
				Object.Destroy((Object)(object)HomesteadUiController.Root);
				HomesteadUiController.Root = null;
				HomesteadUiController.ClearCachedUiState();
			}
			if (!((Object)(object)HomesteadUiController.Root != (Object)null))
			{
				HomesteadUiController.Root = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 460f, 860f);
				HomesteadUiController.Root.SetActive(false);
				HomesteadUiController.MainPage = CreatePage("MainPage");
				HomesteadUiController.CropsPage = CreatePage("CropsPage");
				HomesteadUiController.InvPage = CreatePage("InvPage");
				HomesteadUiController.ChestInvPage = CreatePage("ChestInvPage");
				HomesteadMainPage.BuildMainPage();
				HomesteadCropsPage.BuildCropsPage();
				HomesteadInventoryPages.BuildInventoryPage();
				HomesteadInventoryPages.BuildChestInventoryPage();
				if ((Object)(object)HomesteadUiController.Root.GetComponent<HomesteadUiInput>() == (Object)null)
				{
					HomesteadUiController.Root.AddComponent<HomesteadUiInput>();
				}
				HomesteadUiController.BuiltLayoutVersion = 24;
				HomesteadUiController.ShowMainPage();
			}
		}

		internal static GameObject CreatePage(string name)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(HomesteadUiController.Root.transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			return val;
		}

		internal static void SetPanelSize(float width, float height)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)HomesteadUiController.Root == (Object)null))
			{
				RectTransform component = HomesteadUiController.Root.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.sizeDelta = new Vector2(width, height);
				}
			}
		}
	}
	internal static class HomesteadUiWidgets
	{
		internal static void CreateHelpText(Transform parent, string text, ref float y, float height, float columnX = 0f, float width = 400f)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GUIManager.Instance.CreateText(text, parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(columnX, y), GUIManager.Instance.AveriaSerifBold, 12, GUIManager.Instance.ValheimOrange, true, Color.black, width, height, false);
			Text val2 = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.alignment = (TextAnchor)0;
				val2.horizontalOverflow = (HorizontalWrapMode)0;
				val2.verticalOverflow = (VerticalWrapMode)1;
				RectTransform rectTransform = ((Graphic)val2).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(columnX, y);
				rectTransform.sizeDelta = new Vector2(width, height);
			}
			y -= height + 6f;
		}

		internal static Sprite TryGetItemIcon(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return null;
			}
			Sprite[] array = itemPrefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0 || (Object)(object)array[0] == (Object)null)
			{
				return null;
			}
			return array[0];
		}

		internal static void CreateTitle(Transform parent, string text, float y, int fontSize)
		{
			CreateTitle(parent, text, 0f, y, fontSize, 420f, (TextAnchor)4);
		}

		internal static void CreateTitle(Transform parent, string text, float x, float y, int fontSize, float width, TextAnchor alignment = (TextAnchor)4)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Invalid comparison between Unknown and I4
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_0102: 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)
			GameObject val = GUIManager.Instance.CreateText(text, parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(x, y), GUIManager.Instance.AveriaSerifBold, fontSize, GUIManager.Instance.ValheimOrange, true, Color.black, width, 26f, false);
			Text val2 = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if (!((Object)(object)val2 == (Object)null))
			{
				val2.alignment = alignment;
				RectTransform rectTransform = ((Graphic)val2).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				if ((int)alignment == 3 || (int)alignment == 0)
				{
					float num = ((Mathf.Abs(x) < 0.01f) ? (-420f) : (x - width * 0.5f));
					rectTransform.pivot = new Vector2(0f, 1f);
					rectTransform.anchoredPosition = new Vector2(num, y);
					rectTransform.sizeDelta = new Vector2(width, 26f);
				}
				else
				{
					rectTransform.anchoredPosition = new Vector2(x, y);
					rectTransform.sizeDelta = new Vector2(width, 26f);
				}
			}
		}

		internal static void AddSectionHeader(Transform parent, string text, ref float y)
		{
			//IL_001b: 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_0036: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			y -= 7f;
			GameObject val = GUIManager.Instance.CreateText(text, parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), GUIManager.Instance.AveriaSerifBold, 15, GUIManager.Instance.ValheimOrange, true, Color.black, 420f, 22f, false);
			Text val2 = (((Object)(object)val != (Object)null) ? val.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.alignment = (TextAnchor)4;
				RectTransform rectTransform = ((Graphic)val2).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(0f, y);
				rectTransform.sizeDelta = new Vector2(420f, 22f);
			}
			y -= 37f;
		}

		internal static GameObject CreateSliderRow(Transform parent, string crop, string kind, float y, int min, int max, Dictionary<string, Slider> sliders, Dictionary<string, Text> labels, UnityAction<float> onChanged, string iconPrefab, Func<int, string> formatLabel, float columnX, float columnWidth)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Expected O, but got Unknown
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: 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_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Expected O, but got Unknown
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_051f: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Expected O, but got Unknown
			//IL_0605: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_0694: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06db: 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_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: 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)
			float num = -26f;
			float num2 = num - 8f;
			GameObject val = new GameObject(crop + "_" + kind + "_row", new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasGroup)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(columnWidth, 62f);
			component.anchoredPosition = new Vector2(columnX, y);
			float num3 = 0f - columnWidth * 0.5f;
			float num4 = num3 + 24.5f;
			float num5 = num3 + 49f + 10f;
			float num6 = columnWidth - 49f - 16f;
			Sprite val2 = TryGetItemIcon(iconPrefab);
			if ((Object)(object)val2 != (Object)null)
			{
				GameObject val3 = new GameObject(crop + "_" + kind + "_icon", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val3.transform.SetParent(val.transform, false);
				RectTransform component2 = val3.GetComponent<RectTransform>();
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.anchorMin = new Vector2(0.5f, 1f);
				component2.anchorMax = new Vector2(0.5f, 1f);
				component2.sizeDelta = new Vector2(49f, 49f);
				component2.anchoredPosition = new Vector2(num4, num2);
				Image component3 = val3.GetComponent<Image>();
				component3.sprite = val2;
				component3.preserveAspect = true;
				((Graphic)component3).raycastTarget = false;
			}
			GameObject val4 = GUIManager.Instance.CreateText(formatLabel(min), val.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(num5 + num6 * 0.5f - columnWidth * 0.25f, 0f), GUIManager.Instance.AveriaSerifBold, 13, GUIManager.Instance.ValheimOrange, true, Color.black, num6, 18f, false);
			if ((Object)(object)val4 != (Object)null && (Object)(object)val4.transform.parent != (Object)(object)val.transform)
			{
				val4.transform.SetParent(val.transform, false);
			}
			Text val5 = (((Object)(object)val4 != (Object)null) ? val4.GetComponentInChildren<Text>(true) : null);
			if ((Object)(object)val5 != (Object)null)
			{
				if ((Object)(object)val4 != (Object)null && (Object)(object)((Component)val5).gameObject != (Object)(object)val4)
				{
					val4.transform.SetParent(val.transform, false);
				}
				val5.alignment = (TextAnchor)3;
				RectTransform rectTransform = ((Graphic)val5).rectTransform;
				rectTransform.pivot = new Vector2(0f, 1f);
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				rectTransform.anchoredPosition = new Vector2(num5, 0f);
				rectTransform.sizeDelta = new Vector2(num6, 18f);
				labels[crop] = val5;
			}
			GameObject val6 = new GameObject(crop + "_" + kind + "_slider", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(val.transform, false);
			RectTransform component4 = val6.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0.5f, 1f);
			component4.anchorMax = new Vector2(0.5f, 1f);
			component4.pivot = new Vector2(0f, 1f);
			component4.sizeDelta = new Vector2(num6, 16f);
			component4.anchoredPosition = new Vector2(num5, num);
			Slider val7 = val6.AddComponent<Slider>();
			val7.minValue = min;
			val7.maxValue = max;
			val7.wholeNumbers = true;
			val7.value = min;
			GameObject val8 = new GameObject("Background", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val8.transform.SetParent(val6.transform, false);
			RectTransform component5 = val8.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = Vector2.zero;
			component5.offsetMax = Vector2.zero;
			Image component6 = val8.GetComponent<Image>();
			((Graphic)component6).color = new Color(0.15f, 0.12f, 0.1f, 0.9f);
			((Selectable)val7).targetGraphic = (Graphic)(object)component6;
			GameObject val9 = new GameObject("Fill Area", new Type[1] { typeof(RectTransform) });
			val9.transform.SetParent(val6.transform, false);
			RectTransform component7 = val9.GetComponent<RectTransform>();
			component7.anchorMin = Vector2.zero;
			component7.anchorMax = Vector2.one;
			component7.offsetMin = new Vector2(4f, 4f);
			component7.offsetMax = new Vector2(-4f, -4f);
			GameObject val10 = new GameObject("Fill", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val10.transform.SetParent(val9.transform, false);
			RectTransform component8 = val10.GetComponent<RectTransform>();
			component8.anchorMin = Vector2.zero;
			component8.anchorMax = Vector2.one;
			component8.offsetMin = Vector2.zero;
			component8.offsetMax = Vector2.zero;
			((Graphic)val10.GetComponent<Image>()).color = new Color(0.75f, 0.45f, 0.15f, 1f);
			val7.fillRect = component8;
			GameObject val11 = new GameObject("Handle Slide Area", new Type[1] { typeof(RectTransform) });
			val11.transform.SetParent(val6.transform, false);
			RectTransform component9 = val11.GetComponent<RectTransform>();
			component9.anchorMin = Vector2.zero;
			component9.anchorMax = Vector2.one;
			component9.offsetMin = new Vector2(8f, 0f);
			component9.offsetMax = new Vector2(-8f, 0f);
			GameObject val12 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val12.transform.SetParent(val11.transform, false);
			RectTransform component10 = val12.GetComponent<RectTransform>();
			component10.sizeDelta = new Vector2(14f, 18f);
			((Graphic)val12.GetComponent<Image>()).color = new Color(0.95f, 0.8f, 0.45f, 1f);
			val7.handleRect = component10;
			try
			{
				GUIManager.Instance.ApplySliderStyle(val7, new Vector2(14f, 18f));
			}
			catch
			{
			}
			((UnityEvent<float>)(object)val7.onValueChanged).AddListener(onChanged);
			sliders[crop] = val7;
			return val;
		}

		internal static void AddButton(Transform parent, string label, ref float y, UnityAction action)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			((UnityEvent)GUIManager.Instance.CreateButton(label, parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), 300f, 28f).GetComponentInChildren<Button>().onClick).AddListener(action);
			y -= 32f;
		}
	}
}
namespace ValheimFarmerNPC.Resolvers
{
	internal static class ChestResolver
	{
		public static Container ResolveNearest(HomesteadData data, Vector3 from)
		{
			//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)
			if (data == null)
			{
				return null;
			}
			data.SyncChestListsFromCsv();
			return (from c in ChestAssignments.ResolveFromPositions(data.ChestPositions)
				orderby Vector3.Distance(@from, ((Component)c).transform.position)
				select c).FirstOrDefault();
		}

		public static bool IsValid(Container container)
		{
			if ((Object)(object)container != (Object)null)
			{
				return container.GetInventory() != null;
			}
			return false;
		}
	}
	internal enum CropResolveStatus
	{
		Missing,
		Growing,
		Ready,
		WrongCrop,
		Destroyed
	}
	internal readonly struct CropResolveResult
	{
		public readonly CropResolveStatus Status;

		public readonly Pickable Pickable;

		public readonly Plant Plant;

		public CropResolveResult(CropResolveStatus status, Pickable pickable = null, Plant plant = null)
		{
			Status = status;
			Pickable = pickable;
			Plant = plant;
		}
	}
	internal static class CropResolver
	{
		public static CropResolveResult Resolve(FarmSlot slot)
		{
			//IL_000d: 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)
			if (slot == null)
			{
				return new CropResolveResult(CropResolveStatus.Missing);
			}
			Pickable val = FarmScanner.FindPickableAt(slot.Position);
			if ((Object)(object)val != (Object)null)
			{
				if (val.m_picked)
				{
					return new CropResolveResult(CropResolveStatus.Destroyed);
				}
				return new CropResolveResult(CropResolveStatus.Ready, val);
			}
			Plant val2 = FarmScanner.FindPlantAt(slot.Position);
			if ((Object)(object)val2 != (Object)null)
			{
				return new CropResolveResult(CropResolveStatus.Growing, null, val2);
			}
			return new CropResolveResult(CropResolveStatus.Missing);
		}
	}
	internal static class SlotResolver
	{
		public static FarmSlot ById(HomesteadData data, string slotId)
		{
			if (data?.Slots == null || string.IsNullOrEmpty(slotId))
			{
				return null;
			}
			return data.Slots.FirstOrDefault((FarmSlot s) => s != null && s.Id == slotId);
		}

		public static FarmSlot Nearest(HomesteadData data, Vector3 from, Func<FarmSlot, bool> predicate)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (data?.Slots == null)
			{
				return null;
			}
			return (from s in data.Slots
				where s != null && (predicate == null || predicate(s))
				orderby Vector3.Distance(@from, s.Position)
				select s).FirstOrDefault();
		}
	}
}
namespace ValheimFarmerNPC.Registration
{
	internal static class ItemRegistrar
	{
		public static void Register()
		{
			Log.Debug("ItemRegistrar: no custom items in MVP");
		}
	}
	internal static class NpcRegistrar
	{
		private static bool _registered;

		public static void Register()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (_registered)
			{
				return;
			}
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("FarmerNpc", "Goblin");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Failed to clone NPC from Goblin");
				return;
			}
			MonsterAI[] componentsInChildren = val.GetComponentsInChildren<MonsterAI>(true);
			foreach (MonsterAI val2 in componentsInChildren)
			{
				((Behaviour)val2).enabled = false;
				try
				{
					val2.m_enableHuntPlayer = false;
				}
				catch
				{
				}
			}
			BaseAI[] componentsInChildren2 = val.GetComponentsInChildren<BaseAI>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				((Behaviour)componentsInChildren2[i]).enabled = false;
			}
			CharacterDrop component = val.GetComponent<CharacterDrop>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			Character component2 = val.GetComponent<Character>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_name = "$fj_npc_name";
				component2.m_faction = (Faction)0;
				component2.m_group = "farmer_npc";
				component2.m_boss = false;
			}
			Humanoid component3 = val.GetComponent<Humanoid>();
			if ((Object)(object)component3 != (Object)null)
			{
				((Character)component3).m_faction = (Faction)0;
			}
			if ((Object)(object)val.GetComponent<FarmerNpc>() == (Object)null)
			{
				val.AddComponent<FarmerNpc>();
			}
			ZNetView component4 = val.GetComponent<ZNetView>();
			if ((Object)(object)component4 != (Object)null)
			{
				component4.m_persistent = true;
				component4.m_distant = false;
			}
			PrefabManager.Instance.AddPrefab(val);
			_registered = true;
			Log.Info("NPC prefab 'FarmerNpc' registered (clone of Goblin)");
		}
	}
	internal static class PieceRegistrar
	{
		private static bool _registered;

		public static void Register()
		{
			if (!_registered)
			{
				RegisterHomestead();
				RegisterBoundaryPost();
				_registered = true;
				Log.Info("Custom pieces registered");
			}
		}

		private static void RegisterHomestead()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("FarmerHomestead", "piece_workbench");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Failed to clone homestead from piece_workbench");
				return;
			}
			StripComponent<MapTable>(val);
			StripComponent<CraftingStation>(val);
			StripComponent<StationExtension>(val);
			StripComponent<CircleProjector>(val);
			if ((Object)(object)val.GetComponent<FarmerHomestead>() == (Object)null)
			{
				val.AddComponent<FarmerHomestead>();
			}
			Piece component = val.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = "$piece_farmerhomestead";
				component.m_description = "$piece_farmerhomestead_desc";
				component.m_craftingStation = null;
			}
			PieceConfig val2 = new PieceConfig
			{
				Name = "$piece_farmerhomestead",
				Description = "$piece_farmerhomestead_desc",
				PieceTable = PieceTables.Hammer,
				Category = PieceCategories.Misc
			};
			val2.AddRequirement(new RequirementConfig("Wood", 10, 0, true));
			val2.AddRequirement(new RequirementConfig("Stone", 5, 0, true));
			PieceManager.Instance.AddPiece(new CustomPiece(val, false, val2));
		}

		private static void RegisterBoundaryPost()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0096: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("FarmBoundaryPost", "wood_pole");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Failed to clone boundary post from wood_pole");
				return;
			}
			if ((Object)(object)val.GetComponent<BoundaryPost>() == (Object)null)
			{
				val.AddComponent<BoundaryPost>();
			}
			Piece component = val.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = "$piece_farmboundarypost";
				component.m_description = "$piece_farmboundarypost_desc";
			}
			PieceConfig val2 = new PieceConfig
			{
				Name = "$piece_farmboundarypost",
				Description = "$piece_farmboundarypost_desc",
				PieceTable = PieceTables.Hammer,
				Category = PieceCategories.Misc
			};
			val2.AddRequirement(new RequirementConfig("Wood", 2, 0, true));
			PieceManager.Instance.AddPiece(new CustomPiece(val, false, val2));
		}

		private static void StripComponent<T>(GameObject prefab) where T : Component
		{
			T[] array = prefab.GetComponentsInChildren<T>(true).ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)array[i]);
			}
		}
	}
}
namespace ValheimFarmerNPC.Pieces
{
	public class BoundaryPost : MonoBehaviour
	{
		private ZNetView _nview;

		private void Awake()
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
		}

		public long GetKey()
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return 0L;
			}
			return ZdoIds.ZdoKey(_nview.GetZDO());
		}

		public string GetHoverText()
		{
			return Localization.instance.Localize("$piece_farmboundarypost");
		}
	}
	internal static class FarmerCleanup
	{
		public const string ZdoMarker = "fj_farmer";

		public static void MarkAsFarmer(ZDO zdo)
		{
			FarmerDestroyer.MarkAsFarmer(zdo);
		}

		public static void Register(ZDOID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			FarmerDestroyer.Register(id);
		}

		public static bool LooksLikeFarmerCharacter(Character character)
		{
			return FarmerIdentity.LooksLikeFarmerCharacter(character);
		}

		public static List<ZDOID> CollectLocalFarmerIds(Vector3 pos, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmerDestroyer.CollectLocalFarmerIds(pos, range);
		}

		public static int DestroyLocalFarmerViews(Vector3 pos, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmerDestroyer.DestroyLocalFarmerViews(pos, range);
		}

		public static int ClearNear(Vector3 pos, float range, bool keepOne, List<ZDOID> extraIds = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmerDestroyer.ClearNear(pos, range, keepOne, extraIds);
		}

		public static bool DestroyById(ZDOID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmerDestroyer.DestroyById(id);
		}
	}
	public class FarmerHomestead : MonoBehaviour, Hoverable, Interactable
	{
		private static readonly List<FarmerHomestead> Instances = new List<FarmerHomestead>();

		private ZNetView _nview;

		private HomesteadData _data;

		private FarmerNpc _npc;

		private InventoryManager _pendingInventory;

		private bool _initialized;

		private bool _rpcsRegistered;

		private float _initRetryLogTimer;

		private bool _starterPending;

		private float _starterNextTry;

		private int _starterAttempts;

		public HomesteadData Data => _data;

		public ZNetView NetView => _nview;

		public long HomesteadKey
		{
			get
			{
				if (!((Object)(object)_nview != (Object)null) || !_nview.IsValid())
				{
					return 0L;
				}
				return ZdoIds.ZdoKey(_nview.GetZDO());
			}
		}

		public bool IsReady
		{
			get
			{
				if (_initialized && (Object)(object)_nview != (Object)null)
				{
					return _nview.IsValid();
				}
				return false;
			}
		}

		public static IReadOnlyList<FarmerHomestead> All => Instances;

		private void Awake()
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
			Instances.Add(this);
		}

		private void Start()
		{
			TryInitialize();
		}

		private void Update()
		{
			if (!_initialized)
			{
				TryInitialize();
			}
			else if (_starterPending && Time.time >= _starterNextTry)
			{
				_starterNextTry = Time.time + 0.5f;
				EnsureStarterFarmer();
			}
		}

		public bool TryInitialize()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (_initialized)
			{
				return true;
			}
			if ((Object)(object)_nview == (Object)null)
			{
				_nview = ((Component)this).GetComponent<ZNetView>();
			}
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				_initRetryLogTimer += Time.deltaTime;
				if (_initRetryLogTimer >= 2f)
				{
					_initRetryLogTimer = 0f;
					Log.Debug("FarmerHomestead waiting for valid ZNetView...");
				}
				return false;
			}
			try
			{
				if (!_rpcsRegistered)
				{
					RegisterRpcs();
					_rpcsRegistered = true;
				}
				if (_data == null)
				{
					_data = SaveManager.Load(_nview);
					_pendingInventory = new InventoryManager();
					_pendingInventory.LoadFrom(_data);
				}
				BiomeCropRules.ApplyToData(_data, ((Component)this).transform.position);
				_initialized = true;
				Log.Info($"FarmerHomestead initialized (server={AdminUtil.IsServer()}, owner={_nview.IsOwner()})");
				EnsureStarterFarmer();
				return true;
			}
			catch (Exception arg)
			{
				Log.Error($"FarmerHomestead init failed: {arg}");
				return false;
			}
		}

		private void EnsureStarterFarmer()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				_starterPending = true;
				return;
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO == null || !zDO.IsValid())
			{
				_starterPending = true;
				return;
			}
			if (zDO.GetInt("fj_initial_npc", 0) == 1)
			{
				_starterPending = false;
				return;
			}
			if (FarmerRoster.CountNear(((Component)this).transform.position, 12f) == 0)
			{
				FarmerNpc farmerNpc = HomesteadFarmerOps.SpawnAdditional(((Component)this).transform.position, ((Component)this).transform.rotation, this);
				if (!((Object)(object)farmerNpc != (Object)null))
				{
					_starterAttempts++;
					_starterPending = _starterAttempts < 30;
					if (!_starterPending)
					{
						Log.Warning("EnsureStarterFarmer: gave up after retries (use Add Farmer)");
					}
					else
					{
						Log.Debug($"EnsureStarterFarmer: spawn not ready yet (attempt {_starterAttempts})");
					}
					return;
				}
				_npc = farmerNpc;
				ZNetView component = ((Component)farmerNpc).GetComponent<ZNetView>();
				if (component != null && component.IsValid())
				{
					EnsureData();
					if (_data != null)
					{
						_data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
					}
				}
			}
			int num = FarmerRoster.CountNear(((Component)this).transform.position, 12f);
			if (num <= 0)
			{
				_starterPending = true;
				return;
			}
			_starterPending = false;
			if (_nview.IsOwner())
			{
				zDO.Set("fj_initial_npc", 1);
				Persist();
			}
			PlayerFeedback.Notify($"Farmer ready ({num} total)");
			Log.Info($"EnsureStarterFarmer done farmers={num}");
		}

		private void OnDestroy()
		{
			Instances.Remove(this);
			if (AdminUtil.IsServer() && !((Object)(object)Game.instance == (Object)null) && !((Object)(object)ZNetScene.instance == (Object)null))
			{
				HandleRemoval();
			}
		}

		private void RegisterRpcs()
		{
			_nview.Register<bool>("FJ_SetPaused", (Action<long, bool>)RPC_SetPaused);
			_nview.Register("FJ_TogglePause", (Action<long>)RPC_TogglePause);
			_nview.Register("FJ_ScanField", (Action<long>)RPC_ScanField);
			_nview.Register("FJ_AssignBoundary", (Action<long>)RPC_AssignBoundary);
			_nview.Register("FJ_AssignChest", (Action<long>)RPC_AssignChest);
			_nview.Register<string>("FJ_SetLayoutMode", (Action<long, string>)RPC_SetLayoutMode);
			_nview.Register<string>("FJ_UpdateCropConfig", (Action<long, string>)RPC_UpdateCropConfig);
			_nview.Register("FJ_ClearChests", (Action<long>)RPC_ClearChests);
			_nview.Register("FJ_ClearField", (Action<long>)RPC_ClearField);
			_nview.Register("FJ_EnsureNpc", (Action<long>)RPC_EnsureNpc);
		}

		public void Persist()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (_data == null || (Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return;
			}
			List<FarmerNpc> list = FarmerRoster.ListNear(((Component)this).transform.position);
			if (list.Count > 0)
			{
				_data.CarriedItems = HomesteadStock.Aggregate(list.ConvertAll((FarmerNpc f) => f.Inventory));
				_npc = list[0];
				_data.NpcZdoKey = _npc.ZdoKey;
			}
			else if (_pendingInventory != null)
			{
				_pendingInventory.SaveTo(_data);
			}
			else if ((Object)(object)_npc != (Object)null)
			{
				_npc.Inventory.SaveTo(_data);
				_data.NpcZdoKey = _npc.ZdoKey;
			}
			SaveManager.Save(_nview, _data);
		}

		public int CountFarmers()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return FarmerRoster.CountNear(((Component)this).transform.position);
		}

		public List<CarriedItem> GetAggregatedCarriedItems()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			List<FarmerNpc> list = FarmerRoster.ListNear(((Component)this).transform.position);
			if (list.Count > 0)
			{
				List<CarriedItem> list2 = HomesteadStock.Aggregate(list.ConvertAll((FarmerNpc f) => f.Inventory));
				if (list2.Count > 0)
				{
					return list2;
				}
			}
			if (_data?.CarriedItems == null)
			{
				return new List<CarriedItem>();
			}
			return (from i in _data.CarriedItems
				where i != null && !string.IsNullOrEmpty(i.Prefab) && i.Stack > 0
				select new CarriedItem
				{
					Prefab = i.Prefab,
					Stack = i.Stack,
					Quality = i.Quality,
					Variant = i.Variant,
					Durability = i.Durability
				}).ToList();
		}

		public List<CarriedItem> GetAggregatedChestItems()
		{
			ReloadDataFromZdo();
			EnsureData();
			_data?.SyncChestListsFromCsv();
			return HomesteadStock.AggregateItemsFromChests(_data?.ChestPositions);
		}

		public void AttachExistingNpc(FarmerNpc npc)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)npc == (Object)null))
			{
				_npc = npc;
				ReloadDataFromZdo();
				EnsureData();
				int num = FarmerRoster.CountNear(((Component)this).transform.position);
				if (num <= 1 && _npc.Inventory.UsedSlots == 0 && _data != null)
				{
					_npc.Inventory.LoadFrom(_data);
				}
				Log.Info($"AttachExistingNpc slots={(_data?.Slots?.Count).GetValueOrDefault()} paused={_data?.Paused} farmers={num}");
			}
		}

		public void TrySpawnNpc()
		{
			//IL_0025: 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)
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				Log.Warning("TrySpawnNpc: no homestead data");
				return;
			}
			FarmerNpc farmerNpc = FarmerSpawner.TrySpawnNearHomestead(((Component)this).transform.position, ((Component)this).transform.rotation, this);
			if (!((Object)(object)farmerNpc == (Object)null))
			{
				_npc = farmerNpc;
				ZNetView component = ((Component)_npc).GetComponent<ZNetView>();
				if (component != null && component.IsValid())
				{
					_data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
				}
				Log.Info($"TrySpawnNpc done slots={_data.Slots?.Count ?? 0} paused={_data.Paused} farmers={CountFarmers()}");
			}
		}

		public void TryAddFarmer()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _data != null && !_data.Paused;
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				return;
			}
			if (flag)
			{
				_data.Paused = false;
			}
			FarmerNpc farmerNpc = HomesteadFarmerOps.SpawnAdditional(((Component)this).transform.position, ((Component)this).transform.rotation, this);
			if ((Object)(object)farmerNpc == (Object)null)
			{
				PlayerFeedback.Notify("Could not add farmer (max reached?)");
				return;
			}
			_npc = farmerNpc;
			if (!_data.Paused)
			{
				farmerNpc.ActivateForWork();
			}
			Persist();
			PlayerFeedback.Notify($"Farmer added ({CountFarmers()} total)");
			Log.Info($"TryAddFarmer total={CountFarmers()}");
		}

		public bool TryRemoveFarmer()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			if (!HomesteadFarmerOps.TryRemoveOne(((Component)this).transform.position, _data, _npc, out var newPrimary, out var _))
			{
				PlayerFeedback.Notify("No farmers to remove");
				return false;
			}
			_npc = newPrimary;
			Persist();
			PlayerFeedback.Notify($"Farmer removed ({CountFarmers()} left)");
			Log.Info($"TryRemoveFarmer remaining={CountFarmers()}");
			return true;
		}

		private void HandleRemoval()
		{
			//IL_0030: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			ReservationManager.ReleaseAllForHomestead(HomesteadKey);
			bool blocked;
			if ((Object)(object)_npc != (Object)null)
			{
				ChestLogistics.TryDepositSurplus(_npc.Inventory, _data, ((Component)this).transform.position, out blocked);
				_npc.Inventory.DropAllAt(((Component)this).transform.position);
				_npc.UnbindAndDestroy();
				_npc = null;
			}
			else if (_pendingInventory != null)
			{
				ChestLogistics.TryDepositSurplus(_pendingInventory, _data, ((Component)this).transform.position, out blocked);
				_pendingInventory.DropAllAt(((Component)this).transform.position);
			}
			_data = null;
		}

		private static int CountActiveFarmers()
		{
			return FarmerNpc.ActiveCount;
		}

		public string GetHoverText()
		{
			TryInitialize();
			string text = ((_data != null && _data.Paused) ? "Paused" : "Active");
			int valueOrDefault = (_data?.Slots?.Count).GetValueOrDefault();
			int num = CountFarmers();
			string text2 = (AdminUtil.LocalPlayerCanAccess() ? "\n[<color=yellow><b>E</b></color>] Open farmer panel" : "");
			return Localization.instance.Localize($"$piece_farmerhomestead\nStatus: {text} | Farmers: {num} | Slots: {valueOrDefault}{text2}");
		}

		public string GetHoverName()
		{
			return Localization.instance.Localize("$piece_farmerhomestead");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold)
			{
				return false;
			}
			TryInitialize();
			if (!AdminUtil.LocalPlayerCanAccess())
			{
				PlayerFeedback.Notify(user, "Admin only");
				return true;
			}
			HomesteadUI.Show(this);
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		private bool CanApplyLocally()
		{
			return AdminUtil.IsServer();
		}

		private void GetZdoIdentity(out long userId, out uint id)
		{
			userId = 0L;
			id = 0u;
			if ((Object)(object)_nview != (Object)null && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				if (zDO != null)
				{
					userId = ((ZDOID)(ref zDO.m_uid)).UserID;
					id = ((ZDOID)(ref zDO.m_uid)).ID;
				}
			}
		}

		public void RequestTogglePause()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			EnsureData();
			bool flag = _data != null && _data.Paused;
			if (flag && !TryUnpauseWithDepositCheck())
			{
				return;
			}
			if (CanApplyLocally())
			{
				ApplyTogglePause();
				return;
			}
			GetZdoIdentity(out var userId, out var id);
			PlayerFeedback.Notify(flag ? "Resuming farmer..." : "Pausing farmer...");
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "toggle_pause", userId, id);
			_data.Paused = !flag;
			if (flag)
			{
				BindExistingNpcOnly();
			}
		}

		public void RequestPauseChestsFull()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			EnsureData();
			if (_data == null || !_data.Paused)
			{
				PlayerFeedback.Notify("Chests full — farmers paused. Free space or add a chest, then unpause.");
				if (CanApplyLocally())
				{
					ApplySetPaused(paused: true);
					return;
				}
				_data.Paused = true;
				GetZdoIdentity(out var userId, out var id);
				RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "pause_chests_full", userId, id);
			}
		}

		public bool TryUnpauseWithDepositCheck()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			if (!HomesteadOps.TryUnpauseWithDepositCheck(_data, ((Component)this).transform.position, _pendingInventory))
			{
				Persist();
				PlayerFeedback.Notify("Chests full — farmers paused. Free space or add a chest, then unpause.");
				Log.Info("Unpause aborted: chests still full");
				return false;
			}
			return true;
		}

		public void TryDepositSurplusAll(out bool blocked)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			HomesteadOps.DepositSurplusAll(_data, ((Component)this).transform.position, out blocked, _pendingInventory);
		}

		public void RequestSetPaused(bool paused)
		{
			Dispatch(delegate
			{
				ApplySetPaused(paused);
			}, "FJ_SetPaused", paused);
		}

		public void RequestScan()
		{
			EnsureData();
			if (CanApplyLocally())
			{
				ApplyScan();
			}
			else
			{
				ScanAndSendToServer(clearFirst: false);
			}
		}

		public void RequestClearAndScan()
		{
			EnsureData();
			if (CanApplyLocally())
			{
				ApplyClearAndScan();
			}
			else
			{
				ScanAndSendToServer(clearFirst: true);
			}
		}

		private void ScanAndSendToServer(bool clearFirst)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				PlayerFeedback.Notify("Scan failed: no homestead data");
				return;
			}
			if (!_data.HasBoundary)
			{
				PlayerFeedback.Notify("Assign Boundary Posts before scanning");
				return;
			}
			int num = 0;
			if (clearFirst)
			{
				num = _data.Slots?.Count ?? 0;
				_data.Slots?.Clear();
			}
			FarmScanner.ScanResult scanResult = HomesteadOps.Scan(_data, ((Component)this).transform.position);
			Persist();
			string csv = HomesteadCodecs.EncodeSlots(_data.Slots);
			GetZdoIdentity(out var userId, out var id);
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "apply_slots", userId, id, delegate(ZPackage pkg)
			{
				pkg.Write(csv ?? "");
			});
			string text = (string.IsNullOrEmpty(scanResult.Message) ? "" : (" (" + scanResult.Message + ")"));
			if (clearFirst)
			{
				PlayerFeedback.Notify($"Cleared {num}, scan +{scanResult.Added} total {scanResult.Total}{text}");
			}
			else
			{
				PlayerFeedback.Notify($"Scan: +{scanResult.Added} -{scanResult.Removed} total {scanResult.Total}{text}");
			}
			Log.Info($"Client scan sent to server clear={clearFirst} +{scanResult.Added} total={scanResult.Total} ({scanResult.Message})");
		}

		public void RequestClearField()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (CanApplyLocally())
			{
				ApplyClearField();
				return;
			}
			EnsureData();
			int num = _data.Slots?.Count ?? 0;
			_data.Slots?.Clear();
			GetZdoIdentity(out var userId, out var id);
			PlayerFeedback.Notify($"Clearing field ({num} slots)...");
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "clear_field", userId, id);
		}

		public void RequestAssignBoundary()
		{
			//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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			List<BoundaryPost> list = (from p in Object.FindObjectsOfType<BoundaryPost>()
				orderby Vector3.Distance(((Component)p).transform.position, ((Component)this).transform.position)
				select p).Take(2).ToList();
			if (list.Count < 2)
			{
				PlayerFeedback.Notify("Need 2 boundary posts nearby");
				return;
			}
			Vector3 a = ((Component)list[0]).transform.position;
			Vector3 b = ((Component)list[1]).transform.position;
			if (CanApplyLocally())
			{
				EnsureData();
				HomesteadOps.AssignBoundary(_data, a, b, list[0].GetKey(), list[1].GetKey());
				Persist();
				float num = Mathf.Abs(a.x - b.x);
				float num2 = Mathf.Abs(a.z - b.z);
				PlayerFeedback.Notify($"Boundary assigned ({num:F1}m x {num2:F1}m)");
				return;
			}
			EnsureData();
			HomesteadOps.AssignBoundary(_data, a, b, list[0].GetKey(), list[1].GetKey());
			GetZdoIdentity(out var userId, out var id);
			float num3 = Mathf.Abs(a.x - b.x);
			float num4 = Mathf.Abs(a.z - b.z);
			PlayerFeedback.Notify($"Boundary sent ({num3:F1}m x {num4:F1}m)...");
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "boundary", userId, id, delegate(ZPackage pkg)
			{
				pkg.Write(a.x);
				pkg.Write(a.y);
				pkg.Write(a.z);
				pkg.Write(b.x);
				pkg.Write(b.y);
				pkg.Write(b.z);
			});
		}

		public void RequestSetLayoutMode(string mode)
		{
			Dispatch(delegate
			{
				ApplySetLayoutMode(mode);
			}, "FJ_SetLayoutMode", mode);
		}

		public void RequestClearChests()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (CanApplyLocally())
			{
				ApplyClearChests();
				return;
			}
			EnsureData();
			HomesteadOps.ClearChests(_data);
			GetZdoIdentity(out var userId, out var id);
			PlayerFeedback.Notify("Clearing chests...");
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "clear_chests", userId, id);
		}

		public void RequestClearFarmers()
		{
			//IL_000d: 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_00af: 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)
			List<ZDOID> localIds = FarmerCleanup.CollectLocalFarmerIds(((Component)this).transform.position, 50f);
			int num = FarmerCleanup.DestroyLocalFarmerViews(((Component)this).transform.position, 50f);
			if (CanApplyLocally())
			{
				int num2 = FarmerCleanup.ClearNear(((Component)this).transform.position, 50f, keepOne: false, localIds);
				PlayerFeedback.Notify($"Cleared nearby farmers ({num2}, local {num})");
				return;
			}
			GetZdoIdentity(out var userId, out var id);
			PlayerFeedback.Notify($"Clearing farmers (local {num}, reporting {localIds.Count} ids)...");
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "clear_farmers", userId, id, delegate(ZPackage pkg)
			{
				//IL_0021: 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)
				pkg.Write(localIds.Count);
				foreach (ZDOID item in localIds)
				{
					ZDOID current = item;
					pkg.Write(((ZDOID)(ref current)).UserID);
					pkg.Write(((ZDOID)(ref current)).ID);
				}
			});
		}

		public void RequestUpdateCropConfig(string encoded)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			ApplyUpdateCropConfig(encoded);
			if (!CanApplyLocally())
			{
				GetZdoIdentity(out var userId, out var id);
				RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "crop_config", userId, id, delegate(ZPackage pkg)
				{
					pkg.Write(encoded);
				});
			}
		}

		public void RequestSetCropWeight(string family, int weight)
		{
			EnsureData();
			CropConfigEntry cropConfigEntry = _data.GetCropConfig(family);
			if (cropConfigEntry == null)
			{
				cropConfigEntry = new CropConfigEntry
				{
					Family = family
				};
				_data.CropConfigs.Add(cropConfigEntry);
			}
			string encoded = $"{family}|{(cropConfigEntry.Enabled ? 1 : 0)}|{Mathf.Clamp(weight, 0, 100)}|" + $"{(cropConfigEntry.HarvestEnabled ? 1 : 0)}|{(cropConfigEntry.PlantEnabled ? 1 : 0)}|" + $"{cropConfigEntry.MinimumSeedReserve}|{cropConfigEntry.MaximumSeedPercent}";
			RequestUpdateCropConfig(encoded);
		}

		public void RequestSetCropReserve(string family, int reserve)
		{
			EnsureData();
			CropConfigEntry cropConfigEntry = _data.GetCropConfig(family);
			if (cropConfigEntry == null)
			{
				cropConfigEntry = new CropConfigEntry
				{
					Family = family
				};
				_data.CropConfigs.Add(cropConfigEntry);
			}
			string encoded = $"{family}|{(cropConfigEntry.Enabled ? 1 : 0)}|{cropConfigEntry.Weight}|" + $"{(cropConfigEntry.HarvestEnabled ? 1 : 0)}|{(cropConfigEntry.PlantEnabled ? 1 : 0)}|" + $"{Mathf.Clamp(reserve, 0, 100)}|{cropConfigEntry.MaximumSeedPercent}";
			RequestUpdateCropConfig(encoded);
		}

		public void RequestAssignChest()
		{
			//IL_0030: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			ReloadDataFromZdo();
			EnsureData();
			_data.SyncChestListsFromCsv();
			float chestAssignRange = SyncedConfig.ChestAssignRange;
			Container val = HomesteadOps.FindNearestUnassignedChest(_data, ((Component)this).transform.position, chestAssignRange);
			if ((Object)(object)val == (Object)null)
			{
				PlayerFeedback.Notify(HomesteadOps.BuildNoFreeChestMessage(((Component)this).transform.position, _data, chestAssignRange));
				return;
			}
			Vector3 position = ((Component)val).transform.position;
			if (CanApplyLocally())
			{
				ServerAssignChestAt(position);
				return;
			}
			if (!HomesteadOps.TryAssignChest(_data, position))
			{
				PlayerFeedback.Notify(HomesteadOps.BuildNoFreeChestMessage(((Component)this).transform.position, _data, chestAssignRange));
				return;
			}
			Persist();
			GetZdoIdentity(out var userId, out var id);
			PlayerFeedback.Notify(string.Format("Chest #{0} assigned ({1})", _data.ChestCount, ((Object)val).name.Replace("(Clone)", "").Trim()));
			Log.Info($"Client chest assign at {position} prefab={((Object)val).name} total={_data.ChestCount}");
			RpcMessages.RequestAssignChest(((Component)this).transform.position, position, userId, id);
		}

		public void ServerAssignChestAt(Vector3 chestPos)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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)
			ReloadDataFromZdo();
			EnsureData();
			if (!HomesteadOps.TryAssignChest(_data, chestPos))
			{
				Log.Info($"Chest assign rejected (already used) at {chestPos}");
				PlayerFeedback.Notify(HomesteadOps.BuildNoFreeChestMessage(((Component)this).transform.position, _data, SyncedConfig.ChestAssignRange));
			}
			else
			{
				Persist();
				Log.Info($"Chest assigned at {chestPos} total={_data.ChestCount}");
				PlayerFeedback.Notify($"Chest #{_data.ChestCount} assigned");
			}
		}

		public void ServerApplyOp(string op, ZPackage pkg)
		{
			ReloadDataFromZdo();
			EnsureData();
			switch (op)
			{
			case "toggle_pause":
				ApplyTogglePause();
				break;
			case "pause_chests_full":
				ApplySetPaused(paused: true);
				break;
			case "scan":
				ApplyScan();
				break;
			case "clear_field":
				ApplyClearField();
				break;
			case "clear_scan":
				ApplyClearAndScan();
				break;
			case "boundary":
				ApplyAssignBoundary();
				break;
			case "clear_chests":
				ApplyClearChests();
				break;
			case "add_farmer":
				TryAddFarmer();
				break;
			case "remove_farmer":
				TryRemoveFarmer();
				break;
			case "deposit_all":
				TryForceDepositAll();
				break;
			default:
				Log.Warning("Unknown homestead op '" + op + "'");
				break;
			}
		}

		private void DispatchOrRoute(string op, Action apply, string rpc)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				Log.Warning("Dispatch " + rpc + ": ZNetView invalid");
				return;
			}
			if (CanApplyLocally())
			{
				apply();
				return;
			}
			GetZdoIdentity(out var userId, out var id);
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, op, userId, id);
		}

		private void Dispatch(Action apply, string rpc)
		{
			TryInitialize();
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				Log.Warning("Dispatch " + rpc + ": ZNetView invalid");
			}
			else if (CanApplyLocally())
			{
				apply();
			}
			else
			{
				_nview.InvokeRPC(rpc, Array.Empty<object>());
			}
		}

		private void Dispatch(Action apply, string rpc, bool arg)
		{
			TryInitialize();
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				Log.Warning("Dispatch " + rpc + ": ZNetView invalid");
				return;
			}
			if (CanApplyLocally())
			{
				apply();
				return;
			}
			_nview.InvokeRPC(rpc, new object[1] { arg });
		}

		private void Dispatch(Action apply, string rpc, string arg)
		{
			TryInitialize();
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				Log.Warning("Dispatch " + rpc + ": ZNetView invalid");
				return;
			}
			if (CanApplyLocally())
			{
				apply();
				return;
			}
			_nview.InvokeRPC(rpc, new object[1] { arg });
		}

		private void RPC_TogglePause(long sender)
		{
			Guarded(sender, ApplyTogglePause);
		}

		private void RPC_SetPaused(long sender, bool paused)
		{
			Guarded(sender, delegate
			{
				ApplySetPaused(paused);
			});
		}

		private void RPC_ScanField(long sender)
		{
			Guarded(sender, ApplyScan);
		}

		private void RPC_ClearField(long sender)
		{
			Guarded(sender, ApplyClearField);
		}

		private void RPC_AssignBoundary(long sender)
		{
			Guarded(sender, ApplyAssignBoundary);
		}

		private void RPC_AssignChest(long sender)
		{
			Guarded(sender, ApplyAssignChest);
		}

		private void RPC_SetLayoutMode(long sender, string mode)
		{
			Guarded(sender, delegate
			{
				ApplySetLayoutMode(mode);
			});
		}

		private void RPC_UpdateCropConfig(long sender, string encoded)
		{
			Guarded(sender, delegate
			{
				ApplyUpdateCropConfig(encoded);
			});
		}

		private void RPC_ClearChests(long sender)
		{
			Guarded(sender, ApplyClearChests);
		}

		private void Guarded(long sender, Action action)
		{
			TryInitialize();
			if (Authority.ValidateAdminRequest(sender, "homestead"))
			{
				action?.Invoke();
			}
		}

		private void ApplyTogglePause()
		{
			EnsureData();
			ApplySetPaused(!_data.Paused);
		}

		private void ApplySetPaused(bool paused)
		{
			EnsureData();
			if (paused || TryUnpauseWithDepositCheck())
			{
				HomesteadOps.SetPaused(_data, paused);
				Persist();
				Log.Info($"Homestead {HomesteadKey} paused={paused}");
				if (!paused)
				{
					BindExistingNpcOnly();
				}
			}
		}

		public void RequestEnsureNpc()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			TrySpawnNpc();
			if ((Object)(object)_npc == (Object)null && CountFarmers() == 0)
			{
				RpcMessages.EnsureRoutedRegistered();
				long zdoUserId = 0L;
				uint zdoId = 0u;
				if ((Object)(object)_nview != (Object)null && _nview.IsValid())
				{
					ZDO zDO = _nview.GetZDO();
					if (zDO != null)
					{
						zdoUserId = ((ZDOID)(ref zDO.m_uid)).UserID;
						zdoId = ((ZDOID)(ref zDO.m_uid)).ID;
					}
				}
				RpcMessages.RequestEnsureNpcAt(((Component)this).transform.position, zdoUserId, zdoId);
				PlayerFeedback.Notify("Requesting farmer summon...");
			}
			else
			{
				PlayerFeedback.Notify($"Farmers: {CountFarmers()} (use Add Farmer for more)");
			}
		}

		public void RequestAddFarmer()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (CanApplyLocally())
			{
				TryAddFarmer();
				return;
			}
			GetZdoIdentity(out var userId, out var id);
			TryAddFarmer();
			if (CountFarmers() == 0)
			{
				PlayerFeedback.Notify("Adding farmer...");
				RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "add_farmer", userId, id);
			}
		}

		public void RequestRemoveFarmer()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (CanApplyLocally())
			{
				TryRemoveFarmer();
			}
			else if (!TryRemoveFarmer())
			{
				GetZdoIdentity(out var userId, out var id);
				PlayerFeedback.Notify("Removing farmer...");
				RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "remove_farmer", userId, id);
			}
		}

		public void RequestForceDepositAll()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			TryForceDepositAll();
			if (!CanApplyLocally())
			{
				GetZdoIdentity(out var userId, out var id);
				RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "deposit_all", userId, id);
			}
		}

		public void TryForceDepositAll()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				PlayerFeedback.Notify("No homestead data");
				return;
			}
			HomesteadOps.DepositAllResult depositAllResult = HomesteadOps.ForceDepositAll(_data, ((Component)this).transform.position, _pendingInventory);
			if (depositAllResult.NoChests)
			{
				PlayerFeedback.Notify("Assign a chest first");
				return;
			}
			if (depositAllResult.NoFarmers)
			{
				PlayerFeedback.Notify("No farmers nearby to deposit");
				return;
			}
			Persist();
			if (depositAllResult.Blocked)
			{
				PlayerFeedback.Notify("Deposit All: chests full — some items remain on farmers");
			}
			else
			{
				PlayerFeedback.Notify($"Deposit All: emptied {depositAllResult.Emptied}/{depositAllResult.FarmerCount} farmer(s)");
			}
			Log.Info($"ForceDepositAll farmers={depositAllResult.FarmerCount} emptied={depositAllResult.Emptied} blocked={depositAllResult.Blocked}");
		}

		private void RPC_EnsureNpc(long sender)
		{
			TrySpawnNpc();
		}

		public void BindExistingNpcOnly()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				return;
			}
			FarmerNpc farmerNpc = HomesteadFarmerOps.FindNearest(((Component)this).transform.position, 64f);
			if ((Object)(object)farmerNpc == (Object)null)
			{
				PlayerFeedback.Notify("No farmer nearby — use Add Farmer");
				Log.Info($"Unpause: no existing farmer within 64m of {((Component)this).transform.position} (use Add Farmer)");
				return;
			}
			_npc = farmerNpc;
			farmerNpc.BindHomestead(this);
			farmerNpc.Inventory.LoadFrom(_data);
			ZNetView component = ((Component)farmerNpc).GetComponent<ZNetView>();
			if (component != null && component.IsValid())
			{
				_data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
			}
			if (_data != null && !_data.Paused)
			{
				List<FarmerNpc> list = FarmerRoster.ListNear(((Component)this).transform.position);
				for (int i = 0; i < list.Count; i++)
				{
					FarmerNpc farmerNpc2 = list[i];
					if (!((Object)(object)farmerNpc2 == (Object)null))
					{
						farmerNpc2.BindHomestead(this);
						farmerNpc2.ActivateForWork();
					}
				}
			}
			Log.Info($"Unpause: bound existing farmer at {((Component)farmerNpc).transform.position}");
		}

		private void ApplyScan()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			FarmScanner.ScanResult scanResult = HomesteadOps.Scan(_data, ((Component)this).transform.position);
			Persist();
			string text = (string.IsNullOrEmpty(scanResult.Message) ? "" : (" (" + scanResult.Message + ")"));
			PlayerFeedback.Notify($"Scan: +{scanResult.Added} -{scanResult.Removed} total {scanResult.Total}{text}");
		}

		private void ApplyClearField()
		{
			EnsureData();
			int num = HomesteadOps.ClearField(_data);
			Persist();
			PlayerFeedback.Notify($"Field cleared ({num} slots)");
			Log.Info($"Clear field removed {num} slots");
		}

		private void ApplyClearAndScan()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			int num = _data.Slots?.Count ?? 0;
			FarmScanner.ScanResult scanResult = HomesteadOps.ClearAndScan(_data, ((Component)this).transform.position);
			Persist();
			string text = (string.IsNullOrEmpty(scanResult.Message) ? "" : (" (" + scanResult.Message + ")"));
			PlayerFeedback.Notify($"Cleared {num}, scan +{scanResult.Added} total {scanResult.Total}{text}");
			Log.Info($"Clear+scan cleared={num} +{scanResult.Added} total={scanResult.Total}");
		}

		private void ApplyAssignBoundary()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_006c: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			if (!HomesteadOps.TryAssignBoundaryFromNearbyPosts(_data, ((Component)this).transform.position))
			{
				PlayerFeedback.Notify("Need 2 boundary posts nearby");
				return;
			}
			Persist();
			float num = Mathf.Abs(_data.PostA.x - _data.PostB.x);
			float num2 = Mathf.Abs(_data.PostA.z - _data.PostB.z);
			PlayerFeedback.Notify($"Boundary assigned ({num:F1}m x {num2:F1}m)");
			Log.Info($"Boundary assigned A={_data.PostA} B={_data.PostB} size=({num:F1},{num2:F1})");
		}

		private void ApplyAssignChest()
		{
			//IL_0018: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			float chestAssignRange = SyncedConfig.ChestAssignRange;
			Container val = HomesteadOps.FindNearestUnassignedChest(_data, ((Component)this).transform.position, chestAssignRange);
			if ((Object)(object)val == (Object)null)
			{
				PlayerFeedback.Notify(HomesteadOps.BuildNoFreeChestMessage(((Component)this).transform.position, _data, chestAssignRange));
			}
			else
			{
				ServerAssignChestAt(((Component)val).transform.position);
			}
		}

		private void ApplyClearChests()
		{
			EnsureData();
			HomesteadOps.ClearChests(_data);
			Persist();
			PlayerFeedback.Notify("Chest assignments cleared");
		}

		private void ApplySetLayoutMode(string mode)
		{
			EnsureData();
			HomesteadOps.SetLayoutMode(_data, mode);
			Persist();
			Log.Info("Layout mode set to " + _data.LayoutMode);
		}

		private void ApplyUpdateCropConfig(string encoded)
		{
			EnsureData();
			if (HomesteadOps.UpdateCropConfig(_data, encoded))
			{
				Persist();
			}
		}

		private void EnsureData()
		{
			if (_data == null)
			{
				_data = SaveManager.Load(_nview);
			}
		}

		public void ReloadDataFromZdo()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			if ((Object)(object)_nview != (Object)null && _nview.IsValid())
			{
				_data = SaveManager.Load(_nview);
				BiomeCropRules.ApplyToData(_data, ((Component)this).transform.position);
			}
		}
	}
	internal static class HomesteadLocator
	{
		public static FarmerHomestead FindNearest(Vector3 pos, float maxRange)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			FarmerHomestead result = null;
			float num = maxRange;
			foreach (FarmerHomestead item in FarmerHomestead.All)
			{
				if (!((Object)(object)item == (Object)null))
				{
					float num2 = Vector3.Distance(((Component)item).transform.position, pos);
					if (num2 < num)
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		public static FarmerHomestead ResolveNear(Vector3 pos, float maxRange = 12f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			FarmerHomestead farmerHomestead = FindNearest(pos, maxRange);
			if ((Object)(object)farmerHomestead != (Object)null)
			{
				return farmerHomestead;
			}
			return ForceCreateFromZdo(pos, maxRange);
		}

		private static FarmerHomestead ForceCreateFromZdo(Vector3 pos, float maxRange)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null || ZDOMan.instance == null)
			{
				return null;
			}
			if ((Object)(object)ZNetScene.instance.GetPrefab("FarmerHomestead") == (Object)null)
			{
				Log.Error("ForceCreateFromZdo: FarmerHomestead prefab missing from ZNetScene");
				return null;
			}
			List<ZDO> list = new List<ZDO>();
			HomesteadZdoBinder.TryCollectPrefab("FarmerHomestead", list);
			FarmerHomestead result = null;
			float num = maxRange;
			Log.Info($"ForceCreateFromZdo: found {list.Count} FarmerHomestead ZDO(s), searching near {pos}");
			foreach (ZDO item in list)
			{
				if (item == null || !item.IsValid())
				{
					continue;
				}
				Vector3 position = item.GetPosition();
				float num2 = Vector3.Distance(position, pos);
				if (num2 >= num)
				{
					continue;
				}
				GameObject val = ZNetScene.instance.FindInstance(item.m_uid);
				if ((Object)(object)val == (Object)null)
				{
					val = CreateObjectSafe(item);
					if ((Object)(object)val != (Object)null)
					{
						Log.Info($"Force-created Homestead GameObject from ZDO at {position}");
					}
				}
				if (!((Object)(object)val == (Object)null))
				{
					FarmerHomestead farmerHomestead = val.GetComponent<FarmerHomestead>();
					if ((Object)(object)farmerHomestead == (Object)null)
					{
						farmerHomestead = val.AddComponent<FarmerHomestead>();
						Log.Warning("Added missing FarmerHomestead component on force-created object");
					}
					num = num2;
					result = farmerHomestead;
				}
			}
			return result;
		}

		private static GameObject CreateObjectSafe(ZDO zdo)
		{
			if (zdo == null || !zdo.IsValid() || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(ZNetScene), "CreateObject", new Type[1] { typeof(ZDO) }, (Type[])null);
				if (methodInfo != null)
				{
					object? obj = methodInfo.Invoke(ZNetScene.instance, new object[1] { zdo });
					GameObject val = (GameObject)((obj is GameObject) ? obj : null);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
					Log.Warning($"ZNetScene.CreateObject returned null for {((ZDOID)(ref zdo.m_uid)).UserID}:{((ZDOID)(ref zdo.m_uid)).ID} prefabHash={zdo.GetPrefab()}");
				}
				else
				{
					Log.Warning("ZNetScene.CreateObject method not found via AccessTools");
				}
			}
			catch (Exception ex)
			{
				Log.Warning("ZNetScene.CreateObject failed: " + (ex.InnerException?.Message ?? ex.Message));
			}
			return ForceMaterializeFromZdo(zdo);
		}

		private static GameObject ForceMaterializeFromZdo(ZDO zdo)
		{
			//IL_0064: 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)
			try
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
				if ((Object)(object)prefab == (Object)null)
				{
					Log.Warning($"ForceMaterialize: no prefab for hash {zdo.GetPrefab()}");
					return null;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(ZNetView), "m_forceDisableInit");
				fieldInfo?.SetValue(null, true);
				GameObject val = Object.Instantiate<GameObject>(prefab, zdo.GetPosition(), zdo.GetRotation());
				fieldInfo?.SetValue(null, false);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				ZNetView component = val.GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null)
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				AccessTools.Field(typeof(ZNetView), "m_zdo")?.SetValue(component, zdo);
				ZNetScene.instance.AddInstance(zdo, component);
				zdo.SetOwner(ZDOMan.GetSessionID());
				component.m_persistent = true;
				component.m_distant = false;
				zdo.Persistent = true;
				zdo.SetDistant(false);
				FarmerCleanup.MarkAsFarmer(zdo);
				Log.Info($"ForceMaterialize bound ZDO {((ZDOID)(ref zdo.m_uid)).UserID}:{((ZDOID)(ref zdo.m_uid)).ID} to {((Object)val).name}");
				return val;
			}
			catch (Exception ex)
			{
				Log.Warning("ForceMaterialize failed: " + ex.Message);
				return null;
			}
		}

		internal static GameObject CreateObjectPublic(ZDO zdo)
		{
			return CreateObjectSafe(zdo);
		}

		public static IEnumerator RetryResolveAndSpawn(Vector3 pos, float maxRange, int attempts, float interval)
		{
			//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)
			for (int i = 0; i < attempts; i++)
			{
				FarmerHomestead farmerHomestead = ResolveNear(pos, maxRange);
				if ((Object)(object)farmerHomestead != (Object)null)
				{
					farmerHomestead.TryInitialize();
					farmerHomestead.TrySpawnNpc();
					Log.Info($"RetrySummon succeeded on attempt {i + 1} for homestead at {((Component)farmerHomestead).transform.position}");
					yield break;
				}
				if (i == 0 || i % 5 == 4)
				{
					Log.Warning($"RetrySummon attempt {i + 1}/{attempts}: still no homestead near {pos} (known={FarmerHomestead.All.Count})");
				}
				yield return (object)new WaitForSeconds(interval);
			}
			Log.Error($"RetrySummon gave up near {pos} after {attempts} attempts (known={FarmerHomestead.All.Count})");
		}
	}
	internal class HomesteadSession
	{
		private static readonly Dictionary<string, HomesteadSession> ByKey = new Dictionary<string, HomesteadSession>();

		private static readonly Dictionary<string, FarmerNpc> NpcsByKey = new Dictionary<string, FarmerNpc>();

		private float _nextReloadAt;

		private string _snapData = "";

		private string _snapSlots = "";

		private string _snapCarried = "";

		private string _snapCrops = "";

		private string _snapChests = "";

		public string Key { get; private set; }

		public Vector3 Position { get; private set; }

		public ZDO Zdo { get; private set; }

		public HomesteadData Data { get; private set; }

		public FarmerNpc Npc { get; private set; }

		public static string MakeKey(long userId, uint id)
		{
			return $"{userId}:{id}";
		}

		public static string MakeKey(Vector3 pos)
		{
			return "p:" + pos.x.ToString("F0", CultureInfo.InvariantCulture) + "_" + pos.z.ToString("F0", CultureInfo.InvariantCulture);
		}

		public static HomesteadSession GetOrCreate(long userId, uint zdoId, Vector3 pos)
		{
			//IL_0002: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			ZDO val = HomesteadZdoBinder.ResolveHomesteadZdo(userId, zdoId, pos);
			string text;
			if (val == null || !val.IsValid())
			{
				text = ((userId == 0L && zdoId == 0) ? MakeKey(pos) : MakeKey(userId, zdoId));
			}
			else
			{
				text = MakeKey(((ZDOID)(ref val.m_uid)).UserID, ((ZDOID)(ref val.m_uid)).ID);
				pos = val.GetPosition();
			}
			if (ByKey.TryGetValue(text, out var value) && value != null)
			{
				value.Position = pos;
				if (val != null)
				{
					value.AdoptZdo(val);
				}
				value.Reload();
				return value;
			}
			HomesteadSession homesteadSession = FindSessionNear(pos, 1.5f);
			if (homesteadSession != null && homesteadSession.Zdo != null && homesteadSession.Zdo.IsValid() && (val == null || homesteadSession.Zdo.m_uid == val.m_uid))
			{
				homesteadSession.Position = pos;
				homesteadSession.Reload();
				return homesteadSession;
			}
			HomesteadSession homesteadSession2 = new HomesteadSession
			{
				Key = text,
				Position = pos,
				Zdo = val
			};
			if (val != null)
			{
				HomesteadZdoBinder.MarkAsHomestead(val);
			}
			else
			{
				homesteadSession2.TryBindZdo(userId, zdoId, pos);
			}
			homesteadSession2.Reload();
			ByKey[text] = homesteadSession2;
			Log.Info($"HomesteadSession created key={text} pos={pos} zdo={homesteadSession2.Zdo != null}");
			return homesteadSession2;
		}

		private static HomesteadSession FindSessionNear(Vector3 pos, float range)
		{
			//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)
			HomesteadSession result = null;
			float num = range;
			foreach (HomesteadSession value in ByKey.Values)
			{
				if (value != null)
				{
					float num2 = Vector3.Distance(value.Position, pos);
					if (num2 < num)
					{
						num = num2;
						result = value;
					}
				}
			}
			return result;
		}

		private void AdoptZdo(ZDO zdo)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && zdo.IsValid())
			{
				Zdo = zdo;
				HomesteadZdoBinder.TryFixPrefabHash(zdo);
				Position = zdo.GetPosition();
			}
		}

		private void TryBindZdo(long userId, uint zdoId, Vector3 pos)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return;
			}
			if (userId != 0L || zdoId != 0)
			{
				Zdo = ZDOMan.instance.GetZDO(new ZDOID(userId, zdoId));
			}
			if (Zdo != null && Zdo.IsValid())
			{
				HomesteadZdoBinder.TryFixPrefabHash(Zdo);
				return;
			}
			Zdo = HomesteadZdoBinder.FindNearbyHomesteadZdo(pos, 16f);
			if (Zdo != null)
			{
				HomesteadZdoBinder.TryFixPrefabHash(Zdo);
				Position = Zdo.GetPosition();
			}
		}

		public void Reload()
		{
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (Zdo != null && Zdo.IsValid())
			{
				string text = Zdo.GetString("fj_data", string.Empty);
				if (string.IsNullOrEmpty(text))
				{
					Data = HomesteadData.CreateDefault();
				}
				else
				{
					try
					{
						Data = Versioning.Migrate(JsonUtility.FromJson<HomesteadData>(text));
					}
					catch
					{
						Data = HomesteadData.CreateDefault();
					}
				}
				if (Data.Slots == null)
				{
					Data.Slots = new List<FarmSlot>();
				}
				string text2 = Zdo.GetString("fj_slots", string.Empty);
				if (!string.IsNullOrEmpty(text2))
				{
					Data.Slots = HomesteadCodecs.DecodeSlots(text2);
				}
				string text3 = Zdo.GetString("fj_crops", string.Empty);
				if (!string.IsNullOrEmpty(text3))
				{
					Data.CropConfigs = HomesteadCodecs.DecodeCropConfigs(text3);
				}
				else if (Data.CropConfigs == null || Data.CropConfigs.Count == 0)
				{
					Data.CropConfigs = CropRegistry.CreateDefaultConfigs();
				}
				BiomeCropRules.ApplyToData(Data, Position);
				string text4 = Zdo.GetString("fj_carried", string.Empty);
				if (!string.IsNullOrEmpty(text4))
				{
					Data.CarriedItems = HomesteadCodecs.DecodeCarriedItems(text4);
				}
				else if (Data.CarriedItems == null)
				{
					Data.CarriedItems = new List<CarriedItem>();
				}
				string text5 = Zdo.GetString("fj_chests", string.Empty);
				if (!string.IsNullOrEmpty(text5))
				{
					Data.ChestsCsv = text5;
					Data.ChestPositions = HomesteadCodecs.DecodeRefs(text5);
				}
				Data.SyncChestListsFromCsv();
				CaptureReloadSnapshot(text, text2, text3, text4, text5);
			}
			else if (Data == null)
			{
				HomesteadData homesteadData = (Data = HomesteadData.CreateDefault());
			}
			_nextReloadAt = Time.time + SyncedConfig.ScanInterval;
		}

		public void ReloadIfStale()
		{
			if (Data != null && Time.time < _nextReloadAt)
			{
				return;
			}
			if (Zdo != null && Zdo.IsValid() && Data != null)
			{
				string text = Zdo.GetString("fj_data", string.Empty);
				string text2 = Zdo.GetString("fj_slots", string.Empty);
				string text3 = Zdo.GetString("fj_crops", string.Empty);
				string text4 = Zdo.GetString("fj_carried", string.Empty);
				string text5 = Zdo.GetString("fj_chests", string.Empty);
				if (text == _snapData && text2 == _snapSlots && text3 == _snapCrops && text4 == _snapCarried && text5 == _snapChests)
				{
					_nextReloadAt = Time.time + SyncedConfig.ScanInterval;
					return;
				}
			}
			Reload();
		}

		private void CaptureReloadSnapshot(string json, string slotsCsv, string cropsCsv, string carriedCsv, string chestsCsv)
		{
			_snapData = json ?? "";
			_snapSlots = slotsCsv ?? "";
			_snapCrops = cropsCsv ?? "";
			_snapCarried = carriedCsv ?? "";
			_snapChests = chestsCsv ?? "";
		}

		public void Save()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (Data == null)
			{
				return;
			}
			Data.SyncChestCsvFromLists();
			if (Zdo == null || !Zdo.IsValid())
			{
				Log.Warning("HomesteadSession.Save: no ZDO for key=" + Key + " — data not persisted");
				return;
			}
			if (AdminUtil.IsServer() && !Zdo.IsOwner())
			{
				try
				{
					Zdo.SetOwner(ZDOMan.GetSessionID());
				}
				catch (Exception ex)
				{
					Log.Debug("HomesteadSession.Save SetOwner failed: " + ex.Message);
				}
				GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.FindInstance(Zdo.m_uid) : null);
				AdminUtil.EnsureServerOwnership(((Object)(object)val != (Object)null) ? val.GetComponent<ZNetView>() : null);
			}
			List<FarmSlot> list = Data.Slots ?? new List<FarmSlot>();
			List<CropConfigEntry> list2 = Data.CropConfigs ?? new List<CropConfigEntry>();
			List<CarriedItem> list3 = Data.CarriedItems ?? new List<CarriedItem>();
			Data.Slots = new List<FarmSlot>();
			Data.CropConfigs = new List<CropConfigEntry>();
			Data.CarriedItems = new List<CarriedItem>();
			string text = JsonUtility.ToJson((object)Data);
			Data.Slots = list;
			Data.CropConfigs = list2;
			Data.CarriedItems = list3;
			string text2 = HomesteadCodecs.EncodeSlots(list);
			string text3 = HomesteadCodecs.EncodeCropConfigs(list2);
			string text4 = HomesteadCodecs.EncodeCarriedItems(list3);
			Zdo.Set("fj_schema", Data.SchemaVersion);
			Zdo.Set("fj_data", text);
			Zdo.Set("fj_slots", text2);
			Zdo.Set("fj_crops", text3);
			Zdo.Set("fj_carried", text4);
			Zdo.Set("fj_home", 1);
			Zdo.Set("fj_paused", Data.Paused);
			Zdo.Set("fj_npc", Data.NpcZdoKey);
			Zdo.Set("fj_chests", Data.ChestsCsv ?? "");
			CaptureReloadSnapshot(text, text2, text3, text4, Data.ChestsCsv ?? "");
			Log.Debug($"HomesteadSession saved key={Key} slots={list.Count} crops={list2.Count} carried={list3.Count} jsonLen={text.Length}");
		}

		public void SaveCarriedOnly()
		{
			if (Data != null && Zdo != null && Zdo.IsValid())
			{
				string text = HomesteadCodecs.EncodeCarriedItems(Data.CarriedItems);
				Zdo.Set("fj_carried", text);
				_snapCarried = text ?? "";
				Log.Debug($"HomesteadSession carried-only save key={Key} stacks={Data.CarriedItems?.Count ?? 0}");
			}
		}

		public void UpdateCarried(string encoded)
		{
			Reload();
			Data.CarriedItems = HomesteadCodecs.DecodeCarriedItems(encoded ?? "");
			Save();
			Log.Debug($"Session carried updated count={Data.CarriedItems?.Count ?? 0}");
		}

		public void UpdateCropConfig(string encoded)
		{
			Reload();
			if (HomesteadOps.UpdateCropConfig(Data, encoded, setWeightedLayout: true))
			{
				Save();
				string text = encoded.Split(new char[1] { '|' })[0];
				CropConfigEntry cropConfig = Data.GetCropConfig(text);
				Log.Info($"Session crop config {text} weight={cropConfig?.Weight} reserve={cropConfig?.MinimumSeedReserve}");
			}
		}

		public Quaternion GetFacingRotation()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			FarmerHomestead farmerHomestead = HomesteadLocator.ResolveNear(Position, 4f);
			if ((Object)(object)farmerHomestead != (Object)null)
			{
				return ((Component)farmerHomestead).transform.rotation;
			}
			if (Zdo != null && Zdo.IsValid())
			{
				return Zdo.GetRotation();
			}
			return Quaternion.identity;
		}

		public void SummonFarmer()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			FarmerNpc farmerNpc = HomesteadFarmerOps.FindNearest(Position, 64f, NpcsByKey.Values);
			if ((Object)(object)farmerNpc != (Object)null)
			{
				Npc = farmerNpc;
				NpcsByKey[Key] = farmerNpc;
				farmerNpc.BindSession(this);
				if (Data != null)
				{
					ZNetView component = ((Component)farmerNpc).GetComponent<ZNetView>();
					if (component != null && component.IsValid())
					{
						Data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
						Save();
					}
				}
				Log.Info($"SummonFarmer bound live farmer for key={Key} count={FarmerRoster.CountNear(Position)}");
				return;
			}
			Npc = NpcSpawner.SpawnAt(Position, GetFacingRotation(), null);
			if ((Object)(object)Npc != (Object)null)
			{
				NpcsByKey[Key] = Npc;
				Npc.BindSession(this);
				if (Data != null)
				{
					Npc.Inventory.LoadFrom(Data);
					ZNetView component2 = ((Component)Npc).GetComponent<ZNetView>();
					if (component2 != null && component2.IsValid())
					{
						Data.NpcZdoKey = ZdoIds.ZdoKey(component2.GetZDO());
					}
					Save();
				}
			}
			Log.Info($"SummonFarmer spawned for key={Key} npc={(Object)(object)Npc != (Object)null}");
		}

		public FarmerNpc AddFarmer()
		{
			//IL_0036: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			bool num = Data != null && !Data.Paused;
			Reload();
			if (num && Data != null)
			{
				Data.Paused = false;
			}
			FarmerNpc farmerNpc = HomesteadFarmerOps.SpawnAdditional(Position, GetFacingRotation(), null);
			if ((Object)(object)farmerNpc != (Object)null)
			{
				farmerNpc.BindSession(this);
				farmerNpc.Inventory.Clear();
				Npc = farmerNpc;
				NpcsByKey[Key] = farmerNpc;
				if (Data != null && !Data.Paused)
				{
					farmerNpc.ActivateForWork();
				}
				Log.Info($"AddFarmer spawned key={Key} total={FarmerRoster.CountNear(Position)}");
			}
			return farmerNpc;
		}

		public bool RemoveFarmer()
		{
			//IL_0007: 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_008c: 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)
			Reload();
			if (!HomesteadFarmerOps.TryRemoveOne(Position, Data, Npc, out var newPrimary, out var wroteData))
			{
				Log.Info($"RemoveFarmer: none near {Position}");
				return false;
			}
			if (wroteData)
			{
				Save();
			}
			Npc = newPrimary;
			if ((Object)(object)Npc != (Object)null)
			{
				NpcsByKey[Key] = Npc;
			}
			else
			{
				NpcsByKey.Remove(Key);
			}
			Log.Info($"RemoveFarmer destroyed one near {Position}; remaining={FarmerRoster.CountNear(Position)}");
			return true;
		}

		public bool ForceDepositAll()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Reload();
			HomesteadOps.DepositAllResult depositAllResult = HomesteadOps.ForceDepositAll(Data, Position);
			if (depositAllResult.NoChests || Data == null)
			{
				return true;
			}
			Save();
			Log.Info($"Session ForceDepositAll key={Key} blocked={depositAllResult.Blocked}");
			return !depositAllResult.Blocked;
		}

		public void EnsureNpc()
		{
			SummonFarmer();
		}

		public void ClearAllNearbyFarmers(List<ZDOID> extraIds = null)
		{
			//IL_0001: 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)
			HomesteadFarmerOps.ClearNearbyFarmers(Position, 50f, extraIds);
			NpcsByKey.Remove(Key);
			Npc = null;
			Log.Info($"ClearAllNearbyFarmers near {Position} extras={extraIds?.Count ?? 0}");
		}

		public void AssignBoundary(Vector3 a, Vector3 b)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Reload();
			HomesteadOps.AssignBoundary(Data, a, b, 0L, 0L);
			Save();
			float num = Mathf.Abs(a.x - b.x);
			float num2 = Mathf.Abs(a.z - b.z);
			Log.Info($"Session boundary assigned ({num:F1}x{num2:F1}) for {Key}");
		}

		public void AssignChest(Vector3 chestPos)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Reload();
			if (!HomesteadOps.TryAssignChest(Data, chestPos))
			{
				Log.Info($"Session chest rejected (already assigned) count={Data?.ChestCount}");
				return;
			}
			Save();
			Log.Info($"Session chest assigned total={Data.ChestCount}");
		}

		public void ClearChests()
		{
			Reload();
			HomesteadOps.ClearChests(Data);
			Save();
		}

		public int ClearField()
		{
			Reload();
			int num = HomesteadOps.ClearField(Data);
			Save();
			Log.Info($"Session clear field removed {num} slots");
			return num;
		}

		public FarmScanner.ScanResult Scan()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0041: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num;
			Vector3 val;
			if (Data != null)
			{
				num = (Data.HasBoundary ? 1 : 0);
				if (num != 0)
				{
					val = Data.PostA;
					goto IL_002b;
				}
			}
			else
			{
				num = 0;
			}
			val = Vector3.zero;
			goto IL_002b;
			IL_002b:
			Vector3 a = val;
			Vector3 b = ((num != 0) ? Data.PostB : Vector3.zero);
			Reload();
			if (num != 0 && Data != null && !Data.HasBoundary)
			{
				HomesteadOps.AssignBoundary(Data, a, b, 0L, 0L);
				Log.Warning("Scan: restored in-memory boundary after Reload wiped it");
			}
			FarmScanner.ScanResult result = HomesteadOps.Scan(Data, Position);
			Save();
			return result;
		}

		public int ApplyClientScanSlots(string slotsCsv)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			int num;
			Vector3 val;
			if (Data != null)
			{
				num = (Data.HasBoundary ? 1 : 0);
				if (num != 0)
				{
					val = Data.PostA;
					goto IL_002b;
				}
			}
			else
			{
				num = 0;
			}
			val = Vector3.zero;
			goto IL_002b;
			IL_002b:
			Vector3 a = val;
			Vector3 b = ((num != 0) ? Data.PostB : Vector3.zero);
			List<WorldRef> list = Data?.ChestPositions;
			Reload();
			if (num != 0 && Data != null && !Data.HasBoundary)
			{
				HomesteadOps.AssignBoundary(Data, a, b, 0L, 0L);
			}
			if ((Data.ChestPositions == null || Data.ChestPositions.Count == 0) && list != null && list.Count > 0)
			{
				Data.ChestPositions = list;
				Data.SyncChestCsvFromLists();
			}
			Data.Slots = HomesteadCodecs.DecodeSlots(slotsCsv);
			if (Data.Slots == null)
			{
				Data.Slots = new List<FarmSlot>();
			}
			Save();
			Log.Info($"ApplyClientScanSlots key={Key} slots={Data.Slots.Count}");
			return Data.Slots.Count;
		}

		public FarmScanner.ScanResult ClearAndScan()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num;
			Vector3 val;
			if (Data != null)
			{
				num = (Data.HasBoundary ? 1 : 0);
				if (num != 0)
				{
					val = Data.PostA;
					goto IL_002b;
				}
			}
			else
			{
				num = 0;
			}
			val = Vector3.zero;
			goto IL_002b;
			IL_002b:
			Vector3 a = val;
			Vector3 b = ((num != 0) ? Data.PostB : Vector3.zero);
			Reload();
			if (num != 0 && Data != null && !Data.HasBoundary)
			{
				HomesteadOps.AssignBoundary(Data, a, b, 0L, 0L);
				Log.Warning("ClearAndScan: restored in-memory boundary after Reload wiped it");
			}
			int valueOrDefault = (Data?.Slots?.Count).GetValueOrDefault();
			FarmScanner.ScanResult result = HomesteadOps.ClearAndScan(Data, Position);
			Save();
			Log.Info($"Session clear+scan cleared={valueOrDefault} +{result.Added} total={result.Total}");
			return result;
		}

		public void TogglePause()
		{
			//IL_0065: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			int valueOrDefault = (Data?.Slots?.Count).GetValueOrDefault();
			int num;
			Vector3 val;
			if (Data != null)
			{
				num = (Data.HasBoundary ? 1 : 0);
				if (num != 0)
				{
					val = Data.PostA;
					goto IL_006a;
				}
			}
			else
			{
				num = 0;
			}
			val = Vector3.zero;
			goto IL_006a;
			IL_006a:
			Vector3 a = val;
			Vector3 b = ((num != 0) ? Data.PostB : Vector3.zero);
			List<WorldRef> list = Data?.ChestPositions;
			List<FarmSlot> list2 = Data?.Slots;
			Reload();
			if (list2 != null && list2.Count > 0 && (Data.Slots == null || Data.Slots.Count == 0))
			{
				Data.Slots = list2;
				Log.Warning($"TogglePause: restored {list2.Count} in-memory slots after Reload lost them");
			}
			if (num != 0 && !Data.HasBoundary)
			{
				HomesteadOps.AssignBoundary(Data, a, b, 0L, 0L);
			}
			if ((Data.ChestPositions == null || Data.ChestPositions.Count == 0) && list != null && list.Count > 0)
			{
				Data.ChestPositions = list;
				Data.SyncChestCsvFromLists();
			}
			HomesteadOps.TogglePaused(Data);
			Save();
			if ((Object)(object)Npc != (Object)null)
			{
				Npc.BindSession(this);
			}
			if (!Data.Paused)
			{
				if (!TryUnpauseWithDepositCheck())
				{
					return;
				}
				FarmerNpc farmerNpc = HomesteadFarmerOps.FindNearest(Position, 64f, NpcsByKey.Values);
				if ((Object)(object)farmerNpc != (Object)null)
				{
					Npc = farmerNpc;
					NpcsByKey[Key] = farmerNpc;
					farmerNpc.BindSession(this);
					farmerNpc.ActivateForWork();
					List<FarmerNpc> list3 = FarmerRoster.ListNear(Position);
					for (int i = 0; i < list3.Count; i++)
					{
						FarmerNpc farmerNpc2 = list3[i];
						if (!((Object)(object)farmerNpc2 == (Object)null))
						{
							farmerNpc2.BindSession(this);
							farmerNpc2.ActivateForWork();
						}
					}
					Log.Info("TogglePause: bound existing farmer for key=" + Key);
				}
				else if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated())
				{
					Log.Info("TogglePause: unpaused key=" + Key + " (dedicated; client binds farmers)");
				}
				else
				{
					PlayerFeedback.Notify("No farmer nearby — use Add Farmer");
					Log.Info("TogglePause: unpaused key=" + Key + " with no nearby farmer (use Add Farmer)");
				}
			}
			Log.Info($"Session paused={Data.Paused} for {Key} slots={(Data?.Slots?.Count).GetValueOrDefault()} (was {valueOrDefault}) zdo={Zdo != null}");
		}

		public void PauseChestsFull()
		{
			Reload();
			if (!Data.Paused)
			{
				HomesteadOps.SetPaused(Data, paused: true);
				Save();
				Log.Info("Session pause_chests_full key=" + Key);
			}
		}

		public bool TryUnpauseWithDepositCheck()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (!HomesteadOps.TryUnpauseWithDepositCheck(Data, Position))
			{
				Save();
				Log.Info("Session unpause aborted: chests still full key=" + Key);
				return false;
			}
			return true;
		}

		public static void CullExtraNpcs(Vector3 pos, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			HomesteadFarmerOps.CullExtraNpcs(pos, range);
		}
	}
	internal static class HomesteadUI
	{
		public static void Show(FarmerHomestead homestead)
		{
			HomesteadUiController.Show(homestead);
		}

		public static void Hide()
		{
			HomesteadUiController.Hide();
		}
	}
	internal static class NpcSpawner
	{
		public static FarmerNpc SpawnAt(Vector3 homesteadPos, Quaternion rotation, FarmerHomestead homestead)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FarmerSpawner.TrySpawnNearHomestead(homesteadPos, rotation, homestead);
		}

		public static FarmerHomestead ResolveByZdoId(long userId, uint id, Vector3 fallbackPos)
		{
			//IL_0014: 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_0040: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return HomesteadLocator.ResolveNear(fallbackPos, 16f);
			}
			ZDOID val = default(ZDOID);
			((ZDOID)(ref val))..ctor(userId, id);
			ZDO zDO = ZDOMan.instance.GetZDO(val);
			if (zDO == null || !zDO.IsValid())
			{
				return HomesteadLocator.ResolveNear(fallbackPos, 16f);
			}
			GameObject val2 = ZNetScene.instance.FindInstance(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return HomesteadLocator.ResolveNear(fallbackPos, 16f);
			}
			FarmerHomestead farmerHomestead = val2.GetComponent<FarmerHomestead>();
			if ((Object)(object)farmerHomestead == (Object)null)
			{
				farmerHomestead = val2.AddComponent<FarmerHomestead>();
			}
			return farmerHomestead;
		}
	}
}
namespace ValheimFarmerNPC.Persistence
{
	public static class HomesteadCodecs
	{
		public static string EncodeRefs(List<WorldRef> refs)
		{
			if (refs == null || refs.Count == 0)
			{
				return "";
			}
			return string.Join(";", refs.Select((WorldRef r) => r.X.ToString(CultureInfo.InvariantCulture) + "," + r.Y.ToString(CultureInfo.InvariantCulture) + "," + r.Z.ToString(CultureInfo.InvariantCulture)));
		}

		public static List<WorldRef> DecodeRefs(string csv)
		{
			List<WorldRef> list = new List<WorldRef>();
			if (string.IsNullOrEmpty(csv))
			{
				return list;
			}
			string[] array = csv.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ',' });
				if (array2.Length >= 3 && float.TryParse(array2[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					list.Add(new WorldRef
					{
						X = result,
						Y = result2,
						Z = result3
					});
				}
			}
			return list;
		}

		public static string EncodeSlots(List<FarmSlot> slots)
		{
			if (slots == null || slots.Count == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(slots.Count * 48);
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			for (int i = 0; i < slots.Count; i++)
			{
				FarmSlot farmSlot = slots[i];
				if (farmSlot != null)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(';');
					}
					stringBuilder.Append(farmSlot.X.ToString("F2", invariantCulture)).Append(',').Append(farmSlot.Y.ToString("F2", invariantCulture))
						.Append(',')
						.Append(farmSlot.Z.ToString("F2", invariantCulture))
						.Append(',')
						.Append(farmSlot.RotY.ToString("F1", invariantCulture))
						.Append(',')
						.Append(farmSlot.OriginalCropFamily ?? "")
						.Append(',')
						.Append(farmSlot.CurrentCropFamily ?? "")
						.Append(',')
						.Append((int)farmSlot.State);
				}
			}
			return stringBuilder.ToString();
		}

		public static List<FarmSlot> DecodeSlots(string csv)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			List<FarmSlot> list = new List<FarmSlot>();
			if (string.IsNullOrEmpty(csv))
			{
				return list;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			string[] array = csv.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ',' });
				if (array2.Length >= 7 && float.TryParse(array2[0], NumberStyles.Float, invariantCulture, out var result) && float.TryParse(array2[1], NumberStyles.Float, invariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, invariantCulture, out var result3) && float.TryParse(array2[3], NumberStyles.Float, invariantCulture, out var result4) && int.TryParse(array2[6], out var result5))
				{
					FarmSlot item = new FarmSlot
					{
						X = result,
						Y = result2,
						Z = result3,
						RotY = result4,
						OriginalCropFamily = array2[4],
						CurrentCropFamily = array2[5],
						State = (FarmSlotState)result5,
						Id = FarmSlot.MakeId(new Vector3(result, result2, result3))
					};
					list.Add(item);
				}
			}
			return list;
		}

		public static string EncodeCropConfigs(List<CropConfigEntry> configs)
		{
			if (configs == null || configs.Count == 0)
			{
				return "";
			}
			return string.Join(";", configs.Select((CropConfigEntry c) => $"{c.Family}|{(c.Enabled ? 1 : 0)}|{c.Weight}|" + $"{(c.HarvestEnabled ? 1 : 0)}|{(c.PlantEnabled ? 1 : 0)}|" + $"{c.MinimumSeedReserve}|{c.MaximumSeedPercent}"));
		}

		public static List<CropConfigEntry> DecodeCropConfigs(string csv)
		{
			List<CropConfigEntry> list = new List<CropConfigEntry>();
			if (string.IsNullOrEmpty(csv))
			{
				return list;
			}
			string[] array = csv.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { '|' });
				if (array2.Length >= 7)
				{
					int.TryParse(array2[2], out var result);
					int.TryParse(array2[5], out var result2);
					int.TryParse(array2[6], out var result3);
					list.Add(new CropConfigEntry
					{
						Family = array2[0],
						Enabled = (array2[1] == "1"),
						Weight = result,
						HarvestEnabled = (array2[3] == "1"),
						PlantEnabled = (array2[4] == "1"),
						MinimumSeedReserve = result2,
						MaximumSeedPercent = result3
					});
				}
			}
			return list;
		}

		public static string EncodeCarriedItems(List<CarriedItem> items)
		{
			if (items == null || items.Count == 0)
			{
				return "";
			}
			CultureInfo inv = CultureInfo.InvariantCulture;
			return string.Join(";", from i in items
				where i != null && !string.IsNullOrEmpty(i.Prefab) && i.Stack > 0
				select string.Format("{0}|{1}|{2}|{3}|{4}", i.Prefab, i.Stack, i.Quality, i.Variant, i.Durability.ToString("F1", inv)));
		}

		public static List<CarriedItem> DecodeCarriedItems(string csv)
		{
			List<CarriedItem> list = new List<CarriedItem>();
			if (string.IsNullOrEmpty(csv))
			{
				return list;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			string[] array = csv.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { '|' });
				if (array2.Length >= 2 && !string.IsNullOrEmpty(array2[0]))
				{
					int.TryParse(array2[1], out var result);
					int result2 = 0;
					int result3 = 0;
					float result4 = 100f;
					if (array2.Length > 2)
					{
						int.TryParse(array2[2], out result2);
					}
					if (array2.Length > 3)
					{
						int.TryParse(array2[3], out result3);
					}
					if (array2.Length > 4)
					{
						float.TryParse(array2[4], NumberStyles.Float, invariantCulture, out result4);
					}
					list.Add(new CarriedItem
					{
						Prefab = array2[0],
						Stack = Math.Max(1, result),
						Quality = result2,
						Variant = result3,
						Durability = result4
					});
				}
			}
			return list;
		}
	}
	[Serializable]
	public class CarriedItem
	{
		public string Prefab;

		public int Stack = 1;

		public int Quality;

		public int Variant;

		public float Durability = 100f;
	}
	[Serializable]
	public class WorldRef
	{
		public float X;

		public float Y;

		public float Z;

		public Vector3 Position
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3(X, Y, Z);
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: 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)
				X = value.x;
				Y = value.y;
				Z = value.z;
			}
		}

		public static WorldRef From(Vector3 pos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return new WorldRef
			{
				Position = pos
			};
		}
	}
	[Serializable]
	public class HomesteadData
	{
		public int SchemaVersion = 1;

		public bool Paused;

		public string LayoutMode = "Fixed";

		public bool HasBoundary;

		public float PostAx;

		public float PostAy;

		public float PostAz;

		public float PostBx;

		public float PostBy;

		public float PostBz;

		public long BoundaryPostA;

		public long BoundaryPostB;

		public List<WorldRef> ChestPositions = new List<WorldRef>();

		public string ChestsCsv = "";

		public List<CropConfigEntry> CropConfigs = new List<CropConfigEntry>();

		public List<FarmSlot> Slots = new List<FarmSlot>();

		public List<CarriedItem> CarriedItems = new List<CarriedItem>();

		public long NpcZdoKey;

		public Vector3 PostA => new Vector3(PostAx, PostAy, PostAz);

		public Vector3 PostB => new Vector3(PostBx, PostBy, PostBz);

		public int ChestCount
		{
			get
			{
				SyncChestListsFromCsv();
				return ChestPositions.Count;
			}
		}

		public bool HasAnyChest
		{
			get
			{
				SyncChestListsFromCsv();
				return ChestPositions.Count > 0;
			}
		}

		public void SetBoundary(Vector3 a, Vector3 b)
		{
			//IL_0008: 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_0020: 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_0038: 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)
			HasBoundary = true;
			PostAx = a.x;
			PostAy = a.y;
			PostAz = a.z;
			PostBx = b.x;
			PostBy = b.y;
			PostBz = b.z;
		}

		public void SyncChestCsvFromLists()
		{
			EnsureChestList();
			ChestsCsv = HomesteadCodecs.EncodeRefs(ChestPositions);
		}

		public void SyncChestListsFromCsv()
		{
			EnsureChestList();
			if (ChestPositions.Count == 0 && !string.IsNullOrEmpty(ChestsCsv))
			{
				ChestPositions = HomesteadCodecs.DecodeRefs(ChestsCsv);
			}
		}

		private void EnsureChestList()
		{
			if (ChestPositions == null)
			{
				ChestPositions = new List<WorldRef>();
			}
		}

		public bool IsChestAssigned(Vector3 pos, float radius = 0.35f)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			SyncChestListsFromCsv();
			return IsNearAny(ChestPositions, pos, radius);
		}

		private static bool IsNearAny(List<WorldRef> refs, Vector3 pos, float radius)
		{
			//IL_0023: 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)
			if (refs == null)
			{
				return false;
			}
			float num = radius * radius;
			foreach (WorldRef @ref in refs)
			{
				if (@ref != null)
				{
					float num2 = @ref.X - pos.x;
					float num3 = @ref.Z - pos.z;
					if (num2 * num2 + num3 * num3 < num)
					{
						return true;
					}
				}
			}
			return false;
		}

		public bool TryAddChestPosition(Vector3 pos)
		{
			//IL_0007: 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)
			SyncChestListsFromCsv();
			if (IsChestAssigned(pos))
			{
				return false;
			}
			ChestPositions.Add(WorldRef.From(pos));
			SyncChestCsvFromLists();
			return true;
		}

		public void ClearAllChests()
		{
			ChestPositions = new List<WorldRef>();
			ChestsCsv = "";
		}

		public CropConfigEntry GetCropConfig(string family)
		{
			return CropConfigs.FirstOrDefault((CropConfigEntry c) => string.Equals(c.Family, family, StringComparison.OrdinalIgnoreCase));
		}

		public static HomesteadData CreateDefault()
		{
			return new HomesteadData
			{
				SchemaVersion = 1,
				Paused = true,
				LayoutMode = SyncedConfig.DefaultLayoutMode,
				CropConfigs = CropRegistry.CreateDefaultConfigs()
			};
		}
	}
	internal static class SaveManager
	{
		private const string ZdoChests = "fj_chests";

		private const string ZdoSlots = "fj_slots";

		private const string ZdoCrops = "fj_crops";

		private const string ZdoCarried = "fj_carried";

		public static HomesteadData Load(ZNetView view)
		{
			if ((Object)(object)view == (Object)null || !view.IsValid())
			{
				return HomesteadData.CreateDefault();
			}
			ZDO zDO = view.GetZDO();
			string text = zDO.GetString("fj_data", string.Empty);
			HomesteadData homesteadData;
			if (string.IsNullOrEmpty(text))
			{
				homesteadData = HomesteadData.CreateDefault();
				if (view.IsOwner() || AdminUtil.IsServer())
				{
					Save(view, homesteadData);
				}
				return homesteadData;
			}
			try
			{
				homesteadData = JsonUtility.FromJson<HomesteadData>(text);
				homesteadData = Versioning.Migrate(homesteadData);
			}
			catch (Exception ex)
			{
				Log.Error("Failed to deserialize homestead data: " + ex.Message);
				homesteadData = HomesteadData.CreateDefault();
			}
			if (homesteadData.Slots == null)
			{
				homesteadData.Slots = new List<FarmSlot>();
			}
			string text2 = zDO.GetString("fj_slots", string.Empty);
			if (!string.IsNullOrEmpty(text2))
			{
				homesteadData.Slots = HomesteadCodecs.DecodeSlots(text2);
			}
			string text3 = zDO.GetString("fj_crops", string.Empty);
			if (!string.IsNullOrEmpty(text3))
			{
				homesteadData.CropConfigs = HomesteadCodecs.DecodeCropConfigs(text3);
			}
			else if (homesteadData.CropConfigs == null || homesteadData.CropConfigs.Count == 0)
			{
				homesteadData.CropConfigs = CropRegistry.CreateDefaultConfigs();
			}
			string text4 = zDO.GetString("fj_carried", string.Empty);
			if (!string.IsNullOrEmpty(text4))
			{
				homesteadData.CarriedItems = HomesteadCodecs.DecodeCarriedItems(text4);
			}
			else if (homesteadData.CarriedItems == null)
			{
				homesteadData.CarriedItems = new List<CarriedItem>();
			}
			string text5 = zDO.GetString("fj_chests", string.Empty);
			if (!string.IsNullOrEmpty(text5))
			{
				homesteadData.ChestsCsv = text5;
				homesteadData.ChestPositions = HomesteadCodecs.DecodeRefs(text5);
			}
			homesteadData.SyncChestListsFromCsv();
			return homesteadData;
		}

		public static void Save(ZNetView view, HomesteadData data)
		{
			if ((Object)(object)view == (Object)null || !view.IsValid() || data == null)
			{
				return;
			}
			if (!view.IsOwner())
			{
				if (AdminUtil.IsServer())
				{
					AdminUtil.EnsureServerOwnership(view);
				}
				if (!view.IsOwner())
				{
					Log.Debug("Save skipped: not homestead ZDO owner");
					return;
				}
			}
			data.SchemaVersion = 1;
			data.SyncChestCsvFromLists();
			List<FarmSlot> slots = data.Slots ?? new List<FarmSlot>();
			List<CropConfigEntry> list = data.CropConfigs ?? new List<CropConfigEntry>();
			List<CarriedItem> list2 = data.CarriedItems ?? new List<CarriedItem>();
			data.Slots = new List<FarmSlot>();
			data.CropConfigs = new List<CropConfigEntry>();
			data.CarriedItems = new List<CarriedItem>();
			string text = JsonUtility.ToJson((object)data);
			data.Slots = slots;
			data.CropConfigs = list;
			data.CarriedItems = list2;
			string text2 = HomesteadCodecs.EncodeSlots(slots);
			string text3 = HomesteadCodecs.EncodeCropConfigs(list);
			string text4 = HomesteadCodecs.EncodeCarriedItems(list2);
			ZDO zDO = view.GetZDO();
			zDO.Set("fj_schema", data.SchemaVersion);
			zDO.Set("fj_data", text);
			zDO.Set("fj_slots", text2);
			zDO.Set("fj_crops", text3);
			zDO.Set("fj_carried", text4);
			zDO.Set("fj_paused", data.Paused);
			zDO.Set("fj_npc", data.NpcZdoKey);
			zDO.Set("fj_chests", data.ChestsCsv ?? "");
		}

		public static void SaveCarriedOnly(ZNetView view, HomesteadData data)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid() && data != null && view.IsOwner())
			{
				ZDO zDO = view.GetZDO();
				if (zDO != null && zDO.IsValid())
				{
					string text = HomesteadCodecs.EncodeCarriedItems(data.CarriedItems);
					zDO.Set("fj_carried", text);
				}
			}
		}

		public static string ToPrettySummary(HomesteadData data)
		{
			if (data == null)
			{
				return "No data";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"Paused: {data.Paused}");
			stringBuilder.AppendLine("Layout: " + data.LayoutMode);
			stringBuilder.AppendLine($"Slots: {data.Slots?.Count ?? 0}");
			stringBuilder.AppendLine($"Chests: {data.ChestCount}");
			return stringBuilder.ToString();
		}
	}
	internal static class Versioning
	{
		public static HomesteadData Migrate(HomesteadData data)
		{
			if (data == null)
			{
				return HomesteadData.CreateDefault();
			}
			if (data.SchemaVersion <= 0)
			{
				data.SchemaVersion = 1;
			}
			while (data.SchemaVersion < 1)
			{
				if (data.SchemaVersion == 1)
				{
					data.SchemaVersion = 2;
					continue;
				}
				Log.Warning($"Unknown homestead schema {data.SchemaVersion}, clamping to current");
				data.SchemaVersion = 1;
			}
			if (data.CropConfigs == null || data.CropConfigs.Count == 0)
			{
				data.CropConfigs = CropRegistry.CreateDefaultConfigs();
			}
			if (data.Slots == null)
			{
				data.Slots = new List<FarmSlot>();
			}
			if (data.ChestPositions == null)
			{
				data.ChestPositions = new List<WorldRef>();
			}
			if (data.ChestsCsv == null)
			{
				data.ChestsCsv = "";
			}
			data.SyncChestListsFromCsv();
			if (data.CarriedItems == null)
			{
				data.CarriedItems = new List<CarriedItem>();
			}
			if (string.IsNullOrEmpty(data.LayoutMode))
			{
				data.LayoutMode = "Fixed";
			}
			data.SchemaVersion = 1;
			return data;
		}
	}
}
namespace ValheimFarmerNPC.NPC
{
	public class FarmerNpc : MonoBehaviour, Hoverable, Interactable
	{
		private static float _coalescePersistAt;

		private static long _coalesceHomesteadKey;

		private static readonly List<FarmerNpc> PersistNearScratch = new List<FarmerNpc>(8);

		public const string ZdoHomeX = "fj_home_x";

		public const string ZdoHomeY = "fj_home_y";

		public const string ZdoHomeZ = "fj_home_z";

		private static readonly List<FarmerNpc> Instances = new List<FarmerNpc>();

		private ZNetView _nview;

		private Character _character;

		private Humanoid _humanoid;

		private FarmerHomestead _homestead;

		private HomesteadSession _session;

		private FarmerBrain _brain;

		private InventoryManager _inventory;

		private Vector3 _pendingHomesteadPos;

		private bool _hasPendingHomestead;

		private float _bindTimer;

		private float _bindInterval = 1f;

		private float _sessionReloadAt;

		private float _persistAt;

		private const float InventoryAutosaveSeconds = 30f;

		internal InventoryManager Inventory => _inventory;

		public Character Character => _character;

		internal FarmerHomestead Homestead => _homestead;

		internal HomesteadSession BoundSession => _session;

		public long ZdoKey
		{
			get
			{
				if (!((Object)(object)_nview != (Object)null) || !_nview.IsValid())
				{
					return 0L;
				}
				return ZdoIds.ZdoKey(_nview.GetZDO());
			}
		}

		public static int ActiveCount => Instances.Count;

		internal static IReadOnlyList<FarmerNpc> Live => Instances;

		internal static float InventoryAutosaveInterval => 30f;

		public void SetPendingHomesteadPosition(Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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)
			_pendingHomesteadPos = pos;
			_hasPendingHomestead = true;
			WriteHomePosToZdo(pos);
		}

		internal void BindSession(HomesteadSession session)
		{
			//IL_000d: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (session != null)
			{
				_session = session;
				_pendingHomesteadPos = session.Position;
				_hasPendingHomestead = true;
				WriteHomePosToZdo(session.Position);
				Log.Info($"Farmer bound to session key={session.Key} at {session.Position}");
			}
		}

		public void BindHomestead(FarmerHomestead homestead)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			_homestead = homestead;
			if ((Object)(object)homestead != (Object)null)
			{
				_pendingHomesteadPos = ((Component)homestead).transform.position;
				_hasPendingHomestead = true;
				WriteHomePosToZdo(((Component)homestead).transform.position);
			}
		}

		internal HomesteadData GetWorkData()
		{
			if ((Object)(object)_homestead != (Object)null)
			{
				if ((_homestead.Data == null || _homestead.Data.Slots == null || _homestead.Data.Slots.Count == 0) && Time.time >= _sessionReloadAt)
				{
					_homestead.ReloadDataFromZdo();
					_sessionReloadAt = Time.time + SyncedConfig.ScanInterval;
				}
				if (_homestead.Data != null)
				{
					return _homestead.Data;
				}
			}
			if (_session != null)
			{
				_session.ReloadIfStale();
				return _session.Data;
			}
			TryResolveSession();
			return _session?.Data;
		}

		internal Vector3 GetHomesteadPosition()
		{
			//IL_0019: 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_0043: 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)
			if ((Object)(object)_homestead != (Object)null)
			{
				return ((Component)_homestead).transform.position;
			}
			if (_session != null)
			{
				return _session.Position;
			}
			if (_hasPendingHomestead)
			{
				return _pendingHomesteadPos;
			}
			return ReadHomePosFromZdo();
		}

		internal long GetHomesteadKey()
		{
			if ((Object)(object)_homestead != (Object)null)
			{
				return _homestead.HomesteadKey;
			}
			if (_session?.Zdo != null && _session.Zdo.IsValid())
			{
				return ZdoIds.ZdoKey(_session.Zdo);
			}
			return 0L;
		}

		private void TryResolveSession()
		{
			//IL_0001: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 homesteadPosition = GetHomesteadPosition();
			_session = HomesteadSession.GetOrCreate(0L, 0u, homesteadPosition);
			if (_session != null)
			{
				_pendingHomesteadPos = _session.Position;
				_hasPendingHomestead = true;
			}
		}

		private void WriteHomePosToZdo(Vector3 pos)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				if (zDO != null && zDO.IsValid())
				{
					zDO.Set("fj_home_x", pos.x);
					zDO.Set("fj_home_y", pos.y);
					zDO.Set("fj_home_z", pos.z);
				}
			}
		}

		private Vector3 ReadHomePosFromZdo()
		{
			//IL_0021: 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_007c: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return ((Component)this).transform.position;
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO == null || !zDO.IsValid())
			{
				return ((Component)this).transform.position;
			}
			float num = zDO.GetFloat("fj_home_x", float.NaN);
			if (float.IsNaN(num))
			{
				return ((Component)this).transform.position;
			}
			return new Vector3(num, zDO.GetFloat("fj_home_y", ((Component)this).transform.position.y), zDO.GetFloat("fj_home_z", ((Component)this).transform.position.z));
		}

		internal void PersistWorkData()
		{
			if (!(Time.time < _persistAt))
			{
				long homesteadKey = GetHomesteadKey();
				if (homesteadKey != 0L && homesteadKey == _coalesceHomesteadKey && Time.time < _coalescePersistAt)
				{
					_persistAt = _coalescePersistAt;
					return;
				}
				_persistAt = Time.time + 1f;
				_coalesceHomesteadKey = homesteadKey;
				_coalescePersistAt = _persistAt;
				PersistInventoryCore(carriedOnly: false);
			}
		}

		internal void ForcePersistInventory()
		{
			_persistAt = 0f;
			PersistInventoryCore(carriedOnly: true);
		}

		public void PersistInventory()
		{
			PersistWorkData();
		}

		private void PersistInventoryCore(bool carriedOnly)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			HomesteadData workData = GetWorkData();
			if (workData == null || _inventory == null)
			{
				return;
			}
			FarmerRoster.ListNearNonAlloc(GetHomesteadPosition(), PersistNearScratch);
			if (PersistNearScratch.Count > 0)
			{
				workData.CarriedItems = HomesteadStock.AggregateFromFarmers(PersistNearScratch);
			}
			else
			{
				_inventory.SaveTo(workData);
			}
			if ((Object)(object)_homestead != (Object)null)
			{
				if (carriedOnly)
				{
					SaveManager.SaveCarriedOnly(_homestead.NetView, workData);
				}
				else
				{
					_homestead.Persist();
				}
			}
			else if (carriedOnly)
			{
				_session?.SaveCarriedOnly();
			}
			else
			{
				_session?.Save();
			}
			PushCarriedToServer(workData);
		}

		private void PushCarriedToServer(HomesteadData data)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			string csv = HomesteadCodecs.EncodeCarriedItems(data?.CarriedItems);
			Vector3 homesteadPosition = GetHomesteadPosition();
			GetHomesteadZdoIdentity(out var userId, out var id);
			RpcMessages.RequestHomesteadOp(homesteadPosition, "carried", userId, id, delegate(ZPackage pkg)
			{
				pkg.Write(csv ?? "");
			});
			Log.Debug($"Pushed carried inventory ({(data?.CarriedItems?.Count).GetValueOrDefault()} stacks) to homestead");
		}

		private void GetHomesteadZdoIdentity(out long userId, out uint id)
		{
			userId = 0L;
			id = 0u;
			ZNetView val = (((Object)(object)_homestead != (Object)null) ? ((Component)_homestead).GetComponent<ZNetView>() : null);
			if ((Object)(object)val != (Object)null && val.IsValid())
			{
				ZDO zDO = val.GetZDO();
				if (zDO != null && zDO.IsValid())
				{
					userId = ((ZDOID)(ref zDO.m_uid)).UserID;
					id = ((ZDOID)(ref zDO.m_uid)).ID;
					return;
				}
			}
			if (_session?.Zdo != null && _session.Zdo.IsValid())
			{
				userId = ((ZDOID)(ref _session.Zdo.m_uid)).UserID;
				id = ((ZDOID)(ref _session.Zdo.m_uid)).ID;
			}
		}

		public static FarmerNpc FindByKey(long key)
		{
			foreach (FarmerNpc instance in Instances)
			{
				if ((Object)(object)instance != (Object)null && instance.ZdoKey == key)
				{
					return instance;
				}
			}
			return null;
		}

		private void Awake()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			_nview = ((Component)this).GetComponent<ZNetView>();
			_character = ((Component)this).GetComponent<Character>();
			_humanoid = ((Component)this).GetComponent<Humanoid>();
			_inventory = new InventoryManager();
			Instances.Add(this);
			FarmerRoster.InvalidateNearCache();
			if ((Object)(object)_nview != (Object)null)
			{
				_nview.m_persistent = true;
				_nview.m_distant = false;
			}
			if ((Object)(object)_character != (Object)null)
			{
				_character.m_faction = (Faction)0;
				_character.m_group = "farmer_npc";
			}
		}

		private void Start()
		{
			FarmerAudio.Apply(((Component)this).gameObject);
			EnsureBrain();
		}

		internal void ActivateForWork()
		{
			if ((Object)(object)_nview == (Object)null)
			{
				_nview = ((Component)this).GetComponent<ZNetView>();
			}
			if ((Object)(object)_nview != (Object)null && _nview.IsValid() && !_nview.IsOwner())
			{
				try
				{
					_nview.ClaimOwnership();
				}
				catch
				{
				}
			}
			EnsureBrain()?.KickEvaluate();
		}

		private FarmerBrain EnsureBrain()
		{
			if ((Object)(object)_brain == (Object)null)
			{
				_brain = ((Component)this).gameObject.GetComponent<FarmerBrain>() ?? ((Component)this).gameObject.AddComponent<FarmerBrain>();
				_brain.Init(this);
			}
			return _brain;
		}

		private void Update()
		{
			//IL_0055: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_homestead != (Object)null)
			{
				_bindInterval = 1f;
				return;
			}
			_bindTimer += Time.deltaTime;
			if (!(_bindTimer < _bindInterval))
			{
				_bindTimer = 0f;
				if (_session == null)
				{
					TryResolveSession();
				}
				FarmerHomestead farmerHomestead = HomesteadLocator.FindNearest(GetHomesteadPosition(), 16f);
				if ((Object)(object)farmerHomestead == (Object)null)
				{
					farmerHomestead = HomesteadLocator.ResolveNear(GetHomesteadPosition(), 16f);
				}
				if ((Object)(object)farmerHomestead == (Object)null)
				{
					_bindInterval = Mathf.Min(_bindInterval * 1.5f, 8f);
					return;
				}
				_bindInterval = 1f;
				BindHomestead(farmerHomestead);
				farmerHomestead.AttachExistingNpc(this);
				Log.Info($"Bound orphan farmer to homestead MB at {((Component)farmerHomestead).transform.position}");
			}
		}

		private void OnDestroy()
		{
			try
			{
				ForcePersistInventory();
			}
			catch
			{
			}
			Instances.Remove(this);
			FarmerRoster.InvalidateNearCache();
		}

		public void UnbindAndDestroy()
		{
			_homestead = null;
			_session = null;
			Instances.Remove(this);
			FarmerRoster.InvalidateNearCache();
			if ((Object)(object)_nview != (Object)null && _nview.IsValid())
			{
				_nview.Destroy();
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public string GetHoverText()
		{
			bool flag = true;
			HomesteadData homesteadData = null;
			if ((Object)(object)_homestead != (Object)null)
			{
				homesteadData = _homestead.Data;
			}
			else if ((Object)(object)_nview != (Object)null && _nview.IsValid())
			{
				flag = false;
			}
			if (homesteadData != null)
			{
				flag = homesteadData.Paused;
			}
			return Localization.instance.Localize("$fj_npc_name\n[<color=yellow><b>$KEY_Use</b></color>] Toggle pause");
		}

		public string GetHoverName()
		{
			return Localization.instance.Localize("$fj_npc_name");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00ac: 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)
			if (hold)
			{
				return false;
			}
			if ((Object)(object)_homestead == (Object)null)
			{
				FarmerHomestead farmerHomestead = HomesteadLocator.ResolveNear(((Component)this).transform.position, 16f);
				if ((Object)(object)farmerHomestead != (Object)null)
				{
					BindHomestead(farmerHomestead);
				}
			}
			if ((Object)(object)_homestead != (Object)null)
			{
				_homestead.RequestTogglePause();
				bool flag = _homestead.Data?.Paused ?? false;
				PlayerFeedback.Notify(user, flag ? "Farmer paused" : "Farmer resumed");
				return true;
			}
			Vector3 val = ReadHomePosFromZdo();
			if (Vector3.Distance(val, ((Component)this).transform.position) > 40f)
			{
				val = ((Component)this).transform.position;
			}
			RpcMessages.RequestHomesteadOp(val, "toggle_pause", 0L, 0u);
			PlayerFeedback.Notify(user, "Toggled farmer pause");
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public void QueueDelayedPickup(Vector3 position, float radius, float delaySeconds = 0.25f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)this).StartCoroutine(DelayedPickup(position, radius, delaySeconds));
		}

		private IEnumerator DelayedPickup(Vector3 position, float radius, float delaySeconds)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			float[] array = new float[4] { 0.2f, 0.5f, 1f, 1.75f };
			float[] array2 = array;
			foreach (float num in array2)
			{
				yield return (object)new WaitForSeconds(num);
				if ((Object)(object)this == (Object)null || _inventory == null)
				{
					break;
				}
				WorldDropCollector.AbsorbFromHumanoid(_inventory, _humanoid);
				int destroyed;
				int num2 = WorldDropCollector.PickupNearbyDrops(_inventory, position, radius, GetWorkData(), out destroyed);
				if (num2 > 0)
				{
					PersistInventory();
					Log.Debug($"DelayedPickup grabbed {num2} stack(s) near {position}");
				}
			}
		}
	}
}
namespace ValheimFarmerNPC.Networking
{
	internal static class Authority
	{
		public static bool IsServerAuthoritative()
		{
			return AdminUtil.IsServer();
		}

		public static bool ValidateAdminRequest(long peerId, string action)
		{
			if (AdminUtil.IsServer())
			{
				if (!AdminUtil.CanConfigure(peerId))
				{
					Log.Warning($"Rejected {action} from non-admin peer {peerId}");
					return false;
				}
				return true;
			}
			if (AdminUtil.LocalPlayerCanAccess())
			{
				return true;
			}
			Log.Warning("Rejected " + action + " on client (not allowed to configure homestead)");
			return false;
		}

		public static long CurrentPeerId()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return 0L;
			}
			return ZNet.GetUID();
		}
	}
	internal enum ReservationType
	{
		Harvest,
		Plant
	}
	internal class SlotReservation
	{
		public string SlotId;

		public long HomesteadKey;

		public long FarmerKey;

		public ReservationType Type;

		public float ExpiresAt;
	}
	internal static class ReservationManager
	{
		private static readonly Dictionary<string, SlotReservation> Reservations = new Dictionary<string, SlotReservation>();

		private static readonly List<string> ExpiredScratch = new List<string>(8);

		private static int _tickFrame = -1;

		public static void Init()
		{
			Reservations.Clear();
			_tickFrame = -1;
		}

		public static void Tick()
		{
			if (Time.frameCount == _tickFrame)
			{
				return;
			}
			_tickFrame = Time.frameCount;
			float time = Time.time;
			ExpiredScratch.Clear();
			foreach (KeyValuePair<string, SlotReservation> reservation in Reservations)
			{
				if (reservation.Value.ExpiresAt <= time)
				{
					ExpiredScratch.Add(reservation.Key);
				}
			}
			for (int i = 0; i < ExpiredScratch.Count; i++)
			{
				Reservations.Remove(ExpiredScratch[i]);
			}
		}

		public static bool TryReserve(string slotId, long homesteadKey, long farmerKey, ReservationType type)
		{
			Tick();
			if (string.IsNullOrEmpty(slotId))
			{
				return false;
			}
			if (Reservations.TryGetValue(slotId, out var value))
			{
				if (value.FarmerKey == farmerKey && value.HomesteadKey == homesteadKey)
				{
					value.ExpiresAt = Time.time + SyncedConfig.ReservationTimeout;
					value.Type = type;
					return true;
				}
				return false;
			}
			Reservations[slotId] = new SlotReservation
			{
				SlotId = slotId,
				HomesteadKey = homesteadKey,
				FarmerKey = farmerKey,
				Type = type,
				ExpiresAt = Time.time + SyncedConfig.ReservationTimeout
			};
			return true;
		}

		public static void Release(string slotId, long farmerKey)
		{
			if (!string.IsNullOrEmpty(slotId) && Reservations.TryGetValue(slotId, out var value) && value.FarmerKey == farmerKey)
			{
				Reservations.Remove(slotId);
			}
		}

		public static void ReleaseAllForHomestead(long homesteadKey)
		{
			ExpiredScratch.Clear();
			foreach (KeyValuePair<string, SlotReservation> reservation in Reservations)
			{
				if (reservation.Value.HomesteadKey == homesteadKey)
				{
					ExpiredScratch.Add(reservation.Key);
				}
			}
			for (int i = 0; i < ExpiredScratch.Count; i++)
			{
				Reservations.Remove(ExpiredScratch[i]);
			}
			Log.Debug($"Released reservations for homestead {homesteadKey}");
		}

		public static bool IsReservedByOther(string slotId, long farmerKey)
		{
			Tick();
			if (Reservations.TryGetValue(slotId, out var value))
			{
				return value.FarmerKey != farmerKey;
			}
			return false;
		}
	}
	internal static class RpcMessages
	{
		private static bool _routedRegistered;

		public const string RpcEnsureNpcPos = "FJ_EnsureNpcPos";

		public const string RpcAssignChestPos = "FJ_AssignChestPos";

		public const string RpcHomesteadOp = "FJ_HomesteadOp";

		public const string RpcDestroyFarmer = "FJ_DestroyFarmer";

		public static void Register()
		{
			Log.Debug("RPC message names ready");
		}

		public static void EnsureRoutedRegistered()
		{
			if (!_routedRegistered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<long>("FJ_EnsureNpc", (Action<long, long>)RPC_EnsureNpcRouted);
				ZRoutedRpc.instance.Register<ZPackage>("FJ_EnsureNpcPos", (Action<long, ZPackage>)RPC_EnsureNpcPos);
				ZRoutedRpc.instance.Register<ZPackage>("FJ_AssignChestPos", (Action<long, ZPackage>)RPC_AssignChestPos);
				ZRoutedRpc.instance.Register<ZPackage>("FJ_HomesteadOp", (Action<long, ZPackage>)RPC_HomesteadOp);
				ZRoutedRpc.instance.Register<ZPackage>("FJ_DestroyFarmer", (Action<long, ZPackage>)RPC_DestroyFarmer);
				_routedRegistered = true;
				Log.Info("Registered routed homestead RPCs");
			}
		}

		private static void RPC_EnsureNpcRouted(long sender, long homesteadKey)
		{
			if (AdminUtil.IsServer())
			{
				Log.Debug($"EnsureNpc legacy key={homesteadKey} ignored (use EnsureNpcPos)");
			}
		}

		private static void RPC_EnsureNpcPos(long sender, ZPackage pkg)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			float num = pkg.ReadSingle();
			float num2 = pkg.ReadSingle();
			float num3 = pkg.ReadSingle();
			long userId = 0L;
			uint zdoId = 0u;
			if (pkg.Size() > pkg.GetPos())
			{
				userId = pkg.ReadLong();
				zdoId = pkg.ReadUInt();
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num, num2, num3);
			LogAdminSoft(sender, "SummonFarmer");
			FarmerHomestead farmerHomestead = HomesteadLocator.ResolveNear(val, 16f);
			if ((Object)(object)farmerHomestead != (Object)null)
			{
				farmerHomestead.TrySpawnNpc();
				Log.Info($"SummonFarmer via homestead piece near {val}");
			}
			else
			{
				HomesteadSession orCreate = HomesteadSession.GetOrCreate(userId, zdoId, val);
				orCreate.SummonFarmer();
				Log.Info($"SummonFarmer via session key={orCreate.Key} npc={(Object)(object)orCreate.Npc != (Object)null}");
			}
		}

		private static void RPC_AssignChestPos(long sender, ZPackage pkg)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (AdminUtil.IsServer())
			{
				float num = pkg.ReadSingle();
				float num2 = pkg.ReadSingle();
				float num3 = pkg.ReadSingle();
				float num4 = pkg.ReadSingle();
				float num5 = pkg.ReadSingle();
				float num6 = pkg.ReadSingle();
				long userId = 0L;
				uint zdoId = 0u;
				if (pkg.Size() > pkg.GetPos())
				{
					userId = pkg.ReadLong();
					zdoId = pkg.ReadUInt();
				}
				HomesteadSession orCreate = HomesteadSession.GetOrCreate(userId, zdoId, new Vector3(num, num2, num3));
				orCreate.AssignChest(new Vector3(num4, num5, num6));
				Log.Info("AssignChestPos via session key=" + orCreate.Key);
			}
		}

		private static void RPC_HomesteadOp(long sender, ZPackage pkg)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			if (!AdminUtil.IsServer())
			{
				return;
			}
			string text = pkg.ReadString();
			float num = pkg.ReadSingle();
			float num2 = pkg.ReadSingle();
			float num3 = pkg.ReadSingle();
			long userId = pkg.ReadLong();
			uint zdoId = pkg.ReadUInt();
			Vector3 pos = default(Vector3);
			((Vector3)(ref pos))..ctor(num, num2, num3);
			HomesteadSession orCreate = HomesteadSession.GetOrCreate(userId, zdoId, pos);
			switch (text)
			{
			case "toggle_pause":
				orCreate.TogglePause();
				break;
			case "pause_chests_full":
				orCreate.PauseChestsFull();
				break;
			case "scan":
			{
				FarmScanner.ScanResult scanResult = orCreate.Scan();
				Log.Info($"Session scan +{scanResult.Added} -{scanResult.Removed} total {scanResult.Total} ({scanResult.Message})");
				break;
			}
			case "apply_slots":
			{
				string text2 = ((pkg.Size() > pkg.GetPos()) ? pkg.ReadString() : "");
				int num13 = orCreate.ApplyClientScanSlots(text2);
				Log.Info($"Session apply_slots total={num13} chars={text2?.Length ?? 0}");
				break;
			}
			case "clear_field":
				orCreate.ClearField();
				break;
			case "clear_scan":
			{
				FarmScanner.ScanResult scanResult2 = orCreate.ClearAndScan();
				Log.Info($"Session clear+scan +{scanResult2.Added} -{scanResult2.Removed} total {scanResult2.Total} ({scanResult2.Message})");
				break;
			}
			case "add_farmer":
			{
				FarmerNpc farmerNpc = orCreate.AddFarmer();
				Log.Info($"Session add_farmer ok={(Object)(object)farmerNpc != (Object)null} total={FarmerRoster.CountNear(orCreate.Position)}");
				break;
			}
			case "remove_farmer":
				Log.Info($"Session remove_farmer ok={orCreate.RemoveFarmer()}");
				break;
			case "deposit_all":
				Log.Info($"Session deposit_all blocked={!orCreate.ForceDepositAll()}");
				break;
			case "boundary":
			{
				float num7 = pkg.ReadSingle();
				float num8 = pkg.ReadSingle();
				float num9 = pkg.ReadSingle();
				float num10 = pkg.ReadSingle();
				float num11 = pkg.ReadSingle();
				float num12 = pkg.ReadSingle();
				orCreate.AssignBoundary(new Vector3(num7, num8, num9), new Vector3(num10, num11, num12));
				break;
			}
			case "clear_chests":
				orCreate.ClearChests();
				break;
			case "clear_farmers":
			{
				List<ZDOID> list = new List<ZDOID>();
				if (pkg.Size() > pkg.GetPos())
				{
					int num4 = pkg.ReadInt();
					for (int i = 0; i < num4; i++)
					{
						long num5 = pkg.ReadLong();
						uint num6 = pkg.ReadUInt();
						list.Add(new ZDOID(num5, num6));
					}
				}
				orCreate.ClearAllNearbyFarmers(list);
				break;
			}
			case "crop_config":
			{
				string encoded2 = pkg.ReadString();
				orCreate.UpdateCropConfig(encoded2);
				break;
			}
			case "carried":
			{
				string encoded = pkg.ReadString();
				orCreate.UpdateCarried(encoded);
				break;
			}
			default:
				Log.Warning("Unknown homestead op '" + text + "'");
				break;
			}
		}

		private static void LogAdminSoft(long sender, string action)
		{
			if (SyncedConfig.AdminOnlyAccess && !AdminUtil.CanConfigure(sender))
			{
				Log.Warning($"{action}: peer {sender} failed admin check — continuing");
			}
		}

		private static void RPC_DestroyFarmer(long sender, ZPackage pkg)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (!AdminUtil.IsServer())
			{
				return;
			}
			if (SyncedConfig.AdminOnlyPlacement && !AdminUtil.PeerIsAdmin(sender))
			{
				Log.Warning($"DestroyFarmer denied for peer {sender}");
				return;
			}
			long num = pkg.ReadLong();
			uint num2 = pkg.ReadUInt();
			float num3 = pkg.ReadSingle();
			float num4 = pkg.ReadSingle();
			float num5 = pkg.ReadSingle();
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num3, num4, num5);
			if ((num != 0L || num2 != 0) && FarmerCleanup.DestroyById(new ZDOID(num, num2)))
			{
				Log.Info($"Admin DestroyFarmer id={num}:{num2}");
				return;
			}
			int num6 = FarmerCleanup.ClearNear(val, 4f, keepOne: false);
			Log.Info($"Admin DestroyFarmerNear {val} removed~{num6}");
		}

		public static void RequestDestroyFarmer(ZDOID id, Vector3 pos)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			EnsureRoutedRegistered();
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(((ZDOID)(ref id)).UserID);
				val.Write(((ZDOID)(ref id)).ID);
				val.Write(pos.x);
				val.Write(pos.y);
				val.Write(pos.z);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "FJ_DestroyFarmer", new object[1] { val });
			}
		}

		public static void RequestDestroyFarmerNear(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			RequestDestroyFarmer(ZDOID.None, pos);
		}

		public static void RequestEnsureNpc(long homesteadKey)
		{
			EnsureRoutedRegistered();
		}

		public static void RequestEnsureNpcAt(Vector3 homesteadPos, long zdoUserId = 0L, uint zdoId = 0u)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			EnsureRoutedRegistered();
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(homesteadPos.x);
				val.Write(homesteadPos.y);
				val.Write(homesteadPos.z);
				val.Write(zdoUserId);
				val.Write(zdoId);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "FJ_EnsureNpcPos", new object[1] { val });
				Log.Info($"Sent SummonFarmer ({homesteadPos.x:F1},{homesteadPos.y:F1},{homesteadPos.z:F1}) zdo={zdoUserId}:{zdoId}");
			}
		}

		public static void RequestAssignChest(Vector3 homesteadPos, Vector3 chestPos, long zdoUserId = 0L, uint zdoId = 0u)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			EnsureRoutedRegistered();
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(homesteadPos.x);
				val.Write(homesteadPos.y);
				val.Write(homesteadPos.z);
				val.Write(chestPos.x);
				val.Write(chestPos.y);
				val.Write(chestPos.z);
				val.Write(zdoUserId);
				val.Write(zdoId);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "FJ_AssignChestPos", new object[1] { val });
			}
		}

		public static void RequestHomesteadOp(Vector3 homesteadPos, string op, long zdoUserId, uint zdoId, Action<ZPackage> writeArgs = null)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0024: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			EnsureRoutedRegistered();
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(op ?? "");
				val.Write(homesteadPos.x);
				val.Write(homesteadPos.y);
				val.Write(homesteadPos.z);
				val.Write(zdoUserId);
				val.Write(zdoId);
				writeArgs?.Invoke(val);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "FJ_HomesteadOp", new object[1] { val });
			}
		}
	}
}
namespace ValheimFarmerNPC.Inventory
{
	internal static class ChestAssignments
	{
		private static int _resolveFrame = -1;

		private static object _resolveKey;

		private static float _resolveRange;

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

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

		private static int _containersFrame = -1;

		private static Container[] _containersCache = Array.Empty<Container>();

		public static Container FindContainerNear(Vector3 pos, float maxRange = 3f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FindPlaceableContainerNear(pos, maxRange, requirePiece: false);
		}

		public static Container FindNearestContainer(Vector3 from, float maxRange = 8f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FindContainerNear(from, maxRange);
		}

		public static Container FindNearestUnassigned(Vector3 from, HomesteadData data, float maxRange = 20f)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return FindNearestContainer(from, maxRange);
			}
			data.SyncChestListsFromCsv();
			CollectPlaceableNear(from, maxRange, NearScratch);
			Container val = null;
			float num = maxRange;
			for (int i = 0; i < NearScratch.Count; i++)
			{
				Container val2 = NearScratch[i];
				Vector3 position = ((Component)val2).transform.position;
				float num2 = HorizontalDistance(from, position);
				if (!(num2 >= num) && !data.IsChestAssigned(position))
				{
					num = num2;
					val = val2;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				Log.Info($"Chest assign pick '{((Object)val).name}' dist={num:F1}m " + $"candidates={NearScratch.Count} from={from}");
			}
			else
			{
				Log.Info($"Chest assign: no free chest in {maxRange}m (candidates={NearScratch.Count})");
			}
			return val;
		}

		public static void CountChestsInRange(Vector3 from, HomesteadData data, float maxRange, out int total, out int assigned)
		{
			//IL_0010: 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)
			total = 0;
			assigned = 0;
			data?.SyncChestListsFromCsv();
			CollectPlaceableNear(from, maxRange, NearScratch);
			for (int i = 0; i < NearScratch.Count; i++)
			{
				Container val = NearScratch[i];
				total++;
				if (data != null && data.IsChestAssigned(((Component)val).transform.position))
				{
					assigned++;
				}
			}
		}

		public static List<Container> ResolveFromPositions(IEnumerable<WorldRef> refs, float maxRange = 4f)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (refs == null)
			{
				return new List<Container>();
			}
			if (refs is IList list && Time.frameCount == _resolveFrame && _resolveKey == list && Mathf.Approximately(_resolveRange, maxRange))
			{
				return new List<Container>(ResolveCache);
			}
			ResolveCache.Clear();
			foreach (WorldRef @ref in refs)
			{
				if (@ref != null)
				{
					Container val = FindPlaceableContainerNear(@ref.Position, maxRange, requirePiece: true);
					if ((Object)(object)val != (Object)null && !ResolveCache.Contains(val))
					{
						ResolveCache.Add(val);
					}
				}
			}
			_resolveFrame = Time.frameCount;
			_resolveKey = ((refs is IList list2) ? list2 : null);
			_resolveRange = maxRange;
			return new List<Container>(ResolveCache);
		}

		private static Container[] CachedContainers()
		{
			if (Time.frameCount != _containersFrame)
			{
				_containersFrame = Time.frameCount;
				_containersCache = Object.FindObjectsOfType<Container>();
			}
			return _containersCache;
		}

		public static bool IsAssignableFarmChest(Container c)
		{
			if ((Object)(object)c == (Object)null || c.GetInventory() == null)
			{
				return false;
			}
			if ((Object)(object)((Component)c).GetComponent<Piece>() == (Object)null)
			{
				return false;
			}
			string text = (((Object)((Component)c).gameObject).name ?? "").Replace("(Clone)", "").Trim();
			if (text.StartsWith("piece_chest", StringComparison.OrdinalIgnoreCase))
			{
				return text.IndexOf("treasure", StringComparison.OrdinalIgnoreCase) < 0;
			}
			return string.Equals(text, "Cart", StringComparison.OrdinalIgnoreCase);
		}

		private static Container FindPlaceableContainerNear(Vector3 pos, float maxRange, bool requirePiece)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			CollectContainersNear(pos, maxRange, NearScratch, requirePiece);
			Container[] array = CachedContainers();
			foreach (Container val in array)
			{
				if (!((Object)(object)val == (Object)null) && val.GetInventory() != null && (!requirePiece || !((Object)(object)((Component)val).GetComponent<Piece>() == (Object)null)) && !(HorizontalDistance(pos, ((Component)val).transform.position) >= maxRange) && !NearScratch.Contains(val))
				{
					NearScratch.Add(val);
				}
			}
			return PickNearestAssignable(NearScratch, pos, maxRange);
		}

		private static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		private static Container PickNearestAssignable(List<Container> list, Vector3 pos, float maxRange)
		{
			//IL_0018: 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)
			Container result = null;
			float num = maxRange;
			for (int i = 0; i < list.Count; i++)
			{
				Container val = list[i];
				if (IsAssignableFarmChest(val))
				{
					float num2 = HorizontalDistance(pos, ((Component)val).transform.position);
					if (num2 < num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static void CollectPlaceableNear(Vector3 pos, float maxRange, List<Container> into)
		{
			//IL_001c: 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)
			into.Clear();
			Container[] array = CachedContainers();
			foreach (Container val in array)
			{
				if (IsAssignableFarmChest(val) && HorizontalDistance(pos, ((Component)val).transform.position) < maxRange)
				{
					into.Add(val);
				}
			}
		}

		private static void FilterAssignableInPlace(List<Container> list)
		{
			for (int num = list.Count - 1; num >= 0; num--)
			{
				if (!IsAssignableFarmChest(list[num]))
				{
					list.RemoveAt(num);
				}
			}
		}

		private static void CollectContainersNear(Vector3 pos, float maxRange, List<Container> into, bool requirePiece)
		{
			//IL_0006: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			into.Clear();
			int num = Math.Min(PhysicsQuery.OverlapSphereNonAlloc(pos, maxRange, -1), PhysicsQuery.Buffer.Length);
			for (int i = 0; i < num; i++)
			{
				Collider val = PhysicsQuery.Buffer[i];
				if (!((Object)(object)val == (Object)null))
				{
					Container componentInParent = ((Component)val).GetComponentInParent<Container>();
					if (!((Object)(object)componentInParent == (Object)null) && componentInParent.GetInventory() != null && (!requirePiece || !((Object)(object)((Component)componentInParent).GetComponent<Piece>() == (Object)null)) && !(HorizontalDistance(pos, ((Component)componentInParent).transform.position) > maxRange) && !into.Contains(componentInParent))
					{
						into.Add(componentInParent);
					}
				}
			}
		}

		public static int TryAddPrefabToChests(IEnumerable<WorldRef> chestRefs, string prefabName, int amount)
		{
			if (amount <= 0 || string.IsNullOrEmpty(prefabName))
			{
				return 0;
			}
			GameObject val = null;
			if ((Object)(object)ObjectDB.instance != (Object)null)
			{
				val = ObjectDB.instance.GetItemPrefab(prefabName);
			}
			if ((Object)(object)val == (Object)null && (Object)(object)ZNetScene.instance != (Object)null)
			{
				val = ZNetScene.instance.GetPrefab(prefabName);
			}
			if ((Object)(object)val == (Object)null)
			{
				Log.Warning("Deposit: missing prefab " + prefabName);
				return 0;
			}
			string sharedName = val.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_name;
			int num = amount;
			foreach (Container item in ResolveFromPositions(chestRefs))
			{
				if (num <= 0)
				{
					break;
				}
				int num2 = TryAddPrefabToContainer(item, val, prefabName, sharedName, num);
				num -= num2;
			}
			return amount - num;
		}

		private static int TryAddPrefabToContainer(Container c, GameObject prefab, string prefabName, string sharedName, int amount)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null || (Object)(object)prefab == (Object)null || amount <= 0)
			{
				return 0;
			}
			Inventory inventory = c.GetInventory();
			if (inventory == null)
			{
				return 0;
			}
			ClaimContainerOwnership(c);
			int num = amount;
			if (!inventory.CanAddItem(prefab, num))
			{
				num = 0;
				for (int num2 = amount; num2 >= 1; num2--)
				{
					if (inventory.CanAddItem(prefab, num2))
					{
						num = num2;
						break;
					}
				}
			}
			if (num <= 0)
			{
				return 0;
			}
			int num3 = CountInInventory(inventory, prefabName, sharedName);
			bool flag = inventory.AddItem(prefab, num);
			int num4 = CountInInventory(inventory, prefabName, sharedName) - num3;
			if (num4 <= 0)
			{
				ItemData val = inventory.AddItem(prefabName, num, 1, 0, 0L, string.Empty, false);
				num4 = CountInInventory(inventory, prefabName, sharedName) - num3;
				if (num4 <= 0)
				{
					Log.Warning($"Deposit rejected {prefabName} x{num} into {((Object)c).name} " + $"(AddItem={flag}, nameAdd={val != null}) — keeping on farmer");
					return 0;
				}
			}
			Log.Debug($"Deposit +{num4}x {prefabName} → {((Object)c).name} at {((Component)c).transform.position}");
			return num4;
		}

		private static void ClaimContainerOwnership(Container c)
		{
			ZNetView val = (((Object)(object)c != (Object)null) ? ((Component)c).GetComponent<ZNetView>() : null);
			if ((Object)(object)val == (Object)null || !val.IsValid() || val.IsOwner())
			{
				return;
			}
			try
			{
				val.ClaimOwnership();
			}
			catch (Exception ex)
			{
				Log.Debug("Deposit ownership claim failed: " + ex.Message);
			}
		}

		private static int CountInInventory(Inventory inv, string prefabName, string sharedName)
		{
			if (inv == null)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData allItem in inv.GetAllItems())
			{
				if (allItem != null)
				{
					if ((Object)(object)allItem.m_dropPrefab != (Object)null && string.Equals(((Object)allItem.m_dropPrefab).name, prefabName, StringComparison.OrdinalIgnoreCase))
					{
						num += allItem.m_stack;
					}
					else if (!string.IsNullOrEmpty(sharedName) && allItem.m_shared != null && string.Equals(allItem.m_shared.m_name, sharedName, StringComparison.OrdinalIgnoreCase))
					{
						num += allItem.m_stack;
					}
				}
			}
			return num;
		}

		public static bool TryAddToChests(IEnumerable<WorldRef> chestRefs, ItemData item, out Container used)
		{
			used = null;
			if (item == null)
			{
				return false;
			}
			string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : null);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (TryAddPrefabToChests(chestRefs, text, item.m_stack) <= 0)
			{
				return false;
			}
			List<Container> list = ResolveFromPositions(chestRefs);
			used = ((list.Count > 0) ? list[0] : null);
			return true;
		}
	}
	internal static class ChestLogistics
	{
		private static readonly string[] ReserveFamilies = new string[7] { "Carrot", "Turnip", "Onion", "Barley", "Flax", "JotunPuffs", "Magecap" };

		public static bool TryFetchSeeds(InventoryManager bag, HomesteadData data, string family, int amount = 1)
		{
			if (bag == null || !CropRegistry.TryGet(family, out var def))
			{
				return false;
			}
			int num = bag.CountItem(def.SeedItem);
			if (num >= amount)
			{
				return true;
			}
			int num2 = amount - num;
			data?.SyncChestListsFromCsv();
			if (data?.ChestPositions == null)
			{
				return bag.CountItem(def.SeedItem) > 0;
			}
			foreach (Container item in ChestAssignments.ResolveFromPositions(data.ChestPositions))
			{
				Inventory val = ((item != null) ? item.GetInventory() : null);
				if (val == null)
				{
					continue;
				}
				ItemData val2 = FindItem(val, def.SeedItem);
				if (val2 != null)
				{
					int num3 = Mathf.Min(num2, val2.m_stack);
					if (num3 <= 0)
					{
						return bag.CountItem(def.SeedItem) > 0;
					}
					if (!bag.TryAdd(def.SeedItem, num3))
					{
						return bag.CountItem(def.SeedItem) > 0;
					}
					val2.m_stack -= num3;
					if (val2.m_stack <= 0)
					{
						val.RemoveItem(val2);
					}
					num2 -= num3;
					if (num2 <= 0)
					{
						HomesteadStock.InvalidateTotalsCache();
						SeedManager.InvalidateSeedCountCache();
						return true;
					}
				}
			}
			if (num2 < amount - num)
			{
				HomesteadStock.InvalidateTotalsCache();
				SeedManager.InvalidateSeedCountCache();
			}
			return bag.CountItem(def.SeedItem) > 0;
		}

		public static bool TryFetchPlantingMaterial(InventoryManager bag, HomesteadData data, string family, int amount = 1)
		{
			if (bag == null)
			{
				return false;
			}
			if (bag.CountPlantingMaterialCarried(family) >= amount)
			{
				return true;
			}
			bool flag = TryFetchSeeds(bag, data, family, amount);
			if (bag.CountPlantingMaterialCarried(family) >= amount)
			{
				return true;
			}
			string text = CropWeights.FoodFamilyForSeedFamily(family);
			if (string.IsNullOrEmpty(text) || !CropRegistry.TryGet(text, out var def))
			{
				return bag.CountPlantingMaterialCarried(family) > 0 || flag;
			}
			int num = Math.Max(0, amount - bag.CountPlantingMaterialCarried(family));
			if (num <= 0)
			{
				return true;
			}
			bool flag2 = TryFetchItemFromChests(bag, data?.ChestPositions, def.GrownPrefab, num);
			SeedManager.InvalidateSeedCountCache();
			HomesteadStock.InvalidateTotalsCache();
			return bag.CountPlantingMaterialCarried(family) > 0 || flag || flag2;
		}

		public static bool NeedsReserveRestock(InventoryManager bag, HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (bag == null || data == null || !data.HasAnyChest)
			{
				return false;
			}
			string[] reserveFamilies = ReserveFamilies;
			foreach (string family in reserveFamilies)
			{
				int num = Math.Max(0, data.GetCropConfig(family)?.MinimumSeedReserve ?? 0);
				if (num > 0 && CropRegistry.TryGet(family, out var def) && HomesteadStock.CountPrefabAcrossHomestead(homesteadPos, def.SeedItem) < num)
				{
					int num2 = bag.CountItem(def.SeedItem);
					if (SeedManager.CountSeeds(data, bag, family) > num2)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool TryRestockReserves(InventoryManager bag, HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (bag == null || data == null || !data.HasAnyChest)
			{
				return false;
			}
			data.SyncChestListsFromCsv();
			bool flag = false;
			string[] reserveFamilies = ReserveFamilies;
			foreach (string family in reserveFamilies)
			{
				int num = Math.Max(0, data.GetCropConfig(family)?.MinimumSeedReserve ?? 0);
				if (num > 0 && CropRegistry.TryGet(family, out var def))
				{
					int num2 = HomesteadStock.CountPrefabAcrossHomestead(homesteadPos, def.SeedItem);
					int num3 = num - num2;
					if (num3 > 0 && TryFetchItemFromChests(bag, data.ChestPositions, def.SeedItem, num3))
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				SeedManager.InvalidateSeedCountCache();
				HomesteadStock.InvalidateTotalsCache();
			}
			return flag;
		}

		public static bool HasDepositableSurplus(InventoryManager bag, HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (bag == null || data == null || bag.UsedSlots == 0)
			{
				return false;
			}
			Dictionary<string, int> dictionary = HomesteadStock.SnapshotPrefabTotals(homesteadPos);
			foreach (CarriedItem item in bag.Items)
			{
				if (item != null && item.Stack > 0 && !string.IsNullOrEmpty(item.Prefab))
				{
					int configuredReserve = GetConfiguredReserve(data, item.Prefab);
					if (configuredReserve <= 0)
					{
						return true;
					}
					dictionary.TryGetValue(item.Prefab, out var value);
					int num = Math.Max(0, value - item.Stack);
					int num2 = Math.Min(item.Stack, Math.Max(0, configuredReserve - num));
					if (item.Stack > num2)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool TryDepositSurplus(InventoryManager bag, HomesteadData data, Vector3 homesteadPos, out bool blocked)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return TryDeposit(bag, data, homesteadPos, keepReserves: true, out blocked);
		}

		public static bool TryDepositAll(InventoryManager bag, HomesteadData data, out bool blocked)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return TryDeposit(bag, data, Vector3.zero, keepReserves: false, out blocked);
		}

		private static bool TryDeposit(InventoryManager bag, HomesteadData data, Vector3 homesteadPos, bool keepReserves, out bool blocked)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			blocked = false;
			if (bag == null || data == null)
			{
				return true;
			}
			HomesteadStock.InvalidateTotalsCache();
			List<CarriedItem> mutableItems = bag.MutableItems;
			List<CarriedItem> list = new List<CarriedItem>();
			foreach (CarriedItem item in mutableItems.ToList())
			{
				if (item == null || item.Stack <= 0 || string.IsNullOrEmpty(item.Prefab))
				{
					continue;
				}
				int num = (keepReserves ? GetSeedKeepCount(bag, data, item.Prefab, homesteadPos) : 0);
				int num2 = Mathf.Max(0, item.Stack - num);
				if (num2 <= 0)
				{
					list.Add(item);
					continue;
				}
				data.SyncChestListsFromCsv();
				int num3 = ChestAssignments.TryAddPrefabToChests(data.ChestPositions, item.Prefab, num2);
				int num4 = num2 - num3;
				if (num4 > 0)
				{
					item.Stack = num + num4;
					list.Add(item);
					blocked = data.HasAnyChest;
					if (num3 == 0)
					{
						Log.Warning($"Deposit kept {item.Stack}x {item.Prefab} on farmer (chest add failed)");
					}
				}
				else
				{
					if (num > 0)
					{
						item.Stack = num;
						list.Add(item);
					}
					HomesteadStock.InvalidateTotalsCache();
				}
			}
			mutableItems.Clear();
			mutableItems.AddRange(list);
			SeedManager.InvalidateSeedCountCache();
			HomesteadStock.InvalidateTotalsCache();
			return !blocked;
		}

		private static int GetSeedKeepCount(InventoryManager bag, HomesteadData data, string prefab, Vector3 homesteadPos)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			int configuredReserve = GetConfiguredReserve(data, prefab);
			if (configuredReserve <= 0)
			{
				return 0;
			}
			int num = bag.CountItem(prefab);
			int num2 = Math.Max(0, HomesteadStock.CountPrefabAcrossHomestead(homesteadPos, prefab) - num);
			return Math.Min(num, Math.Max(0, configuredReserve - num2));
		}

		private static int GetConfiguredReserve(HomesteadData data, string prefab)
		{
			if (data == null || !SeedManager.IsSeedItem(prefab))
			{
				return 0;
			}
			string[] reserveFamilies = ReserveFamilies;
			foreach (string family in reserveFamilies)
			{
				if (CropRegistry.TryGet(family, out var def) && string.Equals(def.SeedItem, prefab, StringComparison.OrdinalIgnoreCase))
				{
					return Math.Max(0, data.GetCropConfig(family)?.MinimumSeedReserve ?? 0);
				}
			}
			CropDefinition cropDefinition = CropRegistry.All.FirstOrDefault((CropDefinition d) => string.Equals(d.SeedItem, prefab, StringComparison.OrdinalIgnoreCase));
			if (cropDefinition == null)
			{
				return 0;
			}
			return Math.Max(0, data.GetCropConfig(cropDefinition.Family)?.MinimumSeedReserve ?? 0);
		}

		private static bool TryFetchItemFromChests(InventoryManager bag, List<WorldRef> positions, string prefab, int need)
		{
			if (bag == null || need <= 0 || string.IsNullOrEmpty(prefab) || positions == null)
			{
				return false;
			}
			bool result = false;
			foreach (Container item in ChestAssignments.ResolveFromPositions(positions))
			{
				if (TryTakeFromContainer(bag, item, prefab, ref need))
				{
					result = true;
				}
				if (need <= 0)
				{
					return true;
				}
			}
			return result;
		}

		private static bool TryTakeFromContainer(InventoryManager bag, Container c, string prefab, ref int need)
		{
			Inventory val = ((c != null) ? c.GetInventory() : null);
			if (val == null || need <= 0)
			{
				return false;
			}
			ItemData val2 = FindItem(val, prefab);
			if (val2 == null)
			{
				return false;
			}
			int num = Mathf.Min(need, val2.m_stack);
			if (num <= 0 || !bag.TryAdd(prefab, num))
			{
				return false;
			}
			val2.m_stack -= num;
			if (val2.m_stack <= 0)
			{
				val.RemoveItem(val2);
			}
			need -= num;
			return true;
		}

		private static ItemData FindItem(Inventory inv, string prefab)
		{
			foreach (ItemData allItem in inv.GetAllItems())
			{
				if ((Object)(object)allItem?.m_dropPrefab != (Object)null && string.Equals(((Object)allItem.m_dropPrefab).name, prefab, StringComparison.OrdinalIgnoreCase))
				{
					return allItem;
				}
			}
			return null;
		}
	}
	internal static class HomesteadStock
	{
		private static int _totalsFrame = -1;

		private static Vector3 _totalsPos;

		private static Dictionary<string, int> _totalsCache;

		private static readonly List<FarmerNpc> TotalsFarmersScratch = new List<FarmerNpc>(8);

		public static List<CarriedItem> Aggregate(IEnumerable<InventoryManager> inventories)
		{
			Dictionary<string, CarriedItem> map = new Dictionary<string, CarriedItem>(StringComparer.OrdinalIgnoreCase);
			if (inventories == null)
			{
				return new List<CarriedItem>();
			}
			foreach (InventoryManager inventory in inventories)
			{
				MergeInventory(map, inventory);
			}
			return ToSortedList(map);
		}

		public static List<CarriedItem> AggregateFromFarmers(List<FarmerNpc> farmers)
		{
			Dictionary<string, CarriedItem> map = new Dictionary<string, CarriedItem>(StringComparer.OrdinalIgnoreCase);
			if (farmers == null)
			{
				return new List<CarriedItem>();
			}
			for (int i = 0; i < farmers.Count; i++)
			{
				FarmerNpc farmerNpc = farmers[i];
				if (farmerNpc?.Inventory != null)
				{
					MergeInventory(map, farmerNpc.Inventory);
				}
			}
			return ToSortedList(map);
		}

		private static void MergeInventory(Dictionary<string, CarriedItem> map, InventoryManager inv)
		{
			if (inv == null)
			{
				return;
			}
			foreach (CarriedItem item in inv.Items)
			{
				if (item != null && !string.IsNullOrEmpty(item.Prefab) && item.Stack > 0)
				{
					if (map.TryGetValue(item.Prefab, out var value))
					{
						value.Stack += item.Stack;
					}
					else
					{
						map[item.Prefab] = InventoryManager.CloneItem(item);
					}
				}
			}
		}

		private static List<CarriedItem> ToSortedList(Dictionary<string, CarriedItem> map)
		{
			List<CarriedItem> list = new List<CarriedItem>(map.Count);
			foreach (CarriedItem value in map.Values)
			{
				list.Add(value);
			}
			list.Sort((CarriedItem a, CarriedItem b) => string.Compare(a.Prefab, b.Prefab, StringComparison.OrdinalIgnoreCase));
			return list;
		}

		public static List<CarriedItem> AggregateItemsFromChests(IEnumerable<WorldRef> chestRefs)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (Container item in ChestAssignments.ResolveFromPositions(chestRefs))
			{
				Inventory val = (((Object)(object)item != (Object)null) ? item.GetInventory() : null);
				if (val == null)
				{
					continue;
				}
				foreach (ItemData allItem in val.GetAllItems())
				{
					if (allItem != null && allItem.m_stack > 0 && ItemPrefabResolver.TryResolveAnyItemPrefabName(allItem, out var prefabName) && !string.IsNullOrEmpty(prefabName))
					{
						if (dictionary.TryGetValue(prefabName, out var value))
						{
							dictionary[prefabName] = value + allItem.m_stack;
						}
						else
						{
							dictionary[prefabName] = allItem.m_stack;
						}
					}
				}
			}
			return (from kv in dictionary
				select new CarriedItem
				{
					Prefab = kv.Key,
					Stack = kv.Value
				} into i
				orderby i.Prefab
				select i).ToList();
		}

		public static Dictionary<string, int> SnapshotPrefabTotals(Vector3 homesteadPos)
		{
			//IL_003d: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0017: 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)
			if (Time.frameCount == _totalsFrame)
			{
				Vector3 val = homesteadPos - _totalsPos;
				if (((Vector3)(ref val)).sqrMagnitude < 0.01f && _totalsCache != null)
				{
					return _totalsCache;
				}
			}
			_totalsFrame = Time.frameCount;
			_totalsPos = homesteadPos;
			if (_totalsCache == null)
			{
				_totalsCache = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			}
			else
			{
				_totalsCache.Clear();
			}
			FarmerRoster.ListNearNonAlloc(homesteadPos, TotalsFarmersScratch);
			for (int i = 0; i < TotalsFarmersScratch.Count; i++)
			{
				InventoryManager inventoryManager = TotalsFarmersScratch[i]?.Inventory;
				if (inventoryManager == null)
				{
					continue;
				}
				foreach (CarriedItem item in inventoryManager.Items)
				{
					if (item != null && !string.IsNullOrEmpty(item.Prefab) && item.Stack > 0)
					{
						if (_totalsCache.TryGetValue(item.Prefab, out var value))
						{
							_totalsCache[item.Prefab] = value + item.Stack;
						}
						else
						{
							_totalsCache[item.Prefab] = item.Stack;
						}
					}
				}
			}
			return _totalsCache;
		}

		public static int CountPrefabAcrossHomestead(Vector3 homesteadPos, string prefab)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(prefab))
			{
				return 0;
			}
			if (!SnapshotPrefabTotals(homesteadPos).TryGetValue(prefab, out var value))
			{
				return 0;
			}
			return value;
		}

		public static void InvalidateTotalsCache()
		{
			_totalsFrame = -1;
			_totalsCache?.Clear();
		}
	}
	internal class InventoryManager
	{
		private readonly List<CarriedItem> _items = new List<CarriedItem>();

		private readonly int _capacity;

		public IReadOnlyList<CarriedItem> Items => _items;

		internal List<CarriedItem> MutableItems => _items;

		public int Count => _items.Sum((CarriedItem i) => 1);

		public int UsedSlots => _items.Count;

		public int Capacity => _capacity;

		public bool IsNearlyFull => UsedSlots >= Mathf.CeilToInt((float)_capacity * 0.85f);

		public bool IsFull => UsedSlots >= _capacity;

		public InventoryManager(int capacity = -1)
		{
			_capacity = ((capacity > 0) ? capacity : SyncedConfig.InventoryCapacity);
		}

		public void LoadFrom(HomesteadData data)
		{
			_items.Clear();
			if (data?.CarriedItems != null)
			{
				_items.AddRange(data.CarriedItems.Select(CloneItem));
			}
		}

		public void Clear()
		{
			_items.Clear();
		}

		public void SaveTo(HomesteadData data)
		{
			if (data != null)
			{
				data.CarriedItems = _items.Select(CloneItem).ToList();
			}
		}

		public void AbsorbAll(InventoryManager other)
		{
			if (other == null)
			{
				return;
			}
			foreach (CarriedItem item in other._items.ToList())
			{
				if (item != null && !string.IsNullOrEmpty(item.Prefab) && item.Stack > 0)
				{
					CarriedItem carriedItem = _items.FirstOrDefault((CarriedItem i) => string.Equals(i.Prefab, item.Prefab, StringComparison.OrdinalIgnoreCase));
					if (carriedItem != null)
					{
						carriedItem.Stack += item.Stack;
					}
					else
					{
						_items.Add(CloneItem(item));
					}
				}
			}
			other._items.Clear();
		}

		public int CountItem(string prefab)
		{
			return _items.Where((CarriedItem i) => string.Equals(i.Prefab, prefab, StringComparison.OrdinalIgnoreCase)).Sum((CarriedItem i) => i.Stack);
		}

		public bool TryAdd(string prefab, int stack = 1)
		{
			if (string.IsNullOrEmpty(prefab) || stack <= 0)
			{
				return false;
			}
			CarriedItem carriedItem = _items.FirstOrDefault((CarriedItem i) => string.Equals(i.Prefab, prefab, StringComparison.OrdinalIgnoreCase));
			if (carriedItem != null)
			{
				carriedItem.Stack += stack;
				return true;
			}
			if (IsFull)
			{
				return false;
			}
			_items.Add(new CarriedItem
			{
				Prefab = prefab,
				Stack = stack
			});
			return true;
		}

		public bool TryRemove(string prefab, int stack = 1)
		{
			CarriedItem carriedItem = _items.FirstOrDefault((CarriedItem i) => string.Equals(i.Prefab, prefab, StringComparison.OrdinalIgnoreCase));
			if (carriedItem == null || carriedItem.Stack < stack)
			{
				return false;
			}
			carriedItem.Stack -= stack;
			if (carriedItem.Stack <= 0)
			{
				_items.Remove(carriedItem);
			}
			return true;
		}

		public bool ConsumeSeed(string family)
		{
			if (!CropRegistry.TryGet(family, out var def))
			{
				return false;
			}
			return TryRemove(def.SeedItem);
		}

		public bool ConsumePlantingMaterial(string family)
		{
			if (ConsumeSeed(family))
			{
				return true;
			}
			string text = CropWeights.FoodFamilyForSeedFamily(family);
			if (string.IsNullOrEmpty(text) || !CropRegistry.TryGet(text, out var def))
			{
				return false;
			}
			return TryRemove(def.GrownPrefab);
		}

		public int CountPlantingMaterialCarried(string family)
		{
			if (!CropRegistry.TryGet(family, out var def))
			{
				return 0;
			}
			int num = CountItem(def.SeedItem);
			string text = CropWeights.FoodFamilyForSeedFamily(family);
			if (!string.IsNullOrEmpty(text) && CropRegistry.TryGet(text, out var def2))
			{
				num += CountItem(def2.GrownPrefab);
			}
			return num;
		}

		public void DropAllAt(Vector3 position)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				_items.Clear();
				return;
			}
			foreach (CarriedItem item in _items)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(item.Prefab);
				if (!((Object)(object)prefab == (Object)null))
				{
					ItemDrop component = Object.Instantiate<GameObject>(prefab, position + Vector3.up, Quaternion.identity).GetComponent<ItemDrop>();
					if ((Object)(object)component != (Object)null)
					{
						component.m_itemData.m_stack = item.Stack;
						component.Save();
					}
				}
			}
			_items.Clear();
		}

		internal static CarriedItem CloneItem(CarriedItem i)
		{
			return new CarriedItem
			{
				Prefab = i.Prefab,
				Stack = i.Stack,
				Quality = i.Quality,
				Variant = i.Variant,
				Durability = i.Durability
			};
		}
	}
	internal static class ItemPrefabResolver
	{
		public static bool TryResolveAnyItemPrefabName(ItemData item, out string prefabName)
		{
			prefabName = null;
			if (item == null)
			{
				return false;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				string text = ((Object)item.m_dropPrefab).name?.Replace("(Clone)", "").Trim();
				if (!string.IsNullOrEmpty(text))
				{
					prefabName = text;
					return true;
				}
			}
			if (TryResolveCropPrefabName(item, out prefabName))
			{
				return true;
			}
			string text2 = item.m_shared?.m_name;
			if (!string.IsNullOrEmpty(text2))
			{
				prefabName = (text2.StartsWith("$item_", StringComparison.OrdinalIgnoreCase) ? text2.Substring(6) : text2.TrimStart(new char[1] { '$' }));
				return !string.IsNullOrEmpty(prefabName);
			}
			return false;
		}

		public static bool TryResolveCropPrefabName(ItemData item, out string prefabName)
		{
			prefabName = null;
			if (item == null)
			{
				return false;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				string name = ((Object)item.m_dropPrefab).name;
				if (IsKnownCropLootName(name))
				{
					prefabName = name;
					return true;
				}
			}
			string text = item.m_shared?.m_name;
			if (string.IsNullOrEmpty(text) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			foreach (CropDefinition item2 in CropRegistry.All)
			{
				if (SharedNameMatches(item2.GrownPrefab, text))
				{
					prefabName = item2.GrownPrefab;
					return true;
				}
				if (SharedNameMatches(item2.SeedItem, text))
				{
					prefabName = item2.SeedItem;
					return true;
				}
			}
			return false;
		}

		public static bool IsKnownCropLootItem(ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null)
			{
				return false;
			}
			if (TryResolveCropPrefabName(drop.m_itemData, out var _))
			{
				return true;
			}
			string text = null;
			if ((Object)(object)drop.m_itemData?.m_dropPrefab != (Object)null)
			{
				text = ((Object)drop.m_itemData.m_dropPrefab).name;
			}
			if (string.IsNullOrEmpty(text))
			{
				text = ((Object)drop).name.Replace("(Clone)", "").Trim();
			}
			return IsKnownCropLootName(text);
		}

		public static bool IsKnownCropLootName(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			foreach (CropDefinition item in CropRegistry.All)
			{
				if (string.Equals(item.GrownPrefab, prefabName, StringComparison.OrdinalIgnoreCase) || string.Equals(item.SeedItem, prefabName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool SharedNameMatches(string itemPrefab, string sharedName)
		{
			if (string.IsNullOrEmpty(itemPrefab) || string.IsNullOrEmpty(sharedName))
			{
				return false;
			}
			GameObject itemPrefab2 = ObjectDB.instance.GetItemPrefab(itemPrefab);
			string text = (((Object)(object)itemPrefab2 != (Object)null) ? itemPrefab2.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_name;
			if (!string.IsNullOrEmpty(text))
			{
				return string.Equals(text, sharedName, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}
	}
	internal static class WorldDropCollector
	{
		public static bool IsPickupableWorldDrop(ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null || drop.m_itemData == null)
			{
				return false;
			}
			EnsureItemDataReady(drop);
			if (drop.m_itemData == null)
			{
				return false;
			}
			bool flag = ItemPrefabResolver.IsKnownCropLootItem(drop);
			int num = GetDropStack(drop);
			if (num <= 0 && flag)
			{
				drop.m_itemData.m_stack = 1;
				num = 1;
			}
			if (num <= 0)
			{
				return false;
			}
			if ((Object)(object)((Component)drop).GetComponent<Plant>() != (Object)null)
			{
				return false;
			}
			Pickable component = ((Component)drop).GetComponent<Pickable>();
			if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled && !component.m_picked && (!flag || (!((Object)(object)((Component)drop).GetComponent<Piece>() != (Object)null) && !((Object)(object)((Component)drop).GetComponent<Rigidbody>() != (Object)null))))
			{
				return false;
			}
			if ((Object)(object)((Component)drop).GetComponentInParent<Character>() != (Object)null || (Object)(object)((Component)drop).GetComponentInParent<Container>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)drop).GetComponent<Piece>() != (Object)null && (Object)(object)((Component)drop).GetComponent<WearNTear>() != (Object)null && !flag)
			{
				return false;
			}
			ZNetView component2 = ((Component)drop).GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null && component2.IsValid())
			{
				return true;
			}
			return flag;
		}

		public static bool HasPickupableDrops(Vector3 position, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Min(PhysicsQuery.OverlapSphereNonAlloc(position, radius, PhysicsQuery.DefaultMask), PhysicsQuery.Buffer.Length);
			for (int i = 0; i < num; i++)
			{
				Collider val = PhysicsQuery.Buffer[i];
				if ((Object)(object)val != (Object)null && IsPickupableWorldDrop(((Component)val).GetComponentInParent<ItemDrop>()))
				{
					return true;
				}
			}
			return false;
		}

		public static void PickupNearbyDrops(InventoryManager bag, Vector3 position, float radius, HomesteadData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PickupNearbyDrops(bag, position, radius, data, out var _);
		}

		public static int PickupNearbyDrops(InventoryManager bag, Vector3 position, float radius, HomesteadData data, out int destroyed)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			destroyed = 0;
			if (bag == null)
			{
				return 0;
			}
			Collider[] array = Physics.OverlapSphere(position, radius);
			if (array == null || array.Length == 0)
			{
				return 0;
			}
			List<ItemDrop> list = new List<ItemDrop>();
			HashSet<int> hashSet = new HashSet<int>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponentInParent<ItemDrop>() : null);
				if (IsPickupableWorldDrop(val2))
				{
					int instanceID = ((Object)val2).GetInstanceID();
					if (hashSet.Add(instanceID))
					{
						list.Add(val2);
					}
				}
			}
			int num = 0;
			foreach (ItemDrop item in list)
			{
				if ((Object)(object)item == (Object)null || bag.IsFull)
				{
					break;
				}
				if (!IsPickupableWorldDrop(item))
				{
					continue;
				}
				ZNetView component = ((Component)item).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid() && !component.IsOwner())
				{
					component.ClaimOwnership();
				}
				string prefabName;
				string prefab = ((!ItemPrefabResolver.TryResolveCropPrefabName(item.m_itemData, out prefabName)) ? (((Object)(object)item.m_itemData.m_dropPrefab != (Object)null) ? ((Object)item.m_itemData.m_dropPrefab).name : ((Object)item).name.Replace("(Clone)", "").Trim()) : prefabName);
				int dropStack = GetDropStack(item);
				if (dropStack > 0 && bag.TryAdd(prefab, dropStack))
				{
					if (!TryDestroyWorldDrop(item))
					{
						bag.TryRemove(prefab, dropStack);
						continue;
					}
					num++;
					destroyed++;
				}
			}
			return num;
		}

		public static int AbsorbFromHumanoid(InventoryManager bag, Humanoid humanoid)
		{
			Inventory val = ((humanoid != null) ? humanoid.GetInventory() : null);
			if (bag == null || val == null || bag.IsFull)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData item in val.GetAllItems().ToList())
			{
				if (item == null || bag.IsFull)
				{
					break;
				}
				if (ItemPrefabResolver.TryResolveCropPrefabName(item, out var prefabName))
				{
					int stack = item.m_stack;
					if (stack > 0 && bag.TryAdd(prefabName, stack))
					{
						val.RemoveItem(item);
						num++;
						Log.Debug($"AbsorbFromHumanoid +{stack}x {prefabName}");
					}
				}
			}
			return num;
		}

		public static int EnsureHarvestProduct(InventoryManager bag, string productPrefab, int amountBefore, int yieldAmount)
		{
			if (bag == null || !ItemPrefabResolver.IsKnownCropLootName(productPrefab) || yieldAmount <= 0)
			{
				return 0;
			}
			int num = bag.CountItem(productPrefab) - amountBefore;
			if (num >= yieldAmount)
			{
				return 0;
			}
			int num2 = yieldAmount - Math.Max(0, num);
			if (!bag.TryAdd(productPrefab, num2))
			{
				return 0;
			}
			return num2;
		}

		private static bool TryDestroyWorldDrop(ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null)
			{
				return false;
			}
			GameObject gameObject = ((Component)drop).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)drop).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				Object.Destroy((Object)(object)gameObject);
				return true;
			}
			try
			{
				if (!component.IsOwner())
				{
					component.ClaimOwnership();
				}
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					ZNetScene.instance.Destroy(gameObject);
				}
				else
				{
					component.Destroy();
				}
				return true;
			}
			catch (Exception ex)
			{
				Log.Warning("Pickup destroy failed for " + ((Object)gameObject).name + ": " + ex.Message);
				return false;
			}
		}

		private static void EnsureItemDataReady(ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null)
			{
				return;
			}
			try
			{
				if (drop.m_itemData == null || drop.m_itemData.m_stack <= 0)
				{
					drop.Load();
				}
			}
			catch
			{
			}
		}

		private static int GetDropStack(ItemDrop drop)
		{
			if (drop?.m_itemData == null)
			{
				return 0;
			}
			if (drop.m_itemData.m_stack > 0)
			{
				return drop.m_itemData.m_stack;
			}
			ZNetView component = ((Component)drop).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null && component.IsValid()) ? component.GetZDO() : null);
			if (val == null || !val.IsValid())
			{
				return 0;
			}
			int num = val.GetInt(ZDOVars.s_stack, 0);
			if (num > 0)
			{
				drop.m_itemData.m_stack = num;
			}
			return drop.m_itemData.m_stack;
		}
	}
}
namespace ValheimFarmerNPC.Homestead
{
	internal static class HomesteadFarmerOps
	{
		public static FarmerNpc FindNearest(Vector3 pos, float range, IEnumerable<FarmerNpc> extraCandidates = null)
		{
			//IL_0004: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			FarmerNpc result = null;
			float num = range;
			foreach (FarmerNpc item in FarmerRoster.ListNear(pos, range))
			{
				if (!((Object)(object)item == (Object)null))
				{
					float num2 = Vector3.Distance(((Component)item).transform.position, pos);
					if (num2 < num)
					{
						num = num2;
						result = item;
					}
				}
			}
			if (extraCandidates != null)
			{
				foreach (FarmerNpc extraCandidate in extraCandidates)
				{
					if (!((Object)(object)extraCandidate == (Object)null))
					{
						float num3 = Vector3.Distance(((Component)extraCandidate).transform.position, pos);
						if (num3 < num)
						{
							num = num3;
							result = extraCandidate;
						}
					}
				}
			}
			return result;
		}

		public static bool TryRemoveOne(Vector3 position, HomesteadData data, FarmerNpc currentPrimary, out FarmerNpc newPrimary, out bool wroteData)
		{
			//IL_000e: 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)
			newPrimary = currentPrimary;
			wroteData = false;
			FarmerNpc target = FarmerRoster.PickRemovable(position);
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			List<FarmerNpc> list = FarmerRoster.ListNear(position).FindAll((FarmerNpc n) => (Object)(object)n != (Object)(object)target);
			if (list.Count > 0)
			{
				list[0].Inventory.AbsorbAll(target.Inventory);
			}
			else if (data != null)
			{
				target.Inventory.SaveTo(data);
				wroteData = true;
			}
			if (currentPrimary == target)
			{
				newPrimary = ((list.Count > 0) ? list[0] : null);
			}
			target.UnbindAndDestroy();
			return true;
		}

		public static FarmerNpc SpawnAdditional(Vector3 position, Quaternion rotation, FarmerHomestead pieceOrNull)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FarmerSpawner.SpawnAdditional(position, rotation, pieceOrNull);
		}

		public static FarmerNpc TrySpawnNearHomestead(Vector3 position, Quaternion rotation, FarmerHomestead pieceOrNull)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FarmerSpawner.TrySpawnNearHomestead(position, rotation, pieceOrNull);
		}

		public static void ClearNearbyFarmers(Vector3 position, float range, List<ZDOID> extraIds = null)
		{
			//IL_0000: 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)
			CullExtraNpcs(position, range);
			FarmerCleanup.ClearNear(position, range, keepOne: false, extraIds);
		}

		public static void CullExtraNpcs(Vector3 pos, float range)
		{
			//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_000e: 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)
			List<FarmerNpc> list = FarmerRoster.ListNear(pos, range);
			list.Sort((FarmerNpc a, FarmerNpc b) => Vector3.Distance(((Component)a).transform.position, pos).CompareTo(Vector3.Distance(((Component)b).transform.position, pos)));
			for (int num = 1; num < list.Count; num++)
			{
				Log.Warning($"Destroying surplus farmer #{num} at {((Component)list[num]).transform.position}");
				list[num].UnbindAndDestroy();
			}
		}
	}
	internal static class HomesteadOps
	{
		public struct DepositAllResult
		{
			public int Emptied;

			public int FarmerCount;

			public bool Blocked;

			public bool NoChests;

			public bool NoFarmers;
		}

		public const string ChestsFullMessage = "Chests full — farmers paused. Free space or add a chest, then unpause.";

		public static FarmScanner.ScanResult Scan(HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FarmScanner.Scan(data, homesteadPos);
		}

		public static int ClearField(HomesteadData data)
		{
			int valueOrDefault = (data?.Slots?.Count).GetValueOrDefault();
			if (data != null)
			{
				List<FarmSlot> slots = data.Slots;
				if (slots == null)
				{
					return valueOrDefault;
				}
				slots.Clear();
			}
			return valueOrDefault;
		}

		public static FarmScanner.ScanResult ClearAndScan(HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			data?.Slots?.Clear();
			return FarmScanner.Scan(data, homesteadPos);
		}

		public static void AssignBoundary(HomesteadData data, Vector3 a, Vector3 b, long postAKey = 0L, long postBKey = 0L)
		{
			//IL_0005: 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)
			if (data != null)
			{
				data.SetBoundary(a, b);
				if (postAKey != 0L)
				{
					data.BoundaryPostA = postAKey;
				}
				if (postBKey != 0L)
				{
					data.BoundaryPostB = postBKey;
				}
			}
		}

		public static bool TryAssignBoundaryFromNearbyPosts(HomesteadData data, Vector3 homesteadPos)
		{
			//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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return false;
			}
			List<BoundaryPost> list = (from p in Object.FindObjectsOfType<BoundaryPost>()
				orderby Vector3.Distance(((Component)p).transform.position, homesteadPos)
				select p).Take(2).ToList();
			if (list.Count < 2)
			{
				return false;
			}
			AssignBoundary(data, ((Component)list[0]).transform.position, ((Component)list[1]).transform.position, list[0].GetKey(), list[1].GetKey());
			return true;
		}

		public static bool TryAssignChest(HomesteadData data, Vector3 chestPos)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return data?.TryAddChestPosition(chestPos) ?? false;
		}

		public static Container FindNearestUnassignedChest(HomesteadData data, Vector3 homesteadPos, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ChestAssignments.FindNearestUnassigned(homesteadPos, data, range);
		}

		public static void ClearChests(HomesteadData data)
		{
			data?.ClearAllChests();
		}

		public static void SetPaused(HomesteadData data, bool paused)
		{
			if (data != null)
			{
				data.Paused = paused;
			}
		}

		public static void TogglePaused(HomesteadData data)
		{
			if (data != null)
			{
				data.Paused = !data.Paused;
			}
		}

		public static void SetLayoutMode(HomesteadData data, string mode)
		{
			if (data != null)
			{
				if (string.Equals(mode, "Weighted", StringComparison.OrdinalIgnoreCase))
				{
					data.LayoutMode = "Weighted";
				}
				else
				{
					data.LayoutMode = "Fixed";
				}
			}
		}

		public static bool UpdateCropConfig(HomesteadData data, string encoded, bool setWeightedLayout = false)
		{
			if (data == null || string.IsNullOrEmpty(encoded))
			{
				return false;
			}
			if (data.CropConfigs == null)
			{
				data.CropConfigs = CropRegistry.CreateDefaultConfigs();
			}
			string[] array = encoded.Split(new char[1] { '|' });
			if (array.Length < 7)
			{
				return false;
			}
			CropConfigEntry cropConfigEntry = data.GetCropConfig(array[0]);
			if (cropConfigEntry == null)
			{
				cropConfigEntry = new CropConfigEntry
				{
					Family = array[0]
				};
				data.CropConfigs.Add(cropConfigEntry);
			}
			cropConfigEntry.Enabled = array[1] == "1";
			int.TryParse(array[2], out cropConfigEntry.Weight);
			cropConfigEntry.HarvestEnabled = array[3] == "1";
			cropConfigEntry.PlantEnabled = array[4] == "1";
			int.TryParse(array[5], out cropConfigEntry.MinimumSeedReserve);
			int.TryParse(array[6], out cropConfigEntry.MaximumSeedPercent);
			if (setWeightedLayout)
			{
				data.LayoutMode = "Weighted";
			}
			return true;
		}

		public static string BuildNoFreeChestMessage(Vector3 homesteadPos, HomesteadData data, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ChestAssignments.CountChestsInRange(homesteadPos, data, range, out var total, out var assigned);
			if (total > 0 && assigned >= total)
			{
				return "No chest added — nearby chests are already assigned. " + $"Build more chests within {range:0}m of the homestead, then add again.";
			}
			return "No chest added — no free chest nearby. " + $"Place a chest within {range:0}m of the homestead, then add again.";
		}

		public static DepositAllResult ForceDepositAll(HomesteadData data, Vector3 homesteadPos, InventoryManager pendingInventory = null)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			DepositAllResult result = default(DepositAllResult);
			if (data == null)
			{
				return result;
			}
			data.SyncChestListsFromCsv();
			if (!data.HasAnyChest)
			{
				result.NoChests = true;
				return result;
			}
			List<FarmerNpc> list = FarmerRoster.ListNear(homesteadPos);
			result.FarmerCount = list.Count;
			if (list.Count == 0 && pendingInventory == null)
			{
				result.NoFarmers = true;
				return result;
			}
			foreach (FarmerNpc item in list)
			{
				if (item?.Inventory != null)
				{
					ChestLogistics.TryDepositAll(item.Inventory, data, out var blocked);
					result.Blocked |= blocked;
					item.ForcePersistInventory();
					if (item.Inventory.UsedSlots == 0)
					{
						result.Emptied++;
					}
				}
			}
			if (pendingInventory != null)
			{
				ChestLogistics.TryDepositAll(pendingInventory, data, out var blocked2);
				result.Blocked |= blocked2;
			}
			return result;
		}

		public static void DepositSurplusAll(HomesteadData data, Vector3 homesteadPos, out bool blocked, InventoryManager pendingInventory = null)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			blocked = false;
			if (data == null)
			{
				return;
			}
			data.SyncChestListsFromCsv();
			if (!data.HasAnyChest)
			{
				return;
			}
			foreach (FarmerNpc item in FarmerRoster.ListNear(homesteadPos))
			{
				if (item?.Inventory != null && ChestLogistics.HasDepositableSurplus(item.Inventory, data, homesteadPos))
				{
					ChestLogistics.TryDepositSurplus(item.Inventory, data, homesteadPos, out var blocked2);
					blocked |= blocked2;
					item.ForcePersistInventory();
				}
			}
			if (pendingInventory != null && ChestLogistics.HasDepositableSurplus(pendingInventory, data, homesteadPos))
			{
				ChestLogistics.TryDepositSurplus(pendingInventory, data, homesteadPos, out var blocked3);
				blocked |= blocked3;
			}
		}

		public static bool TryUnpauseWithDepositCheck(HomesteadData data, Vector3 homesteadPos, InventoryManager pendingInventory = null)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return true;
			}
			DepositSurplusAll(data, homesteadPos, out var blocked, pendingInventory);
			if (!blocked)
			{
				return true;
			}
			data.Paused = true;
			return false;
		}
	}
	internal static class HomesteadZdoBinder
	{
		public static int GetHomesteadPrefabHash()
		{
			try
			{
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.GetPrefab("FarmerHomestead") : null);
				return ((Object)(object)val != (Object)null) ? ZNetScene.instance.GetPrefabHash(val) : 0;
			}
			catch
			{
				return 0;
			}
		}

		public static ZDO ResolveHomesteadZdo(long userId, uint zdoId, Vector3 pos)
		{
			//IL_0016: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			ZDO val = null;
			if (ZDOMan.instance != null && (userId != 0L || zdoId != 0))
			{
				val = ZDOMan.instance.GetZDO(new ZDOID(userId, zdoId));
				if (val != null && !val.IsValid())
				{
					val = null;
				}
				if (val != null && Vector3.Distance(val.GetPosition(), pos) <= 4f)
				{
					MaybeFixHomesteadPrefab(val);
					MarkAsHomestead(val);
				}
				else if (val != null)
				{
					Log.Warning($"ResolveHomesteadZdo: client ZDO {userId}:{zdoId} too far (d={Vector3.Distance(val.GetPosition(), pos):F1})");
					val = null;
				}
			}
			if (val != null && !IsRealHomesteadZdo(val, GetHomesteadPrefabHash()))
			{
				object arg = ((ZDOID)(ref val.m_uid)).UserID;
				object arg2 = ((ZDOID)(ref val.m_uid)).ID;
				ZNetScene instance = ZNetScene.instance;
				object arg3;
				if (instance == null)
				{
					arg3 = null;
				}
				else
				{
					GameObject prefab = instance.GetPrefab(val.GetPrefab());
					arg3 = ((prefab != null) ? ((Object)prefab).name : null);
				}
				Log.Warning($"ResolveHomesteadZdo: rejecting {arg}:{arg2} prefab={arg3}");
				val = null;
			}
			if (val == null)
			{
				val = FindNearbyHomesteadZdo(pos, 3f);
			}
			return val;
		}

		public static void MarkAsHomestead(ZDO zdo)
		{
			if (zdo != null && zdo.IsValid())
			{
				zdo.Set("fj_home", 1);
			}
		}

		public static void MaybeFixHomesteadPrefab(ZDO zdo)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject val = ZNetScene.instance.FindInstance(zdo.m_uid);
			if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<CraftingStation>() != (Object)null)
			{
				Log.Warning($"MaybeFixHomesteadPrefab: refusing to touch CraftingStation ZDO {((ZDOID)(ref zdo.m_uid)).UserID}:{((ZDOID)(ref zdo.m_uid)).ID}");
				TryRepairCorruptedWorkbench(zdo, val);
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("FarmerHomestead");
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			int prefabHash = ZNetScene.instance.GetPrefabHash(prefab);
			if (zdo.GetPrefab() == prefabHash)
			{
				MarkAsHomestead(zdo);
				return;
			}
			GameObject prefab2 = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
			if (!((Object)(object)prefab2 != (Object)null) || !(((Object)prefab2).name == "piece_workbench"))
			{
				return;
			}
			Log.Info($"Fixing homestead clone prefab on ZDO {((ZDOID)(ref zdo.m_uid)).UserID}:{((ZDOID)(ref zdo.m_uid)).ID}");
			try
			{
				zdo.SetPrefab(prefabHash);
				MarkAsHomestead(zdo);
			}
			catch (Exception ex)
			{
				Log.Warning("SetPrefab failed: " + ex.Message);
			}
		}

		public static void TryRepairCorruptedWorkbench(ZDO zdo, GameObject instance)
		{
			ZNetScene instance2 = ZNetScene.instance;
			GameObject val = ((instance2 != null) ? instance2.GetPrefab("piece_workbench") : null);
			if ((Object)(object)val == (Object)null || zdo == null)
			{
				return;
			}
			int prefabHash = ZNetScene.instance.GetPrefabHash(val);
			if (zdo.GetPrefab() == prefabHash)
			{
				return;
			}
			Log.Warning($"Repairing corrupted workbench ZDO {((ZDOID)(ref zdo.m_uid)).UserID}:{((ZDOID)(ref zdo.m_uid)).ID} back to piece_workbench");
			try
			{
				zdo.SetPrefab(prefabHash);
				zdo.Set("fj_home", 0);
				zdo.Set("fj_data", "");
				zdo.Set("fj_slots", "");
			}
			catch (Exception ex)
			{
				Log.Warning("Repair workbench failed: " + ex.Message);
			}
		}

		public static void TryFixPrefabHash(ZDO zdo)
		{
		}

		public static bool IsRealHomesteadZdo(ZDO zdo, int wantHash)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.FindInstance(zdo.m_uid) : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<CraftingStation>() != (Object)null)
			{
				TryRepairCorruptedWorkbench(zdo, val);
				return false;
			}
			if (zdo.GetInt("fj_home", 0) == 1)
			{
				return true;
			}
			ZNetScene instance2 = ZNetScene.instance;
			GameObject val2 = ((instance2 != null) ? instance2.GetPrefab(zdo.GetPrefab()) : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if (((Object)val2).name == "piece_workbench" || ((Object)val2).name == "piece_workbench")
			{
				return false;
			}
			if (((Object)val2).name == "FarmerHomestead" || (wantHash != 0 && zdo.GetPrefab() == wantHash))
			{
				string value = zdo.GetString("fj_data", string.Empty);
				string value2 = zdo.GetString("fj_slots", string.Empty);
				if (string.IsNullOrEmpty(value))
				{
					return !string.IsNullOrEmpty(value2);
				}
				return true;
			}
			return false;
		}

		public static ZDO FindNearbyHomesteadZdo(Vector3 pos, float range)
		{
			//IL_0012: 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)
			List<ZDO> list = new List<ZDO>();
			TryCollectPrefab("FarmerHomestead", list);
			ZDO val = PickClosest(list, pos, range);
			if (val != null)
			{
				return val;
			}
			return FindHomesteadByFullScan(pos, range);
		}

		public static ZDO PickClosest(List<ZDO> list, Vector3 pos, float range)
		{
			//IL_0021: 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)
			ZDO result = null;
			float num = range;
			foreach (ZDO item in list)
			{
				if (item != null && item.IsValid())
				{
					float num2 = Vector3.Distance(item.GetPosition(), pos);
					if (num2 < num)
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		public static ZDO FindHomesteadByFullScan(Vector3 pos, float range)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return null;
			}
			int homesteadPrefabHash = GetHomesteadPrefabHash();
			ZDO val = null;
			float num = range;
			try
			{
				if (!(AccessTools.Field(typeof(ZDOMan), "m_objectsByID")?.GetValue(ZDOMan.instance) is IDictionary dictionary))
				{
					return null;
				}
				foreach (DictionaryEntry item in dictionary)
				{
					object? value = item.Value;
					ZDO val2 = (ZDO)((value is ZDO) ? value : null);
					if (val2 != null && val2.IsValid())
					{
						float num2 = Vector3.Distance(val2.GetPosition(), pos);
						if (!(num2 >= num) && IsRealHomesteadZdo(val2, homesteadPrefabHash))
						{
							num = num2;
							val = val2;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("FindHomesteadByFullScan failed: " + ex.Message);
			}
			if (val != null)
			{
				Log.Info($"FindHomesteadByFullScan hit {((ZDOID)(ref val.m_uid)).UserID}:{((ZDOID)(ref val.m_uid)).ID} dist={num:F1}");
			}
			return val;
		}

		public static void TryCollectPrefab(string name, List<ZDO> list)
		{
			if (ZDOMan.instance == null || string.IsNullOrEmpty(name))
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			List<ZDO> list2 = new List<ZDO>();
			while (ZDOMan.instance.GetAllZDOsWithPrefabIterative(name, list2, ref num) && num2++ < 64)
			{
			}
			if (list2.Count == 0)
			{
				TryGetAllWithPrefab(name, list2);
			}
			foreach (ZDO item in list2)
			{
				if (item != null && !list.Contains(item))
				{
					list.Add(item);
				}
			}
		}

		public static void TryGetAllWithPrefab(string prefabName, List<ZDO> zdos)
		{
			try
			{
				typeof(ZDOMan).GetMethod("GetAllZDOsWithPrefab", new Type[2]
				{
					typeof(string),
					typeof(List<ZDO>)
				})?.Invoke(ZDOMan.instance, new object[2] { prefabName, zdos });
			}
			catch (Exception ex)
			{
				Log.Debug("GetAllZDOsWithPrefab fallback failed: " + ex.Message);
			}
		}
	}
}
namespace ValheimFarmerNPC.HarmonyPatches
{
	internal static class FarmerAudioPatches
	{
		public static void Apply(Harmony harmony)
		{
			MethodInfo target = AccessTools.Method(typeof(EffectList), "Create", new Type[5]
			{
				typeof(Vector3),
				typeof(Quaternion),
				typeof(Transform),
				typeof(float),
				typeof(int)
			}, (Type[])null);
			if (!TryPatch(harmony, target, "Create_PrefixFull"))
			{
				MethodInfo target2 = AccessTools.Method(typeof(EffectList), "Create", new Type[4]
				{
					typeof(Vector3),
					typeof(Quaternion),
					typeof(Transform),
					typeof(float)
				}, (Type[])null);
				if (!TryPatch(harmony, target2, "Create_PrefixShort"))
				{
					Log.Warning("Could not find EffectList.Create to patch (farmer mute still uses AudioSource silencing)");
				}
			}
		}

		private static bool TryPatch(Harmony harmony, MethodInfo target, string prefixName)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (target == null)
			{
				return false;
			}
			try
			{
				harmony.Patch((MethodBase)target, new HarmonyMethod(typeof(FarmerAudioPatches), prefixName, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Log.Debug("Patched EffectList.Create via " + prefixName);
				return true;
			}
			catch (Exception ex)
			{
				Log.Warning("EffectList.Create patch failed: " + ex.Message);
				return false;
			}
		}

		private static bool Create_PrefixFull(Vector3 basePos, Transform baseParent, ref GameObject[] __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return AllowCreate(basePos, baseParent, ref __result);
		}

		private static bool Create_PrefixShort(Vector3 basePos, Transform baseParent, ref GameObject[] __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return AllowCreate(basePos, baseParent, ref __result);
		}

		private static bool AllowCreate(Vector3 pos, Transform parent, ref GameObject[] __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!FarmerAudio.ShouldBlockEffectAt(pos, parent))
			{
				return true;
			}
			__result = Array.Empty<GameObject>();
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class FarmerMaterializePatches
	{
		private static void Postfix(Character __instance)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || __instance is Player || (Object)(object)((Component)__instance).GetComponent<FarmerNpc>() != (Object)null)
			{
				return;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null || !zDO.IsValid())
			{
				return;
			}
			bool flag = zDO.GetInt("fj_farmer", 0) == 1;
			string text = FarmerIdentity.PrefabName(zDO);
			bool flag2 = text == "FarmerNpc";
			if (flag || flag2)
			{
				FarmerNpc npc = ((Component)__instance).gameObject.AddComponent<FarmerNpc>();
				(((Component)__instance).GetComponent<FarmerController>() ?? ((Component)__instance).gameObject.AddComponent<FarmerController>()).Bind(npc);
				__instance.m_faction = (Faction)0;
				__instance.m_group = "farmer_npc";
				if (string.IsNullOrEmpty(__instance.m_name) || __instance.m_name.IndexOf("Goblin", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					__instance.m_name = "$fj_npc_name";
				}
				MonsterAI[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<MonsterAI>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Behaviour)componentsInChildren[i]).enabled = false;
				}
				BaseAI[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<BaseAI>(true);
				for (int i = 0; i < componentsInChildren2.Length; i++)
				{
					((Behaviour)componentsInChildren2[i]).enabled = false;
				}
				Log.Info($"Rematerialized FarmerNpc on '{((Object)((Component)__instance).gameObject).name}' prefab={text} marked={flag}");
			}
		}
	}
	internal static class FarmerRemovePatches
	{
		public static void Apply(Harmony harmony)
		{
			TryPatch(harmony, AccessTools.Method(typeof(Player), "RemovePiece", (Type[])null, (Type[])null), "RemovePiece_Prefix");
			TryPatch(harmony, AccessTools.Method(typeof(Character), "Damage", new Type[1] { typeof(HitData) }, (Type[])null), "Damage_Prefix");
			Log.Debug("Farmer remove/damage patches applied");
		}

		private static void TryPatch(Harmony harmony, MethodInfo target, string prefixName)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			if (target == null)
			{
				Log.Warning("Could not find method for patch " + prefixName);
				return;
			}
			try
			{
				harmony.Patch((MethodBase)target, new HarmonyMethod(typeof(FarmerRemovePatches), prefixName, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Log.Warning("Failed to patch " + target.Name + ": " + ex.Message);
			}
		}

		private static bool RemovePiece_Prefix(Player __instance, ref bool __result)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if (!AdminUtil.LocalPlayerIsAdmin())
			{
				return true;
			}
			FarmerNpc farmerNpc = FindHoveringFarmerNpc(__instance);
			if ((Object)(object)farmerNpc != (Object)null)
			{
				DestroyFarmerNpcAsAdmin(farmerNpc);
				PlayerFeedback.Notify(__instance, "Removed farmer NPC");
				__result = true;
				return false;
			}
			Character val = FindHoveringFarmer(__instance);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			DestroyFarmerAsAdmin(val);
			PlayerFeedback.Notify(__instance, "Removed farmer NPC");
			__result = true;
			return false;
		}

		private static bool Damage_Prefix(Character __instance, HitData hit)
		{
			if ((Object)(object)__instance == (Object)null || hit == null || !FarmerCleanup.LooksLikeFarmerCharacter(__instance))
			{
				return true;
			}
			Character attacker = hit.GetAttacker();
			Player val = (Player)(object)((attacker is Player) ? attacker : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer || !AdminUtil.LocalPlayerIsAdmin())
			{
				return false;
			}
			DestroyFarmerAsAdmin(__instance);
			PlayerFeedback.Notify(val, "Removed farmer NPC");
			return false;
		}

		private static void DestroyFarmerAsAdmin(Character farmer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)farmer).GetComponent<ZNetView>();
			ZDOID val = ZDOID.None;
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				val = component.GetZDO().m_uid;
			}
			Vector3 position = ((Component)farmer).transform.position;
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				if (component.IsOwner())
				{
					component.Destroy();
				}
				else
				{
					Object.Destroy((Object)(object)((Component)farmer).gameObject);
				}
			}
			else
			{
				Object.Destroy((Object)(object)((Component)farmer).gameObject);
			}
			if (val != ZDOID.None)
			{
				RpcMessages.RequestDestroyFarmer(val, position);
			}
			else
			{
				RpcMessages.RequestDestroyFarmerNear(position);
			}
			Log.Info($"Admin removed farmer at {position} id={((ZDOID)(ref val)).UserID}:{((ZDOID)(ref val)).ID}");
		}

		private static void DestroyFarmerNpcAsAdmin(FarmerNpc farmer)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0047: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)farmer == (Object)null))
			{
				ZNetView component = ((Component)farmer).GetComponent<ZNetView>();
				ZDOID val = ZDOID.None;
				if ((Object)(object)component != (Object)null && component.IsValid())
				{
					val = component.GetZDO().m_uid;
				}
				Vector3 position = ((Component)farmer).transform.position;
				farmer.UnbindAndDestroy();
				if (val != ZDOID.None)
				{
					RpcMessages.RequestDestroyFarmer(val, position);
				}
				else
				{
					RpcMessages.RequestDestroyFarmerNear(position);
				}
				Log.Info($"Admin removed piece-farmer at {position} id={((ZDOID)(ref val)).UserID}:{((ZDOID)(ref val)).ID}");
			}
		}

		private static FarmerNpc FindHoveringFarmerNpc(Player player)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 eyePoint = ((Character)player).GetEyePoint();
				Vector3 lookDir = ((Character)player).GetLookDir();
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(eyePoint, lookDir, ref val, 10f))
				{
					FarmerNpc componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<FarmerNpc>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						return componentInParent;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Debug("FindHoveringFarmerNpc: " + ex.Message);
			}
			return null;
		}

		private static Character FindHoveringFarmer(Player player)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Player), "m_hovering") ?? AccessTools.Field(typeof(Player), "m_hoveringCreature");
				if (fieldInfo != null)
				{
					object? value = fieldInfo.GetValue(player);
					val = (GameObject)((value is GameObject) ? value : null);
					Character val2 = (Character)((value is Character) ? value : null);
					if (val2 != null && FarmerCleanup.LooksLikeFarmerCharacter(val2))
					{
						return val2;
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)val != (Object)null)
			{
				Character componentInParent = val.GetComponentInParent<Character>();
				if (FarmerCleanup.LooksLikeFarmerCharacter(componentInParent))
				{
					return componentInParent;
				}
			}
			try
			{
				Vector3 eyePoint = ((Character)player).GetEyePoint();
				Vector3 lookDir = ((Character)player).GetLookDir();
				RaycastHit val3 = default(RaycastHit);
				if (Physics.Raycast(eyePoint, lookDir, ref val3, 10f))
				{
					Character componentInParent2 = ((Component)((RaycastHit)(ref val3)).collider).GetComponentInParent<Character>();
					if (FarmerCleanup.LooksLikeFarmerCharacter(componentInParent2))
					{
						return componentInParent2;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Debug("FindHoveringFarmer raycast: " + ex.Message);
			}
			Character result = null;
			float num = 0.55f;
			Vector3 lookDir2 = ((Character)player).GetLookDir();
			Vector3 eyePoint2 = ((Character)player).GetEyePoint();
			Character[] array = Object.FindObjectsOfType<Character>();
			foreach (Character val4 in array)
			{
				if (!FarmerCleanup.LooksLikeFarmerCharacter(val4))
				{
					continue;
				}
				Vector3 val5 = ((Component)val4).transform.position + Vector3.up - eyePoint2;
				float magnitude = ((Vector3)(ref val5)).magnitude;
				if (!(magnitude > 6f) && !(magnitude < 0.1f))
				{
					float num2 = Vector3.Dot(lookDir2, ((Vector3)(ref val5)).normalized);
					if (num2 > num)
					{
						num = num2;
						result = val4;
					}
				}
			}
			return result;
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class GameStartPatch
	{
		private static void Postfix()
		{
			try
			{
				RpcMessages.EnsureRoutedRegistered();
				Log.Info("Game.Start: routed RPCs registered");
			}
			catch (Exception arg)
			{
				Log.Error($"Game.Start RPC register failed: {arg}");
			}
		}
	}
	internal static class PlacementPatches
	{
		public static void Apply(Harmony harmony)
		{
			TryPatch(harmony, AccessTools.Method(typeof(Player), "TryPlacePiece", new Type[1] { typeof(Piece) }, (Type[])null), "TryPlacePiece_Prefix");
			TryPatch(harmony, AccessTools.Method(typeof(Player), "PlacePiece", new Type[4]
			{
				typeof(Piece),
				typeof(Vector3),
				typeof(Quaternion),
				typeof(bool)
			}, (Type[])null), "PlacePiece_Prefix");
			TryPatch(harmony, AccessTools.Method(typeof(Player), "RemovePiece", (Type[])null, (Type[])null), "RemovePiece_Prefix");
			Log.Debug("Harmony placement patches applied");
		}

		private static void TryPatch(Harmony harmony, MethodInfo target, string prefixName)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			if (target == null)
			{
				Log.Warning("Could not find method for patch " + prefixName);
				return;
			}
			try
			{
				harmony.Patch((MethodBase)target, new HarmonyMethod(typeof(PlacementPatches), prefixName, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Log.Debug("Patched " + target.DeclaringType.Name + "." + target.Name);
			}
			catch (Exception ex)
			{
				Log.Warning("Failed to patch " + target.Name + ": " + ex.Message);
			}
		}

		private static bool TryPlacePiece_Prefix(Player __instance, Piece piece, ref bool __result)
		{
			if (!ShouldBlockPlacement(__instance, piece))
			{
				return true;
			}
			__result = false;
			return false;
		}

		private static bool PlacePiece_Prefix(Player __instance, Piece piece)
		{
			return !ShouldBlockPlacement(__instance, piece);
		}

		private static bool RemovePiece_Prefix(Player __instance, ref bool __result)
		{
			if (!SyncedConfig.AdminOnlyPlacement)
			{
				return true;
			}
			if (!IsFarmerPiece(GetHoveringPiece(__instance)))
			{
				return true;
			}
			if (AdminUtil.LocalPlayerIsAdmin())
			{
				return true;
			}
			PlayerFeedback.Notify(__instance, "Only admins can remove Farmer pieces");
			__result = false;
			return false;
		}

		private static bool ShouldBlockPlacement(Player player, Piece piece)
		{
			if (!SyncedConfig.AdminOnlyPlacement || (Object)(object)piece == (Object)null)
			{
				return false;
			}
			if (!IsFarmerPiece(piece))
			{
				return false;
			}
			if (AdminUtil.LocalPlayerIsAdmin())
			{
				return false;
			}
			PlayerFeedback.Notify(player, "Only admins can place Farmer pieces");
			Log.Warning("Blocked non-admin placement of " + ((Object)piece).name);
			return true;
		}

		internal static bool IsFarmerPiece(Piece piece)
		{
			if ((Object)(object)piece == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)piece).GetComponent<FarmerHomestead>() != (Object)null || (Object)(object)((Component)piece).GetComponent<BoundaryPost>() != (Object)null)
			{
				return true;
			}
			string text = ((Object)((Component)piece).gameObject).name.Replace("(Clone)", "").Trim();
			if (text == "FarmerHomestead" || text == "FarmBoundaryPost")
			{
				return true;
			}
			if (!(piece.m_name == "$piece_farmerhomestead"))
			{
				return piece.m_name == "$piece_farmboundarypost";
			}
			return true;
		}

		internal static Piece GetHoveringPiece(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(Player), "GetHoveringPiece", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				object? obj = methodInfo.Invoke(player, null);
				return (Piece)((obj is Piece) ? obj : null);
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(Player), "m_hoveringPiece") ?? AccessTools.Field(typeof(Player), "m_hovering");
			if (fieldInfo != null)
			{
				object value = fieldInfo.GetValue(player);
				Piece val = (Piece)((value is Piece) ? value : null);
				if (val != null)
				{
					return val;
				}
				GameObject val2 = (GameObject)((value is GameObject) ? value : null);
				if (val2 != null)
				{
					return val2.GetComponentInParent<Piece>();
				}
			}
			return null;
		}
	}
}
namespace ValheimFarmerNPC.Farming
{
	internal static class BiomeCropRules
	{
		public static readonly string[] AllFoodCrops = new string[7] { "Carrot", "Turnip", "Onion", "Barley", "Flax", "JotunPuffs", "Magecap" };

		private static readonly Dictionary<Biome, string[]> ByBiome = new Dictionary<Biome, string[]>
		{
			{
				(Biome)1,
				new string[3] { "Carrot", "Turnip", "Onion" }
			},
			{
				(Biome)8,
				new string[3] { "Carrot", "Turnip", "Onion" }
			},
			{
				(Biome)2,
				new string[1] { "Turnip" }
			},
			{
				(Biome)4,
				Array.Empty<string>()
			},
			{
				(Biome)16,
				new string[5] { "Carrot", "Turnip", "Onion", "Barley", "Flax" }
			},
			{
				(Biome)512,
				new string[2] { "JotunPuffs", "Magecap" }
			},
			{
				(Biome)256,
				new string[3] { "Carrot", "Turnip", "Onion" }
			},
			{
				(Biome)64,
				Array.Empty<string>()
			},
			{
				(Biome)32,
				Array.Empty<string>()
			}
		};

		public static Biome GetBiome(Vector3 worldPos)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (WorldGenerator.instance != null)
				{
					return WorldGenerator.instance.GetBiome(worldPos);
				}
			}
			catch (Exception ex)
			{
				Log.Debug("GetBiome failed: " + ex.Message);
			}
			return (Biome)0;
		}

		public unsafe static string GetBiomeDisplayName(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0005: 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_001d: Expected I4, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if ((int)biome <= 16)
			{
				switch (biome - 1)
				{
				default:
					if ((int)biome != 8)
					{
						if ((int)biome != 16)
						{
							break;
						}
						return "Plains";
					}
					return "Black Forest";
				case 0:
					return "Meadows";
				case 1:
					return "Swamp";
				case 3:
					return "Mountains";
				case 2:
					break;
				}
			}
			else if ((int)biome <= 64)
			{
				if ((int)biome == 32)
				{
					return "Ashlands";
				}
				if ((int)biome == 64)
				{
					return "Deep North";
				}
			}
			else
			{
				if ((int)biome == 256)
				{
					return "Ocean";
				}
				if ((int)biome == 512)
				{
					return "Mistlands";
				}
			}
			return ((object)(*(Biome*)(&biome))/*cast due to .constrained prefix*/).ToString();
		}

		public static bool IsCropAllowed(string family, Biome biome)
		{
			//IL_0041: 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)
			if (string.IsNullOrEmpty(family))
			{
				return false;
			}
			string food = family;
			if (family.StartsWith("Seed", StringComparison.OrdinalIgnoreCase))
			{
				food = CropWeights.FoodFamilyForSeedFamily(family) ?? family.Substring(4);
			}
			if (!ByBiome.TryGetValue(biome, out var value) || value == null)
			{
				if ((int)biome != 0)
				{
					return false;
				}
				value = ByBiome[(Biome)1];
			}
			return value.Any((string c) => string.Equals(c, food, StringComparison.OrdinalIgnoreCase));
		}

		public static IReadOnlyList<string> GetAllowedFoodCrops(Biome biome)
		{
			//IL_0005: 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)
			if (ByBiome.TryGetValue(biome, out var value) && value != null)
			{
				return value;
			}
			if ((int)biome != 0)
			{
				return Array.Empty<string>();
			}
			return ByBiome[(Biome)1];
		}

		public static void ApplyToData(HomesteadData data, Vector3 worldPos)
		{
			//IL_0014: 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_001a: 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)
			if (data == null)
			{
				return;
			}
			CropRegistry.EnsureMissingConfigs(data);
			if (data.CropConfigs == null)
			{
				return;
			}
			Biome biome = GetBiome(worldPos);
			foreach (CropConfigEntry cropConfig in data.CropConfigs)
			{
				if (cropConfig != null && !string.IsNullOrEmpty(cropConfig.Family) && !(cropConfig.PlantEnabled = IsCropAllowed(cropConfig.Family, biome)))
				{
					cropConfig.Weight = 0;
				}
			}
		}
	}
	public class CropDefinition
	{
		public string Family;

		public string SeedItem;

		public string PlantablePrefab;

		public string GrownPrefab;

		public string WorldGrownPrefab;

		public bool ProducesSeedItem;
	}
	[Serializable]
	public class CropConfigEntry
	{
		public string Family;

		public bool Enabled = true;

		public int Weight = 50;

		public bool HarvestEnabled = true;

		public bool PlantEnabled = true;

		public int MinimumSeedReserve = 10;

		public int MaximumSeedPercent = 20;
	}
	internal static class CropRegistry
	{
		private static readonly Dictionary<string, CropDefinition> ByFamily = new Dictionary<string, CropDefinition>(StringComparer.OrdinalIgnoreCase);

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

		private static bool _initialized;

		public static IEnumerable<CropDefinition> All
		{
			get
			{
				EnsureInit();
				return ByFamily.Values;
			}
		}

		public static void EnsureInit()
		{
			if (!_initialized)
			{
				Register("Carrot", "CarrotSeeds", "sapling_carrot", "Carrot", "Pickable_Carrot");
				Register("Turnip", "TurnipSeeds", "sapling_turnip", "Turnip", "Pickable_Turnip");
				Register("Onion", "OnionSeeds", "sapling_onion", "Onion", "Pickable_Onion");
				Register("Barley", "Barley", "sapling_barley", "Barley", "Pickable_Barley", producesSeedItem: true);
				Register("Flax", "Flax", "sapling_flax", "Flax", "Pickable_Flax", producesSeedItem: true);
				Register("JotunPuffs", "MushroomJotunPuffs", "sapling_jotunpuffs", "Pickable_Mushroom_JotunPuffs", "Pickable_Mushroom_JotunPuffs", producesSeedItem: true);
				Register("Magecap", "MushroomMagecap", "sapling_magecap", "Pickable_Mushroom_Magecap", "Pickable_Mushroom_Magecap", producesSeedItem: true);
				PrefabToFamily["MushroomJotunPuffs"] = "JotunPuffs";
				PrefabToFamily["MushroomMagecap"] = "Magecap";
				Register("SeedCarrot", "CarrotSeeds", "sapling_seedcarrot", "CarrotSeeds", "Pickable_SeedCarrot", producesSeedItem: true);
				Register("SeedTurnip", "TurnipSeeds", "sapling_seedturnip", "TurnipSeeds", "Pickable_SeedTurnip", producesSeedItem: true);
				Register("SeedOnion", "OnionSeeds", "sapling_seedonion", "OnionSeeds", "Pickable_SeedOnion", producesSeedItem: true);
				_initialized = true;
			}
		}

		private static void Register(string family, string seedItem, string plantable, string grown, string worldGrown = null, bool producesSeedItem = false)
		{
			string text = (string.IsNullOrEmpty(worldGrown) ? grown : worldGrown);
			CropDefinition value = new CropDefinition
			{
				Family = family,
				SeedItem = seedItem,
				PlantablePrefab = plantable,
				GrownPrefab = grown,
				WorldGrownPrefab = text,
				ProducesSeedItem = producesSeedItem
			};
			ByFamily[family] = value;
			PrefabToFamily[plantable] = family;
			PrefabToFamily[grown] = family;
			if (!string.Equals(text, grown, StringComparison.OrdinalIgnoreCase))
			{
				PrefabToFamily[text] = family;
			}
		}

		public static void AddZdoLookupPrefabs(HashSet<string> into)
		{
			EnsureInit();
			if (into == null)
			{
				return;
			}
			foreach (CropDefinition value in ByFamily.Values)
			{
				if (!string.IsNullOrEmpty(value.PlantablePrefab))
				{
					into.Add(value.PlantablePrefab);
				}
				if (!string.IsNullOrEmpty(value.WorldGrownPrefab))
				{
					into.Add(value.WorldGrownPrefab);
				}
				else if (!string.IsNullOrEmpty(value.GrownPrefab))
				{
					into.Add(value.GrownPrefab);
				}
			}
		}

		public static bool EnsureMissingConfigs(HomesteadData data)
		{
			EnsureInit();
			if (data == null)
			{
				return false;
			}
			if (data.CropConfigs == null)
			{
				data.CropConfigs = new List<CropConfigEntry>();
			}
			bool result = false;
			foreach (CropDefinition value in ByFamily.Values)
			{
				if (data.GetCropConfig(value.Family) == null)
				{
					data.CropConfigs.Add(new CropConfigEntry
					{
						Family = value.Family,
						Enabled = true,
						Weight = (value.Family.StartsWith("Seed", StringComparison.OrdinalIgnoreCase) ? 10 : 50),
						HarvestEnabled = true,
						PlantEnabled = true,
						MinimumSeedReserve = (value.ProducesSeedItem ? 20 : 10),
						MaximumSeedPercent = 20
					});
					result = true;
				}
			}
			return result;
		}

		public static bool TryGetFamily(string prefabName, out string family)
		{
			EnsureInit();
			family = null;
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			string text = prefabName.Replace("(Clone)", "").Trim();
			if (PrefabToFamily.TryGetValue(text, out family))
			{
				return true;
			}
			string text2 = text.ToLowerInvariant();
			foreach (KeyValuePair<string, string> item in PrefabToFamily)
			{
				if (text2.Contains(item.Key.ToLowerInvariant()))
				{
					family = item.Value;
					return true;
				}
			}
			return false;
		}

		public static bool TryGet(string family, out CropDefinition def)
		{
			EnsureInit();
			return ByFamily.TryGetValue(family, out def);
		}

		public static CropDefinition Get(string family)
		{
			TryGet(family, out var def);
			return def;
		}

		public static List<CropConfigEntry> CreateDefaultConfigs()
		{
			EnsureInit();
			return ByFamily.Values.Select((CropDefinition d) => new CropConfigEntry
			{
				Family = d.Family,
				Enabled = true,
				Weight = (d.Family.StartsWith("Seed", StringComparison.OrdinalIgnoreCase) ? 10 : 50),
				HarvestEnabled = true,
				PlantEnabled = true,
				MinimumSeedReserve = (d.ProducesSeedItem ? 20 : 10),
				MaximumSeedPercent = 20
			}).ToList();
		}

		public static bool IsSupportedPlant(Component plantOrPickable)
		{
			if ((Object)(object)plantOrPickable == (Object)null)
			{
				return false;
			}
			string family;
			return TryGetFamily(((Object)plantOrPickable.gameObject).name, out family);
		}
	}
	internal static class CropWeights
	{
		private static readonly Dictionary<string, string> FoodToSeedFamily = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "Carrot", "SeedCarrot" },
			{ "Turnip", "SeedTurnip" },
			{ "Onion", "SeedOnion" }
		};

		private static readonly Dictionary<string, string> SeedFamilyToFood = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "SeedCarrot", "Carrot" },
			{ "SeedTurnip", "Turnip" },
			{ "SeedOnion", "Onion" }
		};

		public static string SelectCropForSlot(HomesteadData data, FarmSlot slot, InventoryManager inventory, Func<string, int> availableSeeds)
		{
			if (data == null || slot == null)
			{
				return null;
			}
			string text = SelectSeedCropForReserve(data, inventory);
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			if (string.Equals(data.LayoutMode, "Fixed", StringComparison.OrdinalIgnoreCase))
			{
				string text2 = (string.IsNullOrEmpty(slot.OriginalCropFamily) ? slot.CurrentCropFamily : slot.OriginalCropFamily);
				if (!string.IsNullOrEmpty(text2))
				{
					CropConfigEntry cropConfig = data.GetCropConfig(text2);
					if (cropConfig != null && cropConfig.Enabled && cropConfig.PlantEnabled && availableSeeds(text2) > 0)
					{
						return text2;
					}
				}
			}
			return SelectByDeficit(data, inventory, availableSeeds);
		}

		public static string FoodFamilyForSeedFamily(string seedFamily)
		{
			if (string.IsNullOrEmpty(seedFamily))
			{
				return null;
			}
			if (!SeedFamilyToFood.TryGetValue(seedFamily, out var value))
			{
				return null;
			}
			return value;
		}

		public static string SelectSeedCropForReserve(HomesteadData data, InventoryManager inventory)
		{
			if (data?.CropConfigs == null)
			{
				return null;
			}
			foreach (KeyValuePair<string, string> item in FoodToSeedFamily)
			{
				if (TryPickSeedFamily(data, inventory, item.Key, item.Value, requireZeroSeeds: true, out var picked))
				{
					return picked;
				}
			}
			foreach (KeyValuePair<string, string> item2 in FoodToSeedFamily)
			{
				if (TryPickSeedFamily(data, inventory, item2.Key, item2.Value, requireZeroSeeds: false, out var picked2))
				{
					return picked2;
				}
			}
			return null;
		}

		private static bool TryPickSeedFamily(HomesteadData data, InventoryManager inventory, string food, string seedFamily, bool requireZeroSeeds, out string picked)
		{
			picked = null;
			CropConfigEntry cropConfig = data.GetCropConfig(food);
			if (cropConfig == null || !cropConfig.Enabled)
			{
				return false;
			}
			CropConfigEntry cropConfig2 = data.GetCropConfig(seedFamily);
			if (cropConfig2 != null && (!cropConfig2.Enabled || !cropConfig2.PlantEnabled))
			{
				return false;
			}
			int num = SeedManager.CountSeeds(data, inventory, food);
			int num2 = SeedManager.CountFoodCrop(data, inventory, food);
			if (requireZeroSeeds)
			{
				if (num != 0 || num2 <= 0)
				{
					return false;
				}
				picked = seedFamily;
				return true;
			}
			int minimumSeedReserve = cropConfig.MinimumSeedReserve;
			if (minimumSeedReserve <= 0)
			{
				return false;
			}
			if (num >= minimumSeedReserve)
			{
				return false;
			}
			if (!SeedManager.CanStartSeedPlant(data, inventory, food))
			{
				return false;
			}
			Log.Debug($"SeedReserve: plant {seedFamily} (seeds={num} food={num2} reserve={minimumSeedReserve})");
			picked = seedFamily;
			return true;
		}

		public static string SelectByDeficit(HomesteadData data, InventoryManager inventory, Func<string, int> availableSeeds)
		{
			if (data?.CropConfigs == null || data.Slots == null)
			{
				return null;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < data.CropConfigs.Count; i++)
			{
				CropConfigEntry cropConfigEntry = data.CropConfigs[i];
				if (cropConfigEntry != null && cropConfigEntry.Enabled && cropConfigEntry.PlantEnabled && cropConfigEntry.Weight > 0 && (cropConfigEntry.Family == null || !cropConfigEntry.Family.StartsWith("Seed", StringComparison.OrdinalIgnoreCase)))
				{
					num += cropConfigEntry.Weight;
					num2++;
				}
			}
			if (num2 == 0 || num <= 0)
			{
				return null;
			}
			int num3 = 0;
			for (int j = 0; j < data.Slots.Count; j++)
			{
				FarmSlot farmSlot = data.Slots[j];
				if (farmSlot != null && farmSlot.State != FarmSlotState.Disabled)
				{
					num3++;
				}
			}
			num3 = Math.Max(1, num3);
			string text = null;
			float num4 = float.MinValue;
			string result = null;
			float num5 = float.MinValue;
			for (int k = 0; k < data.CropConfigs.Count; k++)
			{
				CropConfigEntry cropConfigEntry2 = data.CropConfigs[k];
				if (cropConfigEntry2 == null || !cropConfigEntry2.Enabled || !cropConfigEntry2.PlantEnabled || cropConfigEntry2.Weight <= 0 || (cropConfigEntry2.Family != null && cropConfigEntry2.Family.StartsWith("Seed", StringComparison.OrdinalIgnoreCase)))
				{
					continue;
				}
				int num6 = 0;
				for (int l = 0; l < data.Slots.Count; l++)
				{
					FarmSlot farmSlot2 = data.Slots[l];
					if (farmSlot2 != null && farmSlot2.State != FarmSlotState.Empty && farmSlot2.State != FarmSlotState.Disabled && string.Equals(farmSlot2.CurrentCropFamily, cropConfigEntry2.Family, StringComparison.OrdinalIgnoreCase))
					{
						num6++;
					}
				}
				float num7 = (float)num3 * ((float)cropConfigEntry2.Weight / (float)num) - (float)num6;
				int num8 = availableSeeds(cropConfigEntry2.Family);
				int num9 = 0;
				if (inventory != null && CropRegistry.TryGet(cropConfigEntry2.Family, out var def))
				{
					num9 = inventory.CountItem(def.SeedItem);
				}
				if (num9 > 0 && num7 > num4)
				{
					num4 = num7;
					text = cropConfigEntry2.Family;
				}
				if (num8 > 0 && num7 > num5)
				{
					num5 = num7;
					result = cropConfigEntry2.Family;
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return result;
		}

		public static string SelectByDeficit(HomesteadData data, Func<string, int> availableSeeds)
		{
			return SelectByDeficit(data, null, availableSeeds);
		}
	}
	internal static class FarmBoundary
	{
		public static bool TryGetBoundaryAabb(HomesteadData data, Vector3 homesteadPos, out Vector3 min, out Vector3 max)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			min = Vector3.zero;
			max = Vector3.zero;
			if (data == null)
			{
				return false;
			}
			Vector3 pos;
			Vector3 pos2;
			if (data.HasBoundary)
			{
				pos = data.PostA;
				pos2 = data.PostB;
			}
			else
			{
				List<BoundaryPost> list = (from p in Object.FindObjectsOfType<BoundaryPost>()
					orderby Vector3.Distance(((Component)p).transform.position, homesteadPos)
					select p).Take(2).ToList();
				if (list.Count < 2)
				{
					if (data.BoundaryPostA == 0L || data.BoundaryPostB == 0L || !TryFindPostPosition(data.BoundaryPostA, out pos) || !TryFindPostPosition(data.BoundaryPostB, out pos2))
					{
						return false;
					}
				}
				else
				{
					pos = ((Component)list[0]).transform.position;
					pos2 = ((Component)list[1]).transform.position;
					data.SetBoundary(pos, pos2);
				}
			}
			float num = Mathf.Min(pos.x, pos2.x);
			float num2 = Mathf.Max(pos.x, pos2.x);
			float num3 = Mathf.Min(pos.z, pos2.z);
			float num4 = Mathf.Max(pos.z, pos2.z);
			float num5 = (pos.y + pos2.y) * 0.5f;
			float num6 = num5 - 64f;
			float num7 = num5 + 64f;
			float num8 = num2 - num;
			float num9 = num4 - num3;
			if (num8 * 0.5f > SyncedConfig.MaxFarmRadius || num9 * 0.5f > SyncedConfig.MaxFarmRadius)
			{
				Log.Warning($"Farm boundary exceeds MaxFarmRadius ({SyncedConfig.MaxFarmRadius}) size=({num8:F1},{num9:F1})");
				return false;
			}
			if (num8 < 0.5f || num9 < 0.5f)
			{
				Log.Warning($"Farm boundary is too small size=({num8:F1},{num9:F1})");
				return false;
			}
			min = new Vector3(num, num6, num3);
			max = new Vector3(num2, num7, num4);
			return true;
		}

		internal static bool Inside(Vector3 p, 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_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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (p.x >= min.x && p.x <= max.x && p.z >= min.z)
			{
				return p.z <= max.z;
			}
			return false;
		}

		internal static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		internal static float HorizontalDistanceSq(Vector3 a, Vector3 b)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2;
		}

		private static bool TryFindPostPosition(long key, out Vector3 pos)
		{
			//IL_0001: 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)
			pos = Vector3.zero;
			return TryFindZdoByKey(key, out pos);
		}

		private static bool TryFindZdoByKey(long key, out Vector3 pos)
		{
			//IL_0001: 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_003f: 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)
			pos = Vector3.zero;
			ZNetView[] array = Object.FindObjectsOfType<ZNetView>();
			foreach (ZNetView val in array)
			{
				if (!((Object)(object)val == (Object)null) && val.IsValid() && ZdoIds.ZdoKey(val.GetZDO()) == key)
				{
					pos = ((Component)val).transform.position;
					return true;
				}
			}
			return false;
		}
	}
	internal static class FarmCropQuery
	{
		private static readonly List<ZDO> ZdoScratch = new List<ZDO>(32);

		public static bool IsSlotPlantable(FarmSlot slot)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (slot == null || slot.State == FarmSlotState.Disabled)
			{
				return false;
			}
			string family;
			FarmSlotState state;
			return !TryFindCropAt(slot.Position, out family, out state, allowZdoFallback: false);
		}

		public static bool TryFindCropAt(Vector3 position, out string family, out FarmSlotState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return TryFindCropAt(position, out family, out state, allowZdoFallback: true);
		}

		public static bool TryFindCropAt(Vector3 position, out string family, out FarmSlotState state, bool allowZdoFallback)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			family = null;
			state = FarmSlotState.Empty;
			int num = Math.Min(PhysicsQuery.OverlapSphereNonAlloc(position, 2f, PhysicsQuery.CropMask), PhysicsQuery.Buffer.Length);
			for (int i = 0; i < num; i++)
			{
				Collider val = PhysicsQuery.Buffer[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Plant componentInParent = ((Component)val).GetComponentInParent<Plant>();
				Pickable componentInParent2 = ((Component)val).GetComponentInParent<Pickable>();
				GameObject val2 = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).gameObject : (((Object)(object)componentInParent2 != (Object)null) ? ((Component)componentInParent2).gameObject : null));
				if (!((Object)(object)val2 == (Object)null) && !(FarmBoundary.HorizontalDistance(val2.transform.position, position) > 0.85f) && CropRegistry.TryGetFamily(((Object)val2).name, out family))
				{
					if ((Object)(object)componentInParent2 != (Object)null)
					{
						state = ((!componentInParent2.m_picked) ? FarmSlotState.Mature : FarmSlotState.Empty);
						return !componentInParent2.m_picked;
					}
					if ((Object)(object)componentInParent != (Object)null)
					{
						state = FarmSlotState.Occupied;
						return true;
					}
				}
			}
			if (allowZdoFallback && TryFindCropZdoAt(position, 0.85f, out family, out state))
			{
				return state != FarmSlotState.Empty;
			}
			return false;
		}

		private static bool TryFindCropZdoAt(Vector3 position, float radius, out string family, out FarmSlotState state)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			family = null;
			state = FarmSlotState.Empty;
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			float best = radius;
			ZDO bestZdo = null;
			string bestFamily = null;
			FarmSlotState bestState = FarmSlotState.Empty;
			foreach (CropDefinition item in CropRegistry.All)
			{
				ConsiderPrefabNear(item.PlantablePrefab, position, ref best, ref bestZdo, ref bestFamily, ref bestState);
				ConsiderPrefabNear(item.WorldGrownPrefab, position, ref best, ref bestZdo, ref bestFamily, ref bestState);
				if (!string.IsNullOrEmpty(item.GrownPrefab) && !string.Equals(item.GrownPrefab, item.WorldGrownPrefab, StringComparison.OrdinalIgnoreCase) && (item.GrownPrefab.StartsWith("Pickable_", StringComparison.OrdinalIgnoreCase) || item.GrownPrefab.StartsWith("sapling_", StringComparison.OrdinalIgnoreCase)))
				{
					ConsiderPrefabNear(item.GrownPrefab, position, ref best, ref bestZdo, ref bestFamily, ref bestState);
				}
			}
			if (bestZdo == null)
			{
				return false;
			}
			family = bestFamily;
			state = bestState;
			return true;
		}

		private static void ConsiderPrefabNear(string prefabName, Vector3 position, ref float best, ref ZDO bestZdo, ref string bestFamily, ref FarmSlotState bestState)
		{
			//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)
			if (string.IsNullOrEmpty(prefabName))
			{
				return;
			}
			ZdoScratch.Clear();
			int num = 0;
			int num2 = 0;
			while (ZDOMan.instance.GetAllZDOsWithPrefabIterative(prefabName, ZdoScratch, ref num) && num2++ < 64)
			{
			}
			for (int i = 0; i < ZdoScratch.Count; i++)
			{
				ZDO val = ZdoScratch[i];
				if (val != null && val.IsValid())
				{
					float num3 = Vector3.Distance(val.GetPosition(), position);
					if (!(num3 > best) && CropRegistry.TryGetFamily(prefabName, out var family))
					{
						best = num3;
						bestZdo = val;
						bestFamily = family;
						bool flag = prefabName.StartsWith("sapling_", StringComparison.OrdinalIgnoreCase);
						bestState = ((!flag) ? FarmSlotState.Mature : FarmSlotState.Occupied);
					}
				}
			}
		}

		public static Pickable FindPickableAt(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			int val = PhysicsQuery.OverlapSphereNonAlloc(position, 2f, PhysicsQuery.CropMask);
			Pickable result = null;
			float num = float.MaxValue;
			int num2 = Math.Min(val, PhysicsQuery.Buffer.Length);
			for (int i = 0; i < num2; i++)
			{
				Collider val2 = PhysicsQuery.Buffer[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Pickable componentInParent = ((Component)val2).GetComponentInParent<Pickable>();
				if (!((Object)(object)componentInParent == (Object)null) && !componentInParent.m_picked)
				{
					float num3 = FarmBoundary.HorizontalDistance(((Component)componentInParent).transform.position, position);
					if (!(num3 > 0.85f) && num3 < num)
					{
						num = num3;
						result = componentInParent;
					}
				}
			}
			return result;
		}

		public static Plant FindPlantAt(Vector3 position)
		{
			//IL_0000: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			int val = PhysicsQuery.OverlapSphereNonAlloc(position, 2f, PhysicsQuery.CropMask);
			Plant result = null;
			float num = float.MaxValue;
			int num2 = Math.Min(val, PhysicsQuery.Buffer.Length);
			for (int i = 0; i < num2; i++)
			{
				Collider val2 = PhysicsQuery.Buffer[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Plant componentInParent = ((Component)val2).GetComponentInParent<Plant>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					float num3 = FarmBoundary.HorizontalDistance(((Component)componentInParent).transform.position, position);
					if (!(num3 > 0.85f) && num3 < num)
					{
						num = num3;
						result = componentInParent;
					}
				}
			}
			return result;
		}
	}
	internal static class FarmFieldScanner
	{
		private static readonly List<ZDO> ZdoScratch = new List<ZDO>(64);

		public static FarmScanner.ScanResult Scan(HomesteadData data, Vector3 homesteadPos)
		{
			//IL_001f: 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_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_0057: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00a6: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			FarmScanner.ScanResult result = default(FarmScanner.ScanResult);
			if (data == null)
			{
				result.Message = "No homestead data";
				return result;
			}
			CropRegistry.EnsureInit();
			if (!FarmBoundary.TryGetBoundaryAabb(data, homesteadPos, out var min, out var max))
			{
				result.Message = "Boundary missing or invalid";
				Log.Warning("Scan aborted: boundary missing/invalid");
				return result;
			}
			float num = max.x - min.x;
			float num2 = max.z - min.z;
			Log.Info($"Field scan AABB size=({num:F1}x{num2:F1}) center={(min + max) * 0.5f}");
			Dictionary<string, FarmSlot> dictionary = new Dictionary<string, FarmSlot>();
			int plantHits = 0;
			int nameMisses = 0;
			int num3 = 0;
			int zdoHits = 0;
			Vector3 center = (min + max) * 0.5f;
			Vector3 halfExtents = (max - min) * 0.5f;
			num3 = PhysicsQuery.OverlapBoxNonAlloc(center, halfExtents, Quaternion.identity, PhysicsQuery.CropMask);
			CollectFromColliders(PhysicsQuery.Buffer, num3, min, max, dictionary, ref plantHits, ref nameMisses);
			CollectFromZdos(min, max, dictionary, ref zdoHits, ref nameMisses);
			if (zdoHits > plantHits)
			{
				plantHits = zdoHits;
			}
			List<FarmSlot> list = new List<FarmSlot>();
			foreach (FarmSlot slot in data.Slots)
			{
				if (!FarmBoundary.Inside(slot.Position, min, max))
				{
					list.Add(slot);
				}
			}
			foreach (FarmSlot item in list)
			{
				data.Slots.Remove(item);
				result.Removed++;
			}
			foreach (FarmSlot value in dictionary.Values)
			{
				FarmSlot farmSlot = null;
				for (int i = 0; i < data.Slots.Count; i++)
				{
					if (data.Slots[i] != null && data.Slots[i].Id == value.Id)
					{
						farmSlot = data.Slots[i];
						break;
					}
				}
				if (farmSlot == null)
				{
					data.Slots.Add(value);
					result.Added++;
					continue;
				}
				farmSlot.CurrentCropFamily = value.CurrentCropFamily;
				if (string.IsNullOrEmpty(farmSlot.OriginalCropFamily))
				{
					farmSlot.OriginalCropFamily = value.OriginalCropFamily;
				}
				if (farmSlot.State != FarmSlotState.ReservedHarvest && farmSlot.State != FarmSlotState.ReservedPlant && farmSlot.State != FarmSlotState.Disabled)
				{
					farmSlot.State = value.State;
				}
				farmSlot.LastUpdated = Time.time;
				result.Updated++;
			}
			foreach (FarmSlot slot2 in data.Slots)
			{
				if (!dictionary.ContainsKey(slot2.Id) && slot2.State != FarmSlotState.Disabled && slot2.State != FarmSlotState.ReservedHarvest && slot2.State != FarmSlotState.ReservedPlant)
				{
					slot2.State = FarmSlotState.Empty;
					slot2.CurrentCropFamily = slot2.OriginalCropFamily;
				}
			}
			result.Total = data.Slots.Count;
			result.Message = $"plants={plantHits} unrecognized={nameMisses} physCols={num3} zdo={zdoHits}";
			Log.Info($"Field scan: +{result.Added} -{result.Removed} ~{result.Updated} total={result.Total} ({result.Message})");
			return result;
		}

		private static void CollectFromColliders(Collider[] hits, int hitCount, Vector3 min, Vector3 max, Dictionary<string, FarmSlot> found, ref int plantHits, ref int nameMisses)
		{
			//IL_004b: 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)
			if (hits == null || hitCount <= 0)
			{
				return;
			}
			int num = Math.Min(hitCount, hits.Length);
			for (int i = 0; i < num; i++)
			{
				Collider val = hits[i];
				if (!((Object)(object)val == (Object)null))
				{
					Plant componentInParent = ((Component)val).GetComponentInParent<Plant>();
					object obj = ((componentInParent != null) ? ((Component)componentInParent).gameObject : null);
					if (obj == null)
					{
						Pickable componentInParent2 = ((Component)val).GetComponentInParent<Pickable>();
						obj = ((componentInParent2 != null) ? ((Component)componentInParent2).gameObject : null);
					}
					TryAddCropObject((GameObject)obj, min, max, found, ref plantHits, ref nameMisses);
				}
			}
		}

		private static void CollectFromZdos(Vector3 min, Vector3 max, Dictionary<string, FarmSlot> found, ref int zdoHits, ref int nameMisses)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			CropRegistry.AddZdoLookupPrefabs(hashSet);
			foreach (string item in hashSet)
			{
				ZdoScratch.Clear();
				int num = 0;
				int num2 = 0;
				while (ZDOMan.instance.GetAllZDOsWithPrefabIterative(item, ZdoScratch, ref num) && num2++ < 128)
				{
				}
				for (int i = 0; i < ZdoScratch.Count; i++)
				{
					ConsiderZdo(ZdoScratch[i], item, min, max, found, ref zdoHits, ref nameMisses);
				}
			}
			int count = found.Count;
			CollectCropZdosFullScan(min, max, hashSet, found, ref zdoHits, ref nameMisses);
			if (found.Count > count)
			{
				Log.Info($"Field scan ZDO full-scan added {found.Count - count} slots");
			}
		}

		private static void CollectCropZdosFullScan(Vector3 min, Vector3 max, HashSet<string> prefabNames, Dictionary<string, FarmSlot> found, ref int zdoHits, ref int nameMisses)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!(AccessTools.Field(typeof(ZDOMan), "m_objectsByID")?.GetValue(ZDOMan.instance) is IDictionary dictionary))
				{
					return;
				}
				Vector3 min2 = min - new Vector3(1f, 0f, 1f);
				Vector3 max2 = max + new Vector3(1f, 0f, 1f);
				foreach (DictionaryEntry item in dictionary)
				{
					object? value = item.Value;
					ZDO val = (ZDO)((value is ZDO) ? value : null);
					if (val == null || !val.IsValid() || !FarmBoundary.Inside(val.GetPosition(), min2, max2))
					{
						continue;
					}
					GameObject prefab = ZNetScene.instance.GetPrefab(val.GetPrefab());
					if (!((Object)(object)prefab == (Object)null))
					{
						string name = ((Object)prefab).name;
						if (prefabNames.Contains(name) || CropRegistry.TryGetFamily(name, out var _))
						{
							ConsiderZdo(val, name, min, max, found, ref zdoHits, ref nameMisses);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("CollectCropZdosFullScan failed: " + ex.Message);
			}
		}

		private static void ConsiderZdo(ZDO zdo, string prefabName, Vector3 min, Vector3 max, Dictionary<string, FarmSlot> found, ref int zdoHits, ref int nameMisses)
		{
			//IL_000d: 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_0013: 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_0015: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid())
			{
				return;
			}
			Vector3 position = zdo.GetPosition();
			if (!FarmBoundary.Inside(position, min, max))
			{
				return;
			}
			zdoHits++;
			if (!CropRegistry.TryGetFamily(prefabName, out var family))
			{
				nameMisses++;
				return;
			}
			FarmSlotState state = ((!prefabName.StartsWith("sapling_", StringComparison.OrdinalIgnoreCase)) ? FarmSlotState.Mature : FarmSlotState.Occupied);
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.FindInstance(zdo.m_uid) : null);
			if ((Object)(object)val != (Object)null)
			{
				Pickable component = val.GetComponent<Pickable>();
				if ((Object)(object)component != (Object)null)
				{
					state = ((!component.m_picked) ? FarmSlotState.Mature : FarmSlotState.Empty);
				}
				else if ((Object)(object)val.GetComponent<Plant>() != (Object)null)
				{
					state = FarmSlotState.Occupied;
				}
			}
			string text = FarmSlot.MakeId(position);
			if (!found.ContainsKey(text))
			{
				found[text] = new FarmSlot
				{
					Id = text,
					Position = position,
					RotY = 0f,
					OriginalCropFamily = family,
					CurrentCropFamily = family,
					State = state,
					LastUpdated = Time.time
				};
			}
		}

		private static void TryAddCropObject(GameObject go, Vector3 min, Vector3 max, Dictionary<string, FarmSlot> found, ref int hits, ref int nameMisses)
		{
			//IL_0010: 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_0016: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Vector3 position = go.transform.position;
			if (!FarmBoundary.Inside(position, min, max))
			{
				return;
			}
			hits++;
			if (!CropRegistry.TryGetFamily(((Object)go).name, out var family))
			{
				nameMisses++;
				Log.Debug("Scan skipped unrecognized plant '" + ((Object)go).name + "'");
				return;
			}
			string text = FarmSlot.MakeId(position);
			if (!found.ContainsKey(text))
			{
				Pickable component = go.GetComponent<Pickable>();
				Plant component2 = go.GetComponent<Plant>();
				FarmSlotState state = FarmSlotState.Occupied;
				if ((Object)(object)component != (Object)null && component.m_picked)
				{
					state = FarmSlotState.Empty;
				}
				else if ((Object)(object)component != (Object)null)
				{
					state = FarmSlotState.Mature;
				}
				else if ((Object)(object)component2 != (Object)null)
				{
					state = FarmSlotState.Occupied;
				}
				FarmSlot obj = new FarmSlot
				{
					Id = text,
					Position = position
				};
				Quaternion rotation = go.transform.rotation;
				obj.RotY = ((Quaternion)(ref rotation)).eulerAngles.y;
				obj.OriginalCropFamily = family;
				obj.CurrentCropFamily = family;
				obj.State = state;
				obj.LastUpdated = Time.time;
				found[text] = obj;
			}
		}
	}
	internal static class FarmScanner
	{
		public struct ScanResult
		{
			public int Added;

			public int Removed;

			public int Updated;

			public int Total;

			public string Message;
		}

		public static bool TryGetBoundaryAabb(HomesteadData data, Vector3 homesteadPos, out Vector3 min, out Vector3 max)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FarmBoundary.TryGetBoundaryAabb(data, homesteadPos, out min, out max);
		}

		public static ScanResult Scan(HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FarmFieldScanner.Scan(data, homesteadPos);
		}

		public static void RefreshSlotStates(HomesteadData data)
		{
			FarmSlotAssigner.RefreshSlotStates(data);
		}

		public static bool IsSlotPlantable(FarmSlot slot)
		{
			return FarmCropQuery.IsSlotPlantable(slot);
		}

		public static bool TryFindCropAt(Vector3 position, out string family, out FarmSlotState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmCropQuery.TryFindCropAt(position, out family, out state);
		}

		public static bool TryFindCropAt(Vector3 position, out string family, out FarmSlotState state, bool allowZdoFallback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmCropQuery.TryFindCropAt(position, out family, out state, allowZdoFallback);
		}

		public static Pickable FindPickableAt(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmCropQuery.FindPickableAt(position);
		}

		public static Plant FindPlantAt(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FarmCropQuery.FindPlantAt(position);
		}

		public static long ZdoKey(ZDO zdo)
		{
			return ZdoIds.ZdoKey(zdo);
		}
	}
	public enum FarmSlotState
	{
		Occupied,
		Mature,
		Empty,
		ReservedHarvest,
		ReservedPlant,
		Blocked,
		Disabled
	}
	[Serializable]
	public class FarmSlot
	{
		public string Id;

		public float X;

		public float Y;

		public float Z;

		public float RotY;

		public string OriginalCropFamily;

		public string CurrentCropFamily;

		public FarmSlotState State = FarmSlotState.Empty;

		public long ReservedBy;

		public float LastUpdated;

		public Vector3 Position
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3(X, Y, Z);
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: 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)
				X = value.x;
				Y = value.y;
				Z = value.z;
			}
		}

		public Quaternion Rotation => Quaternion.Euler(0f, RotY, 0f);

		public static string MakeId(Vector3 pos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"{pos.x:F2}_{pos.y:F2}_{pos.z:F2}";
		}
	}
	[Serializable]
	public class FarmSlotList
	{
		public List<FarmSlot> Slots = new List<FarmSlot>();
	}
	internal static class FarmSlotAssigner
	{
		private static readonly Dictionary<int, float> RefreshAtByData = new Dictionary<int, float>(8);

		public static void RefreshSlotStates(HomesteadData data)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (data?.Slots == null || data.Slots.Count == 0)
			{
				return;
			}
			int hashCode = RuntimeHelpers.GetHashCode(data);
			float time = Time.time;
			if (RefreshAtByData.TryGetValue(hashCode, out var value) && time < value)
			{
				return;
			}
			RefreshAtByData[hashCode] = time + SyncedConfig.ScanInterval;
			foreach (FarmSlot slot in data.Slots)
			{
				if (slot != null && slot.State != FarmSlotState.Disabled && slot.State != FarmSlotState.ReservedHarvest && slot.State != FarmSlotState.ReservedPlant)
				{
					if (FarmCropQuery.TryFindCropAt(slot.Position, out var family, out var state, allowZdoFallback: false))
					{
						slot.CurrentCropFamily = family;
						slot.State = state;
						slot.LastUpdated = time;
					}
					else if ((slot.State != FarmSlotState.Occupied && slot.State != FarmSlotState.Mature) || !(time - slot.LastUpdated < SyncedConfig.ScanInterval * 3f))
					{
						slot.State = FarmSlotState.Empty;
						slot.LastUpdated = time;
					}
				}
			}
		}
	}
	internal static class SeedManager
	{
		private static int _seedCountFrame = -1;

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

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

		public static int CountSeeds(HomesteadData data, InventoryManager inventory, string family)
		{
			if (!CropRegistry.TryGet(family, out var def))
			{
				return 0;
			}
			int value;
			if (Time.frameCount != _seedCountFrame)
			{
				_seedCountFrame = Time.frameCount;
				SeedCountCache.Clear();
				FoodCountCache.Clear();
			}
			else if (SeedCountCache.TryGetValue(family, out value))
			{
				return value;
			}
			int num = inventory?.CountItem(def.SeedItem) ?? 0;
			data?.SyncChestListsFromCsv();
			int num2 = CountItemInChests(data?.ChestPositions, def.SeedItem);
			int num3 = num + num2;
			SeedCountCache[family] = num3;
			return num3;
		}

		public static int CountFoodCrop(HomesteadData data, InventoryManager inventory, string foodFamily)
		{
			if (!CropRegistry.TryGet(foodFamily, out var def))
			{
				return 0;
			}
			if (def.ProducesSeedItem)
			{
				return 0;
			}
			int value;
			if (Time.frameCount != _seedCountFrame)
			{
				_seedCountFrame = Time.frameCount;
				SeedCountCache.Clear();
				FoodCountCache.Clear();
			}
			else if (FoodCountCache.TryGetValue(foodFamily, out value))
			{
				return value;
			}
			int num = inventory?.CountItem(def.GrownPrefab) ?? 0;
			data?.SyncChestListsFromCsv();
			int num2 = CountItemInChests(data?.ChestPositions, def.GrownPrefab);
			int num3 = num + num2;
			FoodCountCache[foodFamily] = num3;
			return num3;
		}

		public static bool CanStartSeedPlant(HomesteadData data, InventoryManager inventory, string foodFamily)
		{
			if (CountSeeds(data, inventory, foodFamily) <= 0)
			{
				return CountFoodCrop(data, inventory, foodFamily) > 0;
			}
			return true;
		}

		private static int CountItemInChests(List<WorldRef> positions, string prefab)
		{
			int num = 0;
			if (positions == null)
			{
				return 0;
			}
			foreach (Container item in ChestAssignments.ResolveFromPositions(positions))
			{
				if (((item != null) ? item.GetInventory() : null) != null)
				{
					num += CountInInventory(item.GetInventory(), prefab);
				}
			}
			return num;
		}

		public static void InvalidateSeedCountCache()
		{
			_seedCountFrame = -1;
			SeedCountCache.Clear();
			FoodCountCache.Clear();
		}

		public static int AvailableSeedsForPlanting(HomesteadData data, InventoryManager inventory, string family)
		{
			if (!CropRegistry.TryGet(family, out var _))
			{
				return 0;
			}
			int num = CountSeeds(data, inventory, family);
			if (family.StartsWith("Seed", StringComparison.OrdinalIgnoreCase))
			{
				return num;
			}
			int num2 = (data?.GetCropConfig(family))?.MinimumSeedReserve ?? 0;
			return Math.Max(0, num - num2);
		}

		public static int SuggestedFetchAmount(HomesteadData data, InventoryManager inventory, string family)
		{
			if (!CropRegistry.TryGet(family, out var _))
			{
				return 5;
			}
			int valueOrDefault = (data?.Slots?.Count((FarmSlot s) => s.State == FarmSlotState.Empty)).GetValueOrDefault();
			int val = Math.Max(20, valueOrDefault);
			int val2 = inventory?.CountPlantingMaterialCarried(family) ?? 0;
			string text = CropWeights.FoodFamilyForSeedFamily(family);
			if (!string.IsNullOrEmpty(text))
			{
				int num = CountSeeds(data, inventory, text);
				int num2 = CountFoodCrop(data, inventory, text);
				int val3 = num + num2;
				return Math.Max(1, Math.Min(val, Math.Max(val2, val3)));
			}
			int val4 = CountSeeds(data, inventory, family);
			return Math.Max(1, Math.Min(val, val4));
		}

		public static bool ShouldKeepAsSeed(HomesteadData data, string itemName, int currentSeedCount)
		{
			CropDefinition cropDefinition = CropRegistry.All.FirstOrDefault((CropDefinition d) => string.Equals(d.SeedItem, itemName, StringComparison.OrdinalIgnoreCase) || string.Equals(d.GrownPrefab, itemName, StringComparison.OrdinalIgnoreCase));
			if (cropDefinition == null)
			{
				return false;
			}
			CropConfigEntry cropConfigEntry = data?.GetCropConfig(cropDefinition.Family);
			if (cropConfigEntry == null)
			{
				return false;
			}
			return currentSeedCount < cropConfigEntry.MinimumSeedReserve;
		}

		public static bool IsSeedItem(string itemName)
		{
			return CropRegistry.All.Any((CropDefinition d) => string.Equals(d.SeedItem, itemName, StringComparison.OrdinalIgnoreCase));
		}

		private static int CountInInventory(Inventory inv, string prefab)
		{
			if (inv == null || string.IsNullOrEmpty(prefab))
			{
				return 0;
			}
			string text = null;
			if ((Object)(object)ObjectDB.instance != (Object)null)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefab);
				text = ((itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_name);
			}
			int num = 0;
			foreach (ItemData allItem in inv.GetAllItems())
			{
				if (allItem != null)
				{
					if ((Object)(object)allItem.m_dropPrefab != (Object)null && string.Equals(((Object)allItem.m_dropPrefab).name, prefab, StringComparison.OrdinalIgnoreCase))
					{
						num += allItem.m_stack;
					}
					else if (!string.IsNullOrEmpty(text) && allItem.m_shared != null && string.Equals(allItem.m_shared.m_name, text, StringComparison.OrdinalIgnoreCase))
					{
						num += allItem.m_stack;
					}
				}
			}
			return num;
		}
	}
}
namespace ValheimFarmerNPC.Farmer
{
	internal static class FarmerAudio
	{
		public static void Apply(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				if ((Object)(object)go.GetComponent<FarmerAudioGate>() == (Object)null)
				{
					go.AddComponent<FarmerAudioGate>();
				}
				if (!SyncedConfig.EnableFarmerSounds)
				{
					MuteAudioSources(go);
					ClearEffectLists((Component)(object)go.GetComponent<Character>());
					ClearEffectLists((Component)(object)go.GetComponent<Humanoid>());
				}
			}
		}

		public static void MuteAudioSources(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			AudioSource[] componentsInChildren = go.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.mute = true;
					val.volume = 0f;
				}
			}
		}

		public static bool ShouldBlockEffectAt(Vector3 pos, Transform parent)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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)
			if (SyncedConfig.EnableFarmerSounds)
			{
				return false;
			}
			if ((Object)(object)parent != (Object)null && (Object)(object)((Component)parent).GetComponentInParent<FarmerNpc>() != (Object)null)
			{
				return true;
			}
			foreach (FarmerNpc item in FarmerNpc.Live)
			{
				if (!((Object)(object)item == (Object)null))
				{
					Vector3 val = ((Component)item).transform.position - pos;
					if (((Vector3)(ref val)).sqrMagnitude <= 2.25f)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static void ClearEffectLists(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			Type typeFromHandle = typeof(EffectList);
			FieldInfo[] fields = ((object)component).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (fieldInfo.FieldType != typeFromHandle)
				{
					continue;
				}
				object value = fieldInfo.GetValue(component);
				if (value != null)
				{
					FieldInfo field = typeFromHandle.GetField("m_effectPrefabs", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (!(field == null) && field.GetValue(value) is Array { Length: not 0 } array)
					{
						Array value2 = Array.CreateInstance(array.GetType().GetElementType(), 0);
						field.SetValue(value, value2);
					}
				}
			}
		}
	}
	internal sealed class FarmerAudioGate : MonoBehaviour
	{
		private float _nextCheck;

		private void Update()
		{
			if (!SyncedConfig.EnableFarmerSounds && !(Time.time < _nextCheck))
			{
				_nextCheck = Time.time + 0.5f;
				FarmerAudio.MuteAudioSources(((Component)this).gameObject);
			}
		}
	}
	internal class FarmerController : MonoBehaviour
	{
		private FarmerNpc _npc;

		private FarmerBrain _brain;

		public FarmerNpc Npc => _npc;

		public void Bind(FarmerNpc npc)
		{
			_npc = npc;
			_brain = ((Component)this).GetComponent<FarmerBrain>() ?? ((Component)this).gameObject.AddComponent<FarmerBrain>();
			_brain.Init(npc);
		}
	}
	internal static class FarmerDestroyer
	{
		private static readonly List<ZDOID> SpawnedIds = new List<ZDOID>();

		public static void MarkAsFarmer(ZDO zdo)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && zdo.IsValid())
			{
				zdo.Set("fj_farmer", 1);
				Register(zdo.m_uid);
			}
		}

		public static void Register(ZDOID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!(id == ZDOID.None) && !SpawnedIds.Contains(id))
			{
				SpawnedIds.Add(id);
			}
		}

		public static List<ZDOID> CollectLocalFarmerIds(Vector3 pos, float range)
		{
			//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_0053: Unknown result type (might be due to invalid IL or missing references)
			List<ZDOID> list = new List<ZDOID>();
			Character[] array = Object.FindObjectsOfType<Character>();
			foreach (Character val in array)
			{
				if (FarmerIdentity.LooksLikeFarmerCharacter(val) && !(Vector3.Distance(((Component)val).transform.position, pos) > range))
				{
					ZNetView component = ((Component)val).GetComponent<ZNetView>();
					if ((Object)(object)component != (Object)null && component.IsValid())
					{
						list.Add(component.GetZDO().m_uid);
					}
				}
			}
			return list;
		}

		public static int DestroyLocalFarmerViews(Vector3 pos, float range)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Character[] array = Object.FindObjectsOfType<Character>();
			foreach (Character val in array)
			{
				if (FarmerIdentity.LooksLikeFarmerCharacter(val) && !(Vector3.Distance(((Component)val).transform.position, pos) > range))
				{
					Log.Warning($"Client destroying local farmer view '{val.m_name}' at {((Component)val).transform.position}");
					ZNetView component = ((Component)val).GetComponent<ZNetView>();
					DestroyCharacterOrView(((Component)val).gameObject, component);
					num++;
				}
			}
			return num;
		}

		public static int ClearNear(Vector3 pos, float range, bool keepOne, List<ZDOID> extraIds = null)
		{
			//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_0015: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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_01dc: 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_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			if (!AdminUtil.IsServer())
			{
				return DestroyLocalFarmerViews(pos, range);
			}
			int num = 0;
			HashSet<ZDOID> hashSet = new HashSet<ZDOID>();
			if (extraIds != null)
			{
				foreach (ZDOID extraId in extraIds)
				{
					if (!(extraId == ZDOID.None) && !hashSet.Contains(extraId) && DestroyById(extraId))
					{
						hashSet.Add(extraId);
						num++;
					}
				}
			}
			for (int num2 = SpawnedIds.Count - 1; num2 >= 0; num2--)
			{
				ZDOID val = SpawnedIds[num2];
				ZDOMan instance = ZDOMan.instance;
				ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
				if (val2 == null || !val2.IsValid())
				{
					SpawnedIds.RemoveAt(num2);
				}
				else if (!(Vector3.Distance(val2.GetPosition(), pos) > range) && (!keepOne || hashSet.Count != 0 || num != 0) && !hashSet.Contains(val))
				{
					Log.Warning($"Destroying registered farmer ZDO {((ZDOID)(ref val)).UserID}:{((ZDOID)(ref val)).ID} at {val2.GetPosition()}");
					DestroyZdo(val2);
					hashSet.Add(val);
					SpawnedIds.RemoveAt(num2);
					num++;
				}
			}
			List<FarmerNpc> list = new List<FarmerNpc>();
			FarmerNpc[] array = Object.FindObjectsOfType<FarmerNpc>();
			foreach (FarmerNpc farmerNpc in array)
			{
				if ((Object)(object)farmerNpc != (Object)null && Vector3.Distance(((Component)farmerNpc).transform.position, pos) <= range)
				{
					list.Add(farmerNpc);
				}
			}
			for (int j = (keepOne ? 1 : 0); j < list.Count; j++)
			{
				ZDOID id = GetId(((Component)list[j]).GetComponent<ZNetView>());
				if (!(id != ZDOID.None) || !hashSet.Contains(id))
				{
					Log.Warning($"Clearing live FarmerNpc at {((Component)list[j]).transform.position}");
					list[j].UnbindAndDestroy();
					if (id != ZDOID.None)
					{
						hashSet.Add(id);
					}
					num++;
				}
			}
			bool alreadyKeptOne = keepOne && list.Count > 0;
			num += DestroyNearbyFarmerCharacters(pos, range, keepOne, alreadyKeptOne, hashSet);
			List<ZDO> list2 = new List<ZDO>();
			string[] prefabNames = FarmerIdentity.PrefabNames;
			for (int i = 0; i < prefabNames.Length; i++)
			{
				CollectPrefabZdos(prefabNames[i], pos, range, list2);
			}
			CollectNearbyZdosFullScan(pos, range, list2);
			List<ZDO> list3 = new List<ZDO>();
			foreach (ZDO item in list2)
			{
				if (item != null && item.IsValid() && !list3.Contains(item) && !hashSet.Contains(item.m_uid))
				{
					list3.Add(item);
				}
			}
			list3.Sort((ZDO a, ZDO b) => Vector3.Distance(a.GetPosition(), pos).CompareTo(Vector3.Distance(b.GetPosition(), pos)));
			int num3 = ((keepOne && (list.Count > 0 || num > 0)) ? 1 : 0);
			foreach (ZDO item2 in list3)
			{
				if (FarmerIdentity.IsFarmerOrOrphan(item2))
				{
					if (keepOne && num3 == 0)
					{
						num3++;
						continue;
					}
					Log.Warning($"Destroying farmer/orphan ZDO {((ZDOID)(ref item2.m_uid)).UserID}:{((ZDOID)(ref item2.m_uid)).ID} prefab={FarmerIdentity.PrefabName(item2)} at {item2.GetPosition()}");
					DestroyZdo(item2);
					hashSet.Add(item2.m_uid);
					num++;
				}
			}
			Log.Info($"FarmerCleanup near {pos}: removed={num} live={list.Count} zdoCandidates={list3.Count} registry={SpawnedIds.Count} extraIds={extraIds?.Count ?? 0} keepOne={keepOne}");
			return num;
		}

		public static bool DestroyById(ZDOID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (id == ZDOID.None || ZDOMan.instance == null)
			{
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(id);
			if (zDO != null && zDO.IsValid())
			{
				Log.Warning($"DestroyById ZDO {((ZDOID)(ref id)).UserID}:{((ZDOID)(ref id)).ID} prefab={FarmerIdentity.PrefabName(zDO)} at {zDO.GetPosition()}");
				DestroyZdo(zDO);
				SpawnedIds.Remove(id);
				return true;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.FindInstance(id) : null);
			if ((Object)(object)val != (Object)null)
			{
				Log.Warning($"DestroyById instance {((ZDOID)(ref id)).UserID}:{((ZDOID)(ref id)).ID} go={((Object)val).name}");
				ZNetView component = val.GetComponent<ZNetView>();
				DestroyCharacterOrView(val, component);
				SpawnedIds.Remove(id);
				return true;
			}
			Log.Debug($"DestroyById: nothing for {((ZDOID)(ref id)).UserID}:{((ZDOID)(ref id)).ID}");
			return false;
		}

		private static int DestroyNearbyFarmerCharacters(Vector3 pos, float range, bool keepOne, bool alreadyKeptOne, HashSet<ZDOID> destroyedIds)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			bool flag = alreadyKeptOne;
			Character[] array = Object.FindObjectsOfType<Character>();
			foreach (Character val in array)
			{
				if (!FarmerIdentity.LooksLikeFarmerCharacter(val) || Vector3.Distance(((Component)val).transform.position, pos) > range)
				{
					continue;
				}
				ZNetView component = ((Component)val).GetComponent<ZNetView>();
				ZDOID id = GetId(component);
				if (id != ZDOID.None && destroyedIds.Contains(id))
				{
					continue;
				}
				if (keepOne && !flag)
				{
					flag = true;
					continue;
				}
				Log.Warning($"Destroying farmer Character '{val.m_name}' prefab={((Object)((Component)val).gameObject).name} at {((Component)val).transform.position}");
				DestroyCharacterOrView(((Component)val).gameObject, component);
				if (id != ZDOID.None)
				{
					destroyedIds.Add(id);
				}
				num++;
			}
			return num;
		}

		private static void CollectPrefabZdos(string prefabName, Vector3 pos, float range, List<ZDO> into)
		{
			//IL_0069: 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)
			if (string.IsNullOrEmpty(prefabName) || ZDOMan.instance == null)
			{
				return;
			}
			List<ZDO> list = new List<ZDO>();
			int num = 0;
			int num2 = 0;
			while (ZDOMan.instance.GetAllZDOsWithPrefabIterative(prefabName, list, ref num) && num2++ < 128)
			{
			}
			if (list.Count == 0)
			{
				TryGetAllWithPrefab(prefabName, list);
			}
			int num3 = 0;
			foreach (ZDO item in list)
			{
				if (item != null && item.IsValid() && Vector3.Distance(item.GetPosition(), pos) <= range)
				{
					into.Add(item);
					num3++;
				}
			}
			if (list.Count > 0 || num3 > 0)
			{
				Log.Info($"CollectPrefabZdos('{prefabName}'): total={list.Count} inRange={num3}");
			}
		}

		private static void CollectNearbyZdosFullScan(Vector3 pos, float range, List<ZDO> into)
		{
			//IL_01a6: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			try
			{
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.GetPrefab("FarmerNpc") : null);
				ZNetScene instance2 = ZNetScene.instance;
				GameObject val2 = ((instance2 != null) ? instance2.GetPrefab("Goblin") : null);
				if ((Object)(object)val != (Object)null)
				{
					num = ZNetScene.instance.GetPrefabHash(val);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					num2 = ZNetScene.instance.GetPrefabHash(val2);
				}
			}
			catch
			{
			}
			int num3 = 0;
			try
			{
				if (AccessTools.Field(typeof(ZDOMan), "m_objectsByID")?.GetValue(ZDOMan.instance) is IDictionary dictionary)
				{
					foreach (DictionaryEntry item in dictionary)
					{
						object? value = item.Value;
						ZDO val3 = (ZDO)((value is ZDO) ? value : null);
						if (val3 != null && val3.IsValid() && !(Vector3.Distance(val3.GetPosition(), pos) > range))
						{
							int prefab = val3.GetPrefab();
							bool flag = val3.GetInt("fj_farmer", 0) == 1 || (num != 0 && prefab == num) || (num2 != 0 && prefab == num2);
							if (!flag)
							{
								string text = FarmerIdentity.PrefabName(val3);
								flag = text == "FarmerNpc" || text.StartsWith("Goblin");
							}
							if (flag)
							{
								into.Add(val3);
								num3++;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("Full ZDO scan failed: " + ex.Message);
			}
			if (num3 > 0)
			{
				Log.Info($"CollectNearbyZdosFullScan: added={num3} near {pos}");
			}
		}

		private static void TryGetAllWithPrefab(string prefabName, List<ZDO> zdos)
		{
			try
			{
				typeof(ZDOMan).GetMethod("GetAllZDOsWithPrefab", new Type[2]
				{
					typeof(string),
					typeof(List<ZDO>)
				})?.Invoke(ZDOMan.instance, new object[2] { prefabName, zdos });
			}
			catch (Exception ex)
			{
				Log.Debug("GetAllZDOsWithPrefab fallback failed: " + ex.Message);
			}
		}

		private static ZDOID GetId(ZNetView nv)
		{
			//IL_001d: 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)
			if ((Object)(object)nv != (Object)null && nv.IsValid())
			{
				return nv.GetZDO().m_uid;
			}
			return ZDOID.None;
		}

		private static void DestroyCharacterOrView(GameObject go, ZNetView nv)
		{
			try
			{
				if ((Object)(object)nv != (Object)null && nv.IsValid())
				{
					if (!nv.IsOwner())
					{
						nv.ClaimOwnership();
					}
					nv.Destroy();
				}
				else
				{
					Object.Destroy((Object)(object)go);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("DestroyCharacterOrView failed: " + ex.Message);
			}
		}

		private static void DestroyZdo(ZDO zdo)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid())
			{
				return;
			}
			try
			{
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.FindInstance(zdo.m_uid) : null);
				if ((Object)(object)val != (Object)null)
				{
					ZNetView component = val.GetComponent<ZNetView>();
					if ((Object)(object)component != (Object)null && component.IsValid())
					{
						if (!component.IsOwner())
						{
							component.ClaimOwnership();
						}
						component.Destroy();
						return;
					}
					Object.Destroy((Object)(object)val);
				}
				zdo.SetOwner(ZDOMan.GetSessionID());
				ZDOMan.instance.DestroyZDO(zdo);
			}
			catch (Exception ex)
			{
				Log.Warning("DestroyZdo failed: " + ex.Message);
			}
		}
	}
	internal static class FarmerIdentity
	{
		public const string ZdoMarker = "fj_farmer";

		public const string GroupName = "farmer_npc";

		public static readonly string[] PrefabNames = new string[5] { "FarmerNpc", "Goblin", "GoblinArcher", "GoblinBrute", "GoblinShaman" };

		public static bool LooksLikeFarmerCharacter(Character character)
		{
			if ((Object)(object)character == (Object)null || character is Player)
			{
				return false;
			}
			if ((Object)(object)((Component)character).GetComponent<FarmerNpc>() != (Object)null)
			{
				return true;
			}
			if (string.Equals(character.m_group, "farmer_npc", StringComparison.Ordinal))
			{
				return true;
			}
			ZNetView component = ((Component)character).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				ZDO zDO = component.GetZDO();
				if (zDO != null && zDO.IsValid())
				{
					if (zDO.GetInt("fj_farmer", 0) == 1)
					{
						return true;
					}
					if (PrefabName(zDO) == "FarmerNpc")
					{
						return true;
					}
				}
			}
			string text = character.m_name ?? string.Empty;
			if (text == "$fj_npc_name" || text == "Farmer")
			{
				return true;
			}
			if ((((Object)((Component)character).gameObject).name ?? string.Empty).Replace("(Clone)", "").Trim() == "FarmerNpc")
			{
				return true;
			}
			return false;
		}

		public static bool IsFarmerOrOrphan(ZDO zdo)
		{
			if (zdo.GetInt("fj_farmer", 0) == 1)
			{
				return true;
			}
			string text = PrefabName(zdo);
			if (!(text == "FarmerNpc") && !(text == "Goblin"))
			{
				return text.StartsWith("Goblin");
			}
			return true;
		}

		public static string PrefabName(ZDO zdo)
		{
			if (zdo == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return "";
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
			if (!((Object)(object)prefab != (Object)null))
			{
				return zdo.GetPrefab().ToString();
			}
			return ((Object)prefab).name;
		}
	}
	internal static class FarmerRoster
	{
		public const float DefaultRange = 64f;

		private static int _nearFrame = -1;

		private static Vector3 _nearPos;

		private static float _nearRange;

		private static readonly List<FarmerNpc> NearCache = new List<FarmerNpc>(8);

		public static void InvalidateNearCache()
		{
			_nearFrame = -1;
		}

		public static IReadOnlyList<FarmerNpc> AllCached()
		{
			return FarmerNpc.Live;
		}

		public static List<FarmerNpc> ListNear(Vector3 homesteadPos, float range = 64f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			FillNearCache(homesteadPos, range);
			return new List<FarmerNpc>(NearCache);
		}

		public static void ListNearNonAlloc(Vector3 homesteadPos, List<FarmerNpc> into, float range = 64f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			FillNearCache(homesteadPos, range);
			into.Clear();
			into.AddRange(NearCache);
		}

		private static void FillNearCache(Vector3 homesteadPos, float range)
		{
			//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_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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (Time.frameCount == _nearFrame && Mathf.Approximately(_nearRange, range))
			{
				Vector3 val = homesteadPos - _nearPos;
				if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
				{
					return;
				}
			}
			_nearFrame = Time.frameCount;
			_nearPos = homesteadPos;
			_nearRange = range;
			NearCache.Clear();
			float num = range * range;
			IReadOnlyList<FarmerNpc> readOnlyList = AllCached();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				FarmerNpc farmerNpc = readOnlyList[i];
				if (!((Object)(object)farmerNpc == (Object)null))
				{
					float num2 = ((Component)farmerNpc).transform.position.x - homesteadPos.x;
					float num3 = ((Component)farmerNpc).transform.position.z - homesteadPos.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						NearCache.Add(farmerNpc);
					}
				}
			}
			NearCache.Sort((FarmerNpc a, FarmerNpc b) => PlanarDistSq(((Component)a).transform.position, homesteadPos).CompareTo(PlanarDistSq(((Component)b).transform.position, homesteadPos)));
		}

		public static int CountNear(Vector3 homesteadPos, float range = 64f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			FillNearCache(homesteadPos, range);
			return NearCache.Count;
		}

		public static FarmerNpc PickRemovable(Vector3 homesteadPos, float range = 64f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			FillNearCache(homesteadPos, range);
			if (NearCache.Count == 0)
			{
				return null;
			}
			return NearCache[NearCache.Count - 1];
		}

		private static float PlanarDistSq(Vector3 a, Vector3 b)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2;
		}
	}
	internal class FarmerRuntime
	{
		public float ThinkTimer;

		public float BlockedTimer;

		public string ReservedSlotId;

		public bool LoggedActive;

		public FarmerStateMachine Fsm { get; } = new FarmerStateMachine();

		public Navigation Nav { get; private set; }

		public PlannedTask Task { get; set; } = new PlannedTask
		{
			Type = PlannedTaskType.None
		};

		public void Bind(FarmerNpc npc)
		{
			Nav = new Navigation(npc);
			Fsm.Set(FarmerState.Evaluate);
			Task = new PlannedTask
			{
				Type = PlannedTaskType.None
			};
			ThinkTimer = 0f;
			BlockedTimer = 0f;
			ReservedSlotId = null;
			LoggedActive = false;
		}

		public void TearDown()
		{
			Nav?.Stop();
			Nav?.Clear();
			Task = new PlannedTask
			{
				Type = PlannedTaskType.None
			};
			ReservedSlotId = null;
			LoggedActive = false;
		}
	}
	internal static class FarmerSpawner
	{
		public static FarmerNpc TrySpawnNearHomestead(Vector3 homesteadPos, Quaternion rotation, FarmerHomestead homestead)
		{
			//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: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_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_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!CanSpawnHere())
			{
				return null;
			}
			Vector3 val = ResolveSpawnPosition(homesteadPos, rotation, 0);
			FarmerNpc farmerNpc = FindNearby(homesteadPos, 64f);
			if ((Object)(object)farmerNpc != (Object)null)
			{
				if (Vector3.Distance(((Component)farmerNpc).transform.position, val) > 2.5f)
				{
					PlaceAt(((Component)farmerNpc).gameObject, val, rotation);
					Log.Info($"FarmerSpawner repositioned existing farmer to {val}");
				}
				if ((Object)(object)homestead != (Object)null)
				{
					farmerNpc.BindHomestead(homestead);
				}
				return farmerNpc;
			}
			return CreateNew(homesteadPos, val, rotation, homestead, loadSharedInventory: true);
		}

		public static FarmerNpc SpawnAdditional(Vector3 homesteadPos, Quaternion rotation, FarmerHomestead homestead)
		{
			//IL_0021: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!CanSpawnHere())
			{
				return null;
			}
			if (FarmerNpc.ActiveCount >= SyncedConfig.MaxFarmers)
			{
				Log.Warning("Max farmers reached; not adding another");
				return null;
			}
			int slotIndex = FarmerRoster.CountNear(homesteadPos);
			Vector3 spawnPos = ResolveSpawnPosition(homesteadPos, rotation, slotIndex);
			return CreateNew(homesteadPos, spawnPos, rotation, homestead, loadSharedInventory: false);
		}

		private static bool CanSpawnHere()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated() && (Object)(object)Player.m_localPlayer == (Object)null)
			{
				Log.Debug("FarmerSpawner skip: dedicated has no local player");
				return false;
			}
			return true;
		}

		private static FarmerNpc CreateNew(Vector3 homesteadPos, Vector3 spawnPos, Quaternion rotation, FarmerHomestead homestead, bool loadSharedInventory)
		{
			//IL_0107: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			if (FarmerNpc.ActiveCount >= SyncedConfig.MaxFarmers)
			{
				Log.Warning("Max farmers reached; not spawning");
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("FarmerNpc");
			if ((Object)(object)prefab == (Object)null)
			{
				Log.Error("FarmerSpawner: 'FarmerNpc' prefab missing (is Jötunn registration done?)");
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab, spawnPos, rotation);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)val).name = "FarmerNpc";
			PlaceAt(val, spawnPos, rotation);
			ZNetView component = val.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.m_persistent = true;
				component.m_distant = false;
				ZDO zDO = component.GetZDO();
				if (zDO != null && zDO.IsValid())
				{
					zDO.Persistent = true;
					zDO.SetDistant(false);
					FarmerCleanup.MarkAsFarmer(zDO);
					if (!component.IsOwner())
					{
						try
						{
							component.ClaimOwnership();
						}
						catch
						{
						}
					}
					Log.Info($"FarmerSpawner spawned id={((ZDOID)(ref zDO.m_uid)).UserID}:{((ZDOID)(ref zDO.m_uid)).ID} at {spawnPos} owner={component.IsOwner()}");
				}
			}
			FarmerNpc farmerNpc = val.GetComponent<FarmerNpc>() ?? val.AddComponent<FarmerNpc>();
			(val.GetComponent<FarmerController>() ?? val.AddComponent<FarmerController>()).Bind(farmerNpc);
			Character component2 = val.GetComponent<Character>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_faction = (Faction)0;
				component2.m_name = "$fj_npc_name";
				component2.m_group = "farmer_npc";
			}
			FarmerAudio.Apply(val);
			MonsterAI[] componentsInChildren = val.GetComponentsInChildren<MonsterAI>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Behaviour)componentsInChildren[i]).enabled = false;
			}
			BaseAI[] componentsInChildren2 = val.GetComponentsInChildren<BaseAI>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				((Behaviour)componentsInChildren2[i]).enabled = false;
			}
			CharacterDrop component3 = val.GetComponent<CharacterDrop>();
			if ((Object)(object)component3 != (Object)null)
			{
				((Behaviour)component3).enabled = false;
			}
			if ((Object)(object)homestead != (Object)null)
			{
				farmerNpc.BindHomestead(homestead);
				if (loadSharedInventory && homestead.Data != null)
				{
					farmerNpc.Inventory.LoadFrom(homestead.Data);
				}
				else
				{
					farmerNpc.Inventory.Clear();
				}
				if (homestead.Data != null && !homestead.Data.Paused)
				{
					farmerNpc.ActivateForWork();
				}
			}
			else
			{
				farmerNpc.SetPendingHomesteadPosition(homesteadPos);
				farmerNpc.Inventory.Clear();
			}
			return farmerNpc;
		}

		public static FarmerNpc FindNearby(Vector3 homesteadPos, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			List<FarmerNpc> list = FarmerRoster.ListNear(homesteadPos, range);
			if (list.Count <= 0)
			{
				return null;
			}
			return list[0];
		}

		private static Vector3 ResolveSpawnPosition(Vector3 homesteadPos, Quaternion rotation, int slotIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0017: 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_0047: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_00bc: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: 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_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)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = rotation * Vector3.forward;
			Vector3 val2 = rotation * Vector3.right;
			float num = 0f;
			if (slotIndex > 0)
			{
				int num2 = (slotIndex + 1) / 2;
				num = ((slotIndex % 2 == 1) ? 1f : (-1f)) * (float)num2 * 1.25f;
			}
			Vector3 val3 = homesteadPos + val * 1.75f + val2 * num;
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				float groundHeight = ZoneSystem.instance.GetGroundHeight(val3);
				if (groundHeight > 1f && Mathf.Abs(groundHeight - homesteadPos.y) < 40f)
				{
					return new Vector3(val3.x, groundHeight + 0.15f, val3.z);
				}
			}
			RaycastHit val4 = default(RaycastHit);
			if (Physics.Raycast(new Vector3(val3.x, homesteadPos.y + 2f, val3.z), Vector3.down, ref val4, 6f, LayerMask.GetMask(new string[4] { "Default", "static_solid", "Default_small", "terrain" }), (QueryTriggerInteraction)1))
			{
				return ((RaycastHit)(ref val4)).point + Vector3.up * 0.15f;
			}
			return homesteadPos + val * 1.75f + Vector3.up * 0.25f;
		}

		private static void PlaceAt(GameObject go, Vector3 pos, Quaternion rot)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Character component = go.GetComponent<Character>();
			Rigidbody component2 = go.GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				((Component)component).transform.position = pos;
				((Component)component).transform.rotation = rot;
				if ((Object)(object)component2 != (Object)null)
				{
					component2.position = pos;
					component2.rotation = rot;
					component2.velocity = Vector3.zero;
					component2.angularVelocity = Vector3.zero;
				}
			}
			else if ((Object)(object)component2 != (Object)null)
			{
				component2.position = pos;
				component2.rotation = rot;
			}
			else
			{
				go.transform.SetPositionAndRotation(pos, rot);
			}
			ZNetView component3 = go.GetComponent<ZNetView>();
			if ((Object)(object)component3 != (Object)null && component3.IsValid())
			{
				ZDO zDO = component3.GetZDO();
				if (zDO != null && zDO.IsValid())
				{
					zDO.SetPosition(pos);
					zDO.SetRotation(rot);
				}
			}
		}
	}
}
namespace ValheimFarmerNPC.Config
{
	internal class PluginConfig
	{
		public ConfigEntry<bool> AdminOnlyPlacement { get; }

		public ConfigEntry<bool> AdminOnlyAccess { get; }

		public ConfigEntry<float> MaxFarmRadius { get; }

		public ConfigEntry<string> DefaultLayoutMode { get; }

		public ConfigEntry<float> ScanInterval { get; }

		public ConfigEntry<int> InventoryCapacity { get; }

		public ConfigEntry<float> ReservationTimeout { get; }

		public ConfigEntry<bool> EnableFarmerSounds { get; }

		public ConfigEntry<bool> DebugLogging { get; }

		public ConfigEntry<bool> LogFeedbackToChat { get; }

		public ConfigEntry<int> MaxFarmers { get; }

		public ConfigEntry<float> ThinkInterval { get; }

		public ConfigEntry<float> MoveSpeed { get; }

		public ConfigEntry<float> WorkRange { get; }

		public ConfigEntry<float> ChestAssignRange { get; }

		public PluginConfig(ConfigFile config)
		{
			AdminOnlyPlacement = config.Bind<bool>("General", "AdminOnlyPlacement", true, "Only server admins may place or remove Farmer Homestead and Boundary Post pieces.");
			AdminOnlyAccess = config.Bind<bool>("General", "AdminOnlyAccess", true, "If true, only admins can open the homestead panel and change settings. If false, any player can.");
			MaxFarmers = config.Bind<int>("General", "MaxFarmers", 16, "Hard cap on active farmer NPCs across the whole world/server.");
			MaxFarmRadius = config.Bind<float>("Farming", "MaxFarmRadius", 64f, "Max half-width (meters) of a farm boundary on X or Z. Larger fields fail to scan.");
			DefaultLayoutMode = config.Bind<string>("Farming", "DefaultLayoutMode", "Weighted", "Planting mode for new homesteads: Weighted (Crop settings ratios) or Fixed (replant each slot's original crop). Changing weights in the UI switches the homestead to Weighted.");
			ScanInterval = config.Bind<float>("Farming", "ScanInterval", 2f, "Seconds between background field refreshes while farmers are working (crop growth / empty-slot detection).");
			ChestAssignRange = config.Bind<float>("Farming", "ChestAssignRange", 20f, "Max distance (meters) from the homestead when using Add Chest (nearest free container).");
			InventoryCapacity = config.Bind<int>("Inventory", "InventoryCapacity", 20, "Max distinct item stacks a farmer can carry in their bag (not total item count).");
			ReservationTimeout = config.Bind<float>("Networking", "ReservationTimeout", 30f, "Seconds a harvest/plant slot reservation lasts before another farmer can take it (multiplayer).");
			EnableFarmerSounds = config.Bind<bool>("AI", "EnableFarmerSounds", true, "If true, farmers use Fuling/goblin vocal sounds. If false, farmer NPCs are muted.");
			ThinkInterval = config.Bind<float>("AI", "ThinkInterval", 0.5f, "Seconds between AI decision ticks (picking the next harvest/plant/deposit task). Lower = more responsive, more CPU.");
			MoveSpeed = config.Bind<float>("AI", "MoveSpeed", 2.5f, "Farmer walking speed (units per second) when moving between tasks.");
			WorkRange = config.Bind<float>("AI", "WorkRange", 2f, "Distance (meters) at which the farmer can harvest, plant, or interact with a chest.");
			DebugLogging = config.Bind<bool>("Debug", "DebugLogging", false, "If true, verbose farmer AI logs are written (can hurt FPS with the console open). Leave off for normal play.");
			LogFeedbackToChat = config.Bind<bool>("UI", "LogFeedbackToChat", true, "If true, homestead feedback (scan, boundary, chests, farmers, etc.) is also written to chat. Center-screen messages always show.");
		}
	}
	internal static class SyncedConfig
	{
		private static PluginConfig _config;

		public static bool AdminOnlyPlacement => _config?.AdminOnlyPlacement?.Value ?? true;

		public static bool AdminOnlyAccess => _config?.AdminOnlyAccess?.Value ?? true;

		public static int MaxFarmers => _config?.MaxFarmers?.Value ?? 16;

		public static float MaxFarmRadius => _config?.MaxFarmRadius?.Value ?? 64f;

		public static string DefaultLayoutMode => _config?.DefaultLayoutMode?.Value ?? "Weighted";

		public static float ScanInterval => _config?.ScanInterval?.Value ?? 2f;

		public static int InventoryCapacity => _config?.InventoryCapacity?.Value ?? 20;

		public static float ReservationTimeout => _config?.ReservationTimeout?.Value ?? 30f;

		public static bool EnableFarmerSounds => _config?.EnableFarmerSounds?.Value ?? true;

		public static float ThinkInterval => _config?.ThinkInterval?.Value ?? 0.5f;

		public static float MoveSpeed => _config?.MoveSpeed?.Value ?? 2.5f;

		public static float WorkRange => _config?.WorkRange?.Value ?? 2f;

		public static float ChestAssignRange => Mathf.Clamp(_config?.ChestAssignRange?.Value ?? 20f, 1f, 128f);

		public static bool DebugLogging => _config?.DebugLogging?.Value == true;

		public static bool LogFeedbackToChat => _config?.LogFeedbackToChat?.Value ?? true;

		public static void Init(PluginConfig config)
		{
			_config = config;
			TryLockAdminConfig((ConfigEntryBase)(object)config.AdminOnlyPlacement);
			TryLockAdminConfig((ConfigEntryBase)(object)config.AdminOnlyAccess);
			TryLockAdminConfig((ConfigEntryBase)(object)config.MaxFarmers);
			TryLockAdminConfig((ConfigEntryBase)(object)config.MaxFarmRadius);
			TryLockAdminConfig((ConfigEntryBase)(object)config.ChestAssignRange);
			TryLockAdminConfig((ConfigEntryBase)(object)config.ReservationTimeout);
			TryLockAdminConfig((ConfigEntryBase)(object)config.InventoryCapacity);
		}

		private static void TryLockAdminConfig(ConfigEntryBase entry)
		{
			try
			{
				_ = SynchronizationManager.Instance;
			}
			catch
			{
			}
		}
	}
}
namespace ValheimFarmerNPC.Commands
{
	internal static class DepositItemsCommand
	{
		public static bool TryExecute(FarmerNpc npc, HomesteadData data, out bool blocked)
		{
			//IL_0012: 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_001f: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			blocked = false;
			if ((Object)(object)npc == (Object)null || data == null)
			{
				return false;
			}
			Vector3 homesteadPosition = npc.GetHomesteadPosition();
			bool flag = ChestLogistics.TryDepositSurplus(npc.Inventory, data, homesteadPosition, out blocked);
			if (!flag | blocked)
			{
				return flag;
			}
			HomesteadStock.InvalidateTotalsCache();
			SeedManager.InvalidateSeedCountCache();
			if (ChestLogistics.NeedsReserveRestock(npc.Inventory, data, homesteadPosition))
			{
				ChestLogistics.TryRestockReserves(npc.Inventory, data, homesteadPosition);
				HomesteadStock.InvalidateTotalsCache();
				Log.Debug("DepositItemsCommand ok (+reserve restock)");
			}
			else
			{
				Log.Debug("DepositItemsCommand ok (no restock needed)");
			}
			return true;
		}
	}
	internal static class FetchSeedsCommand
	{
		public static bool TryExecute(FarmerNpc npc, HomesteadData data, string family, int amount = 5)
		{
			if ((Object)(object)npc == (Object)null || data == null || string.IsNullOrEmpty(family))
			{
				return false;
			}
			bool num = ChestLogistics.TryFetchSeeds(npc.Inventory, data, family, amount);
			Log.Info(num ? $"FetchSeedsCommand ok family={family} amount={amount}" : ("FetchSeedsCommand fail family=" + family + " (no chest/seeds)"));
			return num;
		}
	}
	internal static class HarvestCropCommand
	{
		public static bool TryExecute(FarmerNpc npc, HomesteadData data, FarmSlot slot)
		{
			//IL_00d4: 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)
			if ((Object)(object)npc == (Object)null || data == null || slot == null)
			{
				return false;
			}
			CropResolveResult cropResolveResult = CropResolver.Resolve(slot);
			if (cropResolveResult.Status != CropResolveStatus.Ready || (Object)(object)cropResolveResult.Pickable == (Object)null)
			{
				slot.State = FarmSlotState.Empty;
				slot.LastUpdated = Time.time;
				Log.Debug($"HarvestCropCommand fail slot={slot.Id} status={cropResolveResult.Status}");
				return false;
			}
			Pickable pickable = cropResolveResult.Pickable;
			string text = ResolveHarvestProduct(pickable, slot);
			int yieldAmount = Mathf.Max(1, pickable.m_amount);
			int amountBefore = ((!string.IsNullOrEmpty(text)) ? npc.Inventory.CountItem(text) : 0);
			Humanoid component = ((Component)npc).GetComponent<Humanoid>();
			if ((Object)(object)component != (Object)null)
			{
				pickable.Interact(component, false, false);
			}
			else
			{
				pickable.SetPicked(true);
			}
			int num = WorldDropCollector.AbsorbFromHumanoid(npc.Inventory, component);
			int destroyed;
			int num2 = WorldDropCollector.PickupNearbyDrops(npc.Inventory, slot.Position, 4.5f, data, out destroyed);
			npc.QueueDelayedPickup(slot.Position, 4.5f);
			int num3 = 0;
			if (!string.IsNullOrEmpty(text))
			{
				num3 = WorldDropCollector.EnsureHarvestProduct(npc.Inventory, text, amountBefore, yieldAmount);
			}
			slot.State = FarmSlotState.Empty;
			slot.LastUpdated = Time.time;
			Log.Debug("HarvestCropCommand ok slot=" + slot.Id + " product=" + text + " " + $"absorbed={num} picked={num2} ensured={num3}");
			return true;
		}

		private static string ResolveHarvestProduct(Pickable pickable, FarmSlot slot)
		{
			if ((Object)(object)pickable?.m_itemPrefab != (Object)null)
			{
				string name = ((Object)pickable.m_itemPrefab).name;
				if (!string.IsNullOrEmpty(name))
				{
					return name;
				}
			}
			if (!string.IsNullOrEmpty(slot?.CurrentCropFamily) && CropRegistry.TryGet(slot.CurrentCropFamily, out var def))
			{
				if (!def.ProducesSeedItem)
				{
					return def.GrownPrefab;
				}
				return def.SeedItem;
			}
			return null;
		}
	}
	internal static class PlantCropCommand
	{
		public static bool TryExecute(FarmerNpc npc, HomesteadData data, FarmSlot slot, string family)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)npc == (Object)null || data == null || slot == null || string.IsNullOrEmpty(family))
			{
				return false;
			}
			if (!CropRegistry.TryGet(family, out var def))
			{
				Log.Info("PlantCropCommand: unknown family " + family);
				return false;
			}
			CropResolveResult cropResolveResult = CropResolver.Resolve(slot);
			if (cropResolveResult.Status == CropResolveStatus.Growing || cropResolveResult.Status == CropResolveStatus.Ready)
			{
				slot.State = ((cropResolveResult.Status == CropResolveStatus.Ready) ? FarmSlotState.Mature : FarmSlotState.Occupied);
				slot.LastUpdated = Time.time;
				Log.Info($"PlantCropCommand: slot={slot.Id} already has crop ({cropResolveResult.Status}) — mark occupied, skip");
				return false;
			}
			if (!npc.Inventory.ConsumePlantingMaterial(family) && (!ChestLogistics.TryFetchPlantingMaterial(npc.Inventory, data, family) || !npc.Inventory.ConsumePlantingMaterial(family)))
			{
				Log.Info("PlantCropCommand: no seeds/food for " + family);
				return false;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(def.PlantablePrefab) : null);
			if ((Object)(object)val == (Object)null)
			{
				npc.Inventory.TryAdd(def.SeedItem);
				Log.Warning("PlantCropCommand missing prefab " + def.PlantablePrefab);
				return false;
			}
			Object.Instantiate<GameObject>(val, slot.Position, slot.Rotation);
			slot.CurrentCropFamily = family;
			if (string.IsNullOrEmpty(slot.OriginalCropFamily))
			{
				slot.OriginalCropFamily = family;
			}
			slot.State = FarmSlotState.Occupied;
			slot.LastUpdated = Time.time;
			Log.Info($"PlantCropCommand ok {family} slot={slot.Id} at {slot.Position}");
			return true;
		}
	}
}
namespace ValheimFarmerNPC.AI
{
	public class FarmerBrain : MonoBehaviour
	{
		private const float StatusLogInterval = 3f;

		private FarmerNpc _npc;

		private ZNetView _nview;

		private FarmerRuntime _runtime;

		private bool _wasOwner;

		private FarmerState _loggedState = FarmerState.Idle;

		private float _statusLogTimer;

		private float _idlePlanLogAt;

		private float _inventoryAutosaveTimer;

		public void Init(FarmerNpc npc)
		{
			_npc = npc;
			_nview = ((Component)this).GetComponent<ZNetView>();
			_runtime = new FarmerRuntime();
			_runtime.Bind(npc);
			_wasOwner = false;
			_loggedState = FarmerState.Idle;
			_statusLogTimer = 0f;
		}

		public void KickEvaluate()
		{
			if (!((Object)(object)_npc == (Object)null))
			{
				if ((Object)(object)_nview == (Object)null)
				{
					_nview = ((Component)this).GetComponent<ZNetView>();
				}
				if (_runtime == null)
				{
					_runtime = new FarmerRuntime();
				}
				_runtime.Bind(_npc);
				_runtime.Fsm.Set(FarmerState.Evaluate);
				_runtime.ThinkTimer = SyncedConfig.ThinkInterval;
				_runtime.LoggedActive = false;
				if ((Object)(object)_nview != (Object)null && _nview.IsValid() && _nview.IsOwner())
				{
					_wasOwner = true;
				}
			}
		}

		private void Update()
		{
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_npc == (Object)null)
			{
				return;
			}
			if ((Object)(object)_nview == (Object)null)
			{
				_nview = ((Component)this).GetComponent<ZNetView>();
			}
			if (!((Object)(object)_nview != (Object)null) || !_nview.IsValid() || !_nview.IsOwner())
			{
				if (_wasOwner)
				{
					Log.Debug("FarmerBrain ownership lost — flushing inventory then teardown");
					_npc.ForcePersistInventory();
					_runtime?.TearDown();
					_wasOwner = false;
				}
				return;
			}
			if (!_wasOwner)
			{
				Log.Debug("FarmerBrain ownership acquired — reset to Evaluate");
				if (_runtime == null)
				{
					_runtime = new FarmerRuntime();
				}
				_runtime.Bind(_npc);
				_wasOwner = true;
				_loggedState = FarmerState.Evaluate;
				_statusLogTimer = 0f;
			}
			HomesteadData workData = _npc.GetWorkData();
			if (workData == null)
			{
				Log.Warning("FarmerBrain: no homestead work data");
				return;
			}
			ReservationManager.Tick();
			if (workData.Paused)
			{
				if (_runtime.Fsm.Current != FarmerState.Paused)
				{
					Log.Debug("FarmerBrain: homestead paused — stopping");
				}
				_runtime.Fsm.Set(FarmerState.Paused);
				_runtime.Nav?.Stop();
				FarmerTaskExecutor.ReleaseReservation(_npc, _runtime);
				_runtime.LoggedActive = false;
				return;
			}
			if (_runtime.Fsm.Current == FarmerState.Paused)
			{
				_runtime.Fsm.Set(FarmerState.Evaluate);
				_runtime.ThinkTimer = SyncedConfig.ThinkInterval;
				Log.Debug("FarmerBrain: unpaused — evaluating");
			}
			if (!_runtime.LoggedActive)
			{
				_runtime.LoggedActive = true;
				Log.Debug($"FarmerBrain active slots={workData.Slots?.Count ?? 0} inv={FarmerTaskExecutor.DescribeInventory(_npc)} at {((Component)_npc).transform.position}");
			}
			float deltaTime = Time.deltaTime;
			_runtime.ThinkTimer += deltaTime;
			if (_runtime.ThinkTimer >= SyncedConfig.ThinkInterval)
			{
				_runtime.ThinkTimer = 0f;
				Think(workData);
			}
			FarmerTaskExecutor.Execute(_npc, _runtime, workData, deltaTime);
			LogStateChanges();
			MaybeLogStatus(deltaTime);
			_inventoryAutosaveTimer += deltaTime;
			if (_inventoryAutosaveTimer >= FarmerNpc.InventoryAutosaveInterval)
			{
				_inventoryAutosaveTimer = 0f;
				_npc.ForcePersistInventory();
				Log.Debug("FarmerBrain inventory autosave (" + FarmerTaskExecutor.DescribeInventory(_npc) + ")");
			}
			if (_runtime.Fsm.Current == FarmerState.Blocked)
			{
				_runtime.BlockedTimer += deltaTime;
				if (_runtime.BlockedTimer > 5f)
				{
					_runtime.BlockedTimer = 0f;
					Log.Debug("FarmerBrain: blocked timeout — re-evaluating");
					_runtime.Fsm.Set(FarmerState.Evaluate);
				}
			}
		}

		private void Think(HomesteadData data)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: 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_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			FarmerStateMachine fsm = _runtime.Fsm;
			Navigation nav = _runtime.Nav;
			if (fsm.Current == FarmerState.Harvest || fsm.Current == FarmerState.Plant || fsm.Current == FarmerState.FetchSeeds || fsm.Current == FarmerState.Deposit || fsm.Current == FarmerState.Collect)
			{
				if (nav != null && !nav.IsStuck)
				{
					return;
				}
				if (nav != null && nav.IsStuck)
				{
					Log.Debug($"FarmerBrain: stuck in {fsm.Current} — replanning ({FarmerTaskExecutor.DescribeTask(_runtime.Task)})");
				}
			}
			Vector3 homesteadPosition = _npc.GetHomesteadPosition();
			long homesteadKey = _npc.GetHomesteadKey();
			fsm.Set(FarmerState.Evaluate);
			PlannedTask plannedTask = TaskPlanner.Plan(data, _npc.Inventory, _npc.ZdoKey, ((Component)_npc).transform.position, homesteadPosition);
			_runtime.Task = plannedTask;
			bool flag = plannedTask.Type == PlannedTaskType.None || plannedTask.Type == PlannedTaskType.ReturnHome;
			if (!flag || Time.time >= _idlePlanLogAt)
			{
				Log.Debug("FarmerBrain plan → " + FarmerTaskExecutor.DescribeTask(plannedTask) + " | " + FarmerTaskExecutor.SummarizeSlots(data) + " | " + FarmerTaskExecutor.DescribeInventory(_npc));
				if (flag)
				{
					_idlePlanLogAt = Time.time + 10f;
				}
			}
			switch (plannedTask.Type)
			{
			case PlannedTaskType.Deposit:
				fsm.Set(FarmerState.Deposit);
				nav?.SetDestination(plannedTask.TargetPosition);
				Log.Debug("FarmerBrain: deposit → walk to " + FarmerTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.Harvest:
				if (plannedTask.Slot != null && ReservationManager.TryReserve(plannedTask.Slot.Id, homesteadKey, _npc.ZdoKey, ReservationType.Harvest))
				{
					_runtime.ReservedSlotId = plannedTask.Slot.Id;
					plannedTask.Slot.State = FarmSlotState.ReservedHarvest;
					fsm.Set(FarmerState.Harvest);
					nav?.SetDestination(plannedTask.TargetPosition);
					Log.Debug("FarmerBrain: harvest " + plannedTask.CropFamily + " slot=" + plannedTask.Slot.Id + " → " + FarmerTaskExecutor.Fmt(plannedTask.TargetPosition));
				}
				else
				{
					Log.Debug("FarmerBrain: harvest reserved by other or missing slot — idle");
					fsm.Set(FarmerState.Idle);
				}
				break;
			case PlannedTaskType.Collect:
				fsm.Set(FarmerState.Collect);
				Log.Debug("FarmerBrain: collecting nearby drops");
				break;
			case PlannedTaskType.FetchSeeds:
				fsm.Set(FarmerState.FetchSeeds);
				nav?.SetDestination(plannedTask.TargetPosition);
				Log.Debug("FarmerBrain: fetch seeds " + plannedTask.CropFamily + " → chest " + FarmerTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.Plant:
				if (plannedTask.Slot != null && ReservationManager.TryReserve(plannedTask.Slot.Id, homesteadKey, _npc.ZdoKey, ReservationType.Plant))
				{
					_runtime.ReservedSlotId = plannedTask.Slot.Id;
					plannedTask.Slot.State = FarmSlotState.ReservedPlant;
					fsm.Set(FarmerState.Plant);
					nav?.SetDestination(plannedTask.TargetPosition);
					Log.Debug("FarmerBrain: plant " + plannedTask.CropFamily + " slot=" + plannedTask.Slot.Id + " → " + FarmerTaskExecutor.Fmt(plannedTask.TargetPosition));
				}
				else
				{
					Log.Debug("FarmerBrain: plant reserved by other or missing slot — idle");
					fsm.Set(FarmerState.Idle);
				}
				break;
			case PlannedTaskType.ReturnHome:
				fsm.Set(FarmerState.ReturnHome);
				nav?.SetDestination(plannedTask.TargetPosition);
				if (Time.time >= _idlePlanLogAt)
				{
					Log.Debug("FarmerBrain: return home → " + FarmerTaskExecutor.Fmt(plannedTask.TargetPosition));
				}
				break;
			default:
				fsm.Set(FarmerState.Idle);
				nav?.Clear();
				break;
			}
		}

		private void LogStateChanges()
		{
			FarmerState current = _runtime.Fsm.Current;
			if (current != _loggedState)
			{
				Log.Debug($"FarmerBrain state {_loggedState} → {current}");
				_loggedState = current;
				_statusLogTimer = 0f;
			}
		}

		private void MaybeLogStatus(float dt)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			FarmerState current = _runtime.Fsm.Current;
			if (current != FarmerState.Idle && current != FarmerState.Evaluate && current != FarmerState.Paused)
			{
				_statusLogTimer += dt;
				if (!(_statusLogTimer < 3f))
				{
					_statusLogTimer = 0f;
					Navigation nav = _runtime.Nav;
					float num = ((nav != null) ? DistToDest(nav) : (-1f));
					Log.Debug($"FarmerBrain status: {current} {FarmerTaskExecutor.DescribeTask(_runtime.Task)} " + $"pos={FarmerTaskExecutor.Fmt(((Component)_npc).transform.position)} destDist={num:F1} " + $"reached={nav?.HasReached} stuck={nav?.IsStuck} | {FarmerTaskExecutor.DescribeInventory(_npc)}");
				}
			}
		}

		private float DistToDest(Navigation nav)
		{
			//IL_0028: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			PlannedTask task = _runtime.Task;
			if (task == null || task.Type == PlannedTaskType.None)
			{
				return -1f;
			}
			return Vector3.Distance(Flat(((Component)_npc).transform.position), Flat(task.TargetPosition));
		}

		private static Vector3 Flat(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(v.x, 0f, v.z);
		}
	}
	public enum FarmerState
	{
		Paused,
		Idle,
		Evaluate,
		Harvest,
		Collect,
		FetchSeeds,
		Plant,
		Deposit,
		ReturnHome,
		Blocked
	}
	internal class FarmerStateMachine
	{
		public FarmerState Current { get; private set; } = FarmerState.Idle;

		public void Set(FarmerState state)
		{
			if (Current != state)
			{
				Current = state;
			}
		}
	}
	internal static class FarmerTaskExecutor
	{
		public static void Execute(FarmerNpc npc, FarmerRuntime runtime, HomesteadData data, float dt)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			FarmerStateMachine fsm = runtime.Fsm;
			Navigation nav = runtime.Nav;
			PlannedTask task = runtime.Task;
			switch (fsm.Current)
			{
			case FarmerState.Paused:
			case FarmerState.Idle:
			case FarmerState.Evaluate:
				break;
			case FarmerState.Harvest:
				nav?.Tick(dt);
				if (nav != null && nav.IsStuck)
				{
					FailCurrent(npc, runtime, "stuck harvesting");
				}
				else if (nav != null && nav.HasReached)
				{
					Log.Debug("FarmerBrain: reached harvest target — picking " + task.CropFamily);
					DoHarvest(npc, runtime, data);
				}
				break;
			case FarmerState.Collect:
			{
				Log.Debug("FarmerBrain: pickup pass");
				if (WorldDropCollector.PickupNearbyDrops(npc.Inventory, ((Component)npc).transform.position, 3.5f, data, out var _) > 0)
				{
					npc.PersistInventory();
				}
				fsm.Set(FarmerState.Evaluate);
				break;
			}
			case FarmerState.FetchSeeds:
				nav?.Tick(dt);
				if (nav != null && nav.IsStuck)
				{
					FailCurrent(npc, runtime, "stuck fetching seeds");
				}
				else if (nav != null && nav.HasReached)
				{
					if (task.CropFamily != null)
					{
						Log.Debug("FarmerBrain: at chest — fetching planting material for " + task.CropFamily);
						int num = SeedManager.SuggestedFetchAmount(data, npc.Inventory, task.CropFamily);
						Log.Debug(ChestLogistics.TryFetchPlantingMaterial(npc.Inventory, data, task.CropFamily, num) ? $"FarmerBrain: fetched planting material {task.CropFamily} x~{num} | {DescribeInventory(npc)}" : ("FarmerBrain: FAILED fetch planting material " + task.CropFamily + " | " + DescribeInventory(npc)));
						npc.PersistInventory();
					}
					fsm.Set(FarmerState.Evaluate);
				}
				break;
			case FarmerState.Plant:
				nav?.Tick(dt);
				if (nav != null && nav.IsStuck)
				{
					FailCurrent(npc, runtime, "stuck planting");
				}
				else if (nav != null && nav.HasReached)
				{
					Log.Debug("FarmerBrain: reached plant target — planting " + task.CropFamily);
					DoPlant(npc, runtime, data);
				}
				break;
			case FarmerState.Deposit:
				nav?.Tick(dt);
				if (nav != null && nav.IsStuck)
				{
					FailCurrent(npc, runtime, "stuck depositing");
				}
				else
				{
					if (nav == null || !nav.HasReached)
					{
						break;
					}
					Log.Debug("FarmerBrain: at chest — depositing");
					bool flag = ChestLogistics.HasDepositableSurplus(npc.Inventory, data, npc.GetHomesteadPosition());
					bool blocked;
					bool flag2 = DepositItemsCommand.TryExecute(npc, data, out blocked);
					npc.PersistInventory();
					if (blocked)
					{
						Log.Warning("FarmerBrain: chests full — pausing homestead | " + DescribeInventory(npc));
						if ((Object)(object)npc.Homestead != (Object)null)
						{
							npc.Homestead.RequestPauseChestsFull();
						}
						else
						{
							PlayerFeedback.Notify("Chests full — farmers paused. Free space or add a chest, then unpause.");
							npc.BoundSession?.PauseChestsFull();
						}
						fsm.Set(FarmerState.Paused);
					}
					else if (!flag2)
					{
						fsm.Set(FarmerState.Blocked);
						Log.Warning("FarmerBrain: BLOCKED depositing (failed) | " + DescribeInventory(npc));
					}
					else
					{
						Log.Debug($"FarmerBrain: deposit/restock done (hadSurplus={flag}) | {DescribeInventory(npc)}");
						fsm.Set(FarmerState.Evaluate);
					}
				}
				break;
			case FarmerState.ReturnHome:
				nav?.Tick(dt);
				if (nav != null && nav.HasReached)
				{
					Log.Debug("FarmerBrain: home reached — idle");
					fsm.Set(FarmerState.Idle);
				}
				break;
			case FarmerState.Blocked:
				nav?.Stop();
				break;
			}
		}

		public static void FailCurrent(FarmerNpc npc, FarmerRuntime runtime, string reason)
		{
			Log.Warning("FarmerBrain: TASK FAILED — " + reason + " | was " + DescribeTask(runtime.Task) + " | " + DescribeInventory(npc));
			ReleaseReservation(npc, runtime);
			PlannedTask task = runtime.Task;
			if (task.Slot != null && (task.Slot.State == FarmSlotState.ReservedHarvest || task.Slot.State == FarmSlotState.ReservedPlant))
			{
				task.Slot.State = FarmSlotState.Empty;
			}
			runtime.Fsm.Set(FarmerState.Evaluate);
			runtime.Nav?.Clear();
		}

		public static void ReleaseReservation(FarmerNpc npc, FarmerRuntime runtime)
		{
			if (!string.IsNullOrEmpty(runtime.ReservedSlotId))
			{
				ReservationManager.Release(runtime.ReservedSlotId, npc.ZdoKey);
				runtime.ReservedSlotId = null;
			}
		}

		public static string DescribeInventory(FarmerNpc npc)
		{
			if (npc?.Inventory == null)
			{
				return "inv=?";
			}
			return $"inv={npc.Inventory.UsedSlots}/{npc.Inventory.Capacity} nearlyFull={npc.Inventory.IsNearlyFull}";
		}

		public static string DescribeTask(PlannedTask task)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (task == null || task.Type == PlannedTaskType.None)
			{
				return "task=None";
			}
			string text = ((task.Slot != null) ? (" slot=" + task.Slot.Id) : "");
			string text2 = ((!string.IsNullOrEmpty(task.CropFamily)) ? (" crop=" + task.CropFamily) : "");
			return $"task={task.Type}{text2}{text} dest={Fmt(task.TargetPosition)}";
		}

		public static string SummarizeSlots(HomesteadData data)
		{
			if (data?.Slots == null)
			{
				return "slots=?";
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			using (List<FarmSlot>.Enumerator enumerator = data.Slots.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current.State)
					{
					case FarmSlotState.Empty:
						num++;
						break;
					case FarmSlotState.Mature:
						num2++;
						break;
					case FarmSlotState.Occupied:
						num3++;
						break;
					case FarmSlotState.ReservedHarvest:
					case FarmSlotState.ReservedPlant:
						num4++;
						break;
					default:
						num5++;
						break;
					}
				}
			}
			return $"slots empty={num} mature={num2} growing={num3} reserved={num4} other={num5}";
		}

		public static string Fmt(Vector3 v)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({v.x:F1},{v.y:F1},{v.z:F1})";
		}

		private static void DoHarvest(FarmerNpc npc, FarmerRuntime runtime, HomesteadData data)
		{
			FarmSlot slot = runtime.Task.Slot;
			if (slot == null)
			{
				FailCurrent(npc, runtime, "no slot");
				return;
			}
			Log.Debug(HarvestCropCommand.TryExecute(npc, data, slot) ? ("FarmerBrain: harvested slot=" + slot.Id + " " + slot.CurrentCropFamily + " | " + DescribeInventory(npc)) : ("FarmerBrain: harvest FAILED slot=" + slot.Id + " (no pickable?)"));
			ReleaseReservation(npc, runtime);
			npc.PersistWorkData();
			runtime.Fsm.Set(FarmerState.Evaluate);
		}

		private static void DoPlant(FarmerNpc npc, FarmerRuntime runtime, HomesteadData data)
		{
			FarmSlot slot = runtime.Task.Slot;
			string cropFamily = runtime.Task.CropFamily;
			if (slot == null || string.IsNullOrEmpty(cropFamily))
			{
				FailCurrent(npc, runtime, "plant missing data");
			}
			else if (!PlantCropCommand.TryExecute(npc, data, slot, cropFamily))
			{
				FailCurrent(npc, runtime, "plant failed (" + cropFamily + " slot=" + slot.Id + ")");
			}
			else
			{
				Log.Debug("FarmerBrain: planted " + cropFamily + " slot=" + slot.Id + " | " + DescribeInventory(npc));
				ReleaseReservation(npc, runtime);
				npc.PersistWorkData();
				runtime.Fsm.Set(FarmerState.Evaluate);
			}
		}
	}
	internal class Navigation
	{
		private const float SidestepDistance = 1.85f;

		private const float SidestepTimeout = 2.75f;

		private const float SidestepTriggerSeconds = 5f;

		private const int MaxSidestepAttempts = 2;

		private const float CrowdRadius = 1.4f;

		private const float ProgressEpsilon = 0.12f;

		private readonly FarmerNpc _npc;

		private readonly Character _character;

		private readonly BaseAI _baseAi;

		private Vector3 _destination;

		private float _stuckTimer;

		private float _lastGoalDist = float.MaxValue;

		private bool _hasDestination;

		private bool _sidestepping;

		private Vector3 _sidestepDest;

		private float _sidestepTimer;

		private int _sidestepAttempts;

		public bool IsStuck { get; private set; }

		public bool HasReached { get; private set; }

		public bool IsSidestepping => _sidestepping;

		public Navigation(FarmerNpc npc)
		{
			_npc = npc;
			_character = (((Object)(object)npc != (Object)null) ? npc.Character : null);
			_baseAi = (((Object)(object)npc != (Object)null) ? ((Component)npc).GetComponent<BaseAI>() : null);
		}

		public void SetDestination(Vector3 dest)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_destination = dest;
			_hasDestination = true;
			HasReached = false;
			IsStuck = false;
			_stuckTimer = 0f;
			_lastGoalDist = float.MaxValue;
			EndSidestep(resetAttempts: true);
		}

		public void Clear()
		{
			_hasDestination = false;
			HasReached = true;
			IsStuck = false;
			_lastGoalDist = float.MaxValue;
			EndSidestep(resetAttempts: true);
			Stop();
		}

		public void Tick(float dt)
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//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_0032: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (!_hasDestination || (Object)(object)_npc == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)_npc).transform.position;
			if (_sidestepping)
			{
				TickSidestep(dt, position);
				return;
			}
			float num = Vector3.Distance(Flat(position), Flat(_destination));
			if (num <= SyncedConfig.WorkRange)
			{
				HasReached = true;
				Stop();
				return;
			}
			HasReached = false;
			MoveToward(dt, position, _destination);
			if (num < _lastGoalDist - 0.12f)
			{
				_stuckTimer = 0f;
				IsStuck = false;
				_sidestepAttempts = 0;
			}
			else
			{
				_stuckTimer += dt;
				if (_stuckTimer >= 5f && _sidestepAttempts < 2 && HasCrowdingFarmer(position) && TryBeginSidestep(position))
				{
					_stuckTimer = 0f;
					_lastGoalDist = num;
					return;
				}
				if (_stuckTimer >= 8f)
				{
					IsStuck = true;
				}
			}
			_lastGoalDist = num;
		}

		private void TickSidestep(float dt, Vector3 pos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			_sidestepTimer += dt;
			float num = Vector3.Distance(Flat(pos), Flat(_sidestepDest));
			if (num <= SyncedConfig.WorkRange * 0.75f || _sidestepTimer >= 2.75f)
			{
				Log.Debug($"Navigation: sidestep done attempts={_sidestepAttempts} " + $"reached={num <= SyncedConfig.WorkRange * 0.75f} — resume {_destination}");
				EndSidestep(resetAttempts: false);
				_stuckTimer = 0f;
				IsStuck = false;
				_lastGoalDist = float.MaxValue;
			}
			else
			{
				HasReached = false;
				MoveToward(dt, pos, _sidestepDest);
			}
		}

		private bool HasCrowdingFarmer(Vector3 pos)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			float num = 1.9599999f;
			IReadOnlyList<FarmerNpc> readOnlyList = FarmerRoster.AllCached();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				FarmerNpc farmerNpc = readOnlyList[i];
				if (!((Object)(object)farmerNpc == (Object)null) && farmerNpc != _npc)
				{
					float num2 = ((Component)farmerNpc).transform.position.x - pos.x;
					float num3 = ((Component)farmerNpc).transform.position.z - pos.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						return true;
					}
				}
			}
			return false;
		}

		private bool TryBeginSidestep(Vector3 pos)
		{
			//IL_0001: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00e0: 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_00bb: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Flat(_destination) - Flat(pos);
			if (((Vector3)(ref val)).sqrMagnitude < 0.05f)
			{
				return false;
			}
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(normalized.z, 0f, 0f - normalized.x);
			float num = ((_sidestepAttempts % 2 == 0) ? 1f : (-1f));
			if ((Object)(object)_npc != (Object)null && (_npc.ZdoKey & 1) != 0L)
			{
				num = 0f - num;
			}
			Vector3 val3 = pos + val2 * (num * 1.85f);
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				float groundHeight = ZoneSystem.instance.GetGroundHeight(val3);
				if (groundHeight > 1f && Mathf.Abs(groundHeight - pos.y) < 8f)
				{
					val3.y = groundHeight + 0.1f;
				}
			}
			_sidestepDest = val3;
			_sidestepping = true;
			_sidestepTimer = 0f;
			_sidestepAttempts++;
			IsStuck = false;
			Log.Debug(string.Format("Navigation: sidestep #{0} {1} ", _sidestepAttempts, (num > 0f) ? "right" : "left") + $"to {val3} (crowded, no progress toward {_destination})");
			return true;
		}

		private void EndSidestep(bool resetAttempts)
		{
			_sidestepping = false;
			_sidestepTimer = 0f;
			if (resetAttempts)
			{
				_sidestepAttempts = 0;
			}
		}

		private void MoveToward(float dt, Vector3 pos, Vector3 target)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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)
			Vector3 val = Flat(target) - Flat(pos);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			bool flag = false;
			if ((Object)(object)_baseAi != (Object)null)
			{
				try
				{
					_baseAi.MoveTo(dt, target, SyncedConfig.WorkRange * 0.5f, false);
					flag = true;
				}
				catch
				{
					flag = false;
				}
			}
			if (!flag && (Object)(object)_character != (Object)null)
			{
				try
				{
					_character.SetMoveDir(normalized);
					_character.UpdateWalking(dt);
					flag = true;
				}
				catch
				{
					flag = false;
				}
			}
			if (!flag)
			{
				Rigidbody component = ((Component)_npc).GetComponent<Rigidbody>();
				if ((Object)(object)component != (Object)null)
				{
					Vector3 val2 = Vector3.MoveTowards(pos, new Vector3(target.x, pos.y, target.z), SyncedConfig.MoveSpeed * dt);
					component.MovePosition(val2);
				}
			}
			if (((Vector3)(ref normalized)).sqrMagnitude > 0.001f && (Object)(object)_character == (Object)null)
			{
				((Component)_npc).transform.rotation = Quaternion.Slerp(((Component)_npc).transform.rotation, Quaternion.LookRotation(normalized), dt * 6f);
			}
		}

		public void Stop()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_character != (Object)null)
			{
				try
				{
					_character.SetMoveDir(Vector3.zero);
				}
				catch
				{
				}
			}
		}

		private static Vector3 Flat(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(v.x, 0f, v.z);
		}
	}
	internal enum PlannedTaskType
	{
		None,
		Deposit,
		Harvest,
		Collect,
		FetchSeeds,
		Plant,
		ReturnHome
	}
	internal class PlannedTask
	{
		public PlannedTaskType Type;

		public FarmSlot Slot;

		public string CropFamily;

		public Vector3 TargetPosition;
	}
	internal static class TaskPlanner
	{
		private static readonly List<FarmSlot> CandidateScratch = new List<FarmSlot>(64);

		private static readonly List<float> DistScratch = new List<float>(64);

		public static PlannedTask Plan(HomesteadData data, InventoryManager inventory, long farmerKey, Vector3 farmerPos, Vector3 homePos)
		{
			//IL_0086: 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_00bd: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: 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_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: 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_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.None
				};
			}
			FarmScanner.RefreshSlotStates(data);
			if (inventory.IsNearlyFull && ChestLogistics.HasDepositableSurplus(inventory, data, homePos))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Deposit,
					TargetPosition = (FindNearestChest(data, farmerPos) ?? homePos)
				};
			}
			FarmSlot farmSlot = FindClosestHarvest(data, farmerPos, farmerKey);
			if (farmSlot != null)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Harvest,
					Slot = farmSlot,
					TargetPosition = farmSlot.Position,
					CropFamily = farmSlot.CurrentCropFamily
				};
			}
			if (WorldDropCollector.HasPickupableDrops(farmerPos, 3.5f))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Collect,
					TargetPosition = farmerPos
				};
			}
			FarmSlot farmSlot2 = FindClosestPlantableEmpty(data, farmerPos, farmerKey);
			if (farmSlot2 != null)
			{
				string text = CropWeights.SelectCropForSlot(data, farmSlot2, inventory, (string fam) => SeedManager.CountSeeds(data, inventory, fam));
				if (!string.IsNullOrEmpty(text))
				{
					if (inventory.CountPlantingMaterialCarried(text) <= 0)
					{
						return new PlannedTask
						{
							Type = PlannedTaskType.FetchSeeds,
							Slot = farmSlot2,
							CropFamily = text,
							TargetPosition = FindFetchTarget(data, text, farmerPos, homePos)
						};
					}
					return new PlannedTask
					{
						Type = PlannedTaskType.Plant,
						Slot = farmSlot2,
						CropFamily = text,
						TargetPosition = farmSlot2.Position
					};
				}
			}
			farmSlot = FindClosestHarvest(data, farmerPos, farmerKey);
			if (farmSlot != null)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Harvest,
					Slot = farmSlot,
					TargetPosition = farmSlot.Position,
					CropFamily = farmSlot.CurrentCropFamily
				};
			}
			if (ChestLogistics.HasDepositableSurplus(inventory, data, homePos) && data.HasAnyChest)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Deposit,
					TargetPosition = (FindNearestChest(data, farmerPos) ?? homePos)
				};
			}
			if (ChestLogistics.NeedsReserveRestock(inventory, data, homePos))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Deposit,
					TargetPosition = (FindNearestChest(data, farmerPos) ?? homePos)
				};
			}
			float num = farmerPos.x - homePos.x;
			float num2 = farmerPos.z - homePos.z;
			if (num * num + num2 * num2 > 6.25f)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.ReturnHome,
					TargetPosition = homePos
				};
			}
			return new PlannedTask
			{
				Type = PlannedTaskType.None,
				TargetPosition = homePos
			};
		}

		private static FarmSlot FindClosestHarvest(HomesteadData data, Vector3 farmerPos, long farmerKey)
		{
			//IL_0066: 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)
			if (data.Slots == null)
			{
				return null;
			}
			FarmSlot result = null;
			float num = float.MaxValue;
			foreach (FarmSlot slot in data.Slots)
			{
				if (slot == null || slot.State != FarmSlotState.Mature)
				{
					continue;
				}
				CropConfigEntry cropConfig = data.GetCropConfig(slot.CurrentCropFamily);
				if ((cropConfig == null || (cropConfig.Enabled && cropConfig.HarvestEnabled)) && !ReservationManager.IsReservedByOther(slot.Id, farmerKey))
				{
					float num2 = DistSq(farmerPos, slot.Position);
					if (num2 < num)
					{
						num = num2;
						result = slot;
					}
				}
			}
			return result;
		}

		private static FarmSlot FindClosestPlantableEmpty(HomesteadData data, Vector3 farmerPos, long farmerKey)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			if (data.Slots == null)
			{
				return null;
			}
			CandidateScratch.Clear();
			DistScratch.Clear();
			foreach (FarmSlot slot in data.Slots)
			{
				if (slot != null && slot.State == FarmSlotState.Empty && !ReservationManager.IsReservedByOther(slot.Id, farmerKey))
				{
					CandidateScratch.Add(slot);
					DistScratch.Add(DistSq(farmerPos, slot.Position));
				}
			}
			int count = CandidateScratch.Count;
			if (count == 0)
			{
				return null;
			}
			for (int i = 1; i < count; i++)
			{
				float num = DistScratch[i];
				FarmSlot value = CandidateScratch[i];
				int num2 = i - 1;
				while (num2 >= 0 && DistScratch[num2] > num)
				{
					DistScratch[num2 + 1] = DistScratch[num2];
					CandidateScratch[num2 + 1] = CandidateScratch[num2];
					num2--;
				}
				DistScratch[num2 + 1] = num;
				CandidateScratch[num2 + 1] = value;
			}
			int num3 = ((count < 24) ? count : 24);
			for (int j = 0; j < num3; j++)
			{
				FarmSlot farmSlot = CandidateScratch[j];
				if (FarmScanner.IsSlotPlantable(farmSlot))
				{
					return farmSlot;
				}
				if (FarmCropQuery.TryFindCropAt(farmSlot.Position, out var family, out var state, allowZdoFallback: false))
				{
					farmSlot.CurrentCropFamily = family;
					farmSlot.State = state;
					farmSlot.LastUpdated = Time.time;
				}
			}
			return null;
		}

		private static float DistSq(Vector3 a, Vector3 b)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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)
			float num = a.x - b.x;
			float num2 = a.y - b.y;
			float num3 = a.z - b.z;
			return num * num + num2 * num2 + num3 * num3;
		}

		private static Vector3? FindNearestChest(HomesteadData data, Vector3 from)
		{
			//IL_0037: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			Container val = null;
			float num = float.MaxValue;
			data?.SyncChestListsFromCsv();
			foreach (Container item in ChestAssignments.ResolveFromPositions(data?.ChestPositions))
			{
				float num2 = DistSq(from, ((Component)item).transform.position);
				if (num2 < num)
				{
					num = num2;
					val = item;
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).transform.position;
		}

		private static Vector3 FindFetchTarget(HomesteadData data, string family, Vector3 farmerPos, Vector3 homePos)
		{
			//IL_0001: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			return FindNearestChest(data, farmerPos) ?? homePos;
		}
	}
}