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 ValheimLumberNPC.AI;
using ValheimLumberNPC.Commands;
using ValheimLumberNPC.Config;
using ValheimLumberNPC.HarmonyPatches;
using ValheimLumberNPC.Homestead;
using ValheimLumberNPC.Inventory;
using ValheimLumberNPC.Logging;
using ValheimLumberNPC.Lumber;
using ValheimLumberNPC.NPC;
using ValheimLumberNPC.Networking;
using ValheimLumberNPC.Persistence;
using ValheimLumberNPC.Pieces;
using ValheimLumberNPC.Registration;
using ValheimLumberNPC.Resolvers;
using ValheimLumberNPC.UI;
using ValheimLumberNPC.Utilities;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimLumberNPC")]
[assembly: AssemblyDescription("Autonomous multiplayer-safe lumberjack NPC for Valheim")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimLumberNPC")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c8f5d3b2-0a4e-5f9b-b2d6-7e3a1c9f5b82")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ValheimLumberNPC
{
	internal static class Constants
	{
		public const int SchemaVersion = 1;

		public const string HomesteadPrefab = "LumberHomestead";

		public const string BoundaryPostPrefab = "LumberBoundaryPost";

		public const string NpcPrefab = "LumberNpc";

		public const string HomesteadCloneSource = "piece_workbench";

		public const string BoundaryPostCloneSource = "wood_pole";

		public const string NpcCloneSource = "Troll";

		public const string ZdoSchemaVersion = "ln_schema";

		public const string ZdoData = "ln_data";

		public const string ZdoNpcId = "ln_npc";

		public const string ZdoPaused = "ln_paused";

		public const string ZdoWorkRadius = "ln_work_radius";

		public const string ZdoLumberBag = "ln_bag";

		public const string ZdoFarmerBag = "ln_bag";

		public const string ZdoLumberBagSet = "ln_bag_set";

		public const string ZdoFarmerBagSet = "ln_bag_set";

		public const string ZdoInitialNpc = "ln_initial_npc";

		public const string RpcTogglePause = "LN_TogglePause";

		public const string RpcScanField = "LN_ScanField";

		public const string RpcAssignBoundary = "LN_AssignBoundary";

		public const string RpcAssignChest = "LN_AssignChest";

		public const string RpcUpdateCropConfig = "LN_UpdateCropConfig";

		public const string RpcSetWorkRadius = "LN_SetWorkRadius";

		public const string RpcSetLayoutMode = "LN_SetLayoutMode";

		public const string RpcSetPaused = "LN_SetPaused";

		public const string RpcClearChests = "LN_ClearChests";

		public const string RpcClearField = "LN_ClearField";

		public const string RpcEnsureNpc = "LN_EnsureNpc";

		public const float DefaultInteractRange = 3.5f;

		public const float DefaultWorkRange = 3f;

		public const float DefaultThinkInterval = 0.5f;

		public const float DefaultChestAssignRange = 20f;

		public const float ChestMatchRadius = 0.35f;

		public const float DefaultWorkRadius = 40f;

		public const float MinWorkRadius = 10f;

		public const float MaxWorkRadius = 100f;

		public const float NpcReclaimRange = 132f;

		public const float WoodPickupRadius = 14f;

		public const float WorkScanVerticalExtent = 64f;

		public const float FarmScanVerticalExtent = 64f;

		public const float TreeMatchRadius = 0.85f;

		public const float CropMatchRadius = 0.85f;

		public const float DefaultStuckSeconds = 8f;

		public const float InventoryNearlyFullRatio = 0.85f;

		public static float EffectiveMaxWorkRadius => Mathf.Min(100f, SyncedConfig.MaxWorkRadius);

		public static float ClampWorkRadius(float radius)
		{
			if (radius <= 0f)
			{
				return 40f;
			}
			return Mathf.Clamp(radius, 10f, EffectiveMaxWorkRadius);
		}
	}
	[BepInPlugin("com.pjanky.valheimlumbernpc", "ValheimLumberNPC", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class Plugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.pjanky.valheimlumbernpc";

		public const string PluginName = "ValheimLumberNPC";

		public const string PluginVersion = "1.0.0";

		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.pjanky.valheimlumbernpc");
			try
			{
				PlacementPatches.Apply(Harmony);
				LumberRemovePatches.Apply(Harmony);
				LumberAudioPatches.Apply(Harmony);
				LumberFriendlyFirePatches.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("ValheimLumberNPC v1.0.0 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_lumberhomestead", "Lumber Homestead" },
				{ "piece_lumberhomestead_desc", "Homestead for a friendly troll lumberjack. Spawns one troll on place. Chops trees in a configurable radius and deposits wood in assigned chests. Admin only." },
				{ "ln_npc_name", "Lumber Troll" },
				{ "ln_npc_paused", "Lumber troll is paused. Talk to resume." },
				{ "ln_npc_working", "Lumber troll is working. Talk to pause." }
			});
		}
	}
}
namespace ValheimLumberNPC.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)("[LumberNPC] " + message));
		}

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

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

		public static void Debug(string message)
		{
			if (SyncedConfig.DebugLogging)
			{
				Logger.LogInfo((object)("[LumberNPC: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 ValheimLumberNPC.UI
{
	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 (LumberNpc item in LumberRoster.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<float> <>9__0_6;

			public static Func<int, string> <>9__0_7;

			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?.RequestAssignChest();
				HomesteadUiController.QueueRefresh();
			}

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

			internal void <BuildMainPage>b__0_6(float v)
			{
				HomesteadUiController.OnRadiusChanged(Mathf.RoundToInt(v));
			}

			internal string <BuildMainPage>b__0_7(int value)
			{
				return HomesteadRadiusPage.FormatRadiusLabel(value);
			}
		}

		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_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: 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_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Expected O, but got Unknown
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Expected O, but got Unknown
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.MainPage.transform, "Lumber 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, "Lumberjacks", 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 Troll", 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 Troll", 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, "Troll inventory", ref y, new UnityAction(HomesteadUiController.ShowInventoryPage));
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Storage", ref y);
			Transform transform5 = HomesteadUiController.MainPage.transform;
			object obj5 = <>c.<>9__0_4;
			if (obj5 == null)
			{
				UnityAction val6 = delegate
				{
					HomesteadUiController.Current?.RequestAssignChest();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_4 = val6;
				obj5 = (object)val6;
			}
			HomesteadUiWidgets.AddButton(transform5, "Add chest", ref y, (UnityAction)obj5);
			Transform transform6 = HomesteadUiController.MainPage.transform;
			object obj6 = <>c.<>9__0_5;
			if (obj6 == null)
			{
				UnityAction val7 = delegate
				{
					HomesteadUiController.Current?.RequestClearChests();
					HomesteadUiController.QueueRefresh();
				};
				<>c.<>9__0_5 = val7;
				obj6 = (object)val7;
			}
			HomesteadUiWidgets.AddButton(transform6, "Clear chests", ref y, (UnityAction)obj6);
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Chest inventory", ref y, new UnityAction(HomesteadUiController.ShowChestInventoryPage));
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Work area", ref y);
			HomesteadUiController.RadiusRow = HomesteadUiWidgets.CreateSliderRow(HomesteadUiController.MainPage.transform, "radius", "work", y, 10, (int)Constants.EffectiveMaxWorkRadius, HomesteadUiController.RadiusSliders, HomesteadUiController.RadiusLabels, delegate(float v)
			{
				HomesteadUiController.OnRadiusChanged(Mathf.RoundToInt(v));
			}, null, (int value3) => HomesteadRadiusPage.FormatRadiusLabel(value3), 0f, 400f);
			HomesteadUiController.RadiusSlider = (HomesteadUiController.RadiusSliders.TryGetValue("radius", out var value) ? value : null);
			HomesteadUiController.RadiusLabel = (HomesteadUiController.RadiusLabels.TryGetValue("radius", out var value2) ? value2 : null);
			y -= 72f;
			HomesteadUiWidgets.AddSectionHeader(HomesteadUiController.MainPage.transform, "Settings", ref y);
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Lumber settings", ref y, new UnityAction(HomesteadUiController.ShowCropsPage));
			y -= 8f;
			HomesteadUiWidgets.AddButton(HomesteadUiController.MainPage.transform, "Close", ref y, new UnityAction(HomesteadUiController.Hide));
		}
	}
	internal static class HomesteadRadiusPage
	{
		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_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Expected O, but got Unknown
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.CropsPage.transform, "Lumber settings", 0f, -22f, 20, 500f, (TextAnchor)3);
			float num = 260f;
			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, 260f, 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(390f, -22f);
				rectTransform.sizeDelta = new Vector2(260f, 24f);
			}
			GameObject val2 = (HomesteadUiController.CropsEmptyRoot = GUIManager.Instance.CreateText("No trees grow in this biome.", HomesteadUiController.CropsPage.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -280f), 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 y = -58f;
			HomesteadUiWidgets.CreateHelpText(HomesteadUiController.CropsPage.transform, "Left: which trees to chop. Right: which seeds to replant after a stump. Set a priority to 0 to skip. Rows are biome-filtered.", ref y, 44f, 0f, 800f);
			float num2 = -205f;
			float num3 = 205f;
			float num4 = 380f;
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.CropsPage.transform, "Tree priorities", num2, y, 17, num4, (TextAnchor)3);
			HomesteadUiWidgets.CreateTitle(HomesteadUiController.CropsPage.transform, "Replant priorities", num3, y, 17, num4, (TextAnchor)3);
			y -= 28f;
			RectTransform content;
			Transform parent = HomesteadUiWidgets.CreateScrollRegion(HomesteadUiController.CropsPage.transform, y, out content);
			HomesteadUiController.CropsRowsContent = content;
			HomesteadUiController.CropsRowYStart = 0f;
			float num5 = 0f;
			string[] weightCrops = HomesteadUiController.WeightCrops;
			foreach (string text in weightCrops)
			{
				string familyKey = text;
				string text2 = WoodRegistry.GetOutputItem(text) ?? "Wood";
				string iconPrefab = WoodRegistry.GetPlantingInputItem(text) ?? text2;
				HomesteadUiController.WeightRows[text] = HomesteadUiWidgets.CreateSliderRow(parent, text, "weight", num5, 0, 100, HomesteadUiController.WeightSliders, HomesteadUiController.WeightLabels, delegate(float v)
				{
					HomesteadUiController.OnWeightChanged(familyKey, Mathf.RoundToInt(v));
				}, text2, (int value2) => FormatWeightLabel(familyKey, value2), num2, num4);
				HomesteadUiController.ReplantRows[text] = HomesteadUiWidgets.CreateSliderRow(parent, text, "replant", num5, 0, 100, HomesteadUiController.ReplantSliders, HomesteadUiController.ReplantLabels, delegate(float v)
				{
					HomesteadUiController.OnReplantWeightChanged(familyKey, Mathf.RoundToInt(v));
				}, iconPrefab, (int value2) => FormatReplantLabel(familyKey, value2), num3, num4);
				if (!WoodRegistry.CanReplant(text) && HomesteadUiController.ReplantRows.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
				{
					(value.GetComponent<CanvasGroup>() ?? value.AddComponent<CanvasGroup>()).interactable = false;
				}
				num5 -= 62f;
			}
			float y2 = -650f;
			HomesteadUiWidgets.AddButton(HomesteadUiController.CropsPage.transform, "Back", ref y2, new UnityAction(HomesteadUiController.ShowMainPage));
		}

		internal static string CropDisplayName(string family)
		{
			return WoodRegistry.GetDisplayName(family);
		}

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

		internal static string FormatReplantLabel(string family, int value)
		{
			string plantingInputItem = WoodRegistry.GetPlantingInputItem(family);
			string arg = ((!string.IsNullOrEmpty(plantingInputItem)) ? plantingInputItem : CropDisplayName(family));
			return $"{arg}: {value}";
		}

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

		internal static string FormatRadiusLabel(int value)
		{
			return $"Work radius: {value}m";
		}
	}
	internal static class HomesteadUiController
	{
		internal static readonly string[] WeightCrops = WoodRegistry.AllFamilies;

		internal static readonly string[] ReserveCrops = Array.Empty<string>();

		internal const int UiLayoutVersion = 30;

		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 = 820f;

		internal const float CropsPanelWidth = 860f;

		internal const float CropsPanelHeight = 700f;

		internal const float CropsLeftColumnX = -205f;

		internal const float CropsRightColumnX = 205f;

		internal const float CropsColumnOffset = 0f;

		internal const float CropsColumnWidth = 380f;

		internal const float CropsRowsBottomMargin = 92f;

		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 LumberHomestead Current;

		internal static Text Status;

		internal static Text CropsBiomeLabel;

		internal static GameObject CropsEmptyRoot;

		internal static float CropsRowYStart;

		internal static RectTransform CropsRowsContent;

		internal static GameObject RadiusRow;

		internal static Slider RadiusSlider;

		internal static Text RadiusLabel;

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

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

		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> ReplantSliders = new Dictionary<string, Slider>(StringComparer.OrdinalIgnoreCase);

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

		internal static readonly Dictionary<string, GameObject> ReplantRows = 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(LumberHomestead 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, 820f);
			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(860f, 700f);
			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_0070: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: 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 = BiomeTreeRules.GetBiome(position);
			BiomeTreeRules.ApplyToData(data, position);
			Current.Persist();
			if ((Object)(object)CropsBiomeLabel != (Object)null)
			{
				CropsBiomeLabel.text = "Biome: " + BiomeTreeRules.GetBiomeDisplayName(biome);
			}
			float num = CropsRowYStart;
			int num2 = 0;
			string[] weightCrops = WeightCrops;
			foreach (string text in weightCrops)
			{
				bool flag = BiomeTreeRules.IsTreeAllowed(text, biome);
				float y = num;
				if (WeightRows.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
				{
					SetCropRowAt(value, flag, -205f, y);
				}
				bool show = flag && WoodRegistry.CanReplant(text);
				if (ReplantRows.TryGetValue(text, out var value2) && (Object)(object)value2 != (Object)null)
				{
					SetCropRowAt(value2, show, 205f, y);
				}
				SetActiveSafe(WeightLabels, text, flag);
				SetActiveSafe(WeightSliders, text, flag);
				SetActiveSafe(ReplantLabels, text, show);
				SetActiveSafe(ReplantSliders, text, show);
				if (flag)
				{
					num2++;
					num -= 62f;
				}
			}
			if ((Object)(object)CropsEmptyRoot != (Object)null)
			{
				CropsEmptyRoot.SetActive(num2 == 0);
			}
			if ((Object)(object)CropsRowsContent != (Object)null)
			{
				float num3 = Mathf.Max(80f, (float)num2 * 62f + 20f);
				CropsRowsContent.sizeDelta = new Vector2(CropsRowsContent.sizeDelta.x, num3);
				CropsRowsContent.anchoredPosition = new Vector2(0f, 0f);
			}
		}

		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 SetCropRowAt(GameObject row, bool show, float columnX, float y)
		{
			//IL_0051: 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);
				}
			}
		}

		private static void SetCropRowVisible(GameObject row, bool show, float columnX, ref float y)
		{
			SetCropRowAt(row, show, columnX, y);
			if (show)
			{
				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 = HomesteadRadiusPage.FormatWeightLabel(family, weight);
				}
				Current.RequestSetLayoutMode("Weighted");
				Current.RequestSetCropWeight(family, weight);
				RefreshStatus();
			}
		}

		internal static void OnReplantWeightChanged(string family, int weight)
		{
			if (!SuppressSliderEvents && !((Object)(object)Current == (Object)null))
			{
				weight = Mathf.Clamp(weight, 0, 100);
				if (ReplantLabels.TryGetValue(family, out var value))
				{
					value.text = HomesteadRadiusPage.FormatReplantLabel(family, weight);
				}
				Current.RequestSetLayoutMode("Weighted");
				Current.RequestSetReplantWeight(family, weight);
				RefreshStatus();
			}
		}

		internal static void OnRadiusChanged(int radius)
		{
			if (!SuppressSliderEvents && !((Object)(object)Current == (Object)null))
			{
				radius = Mathf.RoundToInt(Constants.ClampWorkRadius(radius));
				if ((Object)(object)RadiusLabel != (Object)null)
				{
					RadiusLabel.text = HomesteadRadiusPage.FormatRadiusLabel(radius);
				}
				Current.RequestSetWorkRadius(radius);
				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 = HomesteadRadiusPage.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;
			}
			WoodRegistry.EnsureMissingConfigs(homesteadData);
			SuppressSliderEvents = true;
			try
			{
				int num = Mathf.RoundToInt(homesteadData.GetWorkRadius());
				if ((Object)(object)RadiusSlider != (Object)null)
				{
					RadiusSlider.minValue = 10f;
					RadiusSlider.maxValue = Constants.EffectiveMaxWorkRadius;
					if (Mathf.Abs(RadiusSlider.value - (float)num) >= 0.5f)
					{
						RadiusSlider.value = num;
					}
				}
				if ((Object)(object)RadiusLabel != (Object)null)
				{
					RadiusLabel.text = HomesteadRadiusPage.FormatRadiusLabel(num);
				}
				string[] weightCrops = WeightCrops;
				foreach (string text in weightCrops)
				{
					CropConfigEntry cropConfigEntry = homesteadData.GetCropConfig(text) ?? WoodRegistry.CreateDefaultEntry(text);
					if (WeightSliders.TryGetValue(text, out var value))
					{
						value.value = Mathf.Clamp(cropConfigEntry.Weight, 0, 100);
					}
					if (WeightLabels.TryGetValue(text, out var value2))
					{
						value2.text = HomesteadRadiusPage.FormatWeightLabel(text, Mathf.Clamp(cropConfigEntry.Weight, 0, 100));
					}
					if (ReplantSliders.TryGetValue(text, out var value3))
					{
						value3.value = Mathf.Clamp(cropConfigEntry.ReplantWeight, 0, 100);
					}
					if (ReplantLabels.TryGetValue(text, out var value4))
					{
						value4.text = HomesteadRadiusPage.FormatReplantLabel(text, Mathf.Clamp(cropConfigEntry.ReplantWeight, 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($"Trolls: {Current.CountFarmers()}");
				stringBuilder.AppendLine($"Radius: {data.GetWorkRadius():0}m");
				stringBuilder.Append($"Chests: {data.ChestCount}");
				Status.text = stringBuilder.ToString();
			}
		}

		internal static void ClearCachedUiState()
		{
			WeightSliders.Clear();
			WeightLabels.Clear();
			WeightRows.Clear();
			ReplantSliders.Clear();
			ReplantLabels.Clear();
			ReplantRows.Clear();
			ReserveSliders.Clear();
			ReserveLabels.Clear();
			ReserveRows.Clear();
			RadiusSliders.Clear();
			RadiusLabels.Clear();
			RadiusRow = null;
			RadiusSlider = null;
			RadiusLabel = null;
			CropsBiomeLabel = null;
			CropsEmptyRoot = null;
			CropsRowsContent = 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 != 30))
			{
				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, 820f);
				HomesteadUiController.Root.SetActive(false);
				HomesteadUiController.MainPage = CreatePage("MainPage");
				HomesteadUiController.CropsPage = CreatePage("CropsPage");
				HomesteadUiController.InvPage = CreatePage("InvPage");
				HomesteadUiController.ChestInvPage = CreatePage("ChestInvPage");
				HomesteadMainPage.BuildMainPage();
				HomesteadRadiusPage.BuildCropsPage();
				HomesteadInventoryPages.BuildInventoryPage();
				HomesteadInventoryPages.BuildChestInventoryPage();
				if ((Object)(object)HomesteadUiController.Root.GetComponent<HomesteadUiInput>() == (Object)null)
				{
					HomesteadUiController.Root.AddComponent<HomesteadUiInput>();
				}
				HomesteadUiController.BuiltLayoutVersion = 30;
				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) ? (-390f) : (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_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: 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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Expected O, but got Unknown
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Expected O, but got Unknown
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0592: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_060e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Expected O, but got Unknown
			//IL_0631: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_0665: 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_0699: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0707: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: 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;
			bool num4 = !string.IsNullOrEmpty(iconPrefab);
			float num5 = num3 + 24.5f;
			float num6 = (num4 ? (num3 + 49f + 10f) : (num3 + 8f));
			float num7 = (num4 ? (columnWidth - 49f - 16f) : (columnWidth - 16f));
			if (num4)
			{
				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(num5, 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(num6 + num7 * 0.5f - columnWidth * 0.25f, 0f), GUIManager.Instance.AveriaSerifBold, 13, GUIManager.Instance.ValheimOrange, true, Color.black, num7, 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(num6, 0f);
				rectTransform.sizeDelta = new Vector2(num7, 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(num7, 16f);
			component4.anchoredPosition = new Vector2(num6, 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 Transform CreateScrollRegion(Transform parent, float topPage, out RectTransform content)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0071: 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_009b: 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_00bd: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			float num = topPage + 700f - 92f;
			num = Mathf.Max(80f, num);
			GameObject val = new GameObject("CropsRowsViewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(RectMask2D)
			});
			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(860f, num);
			component.anchoredPosition = new Vector2(0f, topPage);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)component2).raycastTarget = true;
			GameObject val2 = new GameObject("CropsRowsContent", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			content = val2.GetComponent<RectTransform>();
			content.anchorMin = new Vector2(0.5f, 1f);
			content.anchorMax = new Vector2(0.5f, 1f);
			content.pivot = new Vector2(0.5f, 1f);
			content.sizeDelta = new Vector2(860f, num);
			content.anchoredPosition = Vector2.zero;
			ScrollRect obj = val.AddComponent<ScrollRect>();
			obj.content = content;
			obj.viewport = component;
			obj.horizontal = false;
			obj.vertical = true;
			obj.movementType = (MovementType)2;
			obj.scrollSensitivity = 120f;
			obj.inertia = false;
			return (Transform)(object)content;
		}

		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 ValheimLumberNPC.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 TreeResolver
	{
		public static CropResolveResult Resolve(WorkSlot 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 = TreeScanner.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 = TreeScanner.FindPlantAt(slot.Position);
			if ((Object)(object)val2 != (Object)null)
			{
				return new CropResolveResult(CropResolveStatus.Growing, null, val2);
			}
			return new CropResolveResult(CropResolveStatus.Missing);
		}
	}
	internal static class WorkSlotResolver
	{
		public static WorkSlot ById(HomesteadData data, string slotId)
		{
			if (data?.Slots == null || string.IsNullOrEmpty(slotId))
			{
				return null;
			}
			return data.Slots.FirstOrDefault((WorkSlot s) => s != null && s.Id == slotId);
		}

		public static WorkSlot Nearest(HomesteadData data, Vector3 from, Func<WorkSlot, 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 ValheimLumberNPC.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("LumberNpc", "Troll");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Failed to clone NPC from Troll");
				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 = "$ln_npc_name";
				component2.m_faction = (Faction)0;
				component2.m_group = "lumber_npc";
				component2.m_boss = false;
			}
			Humanoid component3 = val.GetComponent<Humanoid>();
			if ((Object)(object)component3 != (Object)null)
			{
				((Character)component3).m_faction = (Faction)0;
				LumberLogWeapon.ApplyToHumanoid(component3);
			}
			if ((Object)(object)val.GetComponent<LumberNpc>() == (Object)null)
			{
				val.AddComponent<LumberNpc>();
			}
			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 'LumberNpc' registered (clone of Troll, troll log weapon)");
		}
	}
	internal static class PieceRegistrar
	{
		private static bool _registered;

		public static void Register()
		{
			if (!_registered)
			{
				RegisterHomestead();
				_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("LumberHomestead", "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<LumberHomestead>() == (Object)null)
			{
				val.AddComponent<LumberHomestead>();
			}
			Piece component = val.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = "$piece_lumberhomestead";
				component.m_description = "$piece_lumberhomestead_desc";
				component.m_craftingStation = null;
			}
			PieceConfig val2 = new PieceConfig
			{
				Name = "$piece_lumberhomestead",
				Description = "$piece_lumberhomestead_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("LumberBoundaryPost", "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_lumberboundarypost";
				component.m_description = "$piece_lumberboundarypost_desc";
			}
			PieceConfig val2 = new PieceConfig
			{
				Name = "$piece_lumberboundarypost",
				Description = "$piece_lumberboundarypost_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 ValheimLumberNPC.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_lumberboundarypost");
		}
	}
	internal static class HomesteadLocator
	{
		public static LumberHomestead 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)
			LumberHomestead result = null;
			float num = maxRange;
			foreach (LumberHomestead item in LumberHomestead.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 LumberHomestead 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)
			LumberHomestead lumberHomestead = FindNearest(pos, maxRange);
			if ((Object)(object)lumberHomestead != (Object)null)
			{
				return lumberHomestead;
			}
			return ForceCreateFromZdo(pos, maxRange);
		}

		private static LumberHomestead 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("LumberHomestead") == (Object)null)
			{
				Log.Error("ForceCreateFromZdo: LumberHomestead prefab missing from ZNetScene");
				return null;
			}
			List<ZDO> list = new List<ZDO>();
			HomesteadZdoBinder.TryCollectPrefab("LumberHomestead", list);
			LumberHomestead result = null;
			float num = maxRange;
			Log.Info($"ForceCreateFromZdo: found {list.Count} LumberHomestead 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))
				{
					LumberHomestead lumberHomestead = val.GetComponent<LumberHomestead>();
					if ((Object)(object)lumberHomestead == (Object)null)
					{
						lumberHomestead = val.AddComponent<LumberHomestead>();
						Log.Warning("Added missing LumberHomestead component on force-created object");
					}
					num = num2;
					result = lumberHomestead;
				}
			}
			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);
				LumberCleanup.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++)
			{
				LumberHomestead lumberHomestead = ResolveNear(pos, maxRange);
				if ((Object)(object)lumberHomestead != (Object)null)
				{
					lumberHomestead.TryInitialize();
					lumberHomestead.TrySpawnNpc();
					Log.Info($"RetrySummon succeeded on attempt {i + 1} for homestead at {((Component)lumberHomestead).transform.position}");
					yield break;
				}
				if (i == 0 || i % 5 == 4)
				{
					Log.Warning($"RetrySummon attempt {i + 1}/{attempts}: still no homestead near {pos} (known={LumberHomestead.All.Count})");
				}
				yield return (object)new WaitForSeconds(interval);
			}
			Log.Error($"RetrySummon gave up near {pos} after {attempts} attempts (known={LumberHomestead.All.Count})");
		}
	}
	internal class HomesteadSession
	{
		private static readonly Dictionary<string, HomesteadSession> ByKey = new Dictionary<string, HomesteadSession>();

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

		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 LumberNpc 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("ln_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<WorkSlot>();
				}
				string text2 = Zdo.GetString("ln_slots", string.Empty);
				if (!string.IsNullOrEmpty(text2))
				{
					Data.Slots = HomesteadCodecs.DecodeSlots(text2);
				}
				string text3 = Zdo.GetString("ln_crops", string.Empty);
				if (!string.IsNullOrEmpty(text3))
				{
					Data.CropConfigs = HomesteadCodecs.DecodeCropConfigs(text3);
				}
				else if (Data.CropConfigs == null || Data.CropConfigs.Count == 0)
				{
					Data.CropConfigs = WoodRegistry.CreateDefaultConfigs();
				}
				BiomeTreeRules.ApplyToData(Data, Position);
				string text4 = Zdo.GetString("ln_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("ln_chests", string.Empty);
				if (!string.IsNullOrEmpty(text5))
				{
					Data.ChestsCsv = text5;
					Data.ChestPositions = HomesteadCodecs.DecodeRefs(text5);
				}
				Data.SyncChestListsFromCsv();
				Data.Paused = Zdo.GetBool("ln_paused", Data.Paused);
				CaptureReloadSnapshot(text, text2, text3, text4, text5);
			}
			else
			{
				if (Data == null)
				{
					HomesteadData homesteadData = (Data = HomesteadData.CreateDefault());
				}
				if (Zdo != null && Zdo.IsValid())
				{
					Data.Paused = Zdo.GetBool("ln_paused", Data.Paused);
				}
			}
			_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("ln_data", string.Empty);
				string text2 = Zdo.GetString("ln_slots", string.Empty);
				string text3 = Zdo.GetString("ln_crops", string.Empty);
				string text4 = Zdo.GetString("ln_carried", string.Empty);
				string text5 = Zdo.GetString("ln_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<WorkSlot> list = Data.Slots ?? new List<WorkSlot>();
			List<CropConfigEntry> list2 = Data.CropConfigs ?? new List<CropConfigEntry>();
			List<CarriedItem> list3 = Data.CarriedItems ?? new List<CarriedItem>();
			Data.Slots = new List<WorkSlot>();
			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("ln_schema", Data.SchemaVersion);
			Zdo.Set("ln_data", text);
			Zdo.Set("ln_slots", text2);
			Zdo.Set("ln_crops", text3);
			Zdo.Set("ln_carried", text4);
			Zdo.Set("ln_home", 1);
			Zdo.Set("ln_paused", Data.Paused);
			Zdo.Set("ln_npc", Data.NpcZdoKey);
			Zdo.Set("ln_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("ln_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];
				Log.Info($"Session tree config {text} weight={Data.GetCropConfig(text)?.Weight}");
			}
		}

		public void SetWorkRadius(float radius)
		{
			Reload();
			HomesteadOps.SetWorkRadius(Data, radius);
			if (Zdo != null && Zdo.IsValid())
			{
				Zdo.Set("ln_work_radius", Data.GetWorkRadius());
			}
			Save();
			Log.Info($"Session work radius={Data.GetWorkRadius():0}");
		}

		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)
			LumberHomestead lumberHomestead = HomesteadLocator.ResolveNear(Position, 4f);
			if ((Object)(object)lumberHomestead != (Object)null)
			{
				return ((Component)lumberHomestead).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)
			LumberNpc lumberNpc = HomesteadLumberOps.FindNearest(Position, 132f, NpcsByKey.Values);
			if ((Object)(object)lumberNpc != (Object)null)
			{
				Npc = lumberNpc;
				NpcsByKey[Key] = lumberNpc;
				lumberNpc.BindSession(this);
				if (Data != null)
				{
					ZNetView component = ((Component)lumberNpc).GetComponent<ZNetView>();
					if (component != null && component.IsValid())
					{
						Data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
						Save();
					}
				}
				Log.Info($"SummonFarmer bound live farmer for key={Key} count={LumberRoster.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.RestoreBagOnBind(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 LumberNpc 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_00a8: 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;
			}
			LumberNpc lumberNpc = HomesteadLumberOps.SpawnAdditional(Position, GetFacingRotation(), null);
			if ((Object)(object)lumberNpc != (Object)null)
			{
				lumberNpc.BindSession(this);
				lumberNpc.Inventory.Clear();
				lumberNpc.ForcePersistInventory();
				Npc = lumberNpc;
				NpcsByKey[Key] = lumberNpc;
				if (Data != null && !Data.Paused)
				{
					lumberNpc.ActivateForWork();
				}
				Log.Info($"AddFarmer spawned key={Key} total={LumberRoster.CountNear(Position)}");
			}
			return lumberNpc;
		}

		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 (!HomesteadLumberOps.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={LumberRoster.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)
			HomesteadLumberOps.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 TreeScanner.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");
			}
			TreeScanner.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<WorkSlot>();
			}
			Save();
			Log.Info($"ApplyClientScanSlots key={Key} slots={Data.Slots.Count}");
			return Data.Slots.Count;
		}

		public void SyncSlots(string slotsCsv)
		{
			Reload();
			if (Data != null)
			{
				Data.Slots = HomesteadCodecs.DecodeSlots(slotsCsv) ?? new List<WorkSlot>();
				Save();
				Log.Debug($"Session sync_slots key={Key} slots={Data.Slots.Count}");
			}
		}

		public TreeScanner.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();
			TreeScanner.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<WorkSlot> 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;
				}
				LumberNpc lumberNpc = HomesteadLumberOps.FindNearest(Position, 132f, NpcsByKey.Values);
				if ((Object)(object)lumberNpc != (Object)null)
				{
					Npc = lumberNpc;
					NpcsByKey[Key] = lumberNpc;
					lumberNpc.BindSession(this);
					lumberNpc.ActivateForWork();
					List<LumberNpc> list3 = LumberRoster.ListNear(Position);
					for (int i = 0; i < list3.Count; i++)
					{
						LumberNpc lumberNpc2 = list3[i];
						if (!((Object)(object)lumberNpc2 == (Object)null))
						{
							lumberNpc2.BindSession(this);
							lumberNpc2.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)
			HomesteadLumberOps.CullExtraNpcs(pos, range);
		}
	}
	internal static class HomesteadUI
	{
		public static void Show(LumberHomestead homestead)
		{
			HomesteadUiController.Show(homestead);
		}

		public static void Hide()
		{
			HomesteadUiController.Hide();
		}
	}
	internal static class LumberCleanup
	{
		public const string ZdoMarker = "ln_farmer";

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

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

		public static bool LooksLikeFarmerCharacter(Character character)
		{
			return LumberIdentity.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 LumberDestroyer.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 LumberDestroyer.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 LumberDestroyer.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 LumberDestroyer.DestroyById(id);
		}
	}
	public class LumberHomestead : MonoBehaviour, Hoverable, Interactable
	{
		private static readonly List<LumberHomestead> Instances = new List<LumberHomestead>();

		private ZNetView _nview;

		private HomesteadData _data;

		private LumberNpc _npc;

		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<LumberHomestead> 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_00b0: 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("LumberHomestead waiting for valid ZNetView...");
				}
				return false;
			}
			try
			{
				if (!_rpcsRegistered)
				{
					RegisterRpcs();
					_rpcsRegistered = true;
				}
				if (_data == null)
				{
					_data = SaveManager.Load(_nview);
				}
				BiomeTreeRules.ApplyToData(_data, ((Component)this).transform.position);
				_initialized = true;
				Log.Info($"LumberHomestead initialized (server={AdminUtil.IsServer()}, owner={_nview.IsOwner()})");
				EnsureStarterFarmer();
				ReclaimNearbyWorkers();
				return true;
			}
			catch (Exception arg)
			{
				Log.Error($"LumberHomestead 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("ln_initial_npc", 0) == 1)
			{
				_starterPending = false;
				return;
			}
			if (LumberRoster.CountNear(((Component)this).transform.position, 12f) == 0)
			{
				LumberNpc lumberNpc = HomesteadLumberOps.SpawnAdditional(((Component)this).transform.position, ((Component)this).transform.rotation, this);
				if (!((Object)(object)lumberNpc != (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 = lumberNpc;
				ZNetView component = ((Component)lumberNpc).GetComponent<ZNetView>();
				if (component != null && component.IsValid())
				{
					EnsureData();
					if (_data != null)
					{
						_data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
					}
				}
			}
			int num = LumberRoster.CountNear(((Component)this).transform.position, 12f);
			if (num <= 0)
			{
				_starterPending = true;
				return;
			}
			_starterPending = false;
			if (_nview.IsOwner())
			{
				zDO.Set("ln_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>("LN_SetPaused", (Action<long, bool>)RPC_SetPaused);
			_nview.Register("LN_TogglePause", (Action<long>)RPC_TogglePause);
			_nview.Register("LN_ScanField", (Action<long>)RPC_ScanField);
			_nview.Register("LN_AssignBoundary", (Action<long>)RPC_AssignBoundary);
			_nview.Register("LN_AssignChest", (Action<long>)RPC_AssignChest);
			_nview.Register<string>("LN_SetLayoutMode", (Action<long, string>)RPC_SetLayoutMode);
			_nview.Register<string>("LN_UpdateCropConfig", (Action<long, string>)RPC_UpdateCropConfig);
			_nview.Register("LN_ClearChests", (Action<long>)RPC_ClearChests);
			_nview.Register("LN_ClearField", (Action<long>)RPC_ClearField);
			_nview.Register("LN_EnsureNpc", (Action<long>)RPC_EnsureNpc);
		}

		public void Persist()
		{
			//IL_0030: 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)
			if (_data == null || (Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return;
			}
			List<LumberNpc> list = LumberRoster.ListNear(((Component)this).transform.position);
			if (list.Count > 0)
			{
				_npc = list[0];
				_data.NpcZdoKey = _npc.ZdoKey;
			}
			if (_nview.IsOwner() || AdminUtil.IsServer())
			{
				SaveManager.Save(_nview, _data);
				return;
			}
			GetZdoIdentity(out var userId, out var id);
			string slotsCsv = HomesteadCodecs.EncodeSlots(_data.Slots ?? new List<WorkSlot>());
			RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "sync_slots", userId, id, delegate(ZPackage pkg)
			{
				pkg.Write(slotsCsv ?? "");
			});
		}

		public int CountFarmers()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return LumberRoster.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<LumberNpc> list = LumberRoster.ListNear(((Component)this).transform.position);
			if (list.Count > 0)
			{
				List<CarriedItem> list2 = HomesteadStock.Aggregate(list.ConvertAll((LumberNpc 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(LumberNpc npc)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)npc == (Object)null))
			{
				_npc = npc;
				ReloadDataFromZdo();
				EnsureData();
				_npc.RestoreBagOnBind(_data);
				int num = LumberRoster.CountNear(((Component)this).transform.position);
				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;
			}
			LumberNpc lumberNpc = LumberSpawner.TrySpawnNearHomestead(((Component)this).transform.position, ((Component)this).transform.rotation, this);
			if (!((Object)(object)lumberNpc == (Object)null))
			{
				_npc = lumberNpc;
				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;
			}
			LumberNpc lumberNpc = HomesteadLumberOps.SpawnAdditional(((Component)this).transform.position, ((Component)this).transform.rotation, this);
			if ((Object)(object)lumberNpc == (Object)null)
			{
				PlayerFeedback.Notify("Could not add farmer (max reached?)");
				return;
			}
			_npc = lumberNpc;
			if (!_data.Paused)
			{
				lumberNpc.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 (!HomesteadLumberOps.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_00b2: 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)
			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 (_data?.CarriedItems != null && _data.CarriedItems.Count > 0)
			{
				InventoryManager inventoryManager = new InventoryManager();
				inventoryManager.LoadFrom(_data);
				ChestLogistics.TryDepositSurplus(inventoryManager, _data, ((Component)this).transform.position, out blocked);
				inventoryManager.DropAllAt(((Component)this).transform.position);
			}
			_data = null;
		}

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

		public string GetHoverText()
		{
			TryInitialize();
			string text = ((_data != null && _data.Paused) ? "Paused" : "Active");
			int num = CountFarmers();
			string text2 = (AdminUtil.LocalPlayerCanAccess() ? "\n[<color=yellow><b>E</b></color>] Open lumber panel" : "");
			return Localization.instance.Localize($"$piece_lumberhomestead\nStatus: {text} | Trolls: {num} | Radius: {_data?.GetWorkRadius() ?? 40f:0}m{text2}");
		}

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

		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_00a5: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			EnsureData();
			if (_data != null && _data.Paused)
			{
				return;
			}
			PlayerFeedback.Notify("Chests full — farmers paused. Free space or add a chest, then unpause.");
			if (CanApplyLocally())
			{
				ApplySetPaused(paused: true);
				return;
			}
			if (_data != null)
			{
				_data.Paused = true;
			}
			if ((Object)(object)_nview != (Object)null && _nview.IsValid() && _nview.IsOwner())
			{
				ZDO zDO = _nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("ln_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))
			{
				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);
		}

		public void RequestSetPaused(bool paused)
		{
			Dispatch(delegate
			{
				ApplySetPaused(paused);
			}, "LN_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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				PlayerFeedback.Notify("Scan failed: no homestead data");
				return;
			}
			int num = 0;
			if (clearFirst)
			{
				num = _data.Slots?.Count ?? 0;
				_data.Slots?.Clear();
			}
			TreeScanner.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_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_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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: 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)
			List<BoundaryPost> list = (from p in Object.FindObjectsByType<BoundaryPost>((FindObjectsSortMode)0)
				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);
			}, "LN_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 = LumberCleanup.CollectLocalFarmerIds(((Component)this).transform.position, 50f);
			int num = LumberCleanup.DestroyLocalFarmerViews(((Component)this).transform.position, 50f);
			if (CanApplyLocally())
			{
				int num2 = LumberCleanup.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);
			}
			cropConfigEntry.Weight = Mathf.Clamp(weight, 0, 100);
			RequestUpdateCropConfig(EncodeCropConfig(cropConfigEntry));
		}

		public void RequestSetReplantWeight(string family, int weight)
		{
			EnsureData();
			CropConfigEntry cropConfigEntry = _data.GetCropConfig(family);
			if (cropConfigEntry == null)
			{
				cropConfigEntry = new CropConfigEntry
				{
					Family = family
				};
				_data.CropConfigs.Add(cropConfigEntry);
			}
			cropConfigEntry.ReplantWeight = Mathf.Clamp(weight, 0, 100);
			RequestUpdateCropConfig(EncodeCropConfig(cropConfigEntry));
		}

		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);
			}
			cropConfigEntry.MinimumSeedReserve = Mathf.Clamp(reserve, 0, 100);
			RequestUpdateCropConfig(EncodeCropConfig(cropConfigEntry));
		}

		private static string EncodeCropConfig(CropConfigEntry cfg)
		{
			return $"{cfg.Family}|{(cfg.Enabled ? 1 : 0)}|{Mathf.Clamp(cfg.Weight, 0, 100)}|" + $"{(cfg.HarvestEnabled ? 1 : 0)}|{(cfg.PlantEnabled ? 1 : 0)}|" + $"{cfg.MinimumSeedReserve}|{cfg.MaximumSeedPercent}|" + $"{Mathf.Clamp(cfg.ReplantWeight, 0, 100)}";
		}

		public void RequestSetWorkRadius(float radius)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			TryInitialize();
			EnsureData();
			ApplySetWorkRadius(radius);
			if (!CanApplyLocally())
			{
				GetZdoIdentity(out var userId, out var id);
				RpcMessages.RequestHomesteadOp(((Component)this).transform.position, "work_radius", userId, id, delegate(ZPackage pkg)
				{
					pkg.Write(radius);
				});
			}
		}

		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);
			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((depositAllResult.Emptied > 0) ? $"Deposit All: emptied {depositAllResult.Emptied}/{depositAllResult.LumberCount}; remaining items — chests may be full" : "Deposit All: chests full — items remain on lumberjacks");
			}
			else
			{
				PlayerFeedback.Notify($"Deposit All: emptied {depositAllResult.Emptied}/{depositAllResult.LumberCount} lumberjack(s)");
			}
			Log.Info($"ForceDepositAll farmers={depositAllResult.LumberCount} emptied={depositAllResult.Emptied} blocked={depositAllResult.Blocked}");
		}

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

		public void BindExistingNpcOnly()
		{
			//IL_0021: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			ReloadDataFromZdo();
			EnsureData();
			if (_data == null)
			{
				return;
			}
			float num = 132f;
			LumberNpc lumberNpc = HomesteadLumberOps.FindNearest(((Component)this).transform.position, num);
			if ((Object)(object)lumberNpc == (Object)null)
			{
				PlayerFeedback.Notify("No farmer nearby — use Add Farmer");
				Log.Info($"Unpause: no existing farmer within {num:0}m of {((Component)this).transform.position} (use Add Farmer)");
				return;
			}
			_npc = lumberNpc;
			lumberNpc.BindHomestead(this);
			lumberNpc.RestoreBagOnBind(_data);
			ZNetView component = ((Component)lumberNpc).GetComponent<ZNetView>();
			if (component != null && component.IsValid())
			{
				_data.NpcZdoKey = ZdoIds.ZdoKey(component.GetZDO());
			}
			if (_data != null && !_data.Paused)
			{
				List<LumberNpc> list = LumberRoster.ListNear(((Component)this).transform.position, num);
				for (int i = 0; i < list.Count; i++)
				{
					LumberNpc lumberNpc2 = list[i];
					if (!((Object)(object)lumberNpc2 == (Object)null))
					{
						lumberNpc2.BindHomestead(this);
						lumberNpc2.ActivateForWork();
					}
				}
			}
			Log.Info($"Unpause: bound existing farmer at {((Component)lumberNpc).transform.position}");
		}

		private void ReclaimNearbyWorkers()
		{
			//IL_0012: 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)
			EnsureData();
			float num = 132f;
			List<LumberNpc> list = LumberRoster.ListNear(((Component)this).transform.position, num);
			int num2 = 0;
			for (int i = 0; i < list.Count; i++)
			{
				LumberNpc lumberNpc = list[i];
				if ((Object)(object)lumberNpc == (Object)null)
				{
					continue;
				}
				if ((Object)(object)lumberNpc.Homestead == (Object)(object)this)
				{
					if (_npc == null)
					{
						_npc = lumberNpc;
					}
				}
				else
				{
					if ((Object)(object)lumberNpc.Homestead != (Object)null)
					{
						continue;
					}
					LumberHomestead lumberHomestead = HomesteadLocator.FindNearest(lumberNpc.GetHomesteadPosition(), num);
					if (!((Object)(object)lumberHomestead != (Object)null) || !((Object)(object)lumberHomestead != (Object)(object)this))
					{
						lumberNpc.BindHomestead(this);
						AttachExistingNpc(lumberNpc);
						if (_data != null && !_data.Paused)
						{
							lumberNpc.ActivateForWork();
						}
						num2++;
					}
				}
			}
			if (num2 > 0)
			{
				Log.Info($"ReclaimNearbyWorkers: bound {num2} orphan lumberjack(s) within {num:0}m");
			}
		}

		private void ApplyScan()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			EnsureData();
			TreeScanner.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;
			TreeScanner.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 ApplySetWorkRadius(float radius)
		{
			EnsureData();
			HomesteadOps.SetWorkRadius(_data, radius);
			if ((Object)(object)_nview != (Object)null && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				if (zDO != null && zDO.IsValid() && (_nview.IsOwner() || AdminUtil.IsServer()))
				{
					zDO.Set("ln_work_radius", _data.GetWorkRadius());
				}
			}
			Persist();
			PlayerFeedback.Notify($"Work radius: {_data.GetWorkRadius():0}m");
		}

		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);
				BiomeTreeRules.ApplyToData(_data, ((Component)this).transform.position);
			}
		}
	}
	internal static class NpcSpawner
	{
		public static LumberNpc SpawnAt(Vector3 homesteadPos, Quaternion rotation, LumberHomestead 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 LumberSpawner.TrySpawnNearHomestead(homesteadPos, rotation, homestead);
		}

		public static LumberHomestead 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);
			}
			LumberHomestead lumberHomestead = val2.GetComponent<LumberHomestead>();
			if ((Object)(object)lumberHomestead == (Object)null)
			{
				lumberHomestead = val2.AddComponent<LumberHomestead>();
			}
			return lumberHomestead;
		}
	}
}
namespace ValheimLumberNPC.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<WorkSlot> 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++)
			{
				WorkSlot workSlot = slots[i];
				if (workSlot != null)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(';');
					}
					stringBuilder.Append(workSlot.X.ToString("F2", invariantCulture)).Append(',').Append(workSlot.Y.ToString("F2", invariantCulture))
						.Append(',')
						.Append(workSlot.Z.ToString("F2", invariantCulture))
						.Append(',')
						.Append(workSlot.RotY.ToString("F1", invariantCulture))
						.Append(',')
						.Append(workSlot.OriginalCropFamily ?? "")
						.Append(',')
						.Append(workSlot.CurrentCropFamily ?? "")
						.Append(',')
						.Append((int)workSlot.State);
				}
			}
			return stringBuilder.ToString();
		}

		public static List<WorkSlot> DecodeSlots(string csv)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			List<WorkSlot> list = new List<WorkSlot>();
			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))
				{
					WorkSlot item = new WorkSlot
					{
						X = result,
						Y = result2,
						Z = result3,
						RotY = result4,
						OriginalCropFamily = array2[4],
						CurrentCropFamily = array2[5],
						State = (WorkSlotState)result5,
						Id = WorkSlot.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}|{c.ReplantWeight}"));
		}

		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);
					int result4 = result;
					if (array2.Length >= 8)
					{
						int.TryParse(array2[7], out result4);
					}
					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,
						ReplantWeight = Mathf.Clamp(result4, 0, 100)
					});
				}
			}
			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 = "Weighted";

		public float WorkRadius = 40f;

		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<WorkSlot> Slots = new List<WorkSlot>();

		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)
			//IL_0040: 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.Y - pos.y;
					float num4 = @ref.Z - pos.z;
					if (num2 * num2 + num3 * num3 + num4 * num4 < 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 void MigrateSeedReserves()
		{
			WoodRegistry.EnsureMissingConfigs(this);
		}

		public float GetWorkRadius()
		{
			return Constants.ClampWorkRadius(WorkRadius);
		}

		public void SetWorkRadius(float radius)
		{
			WorkRadius = Constants.ClampWorkRadius(radius);
		}

		public static HomesteadData CreateDefault()
		{
			return new HomesteadData
			{
				SchemaVersion = 1,
				Paused = true,
				LayoutMode = "Weighted",
				WorkRadius = 40f,
				CropConfigs = WoodRegistry.CreateDefaultConfigs()
			};
		}
	}
	internal static class SaveManager
	{
		private const string ZdoChests = "ln_chests";

		private const string ZdoSlots = "ln_slots";

		private const string ZdoCrops = "ln_crops";

		private const string ZdoCarried = "ln_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("ln_data", string.Empty);
			HomesteadData homesteadData;
			if (string.IsNullOrEmpty(text))
			{
				homesteadData = HomesteadData.CreateDefault();
				if (view.IsOwner() || AdminUtil.IsServer())
				{
					Save(view, homesteadData);
				}
				return homesteadData;
			}
			int num = 1;
			try
			{
				homesteadData = JsonUtility.FromJson<HomesteadData>(text);
				num = homesteadData.SchemaVersion;
				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<WorkSlot>();
			}
			string text2 = zDO.GetString("ln_slots", string.Empty);
			if (!string.IsNullOrEmpty(text2))
			{
				homesteadData.Slots = HomesteadCodecs.DecodeSlots(text2);
			}
			string text3 = zDO.GetString("ln_crops", string.Empty);
			if (!string.IsNullOrEmpty(text3))
			{
				homesteadData.CropConfigs = HomesteadCodecs.DecodeCropConfigs(text3);
			}
			else if (homesteadData.CropConfigs == null || homesteadData.CropConfigs.Count == 0)
			{
				homesteadData.CropConfigs = WoodRegistry.CreateDefaultConfigs();
			}
			if (num < 2)
			{
				homesteadData.MigrateSeedReserves();
			}
			string text4 = zDO.GetString("ln_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("ln_chests", string.Empty);
			if (!string.IsNullOrEmpty(text5))
			{
				homesteadData.ChestsCsv = text5;
				homesteadData.ChestPositions = HomesteadCodecs.DecodeRefs(text5);
			}
			homesteadData.SyncChestListsFromCsv();
			float num2 = zDO.GetFloat("ln_work_radius", -1f);
			if (num2 > 0f)
			{
				homesteadData.WorkRadius = num2;
			}
			homesteadData.Paused = zDO.GetBool("ln_paused", homesteadData.Paused);
			homesteadData.SetWorkRadius(homesteadData.WorkRadius);
			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<WorkSlot> slots = data.Slots ?? new List<WorkSlot>();
			List<CropConfigEntry> list = data.CropConfigs ?? new List<CropConfigEntry>();
			List<CarriedItem> list2 = data.CarriedItems ?? new List<CarriedItem>();
			data.Slots = new List<WorkSlot>();
			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("ln_schema", data.SchemaVersion);
			zDO.Set("ln_data", text);
			zDO.Set("ln_slots", text2);
			zDO.Set("ln_crops", text3);
			zDO.Set("ln_carried", text4);
			zDO.Set("ln_paused", data.Paused);
			zDO.Set("ln_npc", data.NpcZdoKey);
			zDO.Set("ln_work_radius", data.GetWorkRadius());
			zDO.Set("ln_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("ln_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;
			}
			if (data.SchemaVersion > 1)
			{
				Log.Warning($"Homestead schema {data.SchemaVersion} is newer than mod {1}; clamping");
				data.SchemaVersion = 1;
			}
			if (data.CropConfigs == null || data.CropConfigs.Count == 0)
			{
				data.CropConfigs = WoodRegistry.CreateDefaultConfigs();
			}
			else
			{
				WoodRegistry.EnsureMissingConfigs(data);
			}
			if (data.WorkRadius <= 0f)
			{
				data.WorkRadius = 40f;
			}
			data.SetWorkRadius(data.WorkRadius);
			if (data.Slots == null)
			{
				data.Slots = new List<WorkSlot>();
			}
			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 ValheimLumberNPC.NPC
{
	public class LumberNpc : MonoBehaviour, Hoverable, Interactable
	{
		private bool _bagLoaded;

		public const string ZdoHomeX = "ln_home_x";

		public const string ZdoHomeY = "ln_home_y";

		public const string ZdoHomeZ = "ln_home_z";

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

		private ZNetView _nview;

		private Character _character;

		private Humanoid _humanoid;

		private LumberHomestead _homestead;

		private HomesteadSession _session;

		private LumberBrain _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;

		private float _weaponCheckAt;

		private const float WeaponRecheckSeconds = 2f;

		internal InventoryManager Inventory => _inventory;

		public Character Character => _character;

		internal LumberHomestead 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<LumberNpc> 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(LumberHomestead 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("ln_home_x", pos.x);
					zDO.Set("ln_home_y", pos.y);
					zDO.Set("ln_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("ln_home_x", float.NaN);
			if (float.IsNaN(num))
			{
				return ((Component)this).transform.position;
			}
			return new Vector3(num, zDO.GetFloat("ln_home_y", ((Component)this).transform.position.y), zDO.GetFloat("ln_home_z", ((Component)this).transform.position.z));
		}

		internal void PersistWorkData()
		{
			if (!(Time.time < _persistAt))
			{
				_persistAt = Time.time + 1f;
				PersistInventoryCore(carriedOnly: false);
			}
		}

		internal void ForcePersistInventory()
		{
			WriteBagToOwnZdo();
		}

		internal void FlushInventoryIfOwner()
		{
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid() && _nview.IsOwner())
			{
				WriteBagToOwnZdo();
			}
		}

		public void PersistInventory()
		{
			PersistWorkData();
		}

		internal void EnsureBagLoaded()
		{
			if (_bagLoaded || _inventory == null || (Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return;
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO != null && zDO.IsValid())
			{
				if (zDO.GetInt("ln_bag_set", 0) == 1)
				{
					_inventory.LoadFromCsv(zDO.GetString("ln_bag", string.Empty));
				}
				_bagLoaded = true;
			}
		}

		internal void RestoreBagOnBind(HomesteadData homesteadData)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (_inventory != null)
			{
				bool num = HasOwnBagMarker();
				EnsureBagLoaded();
				if (num || _inventory.UsedSlots > 0)
				{
					WriteBagToOwnZdo();
				}
				else if (LumberRoster.CountNear(GetHomesteadPosition()) <= 1 && homesteadData?.CarriedItems != null && homesteadData.CarriedItems.Count > 0)
				{
					MigrateLegacyCarried(homesteadData);
				}
				else
				{
					WriteBagToOwnZdo();
				}
			}
		}

		private void MigrateLegacyCarried(HomesteadData homesteadData)
		{
			InventoryManager inventoryManager = new InventoryManager();
			inventoryManager.LoadFrom(homesteadData);
			int usedSlots = inventoryManager.UsedSlots;
			ChestLogistics.TryDepositAll(inventoryManager, homesteadData, out var _);
			int usedSlots2 = inventoryManager.UsedSlots;
			if (usedSlots2 > 0)
			{
				_inventory.AbsorbAll(inventoryManager);
			}
			WriteBagToOwnZdo();
			homesteadData.CarriedItems = new List<CarriedItem>();
			ClearLegacyHomesteadCarried();
			Log.Info($"Migrated legacy homestead carried bag ({usedSlots} stacks) → chests; {usedSlots2} kept on farmer {ZdoKey}");
		}

		private bool HasOwnBagMarker()
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO != null && zDO.IsValid())
			{
				return zDO.GetInt("ln_bag_set", 0) == 1;
			}
			return false;
		}

		private void PersistInventoryCore(bool carriedOnly)
		{
			WriteBagToOwnZdo();
			if (!carriedOnly)
			{
				if ((Object)(object)_homestead != (Object)null)
				{
					_homestead.Persist();
				}
				else
				{
					_session?.Save();
				}
			}
		}

		private void WriteBagToOwnZdo()
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid() || _inventory == null)
			{
				return;
			}
			if (!_nview.IsOwner())
			{
				if (AdminUtil.IsServer())
				{
					try
					{
						_nview.ClaimOwnership();
					}
					catch
					{
					}
				}
				if (!_nview.IsOwner())
				{
					return;
				}
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO != null && zDO.IsValid())
			{
				zDO.Set("ln_bag", _inventory.EncodeCsv());
				zDO.Set("ln_bag_set", 1);
			}
		}

		private void ClearLegacyHomesteadCarried()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Vector3 homesteadPosition = GetHomesteadPosition();
			GetHomesteadZdoIdentity(out var userId, out var id);
			RpcMessages.RequestHomesteadOp(homesteadPosition, "carried", userId, id, delegate(ZPackage pkg)
			{
				pkg.Write(string.Empty);
			});
		}

		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 LumberNpc FindByKey(long key)
		{
			foreach (LumberNpc 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);
			LumberRoster.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 = "lumber_npc";
			}
		}

		private void Start()
		{
			LumberAudio.Apply(((Component)this).gameObject);
			((MonoBehaviour)this).StartCoroutine(EnsureWeaponOnSpawn());
			EnsureBrain();
		}

		private IEnumerator EnsureWeaponOnSpawn()
		{
			for (int i = 0; i < 5; i++)
			{
				yield return null;
				EnsureLogWeaponEquipped();
				if (LumberLogWeapon.IsHoldingWeapon(_humanoid))
				{
					yield break;
				}
			}
			Log.Warning("LumberNpc: log weapon not equipped after spawn retries");
		}

		private void EnsureLogWeaponEquipped()
		{
			if ((Object)(object)_humanoid == (Object)null)
			{
				_humanoid = ((Component)this).GetComponent<Humanoid>();
			}
			if (!((Object)(object)_humanoid == (Object)null))
			{
				LumberLogWeapon.EnsureEquipped(_humanoid);
			}
		}

		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
				{
				}
			}
			EnsureLogWeaponEquipped();
			EnsureBrain()?.KickEvaluate();
		}

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

		private void Update()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			EnsureBagLoaded();
			if (Time.time >= _weaponCheckAt)
			{
				_weaponCheckAt = Time.time + 2f;
				if ((Object)(object)_nview != (Object)null && _nview.IsValid() && _nview.IsOwner() && !LumberLogWeapon.IsHoldingWeapon(_humanoid))
				{
					EnsureLogWeaponEquipped();
				}
			}
			if ((Object)(object)_homestead != (Object)null)
			{
				_bindInterval = 1f;
				return;
			}
			_bindTimer += Time.deltaTime;
			if (!(_bindTimer < _bindInterval))
			{
				_bindTimer = 0f;
				if (_session == null)
				{
					TryResolveSession();
				}
				float maxRange = 132f;
				Vector3 homesteadPosition = GetHomesteadPosition();
				LumberHomestead lumberHomestead = HomesteadLocator.FindNearest(homesteadPosition, maxRange);
				if ((Object)(object)lumberHomestead == (Object)null)
				{
					lumberHomestead = HomesteadLocator.ResolveNear(homesteadPosition, maxRange);
				}
				if ((Object)(object)lumberHomestead == (Object)null && Vector3.Distance(homesteadPosition, ((Component)this).transform.position) > 1f)
				{
					lumberHomestead = HomesteadLocator.FindNearest(((Component)this).transform.position, maxRange) ?? HomesteadLocator.ResolveNear(((Component)this).transform.position, maxRange);
				}
				if ((Object)(object)lumberHomestead == (Object)null)
				{
					_bindInterval = Mathf.Min(_bindInterval * 1.5f, 8f);
					return;
				}
				_bindInterval = 1f;
				BindHomestead(lumberHomestead);
				lumberHomestead.AttachExistingNpc(this);
				Log.Info($"Bound orphan farmer to homestead MB at {((Component)lumberHomestead).transform.position}");
			}
		}

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

		public void UnbindAndDestroy()
		{
			_homestead = null;
			_session = null;
			Instances.Remove(this);
			LumberRoster.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("$ln_npc_name\n[<color=yellow><b>$KEY_Use</b></color>] Toggle pause");
		}

		public string GetHoverName()
		{
			return Localization.instance.Localize("$ln_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)
			{
				LumberHomestead lumberHomestead = HomesteadLocator.ResolveNear(((Component)this).transform.position, 132f);
				if ((Object)(object)lumberHomestead != (Object)null)
				{
					BindHomestead(lumberHomestead);
				}
			}
			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, null, 0, 0));
		}

		public void QueueDelayedHarvestPickup(Vector3 position, float radius, string product, int amountBefore, int yieldAmount)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)this).StartCoroutine(DelayedPickup(position, radius, product, amountBefore, yieldAmount));
		}

		private IEnumerator DelayedPickup(Vector3 position, float radius, string product, int amountBefore, int yieldAmount)
		{
			//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[] waits = new float[3] { 0.3f, 0.8f, 1.5f };
			for (int i = 0; i < waits.Length; i++)
			{
				yield return (object)new WaitForSeconds(waits[i]);
				if ((Object)(object)this == (Object)null || _inventory == null)
				{
					break;
				}
				WorldDropCollector.AbsorbFromHumanoid(_inventory, _humanoid);
				int destroyed;
				int num = WorldDropCollector.PickupNearbyDrops(_inventory, position, radius, GetWorkData(), out destroyed);
				int num2 = 0;
				if (i == waits.Length - 1 && !string.IsNullOrEmpty(product) && yieldAmount > 0)
				{
					num2 = WorldDropCollector.EnsureHarvestProduct(_inventory, product, amountBefore, yieldAmount);
				}
				if (num > 0 || num2 > 0)
				{
					PersistInventory();
					Log.Debug($"DelayedPickup grabbed {num} stack(s), ensured {num2} near {position}");
				}
			}
		}
	}
	internal static class LumberLogWeapon
	{
		private static GameObject[] _cachedLogs;

		private static readonly string[] LogPrefabs = new string[2] { "troll_log_swing_h", "troll_log_swing_v" };

		public static void ApplyToHumanoid(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return;
			}
			GameObject[] array = ResolveLogWeapons(humanoid);
			if (array == null || array.Length == 0)
			{
				Log.Warning("LumberLogWeapon: no troll_log_swing prefabs resolved");
				return;
			}
			humanoid.m_defaultItems = array;
			humanoid.m_randomWeapon = Array.Empty<GameObject>();
			try
			{
				humanoid.m_randomSets = Array.Empty<ItemSet>();
			}
			catch
			{
			}
			try
			{
				humanoid.GiveDefaultItems();
			}
			catch (Exception ex)
			{
				Log.Debug("LumberLogWeapon GiveDefaultItems: " + ex.Message);
			}
			if (!TryEquipFromInventory(humanoid))
			{
				TryPickupAndEquip(humanoid, array);
			}
			LogHeld(humanoid, array);
		}

		public static bool IsHoldingWeapon(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return false;
			}
			try
			{
				if (IsLogItem(humanoid.RightItem))
				{
					return true;
				}
				return IsLogItem(humanoid.GetCurrentWeapon());
			}
			catch
			{
				return false;
			}
		}

		public static bool IsHoldingLog(Humanoid humanoid)
		{
			return IsHoldingWeapon(humanoid);
		}

		public static bool EnsureEquipped(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return false;
			}
			if (IsHoldingWeapon(humanoid))
			{
				return true;
			}
			if (TryEquipFromInventory(humanoid))
			{
				return true;
			}
			ApplyToHumanoid(humanoid);
			return IsHoldingWeapon(humanoid);
		}

		private static bool TryEquipFromInventory(Humanoid humanoid)
		{
			Inventory inventory = humanoid.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			for (int i = 0; i < allItems.Count; i++)
			{
				ItemData val = allItems[i];
				if (!IsLogItem(val))
				{
					continue;
				}
				try
				{
					if (humanoid.EquipItem(val, false))
					{
						Log.Info("LumberLogWeapon: equipped inventory item " + Describe(val));
						return true;
					}
					Log.Debug("LumberLogWeapon: EquipItem returned false for " + Describe(val));
				}
				catch (Exception ex)
				{
					Log.Debug("LumberLogWeapon EquipItem: " + ex.Message);
				}
			}
			return false;
		}

		private static void TryPickupAndEquip(Humanoid humanoid, GameObject[] logs)
		{
			foreach (GameObject val in logs)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					ItemData val2 = humanoid.PickupPrefab(val, 0, false);
					if (val2 == null)
					{
						Log.Debug("LumberLogWeapon: PickupPrefab failed for " + NameOf(val));
					}
					else if (humanoid.EquipItem(val2, false))
					{
						Log.Info("LumberLogWeapon: pickup+equip " + NameOf(val));
						break;
					}
				}
				catch (Exception ex)
				{
					Log.Debug("LumberLogWeapon PickupPrefab " + NameOf(val) + ": " + ex.Message);
				}
			}
		}

		private static void LogHeld(Humanoid humanoid, GameObject[] logs)
		{
			string arg = "(none)";
			try
			{
				ItemData rightItem = humanoid.RightItem;
				ItemData currentWeapon = humanoid.GetCurrentWeapon();
				if (rightItem != null)
				{
					arg = "right=" + Describe(rightItem);
				}
				else if (currentWeapon != null)
				{
					arg = "current=" + Describe(currentWeapon);
				}
				Inventory inventory = humanoid.GetInventory();
				int num = 0;
				if (inventory != null)
				{
					foreach (ItemData allItem in inventory.GetAllItems())
					{
						if (allItem != null && allItem.IsWeapon())
						{
							num++;
						}
					}
				}
				Log.Info("LumberLogWeapon: loadout=[" + string.Join(",", logs.Select(NameOf)) + "] " + $"held={arg} invWeapons={num}");
			}
			catch (Exception ex)
			{
				Log.Debug("LumberLogWeapon LogHeld: " + ex.Message);
			}
		}

		private static bool IsLogItem(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : null);
			string name = item.m_shared.m_name;
			if (!string.IsNullOrEmpty(text) && text.IndexOf("troll_log", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(name) && name.IndexOf("log", StringComparison.OrdinalIgnoreCase) >= 0 && item.IsWeapon())
			{
				return true;
			}
			if (!string.IsNullOrEmpty(text))
			{
				return text.IndexOf("log_swing", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static string Describe(ItemData item)
		{
			if (item == null)
			{
				return "?";
			}
			string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : null);
			object obj;
			if (string.IsNullOrEmpty(text))
			{
				obj = item.m_shared?.m_name;
				if (obj == null)
				{
					return "?";
				}
			}
			else
			{
				obj = text;
			}
			return (string)obj;
		}

		private static GameObject[] ResolveLogWeapons(Humanoid humanoid)
		{
			if (_cachedLogs != null && _cachedLogs.Length != 0 && _cachedLogs.All((GameObject g) => (Object)(object)g != (Object)null))
			{
				return _cachedLogs;
			}
			List<GameObject> list = new List<GameObject>();
			string[] logPrefabs = LogPrefabs;
			foreach (string prefabName in logPrefabs)
			{
				TryAdd(list, prefabName);
			}
			CollectFromArray(list, humanoid?.m_defaultItems);
			CollectFromArray(list, humanoid?.m_randomWeapon);
			try
			{
				if (humanoid?.m_randomSets != null)
				{
					ItemSet[] randomSets = humanoid.m_randomSets;
					for (int num = 0; num < randomSets.Length; num++)
					{
						CollectFromArray(list, randomSets[num]?.m_items);
					}
				}
			}
			catch
			{
			}
			GameObject[] array = list.Where((GameObject g) => (Object)(object)g != (Object)null).Distinct().ToArray();
			if (array.Length != 0)
			{
				_cachedLogs = array;
			}
			return array;
		}

		private static void CollectFromArray(List<GameObject> into, GameObject[] items)
		{
			if (items == null)
			{
				return;
			}
			foreach (GameObject val in items)
			{
				if (!((Object)(object)val == (Object)null) && NameOf(val).IndexOf("troll_log", StringComparison.OrdinalIgnoreCase) >= 0 && !into.Contains(val))
				{
					into.Add(val);
				}
			}
		}

		private static void TryAdd(List<GameObject> into, string prefabName)
		{
			GameObject val = null;
			try
			{
				PrefabManager instance = PrefabManager.Instance;
				val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null && (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 && !into.Contains(val))
			{
				into.Add(val);
			}
		}

		private static string NameOf(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return "?";
			}
			return ((Object)go).name.Replace("(Clone)", "").Trim();
		}
	}
}
namespace ValheimLumberNPC.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 LumberKey;

		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 lumberKey, ReservationType type)
		{
			Tick();
			if (string.IsNullOrEmpty(slotId))
			{
				return false;
			}
			if (Reservations.TryGetValue(slotId, out var value))
			{
				if (value.LumberKey == lumberKey && value.HomesteadKey == homesteadKey)
				{
					value.ExpiresAt = Time.time + SyncedConfig.ReservationTimeout;
					value.Type = type;
					return true;
				}
				return false;
			}
			Reservations[slotId] = new SlotReservation
			{
				SlotId = slotId,
				HomesteadKey = homesteadKey,
				LumberKey = lumberKey,
				Type = type,
				ExpiresAt = Time.time + SyncedConfig.ReservationTimeout
			};
			return true;
		}

		public static void Release(string slotId, long lumberKey)
		{
			if (!string.IsNullOrEmpty(slotId) && Reservations.TryGetValue(slotId, out var value) && value.LumberKey == lumberKey)
			{
				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 lumberKey)
		{
			Tick();
			if (Reservations.TryGetValue(slotId, out var value))
			{
				return value.LumberKey != lumberKey;
			}
			return false;
		}

		public static bool IsReserved(string slotId)
		{
			Tick();
			if (!string.IsNullOrEmpty(slotId))
			{
				return Reservations.ContainsKey(slotId);
			}
			return false;
		}
	}
	internal static class RpcMessages
	{
		private static bool _routedRegistered;

		public const string RpcEnsureNpcPos = "LN_EnsureNpcPos";

		public const string RpcAssignChestPos = "LN_AssignChestPos";

		public const string RpcHomesteadOp = "LN_HomesteadOp";

		public const string RpcDestroyFarmer = "LN_DestroyFarmer";

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

		public static void EnsureRoutedRegistered()
		{
			if (!_routedRegistered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<long>("LN_EnsureNpc", (Action<long, long>)RPC_EnsureNpcRouted);
				ZRoutedRpc.instance.Register<ZPackage>("LN_EnsureNpcPos", (Action<long, ZPackage>)RPC_EnsureNpcPos);
				ZRoutedRpc.instance.Register<ZPackage>("LN_AssignChestPos", (Action<long, ZPackage>)RPC_AssignChestPos);
				ZRoutedRpc.instance.Register<ZPackage>("LN_HomesteadOp", (Action<long, ZPackage>)RPC_HomesteadOp);
				ZRoutedRpc.instance.Register<ZPackage>("LN_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");
			LumberHomestead lumberHomestead = HomesteadLocator.ResolveNear(val, 16f);
			if ((Object)(object)lumberHomestead != (Object)null)
			{
				lumberHomestead.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_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: 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":
			{
				TreeScanner.ScanResult scanResult2 = orCreate.Scan();
				Log.Info($"Session scan +{scanResult2.Added} -{scanResult2.Removed} total {scanResult2.Total} ({scanResult2.Message})");
				break;
			}
			case "apply_slots":
			{
				string text2 = ((pkg.Size() > pkg.GetPos()) ? pkg.ReadString() : "");
				int num7 = orCreate.ApplyClientScanSlots(text2);
				Log.Info($"Session apply_slots total={num7} chars={text2?.Length ?? 0}");
				break;
			}
			case "sync_slots":
			{
				string slotsCsv = ((pkg.Size() > pkg.GetPos()) ? pkg.ReadString() : "");
				orCreate.SyncSlots(slotsCsv);
				break;
			}
			case "clear_field":
				orCreate.ClearField();
				break;
			case "clear_scan":
			{
				TreeScanner.ScanResult scanResult = orCreate.ClearAndScan();
				Log.Info($"Session clear+scan +{scanResult.Added} -{scanResult.Removed} total {scanResult.Total} ({scanResult.Message})");
				break;
			}
			case "add_farmer":
			{
				LumberNpc lumberNpc = orCreate.AddFarmer();
				Log.Info($"Session add_farmer ok={(Object)(object)lumberNpc != (Object)null} total={LumberRoster.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 num8 = pkg.ReadSingle();
				float num9 = pkg.ReadSingle();
				float num10 = pkg.ReadSingle();
				float num11 = pkg.ReadSingle();
				float num12 = pkg.ReadSingle();
				float num13 = pkg.ReadSingle();
				orCreate.AssignBoundary(new Vector3(num8, num9, num10), new Vector3(num11, num12, num13));
				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 "work_radius":
			{
				float workRadius = pkg.ReadSingle();
				orCreate.SetWorkRadius(workRadius);
				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) && LumberCleanup.DestroyById(new ZDOID(num, num2)))
			{
				Log.Info($"Admin DestroyFarmer id={num}:{num2}");
				return;
			}
			int num6 = LumberCleanup.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, "LN_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, "LN_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, "LN_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, "LN_HomesteadOp", new object[1] { val });
			}
		}
	}
}
namespace ValheimLumberNPC.Lumber
{
	internal static class LumberAudio
	{
		public static void Apply(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				if ((Object)(object)go.GetComponent<LumberAudioGate>() == (Object)null)
				{
					go.AddComponent<LumberAudioGate>();
				}
				if (!SyncedConfig.EnableLumberSounds)
				{
					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.EnableLumberSounds)
			{
				return false;
			}
			if ((Object)(object)parent != (Object)null && (Object)(object)((Component)parent).GetComponentInParent<LumberNpc>() != (Object)null)
			{
				return true;
			}
			foreach (LumberNpc item in LumberNpc.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 LumberAudioGate : MonoBehaviour
	{
		private float _nextCheck;

		private void Update()
		{
			if (!SyncedConfig.EnableLumberSounds && !(Time.time < _nextCheck))
			{
				_nextCheck = Time.time + 0.5f;
				LumberAudio.MuteAudioSources(((Component)this).gameObject);
			}
		}
	}
	internal class LumberController : MonoBehaviour
	{
		private LumberNpc _npc;

		private LumberBrain _brain;

		public LumberNpc Npc => _npc;

		public void Bind(LumberNpc npc)
		{
			_npc = npc;
			_brain = ((Component)this).GetComponent<LumberBrain>() ?? ((Component)this).gameObject.AddComponent<LumberBrain>();
			_brain.Init(npc);
		}
	}
	internal static class LumberDestroyer
	{
		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("ln_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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			List<ZDOID> list = new List<ZDOID>();
			Character[] array = Object.FindObjectsByType<Character>((FindObjectsSortMode)0);
			foreach (Character val in array)
			{
				if (LumberIdentity.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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Character[] array = Object.FindObjectsByType<Character>((FindObjectsSortMode)0);
			foreach (Character val in array)
			{
				if (LumberIdentity.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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01d4: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: 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_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: 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_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: 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<LumberNpc> list = new List<LumberNpc>();
			LumberNpc[] array = Object.FindObjectsByType<LumberNpc>((FindObjectsSortMode)0);
			foreach (LumberNpc lumberNpc in array)
			{
				if ((Object)(object)lumberNpc != (Object)null && Vector3.Distance(((Component)lumberNpc).transform.position, pos) <= range)
				{
					list.Add(lumberNpc);
				}
			}
			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 LumberNpc 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 = LumberIdentity.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 (LumberIdentity.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={LumberIdentity.PrefabName(item2)} at {item2.GetPosition()}");
					DestroyZdo(item2);
					hashSet.Add(item2.m_uid);
					num++;
				}
			}
			Log.Info($"LumberCleanup 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={LumberIdentity.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_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_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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_00b1: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			bool flag = alreadyKeptOne;
			Character[] array = Object.FindObjectsByType<Character>((FindObjectsSortMode)0);
			foreach (Character val in array)
			{
				if (!LumberIdentity.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("LumberNpc") : 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("ln_farmer", 0) == 1 || (num != 0 && prefab == num) || (num2 != 0 && prefab == num2);
							if (!flag)
							{
								string text = LumberIdentity.PrefabName(val3);
								flag = text == "LumberNpc" || 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 LumberIdentity
	{
		public const string ZdoMarker = "ln_farmer";

		public const string GroupName = "lumber_npc";

		public static readonly string[] PrefabNames = new string[5] { "LumberNpc", "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<LumberNpc>() != (Object)null)
			{
				return true;
			}
			if (string.Equals(character.m_group, "lumber_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("ln_farmer", 0) == 1)
					{
						return true;
					}
					if (PrefabName(zDO) == "LumberNpc")
					{
						return true;
					}
				}
			}
			string text = character.m_name ?? string.Empty;
			if (text == "$ln_npc_name" || text == "Farmer")
			{
				return true;
			}
			if ((((Object)((Component)character).gameObject).name ?? string.Empty).Replace("(Clone)", "").Trim() == "LumberNpc")
			{
				return true;
			}
			return false;
		}

		public static bool IsFarmerOrOrphan(ZDO zdo)
		{
			if (zdo.GetInt("ln_farmer", 0) == 1)
			{
				return true;
			}
			string text = PrefabName(zdo);
			if (!(text == "LumberNpc") && !(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 LumberRoster
	{
		public const float DefaultRange = 132f;

		private static int _nearFrame = -1;

		private static Vector3 _nearPos;

		private static float _nearRange;

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

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

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

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

		public static void ListNearNonAlloc(Vector3 homesteadPos, List<LumberNpc> into, float range = 132f)
		{
			//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<LumberNpc> readOnlyList = AllCached();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				LumberNpc lumberNpc = readOnlyList[i];
				if (!((Object)(object)lumberNpc == (Object)null))
				{
					float num2 = ((Component)lumberNpc).transform.position.x - homesteadPos.x;
					float num3 = ((Component)lumberNpc).transform.position.z - homesteadPos.z;
					if (num2 * num2 + num3 * num3 <= num)
					{
						NearCache.Add(lumberNpc);
					}
				}
			}
			NearCache.Sort((LumberNpc a, LumberNpc b) => PlanarDistSq(((Component)a).transform.position, homesteadPos).CompareTo(PlanarDistSq(((Component)b).transform.position, homesteadPos)));
		}

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

		public static LumberNpc PickRemovable(Vector3 homesteadPos, float range = 132f)
		{
			//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 LumberRuntime
	{
		public float ThinkTimer;

		public float BlockedTimer;

		public string ReservedSlotId;

		public bool LoggedActive;

		public float SwingWindupLeft;

		public float SwingCooldownLeft;

		public bool SwingPendingHit;

		public Vector3 LastChopFocus;

		public bool HasChopFocus;

		public bool DepositSettled;

		public bool HasPendingReplant;

		public Vector3 PendingReplantPos;

		public float ReplantDelayLeft;

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

		public Navigation Nav { get; private set; }

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

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

		public void TearDown()
		{
			Nav?.Stop();
			Nav?.Clear();
			Task = new PlannedTask
			{
				Type = PlannedTaskType.None
			};
			ReservedSlotId = null;
			LoggedActive = false;
			DepositSettled = false;
			ClearPendingReplant();
			ResetCombat();
		}

		public void ScheduleReplant(Vector3 pos, float delaySeconds)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			HasPendingReplant = true;
			PendingReplantPos = pos;
			ReplantDelayLeft = Mathf.Max(0.1f, delaySeconds);
		}

		public void ClearPendingReplant()
		{
			//IL_0008: 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)
			HasPendingReplant = false;
			PendingReplantPos = Vector3.zero;
			ReplantDelayLeft = 0f;
		}

		public void ResetCombat()
		{
			SwingWindupLeft = 0f;
			SwingCooldownLeft = 0f;
			SwingPendingHit = false;
		}

		public void ClearChopFocus()
		{
			//IL_0008: 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)
			HasChopFocus = false;
			LastChopFocus = Vector3.zero;
		}
	}
	internal static class LumberSpawner
	{
		public static LumberNpc TrySpawnNearHomestead(Vector3 homesteadPos, Quaternion rotation, LumberHomestead 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);
			LumberNpc lumberNpc = FindNearby(homesteadPos, 132f);
			if ((Object)(object)lumberNpc != (Object)null)
			{
				if (Vector3.Distance(((Component)lumberNpc).transform.position, val) > 2.5f)
				{
					PlaceAt(((Component)lumberNpc).gameObject, val, rotation);
					Log.Info($"LumberSpawner repositioned existing farmer to {val}");
				}
				if ((Object)(object)homestead != (Object)null)
				{
					lumberNpc.BindHomestead(homestead);
				}
				return lumberNpc;
			}
			return CreateNew(homesteadPos, val, rotation, homestead, loadSharedInventory: true);
		}

		public static LumberNpc SpawnAdditional(Vector3 homesteadPos, Quaternion rotation, LumberHomestead 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 (LumberNpc.ActiveCount >= SyncedConfig.MaxLumberjacks)
			{
				Log.Warning("Max farmers reached; not adding another");
				return null;
			}
			int slotIndex = LumberRoster.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("LumberSpawner skip: dedicated has no local player");
				return false;
			}
			return true;
		}

		private static LumberNpc CreateNew(Vector3 homesteadPos, Vector3 spawnPos, Quaternion rotation, LumberHomestead 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_0252: Unknown result type (might be due to invalid IL or missing references)
			if (LumberNpc.ActiveCount >= SyncedConfig.MaxLumberjacks)
			{
				Log.Warning("Max farmers reached; not spawning");
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("LumberNpc");
			if ((Object)(object)prefab == (Object)null)
			{
				Log.Error("LumberSpawner: 'LumberNpc' 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 = "LumberNpc";
			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);
					LumberCleanup.MarkAsFarmer(zDO);
					if (!component.IsOwner())
					{
						try
						{
							component.ClaimOwnership();
						}
						catch
						{
						}
					}
					Log.Info($"LumberSpawner spawned id={((ZDOID)(ref zDO.m_uid)).UserID}:{((ZDOID)(ref zDO.m_uid)).ID} at {spawnPos} owner={component.IsOwner()}");
				}
			}
			LumberNpc lumberNpc = val.GetComponent<LumberNpc>() ?? val.AddComponent<LumberNpc>();
			(val.GetComponent<LumberController>() ?? val.AddComponent<LumberController>()).Bind(lumberNpc);
			Character component2 = val.GetComponent<Character>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_faction = (Faction)0;
				component2.m_name = "$ln_npc_name";
				component2.m_group = "lumber_npc";
			}
			LumberAudio.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)
			{
				lumberNpc.BindHomestead(homestead);
				if (loadSharedInventory && homestead.Data != null)
				{
					lumberNpc.RestoreBagOnBind(homestead.Data);
				}
				else
				{
					lumberNpc.Inventory.Clear();
					lumberNpc.ForcePersistInventory();
				}
				LumberLogWeapon.EnsureEquipped(val.GetComponent<Humanoid>());
				if (homestead.Data != null && !homestead.Data.Paused)
				{
					lumberNpc.ActivateForWork();
				}
			}
			else
			{
				lumberNpc.SetPendingHomesteadPosition(homesteadPos);
				lumberNpc.Inventory.Clear();
			}
			return lumberNpc;
		}

		public static LumberNpc FindNearby(Vector3 homesteadPos, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			List<LumberNpc> list = LumberRoster.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.linearVelocity = 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 ValheimLumberNPC.Logging
{
	internal static class BiomeTreeRules
	{
		public static readonly string[] AllTreeFamilies = WoodRegistry.AllFamilies;

		private static readonly Dictionary<Biome, string[]> ByBiome = new Dictionary<Biome, string[]>
		{
			{
				(Biome)1,
				new string[2] { "Beech", "Birch" }
			},
			{
				(Biome)8,
				new string[5] { "Beech", "Birch", "Fir", "Pine", "Oak" }
			},
			{
				(Biome)2,
				new string[1] { "Swamp" }
			},
			{
				(Biome)4,
				new string[1] { "Fir" }
			},
			{
				(Biome)16,
				new string[2] { "Birch", "Oak" }
			},
			{
				(Biome)512,
				new string[1] { "Ygga" }
			},
			{
				(Biome)256,
				new string[2] { "Beech", "Birch" }
			},
			{
				(Biome)64,
				new string[1] { "Fir" }
			},
			{
				(Biome)32,
				new string[1] { "Ashwood" }
			}
		};

		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 IsTreeAllowed(string family, Biome biome)
		{
			//IL_0021: 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)
			if (string.IsNullOrEmpty(family))
			{
				return false;
			}
			if (!ByBiome.TryGetValue(biome, out var value) || value == null)
			{
				if ((int)biome != 0)
				{
					return false;
				}
				value = ByBiome[(Biome)1];
			}
			return value.Any((string t) => string.Equals(t, family, StringComparison.OrdinalIgnoreCase));
		}

		public static bool IsCropAllowed(string family, Biome biome)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return IsTreeAllowed(family, biome);
		}

		public static IReadOnlyList<string> GetAllowedTrees(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;
			}
			WoodRegistry.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.HarvestEnabled = (cropConfig.PlantEnabled = IsTreeAllowed(cropConfig.Family, biome))))
				{
					cropConfig.Weight = 0;
					cropConfig.Enabled = false;
				}
			}
		}
	}
	internal static class TreeFieldScanner
	{
		private static readonly List<ZDO> ZdoScratch = new List<ZDO>(64);

		public static TreeScanner.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)
			TreeScanner.ScanResult result = default(TreeScanner.ScanResult);
			if (data == null)
			{
				result.Message = "No homestead data";
				return result;
			}
			WoodRegistry.EnsureInit();
			if (!WorkBoundary.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, WorkSlot> dictionary = new Dictionary<string, WorkSlot>();
			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<WorkSlot> list = new List<WorkSlot>();
			foreach (WorkSlot slot in data.Slots)
			{
				if (!WorkBoundary.Inside(slot.Position, min, max))
				{
					list.Add(slot);
				}
			}
			foreach (WorkSlot item in list)
			{
				data.Slots.Remove(item);
				result.Removed++;
			}
			foreach (WorkSlot value in dictionary.Values)
			{
				WorkSlot workSlot = null;
				for (int i = 0; i < data.Slots.Count; i++)
				{
					if (data.Slots[i] != null && data.Slots[i].Id == value.Id)
					{
						workSlot = data.Slots[i];
						break;
					}
				}
				if (workSlot == null)
				{
					data.Slots.Add(value);
					result.Added++;
					continue;
				}
				workSlot.CurrentCropFamily = value.CurrentCropFamily;
				if (string.IsNullOrEmpty(workSlot.OriginalCropFamily))
				{
					workSlot.OriginalCropFamily = value.OriginalCropFamily;
				}
				if (workSlot.State != WorkSlotState.ReservedHarvest && workSlot.State != WorkSlotState.ReservedPlant && workSlot.State != WorkSlotState.Disabled)
				{
					workSlot.State = value.State;
				}
				workSlot.LastUpdated = Time.time;
				result.Updated++;
			}
			foreach (WorkSlot slot2 in data.Slots)
			{
				if (!dictionary.ContainsKey(slot2.Id) && slot2.State != WorkSlotState.Disabled && slot2.State != WorkSlotState.ReservedHarvest && slot2.State != WorkSlotState.ReservedPlant)
				{
					slot2.State = WorkSlotState.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, WorkSlot> 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, WorkSlot> 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);
			WoodRegistry.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, WorkSlot> 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() || !WorkBoundary.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) || WoodRegistry.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, WorkSlot> 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 (!WorkBoundary.Inside(position, min, max))
			{
				return;
			}
			zdoHits++;
			if (!WoodRegistry.TryGetFamily(prefabName, out var family))
			{
				nameMisses++;
				return;
			}
			WorkSlotState state = ((!prefabName.StartsWith("sapling_", StringComparison.OrdinalIgnoreCase)) ? WorkSlotState.Mature : WorkSlotState.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) ? WorkSlotState.Mature : WorkSlotState.Empty);
				}
				else if ((Object)(object)val.GetComponent<Plant>() != (Object)null)
				{
					state = WorkSlotState.Occupied;
				}
			}
			string text = WorkSlot.MakeId(position);
			if (!found.ContainsKey(text))
			{
				found[text] = new WorkSlot
				{
					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, WorkSlot> 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 (!WorkBoundary.Inside(position, min, max))
			{
				return;
			}
			hits++;
			if (!WoodRegistry.TryGetFamily(((Object)go).name, out var family))
			{
				nameMisses++;
				Log.Debug("Scan skipped unrecognized plant '" + ((Object)go).name + "'");
				return;
			}
			string text = WorkSlot.MakeId(position);
			if (!found.ContainsKey(text))
			{
				Pickable component = go.GetComponent<Pickable>();
				Plant component2 = go.GetComponent<Plant>();
				WorkSlotState state = WorkSlotState.Occupied;
				if ((Object)(object)component != (Object)null && component.m_picked)
				{
					state = WorkSlotState.Empty;
				}
				else if ((Object)(object)component != (Object)null)
				{
					state = WorkSlotState.Mature;
				}
				else if ((Object)(object)component2 != (Object)null)
				{
					state = WorkSlotState.Occupied;
				}
				WorkSlot obj = new WorkSlot
				{
					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 TreeFinder
	{
		private static readonly Collider[] OverlapScratch = (Collider[])(object)new Collider[1024];

		public static bool TryFindBestTree(HomesteadData data, Vector3 homePos, float radius, Vector3 fromPos, out TreeBase tree)
		{
			//IL_0016: 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_0088: 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_00ba: 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)
			tree = null;
			float num = -1f;
			float num2 = Mathf.Max(1f, radius);
			int num3 = Physics.OverlapSphereNonAlloc(homePos, num2, OverlapScratch, -1, (QueryTriggerInteraction)1);
			for (int i = 0; i < num3; i++)
			{
				Collider val = OverlapScratch[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				TreeBase componentInParent = ((Component)val).GetComponentInParent<TreeBase>();
				if ((Object)(object)componentInParent == (Object)null || !Object.op_Implicit((Object)(object)componentInParent))
				{
					continue;
				}
				ZNetView component = ((Component)componentInParent).GetComponent<ZNetView>();
				if (((Object)(object)component != (Object)null && !component.IsValid()) || Vector3.Distance(homePos, ((Component)componentInParent).transform.position) > num2 || !WoodRegistry.TryGetFamily(((Object)((Component)componentInParent).gameObject).name, out var family))
				{
					continue;
				}
				int chopWeight = WoodRegistry.GetChopWeight(data, family, homePos);
				if (chopWeight > 0)
				{
					float num4 = Vector3.Distance(fromPos, ((Component)componentInParent).transform.position);
					float num5 = (float)chopWeight / (1f + num4);
					if (num5 > num)
					{
						num = num5;
						tree = componentInParent;
					}
				}
			}
			return (Object)(object)tree != (Object)null;
		}

		public static bool TryFindNearestTree(Vector3 homePos, float radius, Vector3 fromPos, out TreeBase tree)
		{
			//IL_0001: 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)
			return TryFindBestTree(null, homePos, radius, fromPos, out tree);
		}

		public static float ResolveWorkRadius(float configuredRadius)
		{
			return Constants.ClampWorkRadius(configuredRadius);
		}
	}
	internal static class TreeQuery
	{
		private static readonly List<ZDO> ZdoScratch = new List<ZDO>(32);

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

		public static bool TryFindCropAt(Vector3 position, out string family, out WorkSlotState 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 WorkSlotState 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 = WorkSlotState.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) && !(WorkBoundary.HorizontalDistance(val2.transform.position, position) > 0.85f) && WoodRegistry.TryGetFamily(((Object)val2).name, out family))
				{
					if ((Object)(object)componentInParent2 != (Object)null)
					{
						state = ((!componentInParent2.m_picked) ? WorkSlotState.Mature : WorkSlotState.Empty);
						return !componentInParent2.m_picked;
					}
					if ((Object)(object)componentInParent != (Object)null)
					{
						state = WorkSlotState.Occupied;
						return true;
					}
				}
			}
			if (allowZdoFallback && TryFindCropZdoAt(position, 0.85f, out family, out state))
			{
				return state != WorkSlotState.Empty;
			}
			return false;
		}

		private static bool TryFindCropZdoAt(Vector3 position, float radius, out string family, out WorkSlotState 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 = WorkSlotState.Empty;
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			float best = radius;
			ZDO bestZdo = null;
			string bestFamily = null;
			WorkSlotState bestState = WorkSlotState.Empty;
			foreach (CropDefinition item in WoodRegistry.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 WorkSlotState 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) && WoodRegistry.TryGetFamily(prefabName, out var family))
					{
						best = num3;
						bestZdo = val;
						bestFamily = family;
						bool flag = prefabName.StartsWith("sapling_", StringComparison.OrdinalIgnoreCase);
						bestState = ((!flag) ? WorkSlotState.Mature : WorkSlotState.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 = WorkBoundary.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 = WorkBoundary.HorizontalDistance(((Component)componentInParent).transform.position, position);
					if (!(num3 > 0.85f) && num3 < num)
					{
						num = num3;
						result = componentInParent;
					}
				}
			}
			return result;
		}
	}
	internal static class TreeScanner
	{
		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 WorkBoundary.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 TreeFieldScanner.Scan(data, homesteadPos);
		}

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

		public static bool IsSlotPlantable(WorkSlot slot)
		{
			return TreeQuery.IsSlotPlantable(slot);
		}

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

		public static bool TryFindCropAt(Vector3 position, out string family, out WorkSlotState state, bool allowZdoFallback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return TreeQuery.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 TreeQuery.FindPickableAt(position);
		}

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

		public static long ZdoKey(ZDO zdo)
		{
			return ZdoIds.ZdoKey(zdo);
		}
	}
	public class CropDefinition
	{
		public string Family;

		public string SeedItem;

		public string PlantablePrefab;

		public string GrownPrefab;

		public string WorldGrownPrefab;

		public bool ProducesSeedItem;

		public string DisplayName;
	}
	[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;

		public int MaximumSeedPercent = 20;

		public int ReplantWeight = 50;
	}
	internal static class WoodRegistry
	{
		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 readonly string[] AllFamilies = new string[8] { "Beech", "Birch", "Fir", "Pine", "Oak", "Swamp", "Ygga", "Ashwood" };

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

		public static void EnsureInit()
		{
			if (!_initialized)
			{
				Register("Beech", "BeechSeeds", "Beech_Sapling", "Wood", "Beech1", "Beech", "Beech_small1", "Beech_small2");
				Register("Birch", "BirchSeeds", "Birch_Sapling", "FineWood", "Birch1", "Birch", "Birch2", "Birch1_aut", "Birch2_aut");
				Register("Fir", "FirCone", "FirTree_Sapling", "Wood", "FirTree", "Fir", "FirTree_small", "FirTree_small_dead");
				Register("Pine", "PineCone", "PineTree_Sapling", "Wood", "Pinetree_01", "Pine", "PineTree");
				Register("Oak", "Acorn", "Oak_Sapling", "FineWood", "Oak1", "Oak");
				Register("Swamp", "AncientSeed", null, "ElderBark", "SwampTree1", "Ancient", "SwampTree2", "SwampTree2_darkland");
				Register("Ygga", null, null, "YggdrasilWood", "YggaShoot", "Yggdrasil", "YggaShoot_small");
				Register("Ashwood", null, null, "Blackwood", "AshlandsTree1", "Ashwood", "AshlandsTree2", "AshlandsTree3", "AshlandsTree4", "AshlandsTree5", "AshlandsTree6", "AshlandsTree6_big");
				_initialized = true;
			}
		}

		private static void Register(string family, string seedItem, string plantable, string woodItem, string primaryTreePrefab, string displayName, params string[] extraPrefabs)
		{
			CropDefinition value = new CropDefinition
			{
				Family = family,
				SeedItem = seedItem,
				PlantablePrefab = plantable,
				GrownPrefab = woodItem,
				WorldGrownPrefab = primaryTreePrefab,
				ProducesSeedItem = false,
				DisplayName = displayName
			};
			ByFamily[family] = value;
			MapPrefab(primaryTreePrefab, family);
			if (!string.IsNullOrEmpty(plantable))
			{
				MapPrefab(plantable, family);
			}
			if (extraPrefabs != null)
			{
				for (int i = 0; i < extraPrefabs.Length; i++)
				{
					MapPrefab(extraPrefabs[i], family);
				}
			}
		}

		private static void MapPrefab(string prefab, string family)
		{
			if (!string.IsNullOrEmpty(prefab))
			{
				PrefabToFamily[prefab] = family;
			}
		}

		public static void AddZdoLookupPrefabs(HashSet<string> into)
		{
			EnsureInit();
			if (into == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in PrefabToFamily)
			{
				into.Add(item.Key);
			}
		}

		public static bool EnsureMissingConfigs(HomesteadData data)
		{
			EnsureInit();
			if (data == null)
			{
				return false;
			}
			if (data.CropConfigs == null)
			{
				data.CropConfigs = new List<CropConfigEntry>();
			}
			for (int num = data.CropConfigs.Count - 1; num >= 0; num--)
			{
				CropConfigEntry cropConfigEntry = data.CropConfigs[num];
				if (cropConfigEntry == null || string.IsNullOrEmpty(cropConfigEntry.Family) || !ByFamily.ContainsKey(cropConfigEntry.Family))
				{
					data.CropConfigs.RemoveAt(num);
				}
			}
			bool result = false;
			foreach (CropDefinition value in ByFamily.Values)
			{
				if (data.GetCropConfig(value.Family) == null)
				{
					data.CropConfigs.Add(CreateDefaultEntry(value.Family));
					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()) || item.Key.ToLowerInvariant().Contains(text2))
				{
					family = item.Value;
					return true;
				}
			}
			if (text2.StartsWith("beech"))
			{
				family = "Beech";
				return true;
			}
			if (text2.StartsWith("birch"))
			{
				family = "Birch";
				return true;
			}
			if (text2.StartsWith("fir"))
			{
				family = "Fir";
				return true;
			}
			if (text2.StartsWith("pine") || text2.StartsWith("pinetree"))
			{
				family = "Pine";
				return true;
			}
			if (text2.StartsWith("oak"))
			{
				family = "Oak";
				return true;
			}
			if (text2.StartsWith("swamp"))
			{
				family = "Swamp";
				return true;
			}
			if (text2.StartsWith("ygga"))
			{
				family = "Ygga";
				return true;
			}
			if (text2.StartsWith("ashlands") || text2.StartsWith("ashwood"))
			{
				family = "Ashwood";
				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 string GetPlantingInputItem(string family)
		{
			if (!TryGet(family, out var def))
			{
				return null;
			}
			return def.SeedItem;
		}

		public static bool CanReplant(string family)
		{
			if (TryGet(family, out var def) && !string.IsNullOrEmpty(def.SeedItem))
			{
				return !string.IsNullOrEmpty(def.PlantablePrefab);
			}
			return false;
		}

		public static string GetOutputItem(string family)
		{
			if (!TryGet(family, out var def))
			{
				return null;
			}
			return def.GrownPrefab;
		}

		public static string GetDisplayName(string family)
		{
			if (TryGet(family, out var def) && !string.IsNullOrEmpty(def.DisplayName))
			{
				return def.DisplayName;
			}
			return family;
		}

		public static string GetProducerFamily(string itemName)
		{
			EnsureInit();
			if (string.IsNullOrEmpty(itemName))
			{
				return null;
			}
			foreach (CropDefinition value in ByFamily.Values)
			{
				if (string.Equals(value.GrownPrefab, itemName, StringComparison.OrdinalIgnoreCase))
				{
					return value.Family;
				}
			}
			return null;
		}

		public static List<CropConfigEntry> CreateDefaultConfigs()
		{
			EnsureInit();
			return ByFamily.Values.Select((CropDefinition d) => CreateDefaultEntry(d.Family)).ToList();
		}

		public static CropConfigEntry CreateDefaultEntry(string family)
		{
			return new CropConfigEntry
			{
				Family = family,
				Enabled = true,
				Weight = 50,
				HarvestEnabled = true,
				PlantEnabled = true,
				MinimumSeedReserve = 0,
				MaximumSeedPercent = 20,
				ReplantWeight = 50
			};
		}

		public static bool IsSupportedPlant(Component plantOrPickable)
		{
			if ((Object)(object)plantOrPickable == (Object)null)
			{
				return false;
			}
			string family;
			return TryGetFamily(((Object)plantOrPickable.gameObject).name, out family);
		}

		public static int GetChopWeight(HomesteadData data, string family, Vector3 homesteadPos)
		{
			//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)
			//IL_0010: 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)
			if (string.IsNullOrEmpty(family))
			{
				return 0;
			}
			Biome biome = BiomeTreeRules.GetBiome(homesteadPos);
			if (!BiomeTreeRules.IsTreeAllowed(family, biome))
			{
				return 0;
			}
			CropConfigEntry cropConfigEntry = data?.GetCropConfig(family);
			if (cropConfigEntry == null)
			{
				return 50;
			}
			if (!cropConfigEntry.Enabled || !cropConfigEntry.HarvestEnabled || cropConfigEntry.Weight <= 0)
			{
				return 0;
			}
			return Mathf.Clamp(cropConfigEntry.Weight, 0, 100);
		}

		public static int GetChopWeight(HomesteadData data, string family)
		{
			CropConfigEntry cropConfigEntry = data?.GetCropConfig(family);
			if (cropConfigEntry == null)
			{
				return 50;
			}
			if (!cropConfigEntry.Enabled || !cropConfigEntry.HarvestEnabled || cropConfigEntry.Weight <= 0)
			{
				return 0;
			}
			return Mathf.Clamp(cropConfigEntry.Weight, 0, 100);
		}
	}
	internal static class WoodStockManager
	{
		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);

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

		private static void EnsureFreshFrame()
		{
			if (Time.frameCount != _seedCountFrame)
			{
				_seedCountFrame = Time.frameCount;
				SeedCountCache.Clear();
				FoodCountCache.Clear();
				ItemTotalCache.Clear();
			}
		}

		public static int CountSeeds(HomesteadData data, InventoryManager inventory, string family)
		{
			if (!WoodRegistry.TryGet(family, out var def))
			{
				return 0;
			}
			EnsureFreshFrame();
			if (SeedCountCache.TryGetValue(family, out var 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 CountOutput(HomesteadData data, InventoryManager inventory, string family)
		{
			return CountItemTotal(data, inventory, WoodRegistry.GetOutputItem(family));
		}

		public static int CountPlantingInput(HomesteadData data, InventoryManager inventory, string family)
		{
			return CountItemTotal(data, inventory, WoodRegistry.GetPlantingInputItem(family));
		}

		private static int CountItemTotal(HomesteadData data, InventoryManager inventory, string prefab)
		{
			if (string.IsNullOrEmpty(prefab))
			{
				return 0;
			}
			EnsureFreshFrame();
			if (ItemTotalCache.TryGetValue(prefab, out var value))
			{
				return value;
			}
			int num = inventory?.CountItem(prefab) ?? 0;
			data?.SyncChestListsFromCsv();
			int num2 = CountItemInChests(data?.ChestPositions, prefab);
			int num3 = num + num2;
			ItemTotalCache[prefab] = num3;
			return num3;
		}

		public static int CountFoodCrop(HomesteadData data, InventoryManager inventory, string foodFamily)
		{
			if (!WoodRegistry.TryGet(foodFamily, out var def))
			{
				return 0;
			}
			if (def.ProducesSeedItem)
			{
				return 0;
			}
			EnsureFreshFrame();
			if (FoodCountCache.TryGetValue(foodFamily, out var 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();
			ItemTotalCache.Clear();
		}

		public static int AvailableSeedsForPlanting(HomesteadData data, InventoryManager inventory, string family)
		{
			if (!WoodRegistry.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 (!WoodRegistry.TryGet(family, out var _))
			{
				return 5;
			}
			int valueOrDefault = (data?.Slots?.Count((WorkSlot s) => s.State == WorkSlotState.Empty)).GetValueOrDefault();
			int val = Math.Max(20, valueOrDefault);
			int val2 = inventory?.CountPlantingMaterialCarried(family) ?? 0;
			string text = WoodWeights.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 = WoodRegistry.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 WoodRegistry.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;
		}
	}
	internal static class WoodWeights
	{
		private static readonly Dictionary<string, string> SeedFamilyToFood = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "SeedCarrot", "Carrot" },
			{ "SeedTurnip", "Turnip" },
			{ "SeedOnion", "Onion" }
		};

		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 SelectReplantFamily(HomesteadData data, InventoryManager bag, Vector3 plantPos)
		{
			//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_0019: 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)
			if (data?.CropConfigs == null || bag == null)
			{
				return null;
			}
			Biome biome = BiomeTreeRules.GetBiome(plantPos);
			string text = null;
			int num = 0;
			for (int i = 0; i < data.CropConfigs.Count; i++)
			{
				CropConfigEntry cropConfigEntry = data.CropConfigs[i];
				if (cropConfigEntry != null && cropConfigEntry.Enabled && cropConfigEntry.PlantEnabled && cropConfigEntry.ReplantWeight > 0 && WoodRegistry.TryGet(cropConfigEntry.Family, out var def) && !string.IsNullOrEmpty(def.SeedItem) && !string.IsNullOrEmpty(def.PlantablePrefab) && BiomeTreeRules.IsTreeAllowed(cropConfigEntry.Family, biome) && bag.CountItem(def.SeedItem) > 0 && cropConfigEntry.ReplantWeight > num)
				{
					num = cropConfigEntry.ReplantWeight;
					text = cropConfigEntry.Family;
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				Log.Debug($"SelectReplantFamily: {text} replantWeight={num}");
			}
			return text;
		}

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

		private static string SelectByOutputReserve(HomesteadData data, InventoryManager inventory, Func<string, int> availableInput)
		{
			string text = null;
			float num = 0f;
			for (int i = 0; i < data.CropConfigs.Count; i++)
			{
				CropConfigEntry cropConfigEntry = data.CropConfigs[i];
				if (cropConfigEntry == null || !cropConfigEntry.Enabled || !cropConfigEntry.PlantEnabled)
				{
					continue;
				}
				int minimumSeedReserve = cropConfigEntry.MinimumSeedReserve;
				if (minimumSeedReserve <= 0 || availableInput(cropConfigEntry.Family) <= 0)
				{
					continue;
				}
				int num2 = WoodStockManager.CountOutput(data, inventory, cropConfigEntry.Family);
				if (num2 < minimumSeedReserve)
				{
					float num3 = (float)(minimumSeedReserve - num2) / (float)minimumSeedReserve;
					if (num3 > num)
					{
						num = num3;
						text = cropConfigEntry.Family;
					}
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				Log.Debug("OutputReserve: plant " + text + " to rebuild reserve");
			}
			return text;
		}

		private static string SelectInputBootstrap(HomesteadData data, Func<string, int> availableInput)
		{
			string text = null;
			int num = 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.MinimumSeedReserve <= 0) || availableInput(cropConfigEntry.Family) > 0)
				{
					continue;
				}
				string producerFamily = WoodRegistry.GetProducerFamily(WoodRegistry.GetPlantingInputItem(cropConfigEntry.Family));
				if (string.IsNullOrEmpty(producerFamily) || string.Equals(producerFamily, cropConfigEntry.Family, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				CropConfigEntry cropConfig = data.GetCropConfig(producerFamily);
				if (cropConfig != null && cropConfig.Enabled && cropConfig.PlantEnabled && availableInput(producerFamily) > 0)
				{
					int num2 = cropConfigEntry.Weight + cropConfigEntry.MinimumSeedReserve;
					if (num2 > num)
					{
						num = num2;
						text = producerFamily;
					}
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				Log.Debug("InputBootstrap: plant " + text + " to feed a wanted crop");
			}
			return text;
		}

		public static string SelectByDeficit(HomesteadData data, InventoryManager inventory, Func<string, int> availableInput)
		{
			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)
				{
					num += cropConfigEntry.Weight;
					num2++;
				}
			}
			if (num2 == 0 || num <= 0)
			{
				return null;
			}
			int num3 = 0;
			for (int j = 0; j < data.Slots.Count; j++)
			{
				WorkSlot workSlot = data.Slots[j];
				if (workSlot != null && workSlot.State != WorkSlotState.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)
				{
					continue;
				}
				int num6 = 0;
				for (int l = 0; l < data.Slots.Count; l++)
				{
					WorkSlot workSlot2 = data.Slots[l];
					if (workSlot2 != null && workSlot2.State != WorkSlotState.Empty && workSlot2.State != WorkSlotState.Disabled && string.Equals(workSlot2.CurrentCropFamily, cropConfigEntry2.Family, StringComparison.OrdinalIgnoreCase))
					{
						num6++;
					}
				}
				float num7 = (float)num3 * ((float)cropConfigEntry2.Weight / (float)num) - (float)num6;
				int num8 = availableInput(cropConfigEntry2.Family);
				if ((inventory?.CountPlantingMaterialCarried(cropConfigEntry2.Family) ?? 0) > 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> availableInput)
		{
			return SelectByDeficit(data, null, availableInput);
		}
	}
	internal static class WorkBoundary
	{
		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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: 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.FindObjectsByType<BoundaryPost>((FindObjectsSortMode)0)
					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.MaxWorkRadius || num9 * 0.5f > SyncedConfig.MaxWorkRadius)
			{
				Log.Warning($"Farm boundary exceeds MaxWorkRadius ({SyncedConfig.MaxWorkRadius}) 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_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)
			pos = Vector3.zero;
			ZNetView[] array = Object.FindObjectsByType<ZNetView>((FindObjectsSortMode)0);
			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;
		}
	}
	public enum WorkSlotState
	{
		Occupied,
		Mature,
		Empty,
		ReservedHarvest,
		ReservedPlant,
		Blocked,
		Disabled
	}
	[Serializable]
	public class WorkSlot
	{
		public string Id;

		public float X;

		public float Y;

		public float Z;

		public float RotY;

		public string OriginalCropFamily;

		public string CurrentCropFamily;

		public WorkSlotState State = WorkSlotState.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 WorkSlotList
	{
		public List<WorkSlot> Slots = new List<WorkSlot>();
	}
	internal static class WorkSlotAssigner
	{
		private static readonly Dictionary<int, float> RefreshAtByData = new Dictionary<int, float>(8);

		public static void RefreshSlotStates(HomesteadData data)
		{
			//IL_00bc: 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 (WorkSlot slot in data.Slots)
			{
				if (slot == null || slot.State == WorkSlotState.Disabled)
				{
					continue;
				}
				if (slot.State == WorkSlotState.ReservedHarvest || slot.State == WorkSlotState.ReservedPlant)
				{
					if (ReservationManager.IsReserved(slot.Id))
					{
						continue;
					}
					Log.Debug("RefreshSlotStates: reclaiming orphaned reserved slot " + slot.Id);
				}
				if (TreeQuery.TryFindCropAt(slot.Position, out var family, out var state, allowZdoFallback: false))
				{
					slot.CurrentCropFamily = family;
					slot.State = state;
					slot.LastUpdated = time;
				}
				else if ((slot.State != WorkSlotState.Occupied && slot.State != WorkSlotState.Mature) || !(time - slot.LastUpdated < SyncedConfig.ScanInterval * 3f))
				{
					slot.State = WorkSlotState.Empty;
					slot.LastUpdated = time;
				}
			}
		}
	}
}
namespace ValheimLumberNPC.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 = Vector3.Distance(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.FindObjectsByType<Container>((FindObjectsSortMode)0);
			}
			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 = Vector3.Distance(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;
				}
				while (num > 0)
				{
					int num2 = TryAddPrefabToContainer(item, val, prefabName, sharedName, num);
					if (num2 <= 0)
					{
						break;
					}
					num -= num2;
				}
			}
			return amount - num;
		}

		private static int TryAddPrefabToContainer(Container c, GameObject prefab, string prefabName, string sharedName, int amount)
		{
			//IL_019d: 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);
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			int num = 50;
			try
			{
				int valueOrDefault = (component?.m_itemData?.m_shared?.m_maxStackSize).GetValueOrDefault();
				if (valueOrDefault > 0)
				{
					num = valueOrDefault;
				}
			}
			catch
			{
				num = 50;
			}
			int num2 = Mathf.Min(amount, num);
			if (!inventory.CanAddItem(prefab, num2))
			{
				num2 = 0;
				int num3 = 1;
				int num4 = Mathf.Min(amount, num);
				while (num3 <= num4)
				{
					int num5 = (num3 + num4) / 2;
					if (inventory.CanAddItem(prefab, num5))
					{
						num2 = num5;
						num3 = num5 + 1;
					}
					else
					{
						num4 = num5 - 1;
					}
				}
			}
			if (num2 <= 0)
			{
				return 0;
			}
			int num6 = CountInInventory(inventory, prefabName, sharedName);
			bool flag = inventory.AddItem(prefab, num2);
			int num7 = CountInInventory(inventory, prefabName, sharedName) - num6;
			if (num7 <= 0)
			{
				ItemData val = inventory.AddItem(prefabName, num2, 1, 0, 0L, string.Empty, false);
				num7 = CountInInventory(inventory, prefabName, sharedName) - num6;
				if (num7 <= 0)
				{
					Log.Warning($"Deposit rejected {prefabName} x{num2} into {((Object)c).name} " + $"(AddItem={flag}, nameAdd={val != null}) — keeping on farmer");
					return 0;
				}
			}
			Log.Debug($"Deposit +{num7}x {prefabName} → {((Object)c).name} at {((Component)c).transform.position}");
			return num7;
		}

		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
	{
		public static bool TryFetchSeeds(InventoryManager bag, HomesteadData data, string family, int amount = 1)
		{
			if (bag == null || !WoodRegistry.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();
						WoodStockManager.InvalidateSeedCountCache();
						return true;
					}
				}
			}
			if (num2 < amount - num)
			{
				HomesteadStock.InvalidateTotalsCache();
				WoodStockManager.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;
			}
			string plantingInputItem = WoodRegistry.GetPlantingInputItem(family);
			if (string.IsNullOrEmpty(plantingInputItem))
			{
				return false;
			}
			int num = Math.Max(0, amount - bag.CountItem(plantingInputItem));
			if (num <= 0)
			{
				return true;
			}
			data?.SyncChestListsFromCsv();
			if (TryFetchItemFromChests(bag, data?.ChestPositions, plantingInputItem, num))
			{
				WoodStockManager.InvalidateSeedCountCache();
				HomesteadStock.InvalidateTotalsCache();
			}
			return bag.CountPlantingMaterialCarried(family) > 0;
		}

		public static bool NeedsReserveRestock(InventoryManager bag, HomesteadData data, Vector3 homesteadPos)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (bag == null || data == null || !data.HasAnyChest)
			{
				return false;
			}
			if (data.CropConfigs == null)
			{
				return false;
			}
			foreach (CropConfigEntry cropConfig in data.CropConfigs)
			{
				int num = Math.Max(0, cropConfig?.MinimumSeedReserve ?? 0);
				if (num <= 0 || cropConfig == null)
				{
					continue;
				}
				string outputItem = WoodRegistry.GetOutputItem(cropConfig.Family);
				if (!string.IsNullOrEmpty(outputItem) && HomesteadStock.CountPrefabAcrossHomestead(homesteadPos, outputItem) < num)
				{
					int num2 = bag.CountItem(outputItem);
					if (WoodStockManager.CountOutput(data, bag, cropConfig.Family) > num2)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool TryRestockReserves(InventoryManager bag, HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0068: 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;
			if (data.CropConfigs == null)
			{
				return false;
			}
			foreach (CropConfigEntry cropConfig in data.CropConfigs)
			{
				int num = Math.Max(0, cropConfig?.MinimumSeedReserve ?? 0);
				if (num <= 0 || cropConfig == null)
				{
					continue;
				}
				string outputItem = WoodRegistry.GetOutputItem(cropConfig.Family);
				if (!string.IsNullOrEmpty(outputItem))
				{
					int num2 = HomesteadStock.CountPrefabAcrossHomestead(homesteadPos, outputItem);
					int num3 = num - num2;
					if (num3 > 0 && TryFetchItemFromChests(bag, data.ChestPositions, outputItem, num3))
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				WoodStockManager.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 = true;
					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);
			WoodStockManager.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 || string.IsNullOrEmpty(prefab))
			{
				return 0;
			}
			string producerFamily = WoodRegistry.GetProducerFamily(prefab);
			if (string.IsNullOrEmpty(producerFamily))
			{
				return 0;
			}
			return Math.Max(0, data.GetCropConfig(producerFamily)?.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<LumberNpc> TotalsFarmersScratch = new List<LumberNpc>(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<LumberNpc> 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++)
			{
				LumberNpc lumberNpc = farmers[i];
				if (lumberNpc?.Inventory != null)
				{
					MergeInventory(map, lumberNpc.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();
			}
			LumberRoster.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 string EncodeCsv()
		{
			return HomesteadCodecs.EncodeCarriedItems(_items);
		}

		public void LoadFromCsv(string csv)
		{
			_items.Clear();
			if (!string.IsNullOrEmpty(csv))
			{
				_items.AddRange(HomesteadCodecs.DecodeCarriedItems(csv));
			}
		}

		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 (!WoodRegistry.TryGet(family, out var def))
			{
				return false;
			}
			return TryRemove(def.SeedItem);
		}

		public bool ConsumePlantingMaterial(string family)
		{
			string consumedPrefab;
			return ConsumePlantingMaterial(family, out consumedPrefab);
		}

		public bool ConsumePlantingMaterial(string family, out string consumedPrefab)
		{
			consumedPrefab = null;
			string plantingInputItem = WoodRegistry.GetPlantingInputItem(family);
			if (!string.IsNullOrEmpty(plantingInputItem) && TryRemove(plantingInputItem))
			{
				consumedPrefab = plantingInputItem;
				return true;
			}
			return false;
		}

		public int CountPlantingMaterialCarried(string family)
		{
			string plantingInputItem = WoodRegistry.GetPlantingInputItem(family);
			if (!string.IsNullOrEmpty(plantingInputItem))
			{
				return CountItem(plantingInputItem);
			}
			return 0;
		}

		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 string NormalizePrefabName(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return raw;
			}
			int num = raw.IndexOf("(Clone)", StringComparison.Ordinal);
			return ((num >= 0) ? raw.Substring(0, num) : raw).Trim();
		}

		public static string ResolvePickableProduct(Pickable pickable)
		{
			if ((Object)(object)pickable == (Object)null || (Object)(object)pickable.m_itemPrefab == (Object)null)
			{
				return null;
			}
			string text = NormalizePrefabName(((Object)pickable.m_itemPrefab).name);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			if (IsKnownCropLootName(text))
			{
				return text;
			}
			ItemDrop component = pickable.m_itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null && TryResolveCropPrefabName(component.m_itemData, out var prefabName))
			{
				return prefabName;
			}
			return text;
		}

		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 = NormalizePrefabName(((Object)item.m_dropPrefab).name);
				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 WoodRegistry.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 = NormalizePrefabName(((Object)drop).name);
			}
			return IsKnownCropLootName(text);
		}

		public static bool IsKnownCropLootName(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			foreach (CropDefinition item in WoodRegistry.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;
			}
			int num = Math.Min(PhysicsQuery.OverlapSphereNonAlloc(position, radius, PhysicsQuery.CropMask), PhysicsQuery.Buffer.Length);
			if (num <= 0)
			{
				return 0;
			}
			List<ItemDrop> list = new List<ItemDrop>();
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < num; i++)
			{
				Collider val = PhysicsQuery.Buffer[i];
				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 num2 = 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)) ? ItemPrefabResolver.NormalizePrefabName(((Object)(object)item.m_itemData.m_dropPrefab != (Object)null) ? ((Object)item.m_itemData.m_dropPrefab).name : ((Object)item).name) : prefabName);
				int dropStack = GetDropStack(item);
				if (dropStack > 0 && bag.TryAdd(prefab, dropStack))
				{
					if (!TryDestroyWorldDrop(item))
					{
						bag.TryRemove(prefab, dropStack);
						continue;
					}
					num2++;
					destroyed++;
				}
			}
			return num2;
		}

		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 ValheimLumberNPC.Homestead
{
	internal static class HomesteadLumberOps
	{
		public static LumberNpc FindNearest(Vector3 pos, float range, IEnumerable<LumberNpc> 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)
			LumberNpc result = null;
			float num = range;
			foreach (LumberNpc item in LumberRoster.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 (LumberNpc 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, LumberNpc currentPrimary, out LumberNpc 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;
			LumberNpc target = LumberRoster.PickRemovable(position);
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			List<LumberNpc> list = LumberRoster.ListNear(position).FindAll((LumberNpc 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 LumberNpc SpawnAdditional(Vector3 position, Quaternion rotation, LumberHomestead 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 LumberSpawner.SpawnAdditional(position, rotation, pieceOrNull);
		}

		public static LumberNpc TrySpawnNearHomestead(Vector3 position, Quaternion rotation, LumberHomestead 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 LumberSpawner.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);
			LumberCleanup.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_009f: Unknown result type (might be due to invalid IL or missing references)
			List<LumberNpc> list = LumberRoster.ListNear(pos, range);
			list.Sort((LumberNpc a, LumberNpc b) => Vector3.Distance(((Component)a).transform.position, pos).CompareTo(Vector3.Distance(((Component)b).transform.position, pos)));
			LumberNpc lumberNpc = ((list.Count > 0) ? list[0] : null);
			for (int num = 1; num < list.Count; num++)
			{
				LumberNpc lumberNpc2 = list[num];
				if (!((Object)(object)lumberNpc2 == (Object)null))
				{
					if ((Object)(object)lumberNpc != (Object)null && (Object)(object)lumberNpc != (Object)(object)lumberNpc2 && lumberNpc.Inventory != null && lumberNpc2.Inventory != null)
					{
						lumberNpc.Inventory.AbsorbAll(lumberNpc2.Inventory);
					}
					Log.Warning($"Destroying surplus farmer #{num} at {((Component)lumberNpc2).transform.position}");
					lumberNpc2.UnbindAndDestroy();
				}
			}
			lumberNpc?.ForcePersistInventory();
		}
	}
	internal static class HomesteadOps
	{
		public struct DepositAllResult
		{
			public int Emptied;

			public int LumberCount;

			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 TreeScanner.ScanResult Scan(HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return TreeScanner.Scan(data, homesteadPos);
		}

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

		public static TreeScanner.ScanResult ClearAndScan(HomesteadData data, Vector3 homesteadPos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			data?.Slots?.Clear();
			return TreeScanner.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 void SetWorkRadius(HomesteadData data, float radius)
		{
			data?.SetWorkRadius(radius);
		}

		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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return false;
			}
			List<BoundaryPost> list = (from p in Object.FindObjectsByType<BoundaryPost>((FindObjectsSortMode)0)
				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 = WoodRegistry.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 (array.Length >= 8)
			{
				int.TryParse(array[7], out cropConfigEntry.ReplantWeight);
			}
			cropConfigEntry.Weight = Mathf.Clamp(cropConfigEntry.Weight, 0, 100);
			cropConfigEntry.ReplantWeight = Mathf.Clamp(cropConfigEntry.ReplantWeight, 0, 100);
			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)
		{
			//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<LumberNpc> list = LumberRoster.ListNear(homesteadPos);
			result.LumberCount = list.Count;
			if (list.Count == 0)
			{
				result.NoFarmers = true;
				return result;
			}
			foreach (LumberNpc 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++;
					}
				}
			}
			return result;
		}

		public static void DepositSurplusAll(HomesteadData data, Vector3 homesteadPos, out bool blocked)
		{
			//IL_0016: 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_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 (LumberNpc item in LumberRoster.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();
				}
			}
		}

		public static bool TryUnpauseWithDepositCheck(HomesteadData data, Vector3 homesteadPos)
		{
			//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);
			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("LumberHomestead") : 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("ln_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("LumberHomestead");
			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("ln_home", 0);
				zdo.Set("ln_data", "");
				zdo.Set("ln_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("ln_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 == "LumberHomestead" || (wantHash != 0 && zdo.GetPrefab() == wantHash))
			{
				string value = zdo.GetString("ln_data", string.Empty);
				string value2 = zdo.GetString("ln_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("LumberHomestead", 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 ValheimLumberNPC.HarmonyPatches
{
	[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 LumberAudioPatches
	{
		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(LumberAudioPatches), 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 (!LumberAudio.ShouldBlockEffectAt(pos, parent))
			{
				return true;
			}
			__result = Array.Empty<GameObject>();
			return false;
		}
	}
	internal static class LumberFriendlyFirePatches
	{
		public static void Apply(Harmony harmony)
		{
			TryPatch(harmony, AccessTools.Method(typeof(WearNTear), "Damage", new Type[1] { typeof(HitData) }, (Type[])null), "WearNTear_Damage_Prefix");
			TryPatch(harmony, AccessTools.Method(typeof(WearNTear), "ApplyDamage", new Type[2]
			{
				typeof(float),
				typeof(HitData)
			}, (Type[])null), "WearNTear_ApplyDamage_Prefix");
			Log.Debug("Lumber friendly-fire (WearNTear) 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 WearNTear method for " + prefixName);
				return;
			}
			try
			{
				harmony.Patch((MethodBase)target, new HarmonyMethod(typeof(LumberFriendlyFirePatches), 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 WearNTear_Damage_Prefix(WearNTear __instance, HitData hit)
		{
			return !ShouldBlockLumberDamage(__instance, hit);
		}

		private static bool WearNTear_ApplyDamage_Prefix(WearNTear __instance, HitData hitData)
		{
			return !ShouldBlockLumberDamage(__instance, hitData);
		}

		internal static bool ShouldBlockLumberDamage(WearNTear wnt, HitData hit)
		{
			if ((Object)(object)wnt == (Object)null || hit == null)
			{
				return false;
			}
			Character val = null;
			try
			{
				val = hit.GetAttacker();
			}
			catch
			{
				return false;
			}
			if ((Object)(object)val == (Object)null || !LumberIdentity.LooksLikeFarmerCharacter(val))
			{
				return false;
			}
			if ((Object)(object)((Component)wnt).GetComponent<LumberHomestead>() != (Object)null)
			{
				return true;
			}
			Piece val2 = (((Object)(object)wnt.m_piece != (Object)null) ? wnt.m_piece : ((Component)wnt).GetComponent<Piece>());
			if ((Object)(object)val2 != (Object)null)
			{
				string a = (((Object)((Component)val2).gameObject).name ?? string.Empty).Replace("(Clone)", "").Trim();
				if (string.Equals(a, "LumberHomestead", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "LumberBoundaryPost", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			Container component = ((Component)wnt).GetComponent<Container>();
			if ((Object)(object)component != (Object)null && ChestAssignments.IsAssignableFarmChest(component))
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class LumberMaterializePatches
	{
		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<LumberNpc>() != (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("ln_farmer", 0) == 1;
			string text = LumberIdentity.PrefabName(zDO);
			bool flag2 = text == "LumberNpc";
			if (flag || flag2)
			{
				LumberNpc npc = ((Component)__instance).gameObject.AddComponent<LumberNpc>();
				(((Component)__instance).GetComponent<LumberController>() ?? ((Component)__instance).gameObject.AddComponent<LumberController>()).Bind(npc);
				__instance.m_faction = (Faction)0;
				__instance.m_group = "lumber_npc";
				if (string.IsNullOrEmpty(__instance.m_name) || __instance.m_name.IndexOf("Goblin", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					__instance.m_name = "$ln_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 LumberNpc on '{((Object)((Component)__instance).gameObject).name}' prefab={text} marked={flag}");
			}
		}
	}
	internal static class LumberRemovePatches
	{
		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(LumberRemovePatches), 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;
			}
			LumberNpc lumberNpc = FindHoveringLumberNpc(__instance);
			if ((Object)(object)lumberNpc != (Object)null)
			{
				DestroyLumberNpcAsAdmin(lumberNpc);
				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 || !LumberCleanup.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 DestroyLumberNpcAsAdmin(LumberNpc 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 LumberNpc FindHoveringLumberNpc(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))
				{
					LumberNpc componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<LumberNpc>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						return componentInParent;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Debug("FindHoveringLumberNpc: " + 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_011e: 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_012d: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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)
			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 && LumberCleanup.LooksLikeFarmerCharacter(val2))
					{
						return val2;
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)val != (Object)null)
			{
				Character componentInParent = val.GetComponentInParent<Character>();
				if (LumberCleanup.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 (LumberCleanup.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.FindObjectsByType<Character>((FindObjectsSortMode)0);
			foreach (Character val4 in array)
			{
				if (!LumberCleanup.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(ZDOMan), "PrepareSave")]
	internal static class LumberSaveFlushPatch
	{
		private static void Prefix()
		{
			try
			{
				IReadOnlyList<LumberNpc> live = LumberNpc.Live;
				for (int i = 0; i < live.Count; i++)
				{
					live[i]?.FlushInventoryIfOwner();
				}
			}
			catch (Exception ex)
			{
				Log.Warning("PrepareSave farmer flush failed: " + ex.Message);
			}
		}
	}
	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<LumberHomestead>() != (Object)null || (Object)(object)((Component)piece).GetComponent<BoundaryPost>() != (Object)null)
			{
				return true;
			}
			string text = ((Object)((Component)piece).gameObject).name.Replace("(Clone)", "").Trim();
			if (text == "LumberHomestead" || text == "LumberBoundaryPost")
			{
				return true;
			}
			if (!(piece.m_name == "$piece_lumberhomestead"))
			{
				return piece.m_name == "$piece_lumberboundarypost";
			}
			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 ValheimLumberNPC.Config
{
	internal class PluginConfig
	{
		public ConfigEntry<bool> AdminOnlyPlacement { get; }

		public ConfigEntry<bool> AdminOnlyAccess { get; }

		public ConfigEntry<float> MaxWorkRadius { get; }

		public ConfigEntry<string> DefaultLayoutMode { get; }

		public ConfigEntry<float> ScanInterval { get; }

		public ConfigEntry<int> InventoryCapacity { get; }

		public ConfigEntry<float> ReservationTimeout { get; }

		public ConfigEntry<bool> EnableLumberSounds { get; }

		public ConfigEntry<bool> DebugLogging { get; }

		public ConfigEntry<bool> LogFeedbackToChat { get; }

		public ConfigEntry<int> MaxLumberjacks { 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 Lumber 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.");
			MaxLumberjacks = config.Bind<int>("General", "MaxLumberjacks", 8, "Hard cap on active lumber NPCs across the whole world/server.");
			MaxWorkRadius = config.Bind<float>("Logging", "MaxWorkRadius", 100f, "Server hard ceiling (meters) for work radius — NOT the homestead's current radius. Set the radius in the homestead UI (10–this value, capped at 100). If this is 40, every UI change is stuck at 40m.");
			if (MaxWorkRadius.Value <= 40.01f)
			{
				MaxWorkRadius.Value = 100f;
			}
			DefaultLayoutMode = config.Bind<string>("Logging", "DefaultLayoutMode", "Weighted", "Default tree-priority mode for new homesteads (Weighted).");
			ScanInterval = config.Bind<float>("Logging", "ScanInterval", 2f, "Seconds between background tree/work-area refreshes while lumberjacks are working.");
			ChestAssignRange = config.Bind<float>("Logging", "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 lumberjack can carry in their bag (not total item count).");
			ReservationTimeout = config.Bind<float>("Networking", "ReservationTimeout", 30f, "Seconds a tree reservation lasts before another lumberjack can take it (multiplayer).");
			EnableLumberSounds = config.Bind<bool>("AI", "EnableLumberSounds", true, "If true, lumber trolls use troll vocal sounds. If false, lumber NPCs are muted.");
			ThinkInterval = config.Bind<float>("AI", "ThinkInterval", 0.5f, "Seconds between AI decision ticks (picking the next chop/collect/deposit task). Lower = more responsive, more CPU.");
			MoveSpeed = config.Bind<float>("AI", "MoveSpeed", 2.5f, "Lumberjack walking speed (units per second) when moving between tasks.");
			WorkRange = config.Bind<float>("AI", "WorkRange", 3f, "Distance (meters) at which the lumberjack can chop, pick up wood, or interact with a chest.");
			DebugLogging = config.Bind<bool>("Debug", "DebugLogging", false, "If true, verbose lumber 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, lumberjacks, 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 MaxLumberjacks => _config?.MaxLumberjacks?.Value ?? 16;

		public static float MaxWorkRadius => _config?.MaxWorkRadius?.Value ?? 100f;

		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 EnableLumberSounds => _config?.EnableLumberSounds?.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 ?? 3f;

		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.MaxLumberjacks);
			TryLockAdminConfig((ConfigEntryBase)(object)config.MaxWorkRadius);
			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 ValheimLumberNPC.Commands
{
	internal static class CollectWoodCommand
	{
		public static bool TryExecute(LumberNpc npc, HomesteadData data, WorkSlot slot, string family)
		{
			//IL_0113: 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_01bc: 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 (!WoodRegistry.TryGet(family, out var def))
			{
				Log.Info("CollectWoodCommand: unknown family " + family);
				return false;
			}
			CropResolveResult cropResolveResult = TreeResolver.Resolve(slot);
			if (cropResolveResult.Status == CropResolveStatus.Growing || cropResolveResult.Status == CropResolveStatus.Ready)
			{
				slot.State = ((cropResolveResult.Status == CropResolveStatus.Ready) ? WorkSlotState.Mature : WorkSlotState.Occupied);
				slot.LastUpdated = Time.time;
				Log.Info($"CollectWoodCommand: slot={slot.Id} already has crop ({cropResolveResult.Status}) — mark occupied, skip");
				return false;
			}
			if (!npc.Inventory.ConsumePlantingMaterial(family, out var consumedPrefab) && (!ChestLogistics.TryFetchPlantingMaterial(npc.Inventory, data, family) || !npc.Inventory.ConsumePlantingMaterial(family, out consumedPrefab)))
			{
				Log.Info("CollectWoodCommand: 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)
			{
				RefundConsumed(npc, consumedPrefab, def);
				Log.Warning("CollectWoodCommand missing prefab " + def.PlantablePrefab);
				return false;
			}
			try
			{
				if ((Object)(object)Object.Instantiate<GameObject>(val, slot.Position, slot.Rotation) == (Object)null)
				{
					RefundConsumed(npc, consumedPrefab, def);
					Log.Warning("CollectWoodCommand: instantiate returned null for " + def.PlantablePrefab);
					return false;
				}
			}
			catch (Exception ex)
			{
				RefundConsumed(npc, consumedPrefab, def);
				Log.Warning("CollectWoodCommand: instantiate failed for " + def.PlantablePrefab + ": " + ex.Message);
				return false;
			}
			slot.CurrentCropFamily = family;
			if (string.IsNullOrEmpty(slot.OriginalCropFamily))
			{
				slot.OriginalCropFamily = family;
			}
			slot.State = WorkSlotState.Occupied;
			slot.LastUpdated = Time.time;
			Log.Info($"CollectWoodCommand ok {family} slot={slot.Id} at {slot.Position}");
			return true;
		}

		private static void RefundConsumed(LumberNpc npc, string consumedPrefab, CropDefinition def)
		{
			string text = ((!string.IsNullOrEmpty(consumedPrefab)) ? consumedPrefab : def?.SeedItem);
			if (!string.IsNullOrEmpty(text))
			{
				npc.Inventory.TryAdd(text);
			}
		}
	}
	internal static class DepositItemsCommand
	{
		public static bool TryExecute(LumberNpc 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();
			WoodStockManager.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 FetchWoodCommand
	{
		public static bool TryExecute(LumberNpc 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 ? $"FetchWoodCommand ok family={family} amount={amount}" : ("FetchWoodCommand fail family=" + family + " (no chest/seeds)"));
			return num;
		}
	}
	internal static class LumberAttackCommand
	{
		public const float SwingWindup = 0.85f;

		public const float SwingCooldown = 1.6f;

		public const float ReplantDelayAfterStump = 1.25f;

		public const float ApproachRange = 5.5f;

		public const float ChopDamagePerHit = 120f;

		public const int ToolTier = 4;

		public static void FaceTarget(LumberNpc npc, Vector3 targetPos)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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)
			if ((Object)(object)npc == (Object)null)
			{
				return;
			}
			Vector3 val = targetPos - ((Component)npc).transform.position;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				return;
			}
			Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			((Component)npc).transform.rotation = Quaternion.Slerp(((Component)npc).transform.rotation, val2, 0.35f);
			Character character = npc.Character;
			if (!((Object)(object)character != (Object)null))
			{
				return;
			}
			try
			{
				character.SetLookDir(((Vector3)(ref val)).normalized, 0f);
			}
			catch
			{
			}
		}

		public static bool TryStartSwing(LumberNpc npc, Vector3 targetPos)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)npc == (Object)null)
			{
				return false;
			}
			FaceTarget(npc, targetPos);
			Humanoid component = ((Component)npc).GetComponent<Humanoid>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if (!LumberLogWeapon.EnsureEquipped(component))
			{
				Log.Debug("StartAttack skipped — no log weapon equipped");
				return false;
			}
			try
			{
				if (((Character)component).StartAttack((Character)null, false))
				{
					return true;
				}
				return ((Character)component).StartAttack((Character)null, true);
			}
			catch (Exception ex)
			{
				Log.Debug("StartAttack failed: " + ex.Message);
				return false;
			}
		}

		public static bool IsInAttack(LumberNpc npc)
		{
			Humanoid val = (((Object)(object)npc != (Object)null) ? ((Component)npc).GetComponent<Humanoid>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				return ((Character)val).InAttack();
			}
			catch
			{
				return false;
			}
		}

		public static bool TryDamageDestructible(LumberNpc npc, Component target, Vector3 hitPoint)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0066: 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_0087: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00be: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)npc == (Object)null || (Object)(object)target == (Object)null || !Object.op_Implicit((Object)(object)target))
			{
				return false;
			}
			IDestructible val = target.GetComponent<IDestructible>();
			if (val == null)
			{
				val = target.GetComponentInParent<IDestructible>();
			}
			if (val == null)
			{
				return false;
			}
			ZNetView componentInParent = target.GetComponentInParent<ZNetView>();
			if ((Object)(object)componentInParent != (Object)null && !componentInParent.IsValid())
			{
				return false;
			}
			Vector3 val2 = hitPoint - ((Component)npc).transform.position;
			Vector3 dir = ((Vector3)(ref val2)).normalized;
			if (((Vector3)(ref dir)).sqrMagnitude < 0.01f)
			{
				dir = ((Component)npc).transform.forward;
			}
			HitData val3 = new HitData();
			val3.m_damage.m_chop = 120f;
			val3.m_damage.m_blunt = 30f;
			val3.m_toolTier = 4;
			val3.m_point = hitPoint;
			val3.m_dir = dir;
			val3.m_hitType = (HitType)0;
			Character character = npc.Character;
			if ((Object)(object)character != (Object)null)
			{
				val3.SetAttacker(character);
			}
			val.Damage(val3);
			return true;
		}

		public static Vector3 HitPointFor(Component target)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_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_0020: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return Vector3.zero;
			}
			Collider componentInChildren = target.GetComponentInChildren<Collider>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Bounds bounds = componentInChildren.bounds;
				return ((Bounds)(ref bounds)).center;
			}
			return target.transform.position + Vector3.up * 1.2f;
		}
	}
	internal static class TreeLogFinder
	{
		private static readonly Collider[] OverlapScratch = (Collider[])(object)new Collider[128];

		public static bool TryFindNearestLog(Vector3 nearPos, float radius, Vector3 fromPos, out TreeLog log)
		{
			//IL_0015: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			log = null;
			float num = float.MaxValue;
			float num2 = Mathf.Max(1f, radius);
			int num3 = Physics.OverlapSphereNonAlloc(nearPos, num2, OverlapScratch, -1, (QueryTriggerInteraction)1);
			for (int i = 0; i < num3; i++)
			{
				Collider val = OverlapScratch[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				TreeLog componentInParent = ((Component)val).GetComponentInParent<TreeLog>();
				if ((Object)(object)componentInParent == (Object)null || !Object.op_Implicit((Object)(object)componentInParent))
				{
					continue;
				}
				ZNetView component = ((Component)componentInParent).GetComponent<ZNetView>();
				if (!((Object)(object)component != (Object)null) || component.IsValid())
				{
					float num4 = Vector3.Distance(fromPos, ((Component)componentInParent).transform.position);
					if (num4 < num)
					{
						num = num4;
						log = componentInParent;
					}
				}
			}
			return (Object)(object)log != (Object)null;
		}

		public static bool HasLogsNear(Vector3 nearPos, float radius)
		{
			//IL_0000: 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)
			TreeLog log;
			return TryFindNearestLog(nearPos, radius, nearPos, out log);
		}
	}
	internal static class TreeStumpFinder
	{
		private static readonly Collider[] OverlapScratch = (Collider[])(object)new Collider[128];

		public static bool TryFindNearestStump(Vector3 nearPos, float radius, Vector3 fromPos, out Destructible stump)
		{
			//IL_0015: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			stump = null;
			float num = float.MaxValue;
			float num2 = Mathf.Max(1f, radius);
			int num3 = Physics.OverlapSphereNonAlloc(nearPos, num2, OverlapScratch, -1, (QueryTriggerInteraction)1);
			for (int i = 0; i < num3; i++)
			{
				Collider val = OverlapScratch[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Destructible componentInParent = ((Component)val).GetComponentInParent<Destructible>();
				if (!IsTreeStump(componentInParent))
				{
					continue;
				}
				ZNetView component = ((Component)componentInParent).GetComponent<ZNetView>();
				if (!((Object)(object)component != (Object)null) || component.IsValid())
				{
					float num4 = Vector3.Distance(fromPos, ((Component)componentInParent).transform.position);
					if (num4 < num)
					{
						num = num4;
						stump = componentInParent;
					}
				}
			}
			return (Object)(object)stump != (Object)null;
		}

		public static bool IsTreeStump(Destructible d)
		{
			if ((Object)(object)d == (Object)null || !Object.op_Implicit((Object)(object)d))
			{
				return false;
			}
			if ((Object)(object)((Component)d).GetComponent<TreeBase>() != (Object)null || (Object)(object)((Component)d).GetComponent<TreeLog>() != (Object)null)
			{
				return false;
			}
			string text = ((Object)((Component)d).gameObject).name.Replace("(Clone)", "").Trim();
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.IndexOf("stub", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("stump", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}
	}
	internal static class PlantSaplingCommand
	{
		public static bool TryPlant(LumberNpc npc, HomesteadData data, string family, Vector3 position)
		{
			//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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			if (npc?.Inventory == null || data == null || string.IsNullOrEmpty(family))
			{
				return false;
			}
			if (!WoodRegistry.TryGet(family, out var def) || string.IsNullOrEmpty(def.PlantablePrefab))
			{
				Log.Debug("PlantSaplingCommand: no plantable prefab for " + family);
				return false;
			}
			if (!npc.Inventory.ConsumePlantingMaterial(family, out var consumedPrefab))
			{
				Log.Debug("PlantSaplingCommand: no seed in bag for " + family);
				return false;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(def.PlantablePrefab) : null);
			if ((Object)(object)val == (Object)null)
			{
				Refund(npc, consumedPrefab, def);
				Log.Warning("PlantSaplingCommand: missing prefab " + def.PlantablePrefab);
				return false;
			}
			Vector3 val2 = SnapToGround(position);
			try
			{
				if ((Object)(object)Object.Instantiate<GameObject>(val, val2, Quaternion.identity) == (Object)null)
				{
					Refund(npc, consumedPrefab, def);
					Log.Warning("PlantSaplingCommand: instantiate null for " + def.PlantablePrefab);
					return false;
				}
			}
			catch (Exception ex)
			{
				Refund(npc, consumedPrefab, def);
				Log.Warning("PlantSaplingCommand: instantiate failed for " + def.PlantablePrefab + ": " + ex.Message);
				return false;
			}
			npc.PersistInventory();
			Log.Info($"PlantSaplingCommand ok {family} at {val2}");
			return true;
		}

		public static bool TryReplantAfterStump(LumberNpc npc, HomesteadData data, Vector3 stumpPos)
		{
			//IL_0015: 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)
			if ((Object)(object)npc == (Object)null || data == null)
			{
				return false;
			}
			string text = WoodWeights.SelectReplantFamily(data, npc.Inventory, stumpPos);
			if (string.IsNullOrEmpty(text))
			{
				Log.Debug("PlantSaplingCommand: no eligible seed to replant after stump");
				return false;
			}
			return TryPlant(npc, data, text, stumpPos);
		}

		private static Vector3 SnapToGround(Vector3 pos)
		{
			//IL_000d: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return pos;
			}
			try
			{
				float groundHeight = ZoneSystem.instance.GetGroundHeight(pos);
				if (groundHeight > 1f)
				{
					pos.y = groundHeight + 0.05f;
				}
			}
			catch
			{
			}
			return pos;
		}

		private static void Refund(LumberNpc npc, string consumedPrefab, CropDefinition def)
		{
			string text = ((!string.IsNullOrEmpty(consumedPrefab)) ? consumedPrefab : def?.SeedItem);
			if (!string.IsNullOrEmpty(text))
			{
				npc.Inventory.TryAdd(text);
			}
		}
	}
}
namespace ValheimLumberNPC.AI
{
	public class LumberBrain : MonoBehaviour
	{
		private const float StatusLogInterval = 3f;

		private LumberNpc _npc;

		private ZNetView _nview;

		private LumberRuntime _runtime;

		private bool _wasOwner;

		private LumberState _loggedState = LumberState.Idle;

		private float _statusLogTimer;

		private float _idlePlanLogAt;

		private float _inventoryAutosaveTimer;

		private bool _homesteadWasPaused;

		public void Init(LumberNpc npc)
		{
			_npc = npc;
			_nview = ((Component)this).GetComponent<ZNetView>();
			_runtime = new LumberRuntime();
			_runtime.Bind(npc);
			_wasOwner = false;
			_loggedState = LumberState.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 LumberRuntime();
				}
				_runtime.Bind(_npc);
				_runtime.Fsm.Set(LumberState.Evaluate);
				_runtime.ThinkTimer = SyncedConfig.ThinkInterval;
				_runtime.LoggedActive = false;
				_homesteadWasPaused = false;
				if ((Object)(object)_nview != (Object)null && _nview.IsValid() && _nview.IsOwner())
				{
					_wasOwner = true;
				}
			}
		}

		private void Update()
		{
			//IL_0240: 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("LumberBrain ownership lost — flushing inventory then teardown");
					_npc.ForcePersistInventory();
					_runtime?.TearDown();
					_wasOwner = false;
				}
				return;
			}
			if (!_wasOwner)
			{
				Log.Debug("LumberBrain ownership acquired — reset to Evaluate");
				if (_runtime == null)
				{
					_runtime = new LumberRuntime();
				}
				_runtime.Bind(_npc);
				_wasOwner = true;
				_loggedState = LumberState.Evaluate;
				_statusLogTimer = 0f;
			}
			HomesteadData workData = _npc.GetWorkData();
			if (workData == null)
			{
				Log.Warning("LumberBrain: no homestead work data");
				return;
			}
			ReservationManager.Tick();
			if (workData.Paused)
			{
				if (!_homesteadWasPaused || _runtime.Fsm.Current != LumberState.Paused)
				{
					Log.Debug("LumberBrain: homestead paused — stopping");
				}
				_homesteadWasPaused = true;
				_runtime.Fsm.Set(LumberState.Paused);
				_runtime.Nav?.Stop();
				LumberTaskExecutor.AbandonReservation(_npc, _runtime);
				_runtime.LoggedActive = false;
				return;
			}
			if (_homesteadWasPaused)
			{
				_homesteadWasPaused = false;
				_runtime.Fsm.Set(LumberState.Evaluate);
				_runtime.ThinkTimer = SyncedConfig.ThinkInterval;
				Log.Debug("LumberBrain: unpaused — evaluating");
			}
			else if (_runtime.Fsm.Current == LumberState.Paused)
			{
				if (!workData.Paused)
				{
					workData.Paused = true;
				}
				_runtime.Nav?.Stop();
				LumberTaskExecutor.AbandonReservation(_npc, _runtime);
				return;
			}
			if (!_runtime.LoggedActive)
			{
				_runtime.LoggedActive = true;
				Log.Debug($"LumberBrain active slots={workData.Slots?.Count ?? 0} inv={LumberTaskExecutor.DescribeInventory(_npc)} at {((Component)_npc).transform.position}");
			}
			float deltaTime = Time.deltaTime;
			_runtime.ThinkTimer += deltaTime;
			if (_runtime.ThinkTimer >= SyncedConfig.ThinkInterval)
			{
				_runtime.ThinkTimer = 0f;
				Think(workData);
			}
			LumberTaskExecutor.Execute(_npc, _runtime, workData, deltaTime);
			LogStateChanges();
			MaybeLogStatus(deltaTime);
			_inventoryAutosaveTimer += deltaTime;
			if (_inventoryAutosaveTimer >= LumberNpc.InventoryAutosaveInterval)
			{
				_inventoryAutosaveTimer = 0f;
				_npc.ForcePersistInventory();
				Log.Debug("LumberBrain inventory autosave (" + LumberTaskExecutor.DescribeInventory(_npc) + ")");
			}
			if (_runtime.Fsm.Current == LumberState.Blocked)
			{
				_runtime.BlockedTimer += deltaTime;
				if (_runtime.BlockedTimer > 5f)
				{
					_runtime.BlockedTimer = 0f;
					Log.Debug("LumberBrain: blocked timeout — re-evaluating");
					_runtime.Fsm.Set(LumberState.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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: 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_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: 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_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			LumberStateMachine fsm = _runtime.Fsm;
			Navigation nav = _runtime.Nav;
			if (fsm.Current == LumberState.Chop || fsm.Current == LumberState.SmashLog || fsm.Current == LumberState.SmashStump || fsm.Current == LumberState.Deposit || fsm.Current == LumberState.Collect)
			{
				if (nav != null && !nav.IsStuck)
				{
					return;
				}
				if (nav != null && nav.IsStuck)
				{
					Log.Debug($"LumberBrain: stuck in {fsm.Current} — replanning ({LumberTaskExecutor.DescribeTask(_runtime.Task)})");
				}
			}
			Vector3 homesteadPosition = _npc.GetHomesteadPosition();
			LumberTaskExecutor.AbandonReservation(_npc, _runtime);
			_runtime.ResetCombat();
			fsm.Set(LumberState.Evaluate);
			Vector3? chopFocus = (_runtime.HasChopFocus ? new Vector3?(_runtime.LastChopFocus) : ((Vector3?)null));
			PlannedTask plannedTask = TaskPlanner.Plan(data, _npc.Inventory, _npc.ZdoKey, ((Component)_npc).transform.position, homesteadPosition, chopFocus);
			_runtime.Task = plannedTask;
			bool flag = plannedTask.Type == PlannedTaskType.None || plannedTask.Type == PlannedTaskType.ReturnHome;
			if (!flag || Time.time >= _idlePlanLogAt)
			{
				Log.Debug("LumberBrain plan → " + LumberTaskExecutor.DescribeTask(plannedTask) + " | " + LumberTaskExecutor.SummarizeSlots(data) + " | " + LumberTaskExecutor.DescribeInventory(_npc));
				if (flag)
				{
					_idlePlanLogAt = Time.time + 10f;
				}
			}
			switch (plannedTask.Type)
			{
			case PlannedTaskType.Deposit:
				fsm.Set(LumberState.Deposit);
				_runtime.DepositSettled = false;
				nav?.SetDestination(plannedTask.TargetPosition);
				Log.Debug("LumberBrain: deposit → walk to " + LumberTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.Chop:
				fsm.Set(LumberState.Chop);
				nav?.SetDestination(plannedTask.TargetPosition, 5.5f);
				Log.Debug("LumberBrain: chop → " + LumberTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.SmashLog:
				fsm.Set(LumberState.SmashLog);
				nav?.SetDestination(plannedTask.TargetPosition, 5.5f);
				Log.Debug("LumberBrain: smash log → " + LumberTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.SmashStump:
				fsm.Set(LumberState.SmashStump);
				nav?.SetDestination(plannedTask.TargetPosition, 5.5f);
				Log.Debug("LumberBrain: smash stump → " + LumberTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.Collect:
				fsm.Set(LumberState.Collect);
				nav?.SetDestination(plannedTask.TargetPosition, 2.5f);
				Log.Debug("LumberBrain: collecting near " + LumberTaskExecutor.Fmt(plannedTask.TargetPosition));
				break;
			case PlannedTaskType.ReturnHome:
				fsm.Set(LumberState.ReturnHome);
				nav?.SetDestination(plannedTask.TargetPosition);
				if (Time.time >= _idlePlanLogAt)
				{
					Log.Debug("LumberBrain: return home → " + LumberTaskExecutor.Fmt(plannedTask.TargetPosition));
				}
				break;
			default:
				fsm.Set(LumberState.Idle);
				nav?.Clear();
				break;
			}
		}

		private void LogStateChanges()
		{
			LumberState current = _runtime.Fsm.Current;
			if (current != _loggedState)
			{
				Log.Debug($"LumberBrain 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)
			LumberState current = _runtime.Fsm.Current;
			if (current != LumberState.Idle && current != LumberState.Evaluate && current != LumberState.Paused)
			{
				_statusLogTimer += dt;
				if (!(_statusLogTimer < 3f))
				{
					_statusLogTimer = 0f;
					Navigation nav = _runtime.Nav;
					float num = ((nav != null) ? DistToDest(nav) : (-1f));
					Log.Debug($"LumberBrain status: {current} {LumberTaskExecutor.DescribeTask(_runtime.Task)} " + $"pos={LumberTaskExecutor.Fmt(((Component)_npc).transform.position)} destDist={num:F1} " + $"reached={nav?.HasReached} stuck={nav?.IsStuck} | {LumberTaskExecutor.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 LumberState
	{
		Paused,
		Idle,
		Evaluate,
		Chop,
		SmashLog,
		SmashStump,
		Collect,
		Deposit,
		ReturnHome,
		Blocked
	}
	internal class LumberStateMachine
	{
		public LumberState Current { get; private set; } = LumberState.Idle;

		public void Set(LumberState state)
		{
			if (Current != state)
			{
				Current = state;
			}
		}
	}
	internal static class LumberTaskExecutor
	{
		public static void Execute(LumberNpc npc, LumberRuntime runtime, HomesteadData data, float dt)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			LumberStateMachine fsm = runtime.Fsm;
			Navigation nav = runtime.Nav;
			_ = runtime.Task;
			if (runtime.SwingCooldownLeft > 0f)
			{
				runtime.SwingCooldownLeft -= dt;
			}
			TickPendingReplant(npc, runtime, data, dt);
			switch (fsm.Current)
			{
			case LumberState.Paused:
			case LumberState.Idle:
			case LumberState.Evaluate:
				break;
			case LumberState.Chop:
				TickCombat(npc, runtime, data, dt, (Component)(object)runtime.Task?.Tree, "tree");
				break;
			case LumberState.SmashLog:
				TickCombat(npc, runtime, data, dt, (Component)(object)runtime.Task?.Log, "log");
				break;
			case LumberState.SmashStump:
				TickCombat(npc, runtime, data, dt, (Component)(object)runtime.Task?.Stump, "stump");
				break;
			case LumberState.Collect:
				TickCollect(npc, runtime, data, dt);
				break;
			case LumberState.Deposit:
				nav?.Tick(dt);
				if (nav != null && nav.IsStuck)
				{
					FailCurrent(npc, runtime, "stuck depositing");
				}
				else
				{
					if (nav == null || !nav.HasReached || runtime.DepositSettled)
					{
						break;
					}
					runtime.DepositSettled = true;
					Log.Debug("LumberBrain: at chest — depositing");
					Vector3 homesteadPosition = npc.GetHomesteadPosition();
					bool flag = ChestLogistics.HasDepositableSurplus(npc.Inventory, data, homesteadPosition);
					bool blocked;
					bool flag2 = DepositItemsCommand.TryExecute(npc, data, out blocked);
					npc.PersistInventory();
					bool flag3 = ChestLogistics.HasDepositableSurplus(npc.Inventory, data, homesteadPosition);
					if (blocked || (flag && flag3 && !flag2))
					{
						Log.Warning("LumberBrain: chests full — pausing homestead | " + DescribeInventory(npc));
						if (data != null)
						{
							data.Paused = true;
						}
						if ((Object)(object)npc.Homestead != (Object)null)
						{
							npc.Homestead.RequestPauseChestsFull();
						}
						else
						{
							PlayerFeedback.Notify("Chests full — lumberjacks paused. Free space or add a chest, then unpause.");
							npc.BoundSession?.PauseChestsFull();
						}
						fsm.Set(LumberState.Paused);
					}
					else if (!flag2)
					{
						fsm.Set(LumberState.Blocked);
						Log.Warning("LumberBrain: BLOCKED depositing (failed) | " + DescribeInventory(npc));
					}
					else
					{
						Log.Debug($"LumberBrain: deposit done (hadSurplus={flag}) | {DescribeInventory(npc)}");
						fsm.Set(LumberState.Evaluate);
					}
				}
				break;
			case LumberState.ReturnHome:
				nav?.Tick(dt);
				if (nav != null && nav.HasReached)
				{
					Log.Debug("LumberBrain: home reached — idle");
					fsm.Set(LumberState.Idle);
				}
				break;
			case LumberState.Blocked:
				nav?.Stop();
				break;
			}
		}

		private static void TickCollect(LumberNpc npc, LumberRuntime runtime, HomesteadData data, float dt)
		{
			//IL_002a: 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_002f: 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_0074: 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_008b: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			LumberStateMachine fsm = runtime.Fsm;
			Navigation nav = runtime.Nav;
			float num = 14f;
			Vector3 val = (runtime.HasChopFocus ? runtime.LastChopFocus : ((Component)npc).transform.position);
			if (nav != null && !nav.HasReached)
			{
				nav.Tick(dt);
				if (!nav.IsStuck && !nav.HasReached)
				{
					return;
				}
			}
			Log.Debug($"LumberBrain: pickup pass r={num:0} near {Fmt(val)}");
			int destroyed;
			int num2 = WorldDropCollector.PickupNearbyDrops(npc.Inventory, val, num, data, out destroyed);
			if (Vector3.Distance(((Component)npc).transform.position, val) > 1f)
			{
				num2 += WorldDropCollector.PickupNearbyDrops(npc.Inventory, ((Component)npc).transform.position, num, data, out destroyed);
			}
			if (num2 > 0)
			{
				npc.PersistInventory();
			}
			if (!WorldDropCollector.HasPickupableDrops(val, num) && !WorldDropCollector.HasPickupableDrops(((Component)npc).transform.position, num))
			{
				runtime.ClearChopFocus();
			}
			fsm.Set(LumberState.Evaluate);
		}

		private static void TickCombat(LumberNpc npc, LumberRuntime runtime, HomesteadData data, float dt, Component target, string kind)
		{
			//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)
			//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_0032: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			Navigation nav = runtime.Nav;
			if ((Object)(object)target == (Object)null || !Object.op_Implicit((Object)(object)target))
			{
				if (kind == "stump" && runtime.HasChopFocus)
				{
					ScheduleReplant(runtime, runtime.LastChopFocus);
				}
				runtime.ResetCombat();
				runtime.Fsm.Set(LumberState.Evaluate);
				return;
			}
			Vector3 val = (runtime.LastChopFocus = target.transform.position);
			runtime.HasChopFocus = true;
			if (nav != null && !nav.HasReached)
			{
				nav.Tick(dt);
				if (nav.IsStuck)
				{
					FailCurrent(npc, runtime, "stuck approaching " + kind);
				}
				return;
			}
			nav?.Stop();
			LumberAttackCommand.FaceTarget(npc, val);
			if (runtime.SwingPendingHit)
			{
				runtime.SwingWindupLeft -= dt;
				if (runtime.SwingWindupLeft > 0f)
				{
					return;
				}
				Vector3 hitPoint = LumberAttackCommand.HitPointFor(target);
				bool num = LumberAttackCommand.TryDamageDestructible(npc, target, hitPoint);
				runtime.SwingPendingHit = false;
				runtime.SwingCooldownLeft = 1.6f;
				Log.Debug(num ? ("LumberBrain: swing hit " + kind + " " + ((Object)target).name) : ("LumberBrain: swing missed " + ((Object)target).name));
				if ((Object)(object)target == (Object)null || !Object.op_Implicit((Object)(object)target))
				{
					if (kind == "stump")
					{
						ScheduleReplant(runtime, val);
					}
					runtime.ResetCombat();
					runtime.Fsm.Set(LumberState.Evaluate);
				}
			}
			else if (!(runtime.SwingCooldownLeft > 0f) && !LumberAttackCommand.IsInAttack(npc))
			{
				if (LumberAttackCommand.TryStartSwing(npc, val))
				{
					runtime.SwingPendingHit = true;
					runtime.SwingWindupLeft = 0.85f;
					Log.Debug("LumberBrain: started swing at " + kind + " " + ((Object)target).name);
				}
				else
				{
					runtime.SwingPendingHit = true;
					runtime.SwingWindupLeft = 0.85f;
					Log.Debug("LumberBrain: StartAttack unavailable — timed chop to " + kind + " " + ((Object)target).name);
				}
			}
		}

		private static void ScheduleReplant(LumberRuntime runtime, Vector3 stumpPos)
		{
			//IL_0005: 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)
			if (runtime != null)
			{
				runtime.ScheduleReplant(stumpPos, 1.25f);
				Log.Debug($"LumberBrain: stump cleared — replant in {1.25f:0.00}s at {Fmt(stumpPos)}");
			}
		}

		private static void TickPendingReplant(LumberNpc npc, LumberRuntime runtime, HomesteadData data, float dt)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			if (runtime != null && runtime.HasPendingReplant)
			{
				runtime.ReplantDelayLeft -= dt;
				if (!(runtime.ReplantDelayLeft > 0f))
				{
					Vector3 pendingReplantPos = runtime.PendingReplantPos;
					runtime.ClearPendingReplant();
					TryReplantAt(npc, data, pendingReplantPos);
				}
			}
		}

		private static void TryReplantAt(LumberNpc npc, HomesteadData data, Vector3 stumpPos)
		{
			//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)
			if (PlantSaplingCommand.TryReplantAfterStump(npc, data, stumpPos))
			{
				Log.Debug("LumberBrain: replanted sapling at " + Fmt(stumpPos));
			}
		}

		public static void FailCurrent(LumberNpc npc, LumberRuntime runtime, string reason)
		{
			Log.Warning("LumberBrain: TASK FAILED — " + reason + " | was " + DescribeTask(runtime.Task) + " | " + DescribeInventory(npc));
			AbandonReservation(npc, runtime);
			runtime.ResetCombat();
			runtime.Fsm.Set(LumberState.Evaluate);
			runtime.Nav?.Clear();
		}

		public static void AbandonReservation(LumberNpc npc, LumberRuntime runtime)
		{
			ReleaseReservation(npc, runtime);
		}

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

		public static string DescribeInventory(LumberNpc 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (task == null || task.Type == PlannedTaskType.None)
			{
				return "task=None";
			}
			string text = (((Object)(object)task.Tree != (Object)null) ? (" tree=" + ((Object)task.Tree).name) : "");
			string text2 = (((Object)(object)task.Log != (Object)null) ? (" log=" + ((Object)task.Log).name) : "");
			string text3 = (((Object)(object)task.Stump != (Object)null) ? (" stump=" + ((Object)task.Stump).name) : "");
			return $"task={task.Type}{text}{text2}{text3} dest={Fmt(task.TargetPosition)}";
		}

		public static string SummarizeSlots(HomesteadData data)
		{
			return $"chests={(data?.ChestPositions?.Count).GetValueOrDefault()}";
		}

		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})";
		}
	}
	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 LumberNpc _npc;

		private readonly Character _character;

		private readonly BaseAI _baseAi;

		private Vector3 _destination;

		private float _stuckTimer;

		private float _lastGoalDist = float.MaxValue;

		private bool _hasDestination;

		private float _reachDistance;

		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(LumberNpc npc)
		{
			_npc = npc;
			_character = (((Object)(object)npc != (Object)null) ? npc.Character : null);
			_baseAi = (((Object)(object)npc != (Object)null) ? ((Component)npc).GetComponent<BaseAI>() : null);
			_reachDistance = SyncedConfig.WorkRange;
		}

		public void SetDestination(Vector3 dest, float? reachDistance = null)
		{
			//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;
			_reachDistance = reachDistance ?? SyncedConfig.WorkRange;
			_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_0070: 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_00cb: 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 (!_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 <= _reachDistance)
			{
				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<LumberNpc> readOnlyList = LumberRoster.AllCached();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				LumberNpc lumberNpc = readOnlyList[i];
				if (!((Object)(object)lumberNpc == (Object)null) && lumberNpc != _npc)
				{
					float num2 = ((Component)lumberNpc).transform.position.x - pos.x;
					float num3 = ((Component)lumberNpc).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,
		Chop,
		SmashLog,
		SmashStump,
		Collect,
		ReturnHome
	}
	internal class PlannedTask
	{
		public PlannedTaskType Type;

		public TreeBase Tree;

		public TreeLog Log;

		public Destructible Stump;

		public Vector3 TargetPosition;
	}
	internal static class TaskPlanner
	{
		private const float LogSearchRadius = 12f;

		private const float StumpSearchRadius = 14f;

		public static PlannedTask Plan(HomesteadData data, InventoryManager inventory, long lumberKey, Vector3 lumberPos, Vector3 homePos, Vector3? chopFocus = null)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_00a3: 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_00d2: 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_0092: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.None
				};
			}
			if (inventory.IsNearlyFull && ChestLogistics.HasDepositableSurplus(inventory, data, homePos))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Deposit,
					TargetPosition = (FindNearestChest(data, lumberPos) ?? homePos)
				};
			}
			float radius = 14f;
			if (WorldDropCollector.HasPickupableDrops(lumberPos, radius))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Collect,
					TargetPosition = lumberPos
				};
			}
			if (chopFocus.HasValue && WorldDropCollector.HasPickupableDrops(chopFocus.Value, radius))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Collect,
					TargetPosition = chopFocus.Value
				};
			}
			if (TreeLogFinder.TryFindNearestLog(lumberPos, 12f, lumberPos, out var log))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.SmashLog,
					Log = log,
					TargetPosition = ((Component)log).transform.position
				};
			}
			if (TryFindStump(lumberPos, chopFocus, out var stump))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.SmashStump,
					Stump = stump,
					TargetPosition = ((Component)stump).transform.position
				};
			}
			float radius2 = TreeFinder.ResolveWorkRadius(data.GetWorkRadius());
			if (TreeFinder.TryFindBestTree(data, homePos, radius2, lumberPos, out var tree))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Chop,
					Tree = tree,
					TargetPosition = ((Component)tree).transform.position
				};
			}
			if (inventory.UsedSlots > 0 && ChestLogistics.HasDepositableSurplus(inventory, data, homePos))
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.Deposit,
					TargetPosition = (FindNearestChest(data, lumberPos) ?? homePos)
				};
			}
			if (Vector3.Distance(lumberPos, homePos) > 3f)
			{
				return new PlannedTask
				{
					Type = PlannedTaskType.ReturnHome,
					TargetPosition = homePos
				};
			}
			return new PlannedTask
			{
				Type = PlannedTaskType.None,
				TargetPosition = homePos
			};
		}

		private static bool TryFindStump(Vector3 lumberPos, Vector3? chopFocus, out Destructible stump)
		{
			//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_001c: 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)
			if (TreeStumpFinder.TryFindNearestStump(lumberPos, 14f, lumberPos, out stump))
			{
				return true;
			}
			if (chopFocus.HasValue && TreeStumpFinder.TryFindNearestStump(chopFocus.Value, 14f, lumberPos, out stump))
			{
				return true;
			}
			stump = null;
			return false;
		}

		private static Vector3? FindNearestChest(HomesteadData data, Vector3 from)
		{
			//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_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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (data?.ChestPositions == null || data.ChestPositions.Count == 0)
			{
				return null;
			}
			Vector3? result = null;
			float num = float.MaxValue;
			for (int i = 0; i < data.ChestPositions.Count; i++)
			{
				Vector3 position = data.ChestPositions[i].Position;
				float num2 = Vector3.Distance(from, position);
				if (num2 < num)
				{
					num = num2;
					result = position;
				}
			}
			return result;
		}
	}
}