using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("GreydwarfWorkers")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("GreydwarfWorkers")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5fe28502-d2ff-414f-a3ea-6261dfdcc2e4")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace GreydwarfWorkers;

public enum GatherResourceType
{
	Wood,
	Stone,
	Coal,
	Iron,
	FineWood,
	CoreWood,
	Copper,
	Tin,
	Silver,
	BlackMetal
}
public class GatherResourceDefinition
{
	public GatherResourceType Type { get; }

	public string ItemName { get; }

	public string DisplayName { get; }

	public GatherResourceDefinition(GatherResourceType type, string itemName, string displayName)
	{
		Type = type;
		ItemName = itemName;
		DisplayName = displayName;
	}
}
public class GreydwarfWorkerUI : MonoBehaviour
{
	private enum WorkerJob
	{
		Gathering,
		RefuelSmelter,
		PutOreInSmelter,
		RefuelLightsources,
		RefuelCharcoalKiln,
		DropInventory
	}

	private GameObject m_panel;

	private GameObject m_workerList;

	private GameObject m_inventoryPanel;

	private GameObject m_inventoryList;

	private GameObject m_jobPanel;

	private GameObject m_jobList;

	private ScrollRect m_workerScrollRect;

	private GreydwarfWorker m_selectedWorker;

	private GreydwarfWorkersPlugin m_plugin;

	private float m_inventoryRefreshTimer = 0f;

	private Text m_jobStatusText;

	private Text m_gatherResourceText;

	private const float PanelWidth = 700f;

	private const float PanelHeight = 600f;

	private const float InventoryPanelWidth = 600f;

	private const float InventoryPanelHeight = 550f;

	private const float InventoryRefreshInterval = 0.25f;

	private const float RowHeight = 60f;

	private const float RowSpacing = 10f;

	private const float JobPanelWidth = 600f;

	private const float JobPanelHeight = 620f;

	private const float JobButtonHeight = 50f;

	private const float JobButtonSpacing = 12f;

	private readonly Dictionary<string, Text> m_inventoryAmountTexts = new Dictionary<string, Text>();

	public static bool IsOpen { get; private set; }

	private void Awake()
	{
	}

	private void Update()
	{
		if ((Object)(object)m_jobPanel != (Object)null && m_jobPanel.activeSelf)
		{
			UpdateGatherResourceButton();
			RefreshJobStatus();
		}
		if ((Object)(object)m_inventoryPanel != (Object)null && m_inventoryPanel.activeSelf)
		{
			m_inventoryRefreshTimer += Time.deltaTime;
			if (m_inventoryRefreshTimer >= 0.25f)
			{
				m_inventoryRefreshTimer = 0f;
				UpdateInventoryAmounts();
			}
		}
		if (Input.GetKeyDown((KeyCode)27))
		{
			if ((Object)(object)m_jobPanel != (Object)null && m_jobPanel.activeSelf)
			{
				CloseJobMenu();
			}
			else if ((Object)(object)m_inventoryPanel != (Object)null && m_inventoryPanel.activeSelf)
			{
				CloseInventory();
			}
			else if ((Object)(object)m_panel != (Object)null && m_panel.activeSelf)
			{
				Close();
			}
		}
	}

	public void Initialize(GreydwarfWorkersPlugin plugin)
	{
		m_plugin = plugin;
	}

	public void Toggle()
	{
		if ((Object)(object)m_jobPanel != (Object)null && m_jobPanel.activeSelf)
		{
			CloseJobMenu();
			return;
		}
		if ((Object)(object)m_inventoryPanel != (Object)null && m_inventoryPanel.activeSelf)
		{
			CloseInventory();
			return;
		}
		if ((Object)(object)m_panel == (Object)null)
		{
			CreateUI();
		}
		if (!((Object)(object)m_panel == (Object)null))
		{
			bool flag = !m_panel.activeSelf;
			if (flag)
			{
				RefreshWorkerList();
			}
			m_panel.SetActive(flag);
			IsOpen = flag;
		}
	}

	public void Close()
	{
		if ((Object)(object)m_inventoryPanel != (Object)null)
		{
			m_inventoryPanel.SetActive(false);
		}
		if ((Object)(object)m_panel != (Object)null)
		{
			m_panel.SetActive(false);
			IsOpen = false;
		}
		if ((Object)(object)m_jobPanel != (Object)null)
		{
			m_jobPanel.SetActive(false);
		}
		m_selectedWorker = null;
	}

	private void CreateUI()
	{
		//IL_006e: 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_008c: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)m_panel != (Object)null))
		{
			if (GUIManager.Instance == null)
			{
				Debug.LogError((object)"[Greydwarf Workers] GUIManager is not available.");
				return;
			}
			if ((Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				Debug.LogError((object)"[Greydwarf Workers] CustomGUIFront is not available.");
				return;
			}
			m_panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 700f, 600f, true);
			((Object)m_panel).name = "GreydwarfWorkerPanel";
			CreateTitle();
			CreateCloseButton();
			CreateWorkerList();
			CreateInventoryPanel();
			CreateJobPanel();
			m_panel.SetActive(false);
		}
	}

	private void CreateTitle()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: 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)
		GUIManager.Instance.CreateText("GREYDWARF WORKERS", m_panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -45f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 500f, 45f, false);
	}

	private void CreateCloseButton()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Expected O, but got Unknown
		GameObject val = GUIManager.Instance.CreateButton("X", m_panel.transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-35f, -35f), 50f, 50f);
		((Object)val).name = "GreydwarfWorkerCloseButton";
		Button component = val.GetComponent<Button>();
		if ((Object)(object)component != (Object)null)
		{
			((UnityEvent)component.onClick).AddListener(new UnityAction(Close));
		}
	}

	private void CreateWorkerList()
	{
		//IL_0022: 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_006e: 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_00bb: 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_01c7: 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)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = GUIManager.Instance.CreateScrollView(m_panel.transform, false, true, 12f, 5f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.15f), 640f, 470f);
		((Object)val).name = "GreydwarfWorkerScrollView";
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchoredPosition = new Vector2(0f, -20f);
		m_workerScrollRect = val.GetComponentInChildren<ScrollRect>(true);
		Scrollbar verticalScrollbar = m_workerScrollRect.verticalScrollbar;
		if ((Object)(object)verticalScrollbar != (Object)null)
		{
			RectTransform component2 = ((Component)verticalScrollbar).GetComponent<RectTransform>();
			component2.anchoredPosition = new Vector2(3f, component2.anchoredPosition.y);
		}
		if ((Object)(object)m_workerScrollRect == (Object)null || (Object)(object)m_workerScrollRect.content == (Object)null)
		{
			Debug.LogError((object)"[Greydwarf Workers] Failed to create worker scroll view.");
			return;
		}
		m_workerScrollRect.horizontal = false;
		m_workerScrollRect.vertical = true;
		m_workerScrollRect.movementType = (MovementType)2;
		m_workerScrollRect.scrollSensitivity = 35f;
		m_workerList = ((Component)m_workerScrollRect.content).gameObject;
		VerticalLayoutGroup component3 = m_workerList.GetComponent<VerticalLayoutGroup>();
		if ((Object)(object)component3 != (Object)null)
		{
			((Behaviour)component3).enabled = false;
		}
		ContentSizeFitter component4 = m_workerList.GetComponent<ContentSizeFitter>();
		if ((Object)(object)component4 != (Object)null)
		{
			((Behaviour)component4).enabled = false;
		}
		RectTransform component5 = m_workerList.GetComponent<RectTransform>();
		component5.anchorMin = new Vector2(0.5f, 0.5f);
		component5.anchorMax = new Vector2(0.5f, 0.5f);
		component5.pivot = new Vector2(0.5f, 0.5f);
		component5.anchoredPosition = Vector2.zero;
		component5.sizeDelta = new Vector2(640f, 470f);
	}

	private void RefreshWorkerList()
	{
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: 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_01e5: 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)
		if ((Object)(object)m_workerList == (Object)null)
		{
			return;
		}
		ClearWorkerList();
		List<Character> allCharacters = Character.GetAllCharacters();
		List<GreydwarfWorker> list = new List<GreydwarfWorker>();
		foreach (Character item in allCharacters)
		{
			if ((Object)(object)item == (Object)null || !((Object)item).name.Contains("Greydwarf"))
			{
				continue;
			}
			Tameable component = ((Component)item).GetComponent<Tameable>();
			if (!((Object)(object)component == (Object)null) && component.IsTamed())
			{
				GreydwarfWorker component2 = ((Component)item).GetComponent<GreydwarfWorker>();
				if (!((Object)(object)component2 == (Object)null))
				{
					list.Add(component2);
				}
			}
		}
		list.Sort(delegate(GreydwarfWorker a, GreydwarfWorker b)
		{
			Character component4 = ((Component)a).GetComponent<Character>();
			Character component5 = ((Component)b).GetComponent<Character>();
			string x = (((Object)(object)component4 != (Object)null) ? component4.GetHoverName() : "Greydwarf");
			string y = (((Object)(object)component5 != (Object)null) ? component5.GetHoverName() : "Greydwarf");
			return StringComparer.OrdinalIgnoreCase.Compare(x, y);
		});
		float num = (float)list.Count * 70f;
		float num2 = 470f;
		float num3 = Mathf.Max(num2, num);
		RectTransform component3 = m_workerList.GetComponent<RectTransform>();
		component3.sizeDelta = new Vector2(640f, num3);
		float num4 = num * 0.5f - 30f;
		for (int num5 = 0; num5 < list.Count; num5++)
		{
			CreateWorkerRow(list[num5], num4 - (float)num5 * 70f);
		}
		if (list.Count == 0)
		{
			GUIManager.Instance.CreateText("No tamed Greydwarves found.", m_workerList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), GUIManager.Instance.AveriaSerif, 22, Color.white, true, Color.black, 500f, 40f, false);
		}
		if ((Object)(object)m_workerScrollRect != (Object)null)
		{
			m_workerScrollRect.verticalNormalizedPosition = 1f;
		}
	}

	private void CreateWorkerRow(GreydwarfWorker worker, float yPosition)
	{
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Expected O, but got Unknown
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: 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_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: 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_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_023f: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_025f: 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_0296: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_033c: Unknown result type (might be due to invalid IL or missing references)
		//IL_034b: Unknown result type (might be due to invalid IL or missing references)
		//IL_035a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0315: Unknown result type (might be due to invalid IL or missing references)
		//IL_031f: Expected O, but got Unknown
		//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c5: Expected O, but got Unknown
		Character component = ((Component)worker).GetComponent<Character>();
		string text = (((Object)(object)component != (Object)null) ? component.GetHoverName() : "Greydwarf");
		string text2 = (((Object)(object)component != (Object)null) ? $"{component.GetHealth():0} / {component.GetMaxHealth():0}" : "0 / 0");
		string text3;
		if (worker.IsWorking)
		{
			text3 = "Working";
		}
		else
		{
			MonsterAI val = (((Object)(object)component != (Object)null) ? ((Component)component).GetComponent<MonsterAI>() : null);
			text3 = ((!((Object)(object)val != (Object)null) || !((Object)(object)val.GetFollowTarget() != (Object)null)) ? "Inactive" : "Following");
		}
		GameObject val2 = new GameObject("GreydwarfWorkerRow");
		val2.transform.SetParent(m_workerList.transform, false);
		RectTransform val3 = val2.AddComponent<RectTransform>();
		val3.anchorMin = new Vector2(0.5f, 0.5f);
		val3.anchorMax = new Vector2(0.5f, 0.5f);
		val3.pivot = new Vector2(0.5f, 0.5f);
		val3.anchoredPosition = new Vector2(0f, yPosition);
		val3.sizeDelta = new Vector2(620f, 60f);
		GUIManager.Instance.CreateText(text, val2.transform, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(140f, 0f), GUIManager.Instance.AveriaSerifBold, 22, Color.white, true, Color.black, 220f, 35f, false);
		GUIManager.Instance.CreateText("HP: " + text2, val2.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-40f, 10f), GUIManager.Instance.AveriaSerif, 18, Color.white, true, Color.black, 180f, 30f, false);
		GUIManager.Instance.CreateText(text3, val2.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-40f, -12f), GUIManager.Instance.AveriaSerif, 17, Color.white, true, Color.black, 180f, 28f, false);
		GameObject val4 = GUIManager.Instance.CreateButton("Inventory", val2.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-210f, 0f), 140f, 45f);
		((Object)val4).name = "GreydwarfInventoryButton";
		Button component2 = val4.GetComponent<Button>();
		if ((Object)(object)component2 != (Object)null)
		{
			GreydwarfWorker selectedWorker = worker;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				OpenInventory(selectedWorker);
			});
		}
		GameObject val5 = GUIManager.Instance.CreateButton("Job", val2.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-60f, 0f), 100f, 45f);
		((Object)val5).name = "GreydwarfJobButton";
		Button component3 = val5.GetComponent<Button>();
		if ((Object)(object)component3 != (Object)null)
		{
			GreydwarfWorker selectedWorker2 = worker;
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				OpenJobMenu(selectedWorker2);
			});
		}
	}

	private void OpenJobMenu(GreydwarfWorker worker)
	{
		if ((Object)(object)worker == (Object)null || (Object)(object)m_jobPanel == (Object)null)
		{
			return;
		}
		m_selectedWorker = worker;
		UpdateGatherResourceButton();
		RefreshJobStatus();
		Character component = ((Component)worker).GetComponent<Character>();
		string text = (((Object)(object)component != (Object)null) ? component.GetHoverName() : "Greydwarf");
		Transform val = m_jobPanel.transform.Find("GreydwarfJobTitle");
		if ((Object)(object)val != (Object)null)
		{
			Text component2 = ((Component)val).GetComponent<Text>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.text = text + "'s JOBS";
			}
		}
		m_panel.SetActive(false);
		m_jobPanel.SetActive(true);
	}

	private void CloseJobMenu()
	{
		if ((Object)(object)m_jobPanel != (Object)null)
		{
			m_jobPanel.SetActive(false);
		}
		m_selectedWorker = null;
		if ((Object)(object)m_panel != (Object)null)
		{
			m_panel.SetActive(true);
			RefreshWorkerList();
		}
	}

	private void OnJobSelected(WorkerJob job)
	{
		if ((Object)(object)m_selectedWorker == (Object)null)
		{
			return;
		}
		if ((Object)(object)m_plugin == (Object)null)
		{
			Debug.LogError((object)"[Greydwarf Workers] Plugin reference is missing.");
			return;
		}
		if (job != WorkerJob.DropInventory)
		{
			StopSelectedWorker();
		}
		switch (job)
		{
		case WorkerJob.Gathering:
			m_plugin.StartGathering(m_selectedWorker);
			break;
		case WorkerJob.RefuelSmelter:
			m_plugin.RefuelSmelter(m_selectedWorker);
			break;
		case WorkerJob.PutOreInSmelter:
			m_plugin.PutOreInSmelter(m_selectedWorker);
			break;
		case WorkerJob.RefuelLightsources:
			m_plugin.RefuelLightsources(m_selectedWorker);
			break;
		case WorkerJob.RefuelCharcoalKiln:
			m_plugin.RefuelCharcoalKiln(m_selectedWorker);
			break;
		case WorkerJob.DropInventory:
			m_plugin.DropInventory(m_selectedWorker);
			break;
		}
		CloseJobMenu();
	}

	private void CreateInventoryPanel()
	{
		//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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: 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_00b7: 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_00fe: 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_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Expected O, but got Unknown
		//IL_01af: 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_01db: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Expected O, but got Unknown
		m_inventoryPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 600f, 550f, true);
		((Object)m_inventoryPanel).name = "GreydwarfInventoryPanel";
		GameObject val = GUIManager.Instance.CreateText("INVENTORY", m_inventoryPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -45f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 45f, false);
		((Object)val).name = "GreydwarfInventoryTitle";
		GameObject val2 = GUIManager.Instance.CreateButton("X", m_inventoryPanel.transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-35f, -35f), 50f, 50f);
		((Object)val2).name = "GreydwarfInventoryCloseButton";
		Button component = val2.GetComponent<Button>();
		if ((Object)(object)component != (Object)null)
		{
			((UnityEvent)component.onClick).AddListener(new UnityAction(CloseInventory));
		}
		m_inventoryList = new GameObject("GreydwarfInventoryList");
		m_inventoryList.transform.SetParent(m_inventoryPanel.transform, false);
		RectTransform val3 = m_inventoryList.AddComponent<RectTransform>();
		val3.anchorMin = new Vector2(0.5f, 0.5f);
		val3.anchorMax = new Vector2(0.5f, 0.5f);
		val3.pivot = new Vector2(0.5f, 0.5f);
		val3.anchoredPosition = new Vector2(0f, -15f);
		val3.sizeDelta = new Vector2(520f, 420f);
		m_inventoryPanel.SetActive(false);
	}

	private void OpenInventory(GreydwarfWorker worker)
	{
		if (!((Object)(object)worker == (Object)null) && !((Object)(object)m_inventoryPanel == (Object)null))
		{
			m_selectedWorker = worker;
			m_inventoryRefreshTimer = 0f;
			RefreshInventory();
			m_panel.SetActive(false);
			m_inventoryPanel.SetActive(true);
		}
	}

	private void RefreshInventory()
	{
		//IL_00e8: 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_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_inventoryList == (Object)null || (Object)(object)m_selectedWorker == (Object)null)
		{
			return;
		}
		ClearInventoryList();
		Character component = ((Component)m_selectedWorker).GetComponent<Character>();
		string text = (((Object)(object)component != (Object)null) ? component.GetHoverName() : "Greydwarf");
		Transform val = m_inventoryPanel.transform.Find("GreydwarfInventoryTitle");
		if ((Object)(object)val != (Object)null)
		{
			Text component2 = ((Component)val).GetComponent<Text>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.text = text + "'s INVENTORY";
			}
		}
		WorkerInventory component3 = ((Component)m_selectedWorker).GetComponent<WorkerInventory>();
		if ((Object)(object)component3 == (Object)null || component3.IsEmpty())
		{
			GUIManager.Instance.CreateText("Inventory is empty.", m_inventoryList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), GUIManager.Instance.AveriaSerif, 22, Color.white, true, Color.black, 450f, 40f, false);
			return;
		}
		Dictionary<string, int> allItems = component3.GetAllItems();
		float num = (float)allItems.Count * 70f;
		float num2 = num * 0.5f - 30f;
		int num3 = 0;
		foreach (KeyValuePair<string, int> item in allItems)
		{
			CreateInventoryRow(component3, item.Key, item.Value, num2 - (float)num3 * 70f);
			num3++;
		}
	}

	private void CreateInventoryRow(WorkerInventory inventory, string itemName, int amount, float yPosition)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//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_0062: 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_008b: 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_00cb: 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_00eb: 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_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("GreydwarfInventoryRow");
		val.transform.SetParent(m_inventoryList.transform, false);
		RectTransform val2 = val.AddComponent<RectTransform>();
		val2.anchorMin = new Vector2(0.5f, 0.5f);
		val2.anchorMax = new Vector2(0.5f, 0.5f);
		val2.pivot = new Vector2(0.5f, 0.5f);
		val2.anchoredPosition = new Vector2(0f, yPosition);
		val2.sizeDelta = new Vector2(500f, 60f);
		string displayItemName = GetDisplayItemName(itemName);
		int capacity = inventory.GetCapacity(itemName);
		GUIManager.Instance.CreateText(displayItemName, val.transform, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(120f, 0f), GUIManager.Instance.AveriaSerifBold, 21, Color.white, true, Color.black, 250f, 35f, false);
		GameObject val3 = GUIManager.Instance.CreateText(amount + " / " + capacity, val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-80f, 0f), GUIManager.Instance.AveriaSerif, 21, Color.white, true, Color.black, 150f, 35f, false);
		Text component = val3.GetComponent<Text>();
		if ((Object)(object)component != (Object)null)
		{
			m_inventoryAmountTexts[itemName] = component;
		}
	}

	private void CreateJobPanel()
	{
		//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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: 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_00b7: 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_00fe: 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_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_019a: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Expected O, but got Unknown
		//IL_0223: Unknown result type (might be due to invalid IL or missing references)
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		//IL_024f: 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_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Expected O, but got Unknown
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		//IL_0351: Unknown result type (might be due to invalid IL or missing references)
		//IL_0360: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b3: Expected O, but got Unknown
		m_jobPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 600f, 620f, true);
		((Object)m_jobPanel).name = "GreydwarfJobPanel";
		GameObject val = GUIManager.Instance.CreateText("JOBS", m_jobPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -45f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 45f, false);
		((Object)val).name = "GreydwarfJobTitle";
		GameObject val2 = GUIManager.Instance.CreateButton("X", m_jobPanel.transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-35f, -35f), 50f, 50f);
		((Object)val2).name = "GreydwarfJobCloseButton";
		Button component = val2.GetComponent<Button>();
		if ((Object)(object)component != (Object)null)
		{
			((UnityEvent)component.onClick).AddListener(new UnityAction(CloseJobMenu));
		}
		m_jobStatusText = GUIManager.Instance.CreateText("Current Job: Inactive", m_jobPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -95f), GUIManager.Instance.AveriaSerif, 20, Color.white, true, Color.black, 500f, 35f, false).GetComponent<Text>();
		m_jobList = new GameObject("GreydwarfJobList");
		m_jobList.transform.SetParent(m_jobPanel.transform, false);
		RectTransform val3 = m_jobList.AddComponent<RectTransform>();
		val3.anchorMin = new Vector2(0.5f, 0.5f);
		val3.anchorMax = new Vector2(0.5f, 0.5f);
		val3.pivot = new Vector2(0.5f, 0.5f);
		val3.anchoredPosition = new Vector2(0f, -50f);
		val3.sizeDelta = new Vector2(520f, 490f);
		string[] array = new string[5] { "Refuel Smelter", "Put Ore in Smelter", "Refuel Lightsources", "Refuel Charcoal Kiln", "Drop Inventory" };
		WorkerJob[] array2 = new WorkerJob[5]
		{
			WorkerJob.RefuelSmelter,
			WorkerJob.PutOreInSmelter,
			WorkerJob.RefuelLightsources,
			WorkerJob.RefuelCharcoalKiln,
			WorkerJob.DropInventory
		};
		float num = 372f;
		float num2 = num * 0.5f - 25f;
		CreateGatheringRow(num2);
		for (int i = 0; i < array.Length; i++)
		{
			CreateJobButton(array[i], array2[i], num2 - (float)(i + 1) * 62f);
		}
		GameObject val4 = GUIManager.Instance.CreateButton("Stop Working", m_jobPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 40f), 250f, 50f);
		((Object)val4).name = "GreydwarfStopWorkingButton";
		Button component2 = val4.GetComponent<Button>();
		if ((Object)(object)component2 != (Object)null)
		{
			((UnityEvent)component2.onClick).AddListener(new UnityAction(StopSelectedWorker));
		}
		m_jobPanel.SetActive(false);
	}

	private void UpdateGatherResourceButton()
	{
		if (!((Object)(object)m_gatherResourceText == (Object)null) && !((Object)(object)m_selectedWorker == (Object)null))
		{
			m_gatherResourceText.text = m_selectedWorker.GetCurrentResourceDefinition().DisplayName;
		}
	}

	private void PreviousSelectedWorkerResource()
	{
		if (!((Object)(object)m_selectedWorker == (Object)null))
		{
			m_selectedWorker.PreviousGatherResource();
			UpdateGatherResourceButton();
			RefreshJobStatus();
		}
	}

	private void NextSelectedWorkerResource()
	{
		if (!((Object)(object)m_selectedWorker == (Object)null))
		{
			m_selectedWorker.NextGatherResource();
			UpdateGatherResourceButton();
			RefreshJobStatus();
		}
	}

	private void StopSelectedWorker()
	{
		if (!((Object)(object)m_selectedWorker == (Object)null))
		{
			m_selectedWorker.SetState(GreydwarfWorker.WorkerState.Inactive);
			RefreshJobStatus();
		}
	}

	private string GetCurrentJobText()
	{
		if ((Object)(object)m_selectedWorker == (Object)null)
		{
			return "Current Job: Inactive";
		}
		switch (m_selectedWorker.CurrentState)
		{
		case GreydwarfWorker.WorkerState.Gathering:
		case GreydwarfWorker.WorkerState.MovingToResource:
		case GreydwarfWorker.WorkerState.SearchingForChest:
		case GreydwarfWorker.WorkerState.MovingToChest:
		case GreydwarfWorker.WorkerState.WaitingForChest:
			return "Current Job: Gathering " + m_selectedWorker.GetCurrentResourceDefinition().DisplayName;
		case GreydwarfWorker.WorkerState.SearchingForSupplyChest:
		case GreydwarfWorker.WorkerState.MovingToSupplyChest:
		case GreydwarfWorker.WorkerState.RetrievingFromChest:
		case GreydwarfWorker.WorkerState.SearchingForSmelter:
		case GreydwarfWorker.WorkerState.MovingToSmelter:
		case GreydwarfWorker.WorkerState.DepositingToSmelter:
		case GreydwarfWorker.WorkerState.WaitingForSmelter:
			return "Current Job: Refuel Smelter";
		case GreydwarfWorker.WorkerState.SearchingForOreChest:
		case GreydwarfWorker.WorkerState.MovingToOreChest:
		case GreydwarfWorker.WorkerState.RetrievingOreFromChest:
		case GreydwarfWorker.WorkerState.SearchingForOreSmelter:
		case GreydwarfWorker.WorkerState.MovingToOreSmelter:
		case GreydwarfWorker.WorkerState.DepositingOreToSmelter:
		case GreydwarfWorker.WorkerState.WaitingForOreSmelter:
			return "Current Job: Put Ore in Smelter";
		case GreydwarfWorker.WorkerState.SearchingForFireplace:
		case GreydwarfWorker.WorkerState.MovingToFireplace:
		case GreydwarfWorker.WorkerState.SearchingForFireplaceFuel:
		case GreydwarfWorker.WorkerState.MovingToFireplaceFuelChest:
		case GreydwarfWorker.WorkerState.RetrievingFireplaceFuel:
		case GreydwarfWorker.WorkerState.MovingToFireplaceWithFuel:
		case GreydwarfWorker.WorkerState.DepositingToFireplace:
		case GreydwarfWorker.WorkerState.WaitingForFireplace:
			return "Current Job: Refuel Lightsources";
		case GreydwarfWorker.WorkerState.SearchingForKiln:
		case GreydwarfWorker.WorkerState.MovingToKiln:
		case GreydwarfWorker.WorkerState.DepositingToKiln:
		case GreydwarfWorker.WorkerState.WaitingForKiln:
		case GreydwarfWorker.WorkerState.SearchingForKilnChest:
		case GreydwarfWorker.WorkerState.MovingToKilnChest:
		case GreydwarfWorker.WorkerState.RetrievingKilnMaterial:
			return "Current Job: Refuel Charcoal Kiln";
		default:
			return "Current Job: Inactive";
		}
	}

	private void RefreshJobStatus()
	{
		if (!((Object)(object)m_jobStatusText == (Object)null))
		{
			m_jobStatusText.text = GetCurrentJobText();
		}
	}

	private void CreateJobButton(string jobName, WorkerJob job, float yPosition)
	{
		//IL_001c: 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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Expected O, but got Unknown
		GameObject val = GUIManager.Instance.CreateButton(jobName, m_jobList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, yPosition), 400f, 50f);
		((Object)val).name = "GreydwarfJobOption_" + job;
		Button component = val.GetComponent<Button>();
		if ((Object)(object)component != (Object)null)
		{
			WorkerJob selectedJob = job;
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				OnJobSelected(selectedJob);
			});
		}
	}

	private void CreateGatheringRow(float yPosition)
	{
		//IL_0020: 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_003a: 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_00b7: 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_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Expected O, but got Unknown
		//IL_0130: 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_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0167: 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_010f: Expected O, but got Unknown
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Expected O, but got Unknown
		GameObject val = GUIManager.Instance.CreateButton("Gathering", m_jobList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-115f, yPosition), 220f, 50f);
		((Object)val).name = "GreydwarfGatheringButton";
		Button component = val.GetComponent<Button>();
		if ((Object)(object)component != (Object)null)
		{
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				OnJobSelected(WorkerJob.Gathering);
			});
		}
		GameObject val2 = GUIManager.Instance.CreateButton("<", m_jobList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(40f, yPosition), 35f, 50f);
		((Object)val2).name = "GreydwarfGatherPreviousButton";
		Button component2 = val2.GetComponent<Button>();
		if ((Object)(object)component2 != (Object)null)
		{
			((UnityEvent)component2.onClick).AddListener(new UnityAction(PreviousSelectedWorkerResource));
		}
		GameObject val3 = GUIManager.Instance.CreateText("Wood", m_jobList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(120f, yPosition - 3f), GUIManager.Instance.AveriaSerifBold, 21, Color.yellow, true, Color.black, 125f, 50f, false);
		((Object)val3).name = "GreydwarfGatherResourceText";
		m_gatherResourceText = val3.GetComponent<Text>();
		if ((Object)(object)m_gatherResourceText != (Object)null)
		{
			m_gatherResourceText.alignment = (TextAnchor)4;
		}
		GameObject val4 = GUIManager.Instance.CreateButton(">", m_jobList.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, yPosition), 35f, 50f);
		((Object)val4).name = "GreydwarfGatherNextButton";
		Button component3 = val4.GetComponent<Button>();
		if ((Object)(object)component3 != (Object)null)
		{
			((UnityEvent)component3.onClick).AddListener(new UnityAction(NextSelectedWorkerResource));
		}
		UpdateGatherResourceButton();
	}

	private string GetDisplayItemName(string itemName)
	{
		return itemName switch
		{
			"$item_wood" => "Wood", 
			"$item_stone" => "Stone", 
			"$item_coal" => "Coal", 
			"$item_iron" => "Iron", 
			"$item_copperore" => "Copper Ore", 
			"$item_tinore" => "Tin Ore", 
			"$item_ironscrap" => "Iron Scrap", 
			"$item_silverore" => "Silver Ore", 
			"$item_resin" => "Resin", 
			"$item_greydwarf_eye" => "Greydwarf Eye", 
			"$item_guck" => "Guck", 
			"$item_finewood" => "Fine Wood", 
			"$item_roundlog" => "Round Log", 
			"$item_copper" => "Copper", 
			"$item_tin" => "Tin", 
			"$item_silver" => "Silver", 
			"$item_blackmetal" => "Black Metal", 
			_ => itemName, 
		};
	}

	private void ClearWorkerList()
	{
		if (!((Object)(object)m_workerList == (Object)null))
		{
			for (int num = m_workerList.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)m_workerList.transform.GetChild(num)).gameObject);
			}
		}
	}

	private void ClearInventoryList()
	{
		m_inventoryAmountTexts.Clear();
		if (!((Object)(object)m_inventoryList == (Object)null))
		{
			for (int num = m_inventoryList.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)m_inventoryList.transform.GetChild(num)).gameObject);
			}
		}
	}

	private void CloseInventory()
	{
		if ((Object)(object)m_inventoryPanel != (Object)null)
		{
			m_inventoryPanel.SetActive(false);
		}
		m_selectedWorker = null;
		if ((Object)(object)m_panel != (Object)null)
		{
			m_panel.SetActive(true);
			RefreshWorkerList();
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)m_panel != (Object)null || (Object)(object)m_inventoryPanel != (Object)null)
		{
			IsOpen = false;
		}
	}

	private void UpdateInventoryAmounts()
	{
		if ((Object)(object)m_inventoryPanel == (Object)null || !m_inventoryPanel.activeSelf || (Object)(object)m_selectedWorker == (Object)null)
		{
			return;
		}
		WorkerInventory component = ((Component)m_selectedWorker).GetComponent<WorkerInventory>();
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		Dictionary<string, int> allItems = component.GetAllItems();
		foreach (KeyValuePair<string, Text> inventoryAmountText in m_inventoryAmountTexts)
		{
			string key = inventoryAmountText.Key;
			Text value = inventoryAmountText.Value;
			if (!((Object)(object)value == (Object)null))
			{
				int amount = component.GetAmount(key);
				int capacity = component.GetCapacity(key);
				value.text = amount + " / " + capacity;
			}
		}
		bool flag = allItems.Count != m_inventoryAmountTexts.Count;
		if (!flag)
		{
			foreach (string key2 in allItems.Keys)
			{
				if (!m_inventoryAmountTexts.ContainsKey(key2))
				{
					flag = true;
					break;
				}
			}
		}
		if (!flag)
		{
			foreach (string key3 in m_inventoryAmountTexts.Keys)
			{
				if (!allItems.ContainsKey(key3))
				{
					flag = true;
					break;
				}
			}
		}
		if (flag)
		{
			RefreshInventory();
		}
	}
}
[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
public static class MonsterAIWorkerPatch
{
	private static bool Prefix(MonsterAI __instance, float dt)
	{
		GreydwarfWorker component = ((Component)__instance).GetComponent<GreydwarfWorker>();
		if ((Object)(object)component == (Object)null)
		{
			return true;
		}
		if (!component.IsWorking)
		{
			return true;
		}
		return false;
	}
}
public class WorkerInventory : MonoBehaviour
{
	private ZNetView m_nview;

	private const string InventoryZdoPrefix = "GreydwarfWorkers_Inventory_";

	private static readonly Dictionary<string, int> ResourceCapacities = new Dictionary<string, int>
	{
		{ "$item_wood", 20 },
		{ "$item_stone", 20 },
		{ "$item_coal", 20 },
		{ "$item_iron", 10 }
	};

	private readonly Dictionary<string, int> m_items = new Dictionary<string, int>();

	private static readonly Dictionary<string, string> ItemPrefabNames = new Dictionary<string, string>
	{
		{ "$item_wood", "Wood" },
		{ "$item_stone", "Stone" },
		{ "$item_coal", "Coal" },
		{ "$item_iron", "Iron" },
		{ "$item_copperore", "CopperOre" },
		{ "$item_tinore", "TinOre" },
		{ "$item_ironscrap", "IronScrap" },
		{ "$item_silverore", "SilverOre" },
		{ "$item_resin", "Resin" },
		{ "$item_greydwarf_eye", "GreydwarfEye" },
		{ "$item_guck", "Guck" },
		{ "$item_finewood", "FineWood" },
		{ "$item_roundlog", "RoundLog" },
		{ "$item_copper", "Copper" },
		{ "$item_tin", "Tin" },
		{ "$item_silver", "Silver" },
		{ "$item_blackmetal", "BlackMetal" }
	};

	public int CapacityPerResource { get; set; } = 20;

	private void Start()
	{
		m_nview = ((Component)this).GetComponent<ZNetView>();
		LoadInventory();
	}

	private string GetInventoryZdoKey(string itemName)
	{
		return "GreydwarfWorkers_Inventory_" + itemName;
	}

	private void SaveInventory()
	{
		if ((Object)(object)m_nview == (Object)null || !m_nview.IsValid() || !m_nview.IsOwner())
		{
			return;
		}
		ZDO zDO = m_nview.GetZDO();
		if (zDO == null)
		{
			return;
		}
		foreach (string key in ItemPrefabNames.Keys)
		{
			int amount = GetAmount(key);
			zDO.Set(GetInventoryZdoKey(key), amount);
		}
	}

	private void LoadInventory()
	{
		if ((Object)(object)m_nview == (Object)null || !m_nview.IsValid())
		{
			return;
		}
		ZDO zDO = m_nview.GetZDO();
		if (zDO == null)
		{
			return;
		}
		m_items.Clear();
		foreach (string key in ItemPrefabNames.Keys)
		{
			int num = zDO.GetInt(GetInventoryZdoKey(key), 0);
			if (num > 0)
			{
				m_items[key] = num;
			}
		}
	}

	public bool AddItem(string itemName, int amount = 1)
	{
		if (amount <= 0)
		{
			return false;
		}
		int amount2 = GetAmount(itemName);
		if (amount2 + amount > GetCapacity(itemName))
		{
			return false;
		}
		m_items[itemName] = amount2 + amount;
		SaveInventory();
		return true;
	}

	public int GetAmount(string itemName)
	{
		if (m_items.TryGetValue(itemName, out var value))
		{
			return value;
		}
		return 0;
	}

	public int GetCapacity(string itemName)
	{
		if (ResourceCapacities.TryGetValue(itemName, out var value))
		{
			return value;
		}
		return CapacityPerResource;
	}

	public bool RemoveItem(string itemName, int amount)
	{
		if (amount <= 0)
		{
			return false;
		}
		int amount2 = GetAmount(itemName);
		if (amount2 < amount)
		{
			return false;
		}
		amount2 -= amount;
		if (amount2 == 0)
		{
			m_items.Remove(itemName);
		}
		else
		{
			m_items[itemName] = amount2;
		}
		SaveInventory();
		return true;
	}

	public bool IsFull(string itemName)
	{
		return GetAmount(itemName) >= GetCapacity(itemName);
	}

	public bool IsEmpty()
	{
		return m_items.Count == 0;
	}

	public void Clear()
	{
		m_items.Clear();
		SaveInventory();
	}

	public int GetTotalItemCount()
	{
		int num = 0;
		foreach (int value in m_items.Values)
		{
			num += value;
		}
		return num;
	}

	public Dictionary<string, int> GetAllItems()
	{
		return new Dictionary<string, int>(m_items);
	}

	public bool TryCreateItemData(string itemName, int amount, out ItemData itemData)
	{
		itemData = null;
		if (amount <= 0 || (Object)(object)ObjectDB.instance == (Object)null)
		{
			return false;
		}
		if (!ItemPrefabNames.TryGetValue(itemName, out var value))
		{
			return false;
		}
		GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(value);
		if ((Object)(object)itemPrefab == (Object)null)
		{
			Debug.LogWarning((object)("[Greydwarf Workers] Could not find item prefab '" + value + "'."));
			return false;
		}
		ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
		if ((Object)(object)component == (Object)null)
		{
			Debug.LogWarning((object)("[Greydwarf Workers] Prefab '" + value + "' has no ItemDrop."));
			return false;
		}
		itemData = component.m_itemData.Clone();
		itemData.m_dropPrefab = itemPrefab;
		itemData.m_stack = amount;
		itemData.m_worldLevel = (byte)Game.m_worldLevel;
		return true;
	}

	public int TransferResourceToChest(Container chest, string itemName)
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Expected O, but got Unknown
		if ((Object)(object)chest == (Object)null)
		{
			return 0;
		}
		Inventory inventory = chest.GetInventory();
		if (inventory == null)
		{
			return 0;
		}
		int amount = GetAmount(itemName);
		if (amount <= 0)
		{
			return 0;
		}
		if (!TryCreateItemData(itemName, amount, out var itemData))
		{
			return 0;
		}
		Inventory val = new Inventory(true);
		if (!val.AddItem(itemData))
		{
			return 0;
		}
		int num = val.NrOfItemsIncludingStacks();
		List<ItemData> list = new List<ItemData>(val.GetAllItems());
		foreach (ItemData item in list)
		{
			inventory.MoveItemToThis(val, item);
		}
		int num2 = val.NrOfItemsIncludingStacks();
		int num3 = num - num2;
		if (num3 > 0)
		{
			RemoveItem(itemName, num3);
		}
		return num3;
	}

	public void DropAllItems()
	{
		//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_0036: 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_0040: 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_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: 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_01d5: 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_01e4: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)ObjectDB.instance == (Object)null)
		{
			Debug.LogWarning((object)"[Greydwarf Workers] ObjectDB is not available.");
			return;
		}
		Vector3 val = ((Component)this).transform.position + Vector3.up * 0.5f;
		Dictionary<string, int> dictionary = new Dictionary<string, int>(m_items);
		foreach (KeyValuePair<string, int> item in dictionary)
		{
			if (item.Value <= 0)
			{
				continue;
			}
			if (!ItemPrefabNames.TryGetValue(item.Key, out var value))
			{
				Debug.LogWarning((object)("[Greydwarf Workers] No prefab mapping found for " + item.Key + "."));
				continue;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(value);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				Debug.LogWarning((object)("[Greydwarf Workers] Could not find item prefab '" + value + "' for " + item.Key + "."));
				continue;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("[Greydwarf Workers] Prefab '" + value + "' has no ItemDrop component."));
				continue;
			}
			ItemData val2 = component.m_itemData.Clone();
			val2.m_dropPrefab = itemPrefab;
			val2.m_stack = item.Value;
			ItemDrop val3 = ItemDrop.DropItem(val2, item.Value, val, Quaternion.identity);
			if ((Object)(object)val3 == (Object)null)
			{
				Debug.LogWarning((object)("[Greydwarf Workers] Failed to spawn '" + value + "'."));
				continue;
			}
			Rigidbody component2 = ((Component)val3).GetComponent<Rigidbody>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.linearVelocity = (Vector3.up + Random.insideUnitSphere * 0.2f) * 2f;
			}
		}
		m_items.Clear();
		SaveInventory();
	}
}
public static class WorkerMovement
{
	private static readonly MethodInfo MoveToMethod = typeof(BaseAI).GetMethod("MoveTo", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[4]
	{
		typeof(float),
		typeof(Vector3),
		typeof(float),
		typeof(bool)
	}, null);

	public static bool MoveTo(MonsterAI monsterAI, float deltaTime, Vector3 target, float stopDistance)
	{
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)monsterAI == (Object)null || MoveToMethod == null)
		{
			return false;
		}
		object obj = MoveToMethod.Invoke(monsterAI, new object[4] { deltaTime, target, stopDistance, false });
		bool flag = default(bool);
		int num;
		if (obj is bool)
		{
			flag = (bool)obj;
			num = 1;
		}
		else
		{
			num = 0;
		}
		return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
	}
}
public class GreydwarfWorker : MonoBehaviour
{
	public enum WorkerState
	{
		Inactive,
		Gathering,
		MovingToResource,
		SearchingForChest,
		MovingToChest,
		WaitingForChest,
		SearchingForSupplyChest,
		MovingToSupplyChest,
		RetrievingFromChest,
		SearchingForSmelter,
		MovingToSmelter,
		DepositingToSmelter,
		WaitingForSmelter,
		SearchingForOreChest,
		MovingToOreChest,
		RetrievingOreFromChest,
		SearchingForOreSmelter,
		MovingToOreSmelter,
		DepositingOreToSmelter,
		WaitingForOreSmelter,
		SearchingForFireplace,
		MovingToFireplace,
		SearchingForFireplaceFuel,
		MovingToFireplaceFuelChest,
		RetrievingFireplaceFuel,
		MovingToFireplaceWithFuel,
		DepositingToFireplace,
		WaitingForFireplace,
		SearchingForKiln,
		MovingToKiln,
		DepositingToKiln,
		WaitingForKiln,
		SearchingForKilnChest,
		MovingToKilnChest,
		RetrievingKilnMaterial
	}

	private Character m_character;

	private MonsterAI m_monsterAI;

	private Tameable m_tameable;

	private ItemDrop m_targetResource;

	private WorkerInventory m_inventory;

	private Container m_targetChest;

	private Container m_targetSupplyChest;

	private Container m_targetOreChest;

	private Container m_targetFireplaceFuelChest;

	private Container m_targetKilnChest;

	private string m_targetOreItemName;

	private string m_targetFireplaceFuelItemName;

	private string m_targetKilnItemName;

	private Smelter m_targetSmelter;

	private Smelter m_targetOreSmelter;

	private Smelter m_targetKiln;

	private Fireplace m_targetFireplace;

	private float m_searchTimer;

	private float m_smelterWaitTimer;

	private float m_oreSmelterWaitTimer;

	private float m_fireplaceWaitTimer;

	private float m_kilnWaitTimer;

	private const float KilnWaitInterval = 15f;

	private const float ChestSearchRange = 30f;

	private const float ChestSearchInterval = 5f;

	private const float ResourceSearchRange = 20f;

	private const float ResourceSearchInterval = 2f;

	private const float ResourceCollectRange = 2.5f;

	private const float SmelterWaitInterval = 15f;

	private const float OreSmelterWaitInterval = 30f;

	private const float FireplaceWaitInterval = 30f;

	public WorkerState CurrentState { get; private set; } = WorkerState.Inactive;

	public bool IsWorking => CurrentState != WorkerState.Inactive;

	public GatherResourceType CurrentGatherResource { get; private set; } = GatherResourceType.Wood;

	private void Awake()
	{
		m_character = ((Component)this).GetComponent<Character>();
		m_monsterAI = ((Component)this).GetComponent<MonsterAI>();
		m_tameable = ((Component)this).GetComponent<Tameable>();
		m_inventory = ((Component)this).GetComponent<WorkerInventory>();
		if ((Object)(object)m_inventory == (Object)null)
		{
			m_inventory = ((Component)this).gameObject.AddComponent<WorkerInventory>();
		}
		if ((Object)(object)m_character != (Object)null)
		{
			Character character = m_character;
			character.m_onDeath = (Action)Delegate.Combine(character.m_onDeath, new Action(OnDeath));
		}
	}

	private void Update()
	{
		if (!((Object)(object)m_tameable == (Object)null) && m_tameable.IsTamed())
		{
			switch (CurrentState)
			{
			case WorkerState.Inactive:
				UpdateIdle();
				break;
			case WorkerState.Gathering:
				UpdateGathering();
				break;
			case WorkerState.MovingToResource:
				UpdateMovingToResource();
				break;
			case WorkerState.SearchingForChest:
				UpdateSearchingForChest();
				break;
			case WorkerState.MovingToChest:
				UpdateMovingToChest();
				break;
			case WorkerState.WaitingForChest:
				UpdateWaitingForChest();
				break;
			case WorkerState.SearchingForSupplyChest:
				UpdateSearchingForSupplyChest();
				break;
			case WorkerState.MovingToSupplyChest:
				UpdateMovingToSupplyChest();
				break;
			case WorkerState.RetrievingFromChest:
				UpdateRetrievingFromChest();
				break;
			case WorkerState.SearchingForSmelter:
				UpdateSearchingForSmelter();
				break;
			case WorkerState.MovingToSmelter:
				UpdateMovingToSmelter();
				break;
			case WorkerState.DepositingToSmelter:
				UpdateDepositingToSmelter();
				break;
			case WorkerState.WaitingForSmelter:
				UpdateWaitingForSmelter();
				break;
			case WorkerState.SearchingForOreChest:
				UpdateSearchingForOreChest();
				break;
			case WorkerState.MovingToOreChest:
				UpdateMovingToOreChest();
				break;
			case WorkerState.RetrievingOreFromChest:
				UpdateRetrievingOreFromChest();
				break;
			case WorkerState.SearchingForOreSmelter:
				UpdateSearchingForOreSmelter();
				break;
			case WorkerState.MovingToOreSmelter:
				UpdateMovingToOreSmelter();
				break;
			case WorkerState.DepositingOreToSmelter:
				UpdateDepositingOreToSmelter();
				break;
			case WorkerState.WaitingForOreSmelter:
				UpdateWaitingForOreSmelter();
				break;
			case WorkerState.SearchingForFireplace:
				UpdateSearchingForFireplace();
				break;
			case WorkerState.MovingToFireplace:
				UpdateMovingToFireplace();
				break;
			case WorkerState.SearchingForFireplaceFuel:
				UpdateSearchingForFireplaceFuel();
				break;
			case WorkerState.MovingToFireplaceFuelChest:
				UpdateMovingToFireplaceFuelChest();
				break;
			case WorkerState.RetrievingFireplaceFuel:
				UpdateRetrievingFireplaceFuel();
				break;
			case WorkerState.MovingToFireplaceWithFuel:
				UpdateMovingToFireplaceWithFuel();
				break;
			case WorkerState.DepositingToFireplace:
				UpdateDepositingToFireplace();
				break;
			case WorkerState.WaitingForFireplace:
				UpdateWaitingForFireplace();
				break;
			case WorkerState.SearchingForKiln:
				UpdateSearchingForKiln();
				break;
			case WorkerState.MovingToKiln:
				UpdateMovingToKiln();
				break;
			case WorkerState.DepositingToKiln:
				UpdateDepositingToKiln();
				break;
			case WorkerState.WaitingForKiln:
				UpdateWaitingForKiln();
				break;
			case WorkerState.SearchingForKilnChest:
				UpdateSearchingForKilnChest();
				break;
			case WorkerState.MovingToKilnChest:
				UpdateMovingToKilnChest();
				break;
			case WorkerState.RetrievingKilnMaterial:
				UpdateRetrievingKilnMaterial();
				break;
			}
			if (CurrentState != WorkerState.Inactive && (Object)(object)m_monsterAI.GetFollowTarget() != (Object)null)
			{
				CurrentState = WorkerState.Inactive;
				m_targetResource = null;
			}
		}
	}

	private void UpdateIdle()
	{
	}

	private void OnDeath()
	{
		if (!((Object)(object)m_inventory == (Object)null) && !m_inventory.IsEmpty())
		{
			m_inventory.DropAllItems();
		}
	}

	private void UpdateGathering()
	{
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		if ((Object)(object)m_inventory != (Object)null && m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			m_targetChest = null;
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if ((Object)(object)m_targetResource == (Object)null && m_searchTimer >= 2f)
		{
			m_searchTimer = 0f;
			FindNearestResource();
		}
		if ((Object)(object)m_targetResource != (Object)null)
		{
			CurrentState = WorkerState.MovingToResource;
		}
	}

	private void UpdateSearchingForChest()
	{
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		if ((Object)(object)m_inventory == (Object)null || !m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			m_targetChest = null;
			CurrentState = WorkerState.Gathering;
			m_searchTimer = 2f;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestChest();
			if ((Object)(object)m_targetChest != (Object)null)
			{
				CurrentState = WorkerState.MovingToChest;
				return;
			}
			CurrentState = WorkerState.WaitingForChest;
			m_searchTimer = 0f;
		}
	}

	private void FindNearestChest()
	{
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		if ((Object)(object)m_inventory == (Object)null || !m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			m_targetChest = null;
			return;
		}
		if (!m_inventory.TryCreateItemData(currentResourceDefinition.ItemName, 1, out var itemData))
		{
			m_targetChest = null;
			return;
		}
		Container targetChest = null;
		float num = float.MaxValue;
		Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
		Container[] array2 = array;
		foreach (Container val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || !val.IsOwner() || val.IsInUse())
			{
				continue;
			}
			float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
			if (!(num2 > 30f))
			{
				Inventory inventory = val.GetInventory();
				if (inventory != null && inventory.ContainsItemByName(currentResourceDefinition.ItemName) && inventory.CanAddItem(itemData, 1) && num2 < num)
				{
					num = num2;
					targetChest = val;
				}
			}
		}
		m_targetChest = targetChest;
	}

	private void UpdateMovingToChest()
	{
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetChest == (Object)null)
		{
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
			return;
		}
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		if ((Object)(object)m_inventory == (Object)null || !m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			m_targetChest = null;
			CurrentState = WorkerState.Gathering;
			m_searchTimer = 2f;
		}
		else if (!((Component)m_targetChest).gameObject.activeInHierarchy)
		{
			m_targetChest = null;
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
		}
		else if (m_targetChest.IsInUse())
		{
			m_targetChest = null;
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetChest).transform.position, 2.5f))
		{
			DepositCurrentResource();
		}
	}

	private void DepositCurrentResource()
	{
		if ((Object)(object)m_targetChest == (Object)null || (Object)(object)m_inventory == (Object)null)
		{
			CurrentState = WorkerState.Gathering;
			m_targetChest = null;
			return;
		}
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		Inventory inventory = m_targetChest.GetInventory();
		if (inventory == null)
		{
			m_targetChest = null;
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
			return;
		}
		if (!inventory.ContainsItemByName(currentResourceDefinition.ItemName))
		{
			m_targetChest = null;
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
			return;
		}
		if (!m_inventory.TryCreateItemData(currentResourceDefinition.ItemName, 1, out var itemData))
		{
			CurrentState = WorkerState.Gathering;
			m_targetChest = null;
			return;
		}
		if (!inventory.CanAddItem(itemData, 1))
		{
			m_targetChest = null;
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
			return;
		}
		int num = m_inventory.TransferResourceToChest(m_targetChest, currentResourceDefinition.ItemName);
		m_targetChest = null;
		if (m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			CurrentState = WorkerState.SearchingForChest;
			m_searchTimer = 5f;
		}
		else
		{
			CurrentState = WorkerState.Gathering;
			m_searchTimer = 2f;
		}
	}

	private void UpdateWaitingForChest()
	{
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		if ((Object)(object)m_inventory == (Object)null || !m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			CurrentState = WorkerState.Gathering;
			m_searchTimer = 2f;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (m_searchTimer >= 5f)
		{
			m_searchTimer = 0f;
			FindNearestChest();
			if ((Object)(object)m_targetChest != (Object)null)
			{
				CurrentState = WorkerState.MovingToChest;
			}
		}
	}

	private void UpdateSearchingForSupplyChest()
	{
		if ((Object)(object)m_inventory == (Object)null || m_inventory.IsFull("$item_coal"))
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestSupplyChest("$item_coal");
			if ((Object)(object)m_targetSupplyChest != (Object)null)
			{
				CurrentState = WorkerState.MovingToSupplyChest;
			}
		}
	}

	private void UpdateMovingToSupplyChest()
	{
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetSupplyChest == (Object)null)
		{
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
		}
		else if ((Object)(object)m_inventory == (Object)null || m_inventory.IsFull("$item_coal"))
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.Inactive;
		}
		else if (!((Component)m_targetSupplyChest).gameObject.activeInHierarchy)
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
		}
		else if (m_targetSupplyChest.IsInUse())
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetSupplyChest).transform.position, 2.5f))
		{
			CurrentState = WorkerState.RetrievingFromChest;
		}
	}

	private void UpdateRetrievingFromChest()
	{
		if ((Object)(object)m_targetSupplyChest == (Object)null || (Object)(object)m_inventory == (Object)null)
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		if (!((Component)m_targetSupplyChest).gameObject.activeInHierarchy || m_targetSupplyChest.IsInUse())
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
			return;
		}
		Inventory inventory = m_targetSupplyChest.GetInventory();
		if (inventory == null)
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
			return;
		}
		ItemData item = inventory.GetItem("$item_coal", -1, false);
		if (item == null || item.m_stack <= 0)
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
			return;
		}
		int amount = m_inventory.GetAmount("$item_coal");
		int num = m_inventory.GetCapacity("$item_coal") - amount;
		if (num <= 0)
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		int num2 = Mathf.Min(num, item.m_stack);
		if (!m_inventory.AddItem("$item_coal", num2))
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
		}
		else if (!inventory.RemoveItem(item, num2))
		{
			m_inventory.RemoveItem("$item_coal", num2);
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
		}
		else
		{
			m_targetSupplyChest = null;
			CurrentState = WorkerState.SearchingForSmelter;
			m_searchTimer = 5f;
		}
	}

	private void FindNearestSupplyChest(string itemName)
	{
		//IL_007a: 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)
		m_targetSupplyChest = null;
		Container targetSupplyChest = null;
		float num = float.MaxValue;
		Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
		Container[] array2 = array;
		foreach (Container val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || !val.IsOwner() || val.IsInUse())
			{
				continue;
			}
			float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
			if (!(num2 > 30f))
			{
				Inventory inventory = val.GetInventory();
				if (inventory != null && inventory.ContainsItemByName(itemName) && num2 < num)
				{
					num = num2;
					targetSupplyChest = val;
				}
			}
		}
		m_targetSupplyChest = targetSupplyChest;
	}

	private List<string> GetSmelterOreItemNames()
	{
		HashSet<string> hashSet = new HashSet<string>();
		Smelter[] array = Object.FindObjectsByType<Smelter>((FindObjectsSortMode)0);
		Smelter[] array2 = array;
		foreach (Smelter val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || val.m_conversion == null)
			{
				continue;
			}
			foreach (ItemConversion item in val.m_conversion)
			{
				if (!((Object)(object)item.m_from == (Object)null) && item.m_from.m_itemData != null && item.m_from.m_itemData.m_shared != null)
				{
					string name = item.m_from.m_itemData.m_shared.m_name;
					if (!string.IsNullOrEmpty(name))
					{
						hashSet.Add(name);
					}
				}
			}
		}
		return new List<string>(hashSet);
	}

	private bool TryGetAnyOreInInventory(out string oreItemName)
	{
		oreItemName = null;
		if ((Object)(object)m_inventory == (Object)null)
		{
			return false;
		}
		List<string> smelterOreItemNames = GetSmelterOreItemNames();
		Dictionary<string, int> allItems = m_inventory.GetAllItems();
		foreach (string item in smelterOreItemNames)
		{
			if (allItems.TryGetValue(item, out var value) && value > 0)
			{
				oreItemName = item;
				return true;
			}
		}
		return false;
	}

	private void UpdateSearchingForSmelter()
	{
		if ((Object)(object)m_inventory == (Object)null || m_inventory.GetAmount("$item_coal") <= 0)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestSmelter();
			if ((Object)(object)m_targetSmelter != (Object)null)
			{
				CurrentState = WorkerState.MovingToSmelter;
			}
		}
	}

	private void FindNearestSmelter()
	{
		//IL_0054: 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)
		m_targetSmelter = null;
		Smelter targetSmelter = null;
		float num = float.MaxValue;
		Smelter[] array = Object.FindObjectsByType<Smelter>((FindObjectsSortMode)0);
		Smelter[] array2 = array;
		foreach (Smelter val in array2)
		{
			if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
			{
				float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
				if (!(num2 > 30f) && !((Object)(object)val.m_addWoodSwitch == (Object)null) && num2 < num)
				{
					num = num2;
					targetSmelter = val;
				}
			}
		}
		m_targetSmelter = targetSmelter;
	}

	private void UpdateMovingToSmelter()
	{
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetSmelter == (Object)null)
		{
			CurrentState = WorkerState.SearchingForSmelter;
			m_searchTimer = 5f;
		}
		else if ((Object)(object)m_inventory == (Object)null || m_inventory.GetAmount("$item_coal") <= 0)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.Inactive;
		}
		else if (!((Component)m_targetSmelter).gameObject.activeInHierarchy)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.SearchingForSmelter;
			m_searchTimer = 5f;
		}
		else if ((Object)(object)m_targetSmelter.m_addWoodSwitch == (Object)null)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.SearchingForSmelter;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetSmelter).transform.position, 2.5f))
		{
			CurrentState = WorkerState.DepositingToSmelter;
		}
	}

	private void UpdateDepositingToSmelter()
	{
		if ((Object)(object)m_targetSmelter == (Object)null || (Object)(object)m_inventory == (Object)null)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		if (!((Component)m_targetSmelter).gameObject.activeInHierarchy || (Object)(object)m_targetSmelter.m_addWoodSwitch == (Object)null)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.SearchingForSmelter;
			m_searchTimer = 5f;
			return;
		}
		if (m_inventory.GetAmount("$item_coal") <= 0)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
			return;
		}
		Humanoid component = ((Component)this).GetComponent<Humanoid>();
		if ((Object)(object)component == (Object)null)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		Inventory inventory = component.GetInventory();
		if (inventory == null)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		while (m_inventory.GetAmount("$item_coal") > 0)
		{
			float smelterFuel = GetSmelterFuel(m_targetSmelter);
			if (smelterFuel > (float)m_targetSmelter.m_maxFuel - 1f)
			{
				m_smelterWaitTimer = 0f;
				CurrentState = WorkerState.WaitingForSmelter;
				return;
			}
			if (!m_inventory.TryCreateItemData("$item_coal", 1, out var itemData))
			{
				m_targetSmelter = null;
				CurrentState = WorkerState.Inactive;
				return;
			}
			if (!inventory.AddItem(itemData))
			{
				m_targetSmelter = null;
				CurrentState = WorkerState.Inactive;
				return;
			}
			ItemData item = inventory.GetItem("$item_coal", -1, false);
			if (item == null)
			{
				m_targetSmelter = null;
				CurrentState = WorkerState.Inactive;
				return;
			}
			if (!m_targetSmelter.m_addWoodSwitch.UseItem(component, item))
			{
				inventory.RemoveItem(item, 1);
				m_smelterWaitTimer = 0f;
				CurrentState = WorkerState.WaitingForSmelter;
				return;
			}
			m_inventory.RemoveItem("$item_coal", 1);
		}
		m_targetSmelter = null;
		CurrentState = WorkerState.SearchingForSupplyChest;
		m_searchTimer = 5f;
	}

	private void UpdateWaitingForSmelter()
	{
		if ((Object)(object)m_inventory == (Object)null)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		if (m_inventory.GetAmount("$item_coal") <= 0)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.SearchingForSupplyChest;
			m_searchTimer = 5f;
			return;
		}
		if ((Object)(object)m_targetSmelter == (Object)null || !((Component)m_targetSmelter).gameObject.activeInHierarchy)
		{
			m_targetSmelter = null;
			CurrentState = WorkerState.SearchingForSmelter;
			m_searchTimer = 5f;
			return;
		}
		m_smelterWaitTimer += Time.deltaTime;
		if (!(m_smelterWaitTimer < 15f))
		{
			m_smelterWaitTimer = 0f;
			CurrentState = WorkerState.DepositingToSmelter;
		}
	}

	private void UpdateWaitingForOreSmelter()
	{
		if ((Object)(object)m_targetOreSmelter == (Object)null)
		{
			SetState(WorkerState.SearchingForOreSmelter);
			return;
		}
		m_oreSmelterWaitTimer += Time.deltaTime;
		if (!(m_oreSmelterWaitTimer < 30f))
		{
			m_oreSmelterWaitTimer = 0f;
			CurrentState = WorkerState.DepositingOreToSmelter;
		}
	}

	private float GetSmelterFuel(Smelter smelter)
	{
		if ((Object)(object)smelter == (Object)null)
		{
			return 0f;
		}
		ZNetView val = ((Component)smelter).GetComponent<ZNetView>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)smelter).GetComponentInParent<ZNetView>();
		}
		if ((Object)(object)val == (Object)null || !val.IsValid())
		{
			return 0f;
		}
		return val.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);
	}

	private int GetKilnQueueSize(Smelter kiln)
	{
		if ((Object)(object)kiln == (Object)null)
		{
			return 0;
		}
		ZNetView val = ((Component)kiln).GetComponent<ZNetView>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)kiln).GetComponentInParent<ZNetView>();
		}
		if ((Object)(object)val == (Object)null || !val.IsValid())
		{
			return 0;
		}
		return val.GetZDO().GetInt(ZDOVars.s_queued, 0);
	}

	private void UpdateSearchingForOreChest()
	{
		if ((Object)(object)m_inventory == (Object)null)
		{
			CurrentState = WorkerState.Inactive;
			return;
		}
		if (TryGetAnyOreInInventory(out var oreItemName))
		{
			m_targetOreItemName = oreItemName;
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestOreChest();
			if ((Object)(object)m_targetOreChest != (Object)null)
			{
				CurrentState = WorkerState.MovingToOreChest;
			}
		}
	}

	private void FindNearestOreChest()
	{
		//IL_00a9: 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)
		m_targetOreChest = null;
		m_targetOreItemName = null;
		List<string> smelterOreItemNames = GetSmelterOreItemNames();
		if (smelterOreItemNames.Count == 0)
		{
			return;
		}
		Container targetOreChest = null;
		string targetOreItemName = null;
		float num = float.MaxValue;
		Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
		Container[] array2 = array;
		foreach (Container val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || !val.IsOwner() || val.IsInUse())
			{
				continue;
			}
			float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
			if (num2 > 30f)
			{
				continue;
			}
			Inventory inventory = val.GetInventory();
			if (inventory == null)
			{
				continue;
			}
			foreach (string item2 in smelterOreItemNames)
			{
				ItemData item = inventory.GetItem(item2, -1, false);
				if (item == null || item.m_stack <= 0)
				{
					continue;
				}
				if (num2 < num)
				{
					num = num2;
					targetOreChest = val;
					targetOreItemName = item2;
				}
				break;
			}
		}
		m_targetOreChest = targetOreChest;
		m_targetOreItemName = targetOreItemName;
	}

	private void UpdateMovingToOreChest()
	{
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetOreChest == (Object)null || string.IsNullOrEmpty(m_targetOreItemName))
		{
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
		}
		else if ((Object)(object)m_inventory == (Object)null)
		{
			CurrentState = WorkerState.Inactive;
		}
		else if (m_inventory.IsFull(m_targetOreItemName))
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
		}
		else if (!((Component)m_targetOreChest).gameObject.activeInHierarchy || m_targetOreChest.IsInUse())
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetOreChest).transform.position, 2.5f))
		{
			CurrentState = WorkerState.RetrievingOreFromChest;
		}
	}

	private void UpdateRetrievingOreFromChest()
	{
		if ((Object)(object)m_targetOreChest == (Object)null || (Object)(object)m_inventory == (Object)null || string.IsNullOrEmpty(m_targetOreItemName))
		{
			m_targetOreChest = null;
			m_targetOreItemName = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
			return;
		}
		if (!((Component)m_targetOreChest).gameObject.activeInHierarchy || m_targetOreChest.IsInUse())
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
			return;
		}
		Inventory inventory = m_targetOreChest.GetInventory();
		if (inventory == null)
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
			return;
		}
		ItemData item = inventory.GetItem(m_targetOreItemName, -1, false);
		if (item == null || item.m_stack <= 0)
		{
			m_targetOreChest = null;
			m_targetOreItemName = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
			return;
		}
		int amount = m_inventory.GetAmount(m_targetOreItemName);
		int num = m_inventory.GetCapacity(m_targetOreItemName) - amount;
		if (num <= 0)
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
			return;
		}
		int num2 = Mathf.Min(num, item.m_stack);
		if (!m_inventory.AddItem(m_targetOreItemName, num2))
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
		}
		else if (!inventory.RemoveItem(item, num2))
		{
			m_inventory.RemoveItem(m_targetOreItemName, num2);
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
		}
		else
		{
			m_targetOreChest = null;
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
		}
	}

	private void UpdateSearchingForOreSmelter()
	{
		if ((Object)(object)m_inventory == (Object)null)
		{
			CurrentState = WorkerState.Inactive;
			return;
		}
		if (!TryGetAnyOreInInventory(out var oreItemName))
		{
			m_targetOreSmelter = null;
			m_targetOreItemName = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
			return;
		}
		m_targetOreItemName = oreItemName;
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestOreSmelter(m_targetOreItemName);
			if ((Object)(object)m_targetOreSmelter != (Object)null)
			{
				CurrentState = WorkerState.MovingToOreSmelter;
			}
		}
	}

	private void FindNearestOreSmelter(string oreItemName)
	{
		//IL_0143: 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)
		m_targetOreSmelter = null;
		if (string.IsNullOrEmpty(oreItemName))
		{
			return;
		}
		Smelter targetOreSmelter = null;
		float num = float.MaxValue;
		Smelter[] array = Object.FindObjectsByType<Smelter>((FindObjectsSortMode)0);
		Smelter[] array2 = array;
		foreach (Smelter val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || (Object)(object)val.m_addOreSwitch == (Object)null)
			{
				continue;
			}
			bool flag = false;
			if (val.m_conversion != null)
			{
				foreach (ItemConversion item in val.m_conversion)
				{
					if ((Object)(object)item.m_from == (Object)null || item.m_from.m_itemData == null || item.m_from.m_itemData.m_shared == null || !(item.m_from.m_itemData.m_shared.m_name == oreItemName))
					{
						continue;
					}
					flag = true;
					break;
				}
			}
			if (flag)
			{
				float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
				if (!(num2 > 30f) && num2 < num)
				{
					num = num2;
					targetOreSmelter = val;
				}
			}
		}
		m_targetOreSmelter = targetOreSmelter;
	}

	private void UpdateMovingToOreSmelter()
	{
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetOreSmelter == (Object)null)
		{
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
			return;
		}
		if ((Object)(object)m_inventory == (Object)null || !TryGetAnyOreInInventory(out var oreItemName))
		{
			m_targetOreSmelter = null;
			CurrentState = WorkerState.SearchingForOreChest;
			m_searchTimer = 5f;
			return;
		}
		m_targetOreItemName = oreItemName;
		if (!((Component)m_targetOreSmelter).gameObject.activeInHierarchy || (Object)(object)m_targetOreSmelter.m_addOreSwitch == (Object)null)
		{
			m_targetOreSmelter = null;
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetOreSmelter).transform.position, 2.5f))
		{
			CurrentState = WorkerState.DepositingOreToSmelter;
		}
	}

	private void UpdateDepositingOreToSmelter()
	{
		if ((Object)(object)m_targetOreSmelter == (Object)null || (Object)(object)m_inventory == (Object)null)
		{
			m_targetOreSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		if (!((Component)m_targetOreSmelter).gameObject.activeInHierarchy || (Object)(object)m_targetOreSmelter.m_addOreSwitch == (Object)null)
		{
			m_targetOreSmelter = null;
			CurrentState = WorkerState.SearchingForOreSmelter;
			m_searchTimer = 5f;
			return;
		}
		Humanoid component = ((Component)this).GetComponent<Humanoid>();
		if ((Object)(object)component == (Object)null)
		{
			m_targetOreSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		Inventory inventory = component.GetInventory();
		if (inventory == null)
		{
			m_targetOreSmelter = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		string oreItemName;
		while (TryGetAnyOreInInventory(out oreItemName))
		{
			m_targetOreItemName = oreItemName;
			if (!m_inventory.TryCreateItemData(oreItemName, 1, out var itemData))
			{
				m_targetOreItemName = null;
				CurrentState = WorkerState.SearchingForOreChest;
				m_searchTimer = 5f;
				return;
			}
			if (!inventory.AddItem(itemData))
			{
				CurrentState = WorkerState.Inactive;
				return;
			}
			ItemData item = inventory.GetItem(oreItemName, -1, false);
			if (item == null)
			{
				CurrentState = WorkerState.Inactive;
				return;
			}
			if (!m_targetOreSmelter.m_addOreSwitch.UseItem(component, item))
			{
				inventory.RemoveItem(item, 1);
				m_oreSmelterWaitTimer = 0f;
				CurrentState = WorkerState.WaitingForOreSmelter;
				return;
			}
			m_inventory.RemoveItem(oreItemName, 1);
		}
		m_targetOreSmelter = null;
		m_targetOreItemName = null;
		CurrentState = WorkerState.SearchingForOreChest;
		m_searchTimer = 5f;
	}

	private void UpdateMovingToResource()
	{
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetResource == (Object)null)
		{
			CurrentState = WorkerState.Gathering;
			return;
		}
		ZNetView component = ((Component)m_targetResource).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			m_targetResource = null;
			CurrentState = WorkerState.Gathering;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetResource).transform.position, 2.5f))
		{
			CollectResource();
		}
	}

	private void FindNearestResource()
	{
		//IL_0013: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
		string itemName = GetCurrentResourceDefinition().ItemName;
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 20f, LayerMask.GetMask(new string[1] { "item" }));
		ItemDrop targetResource = null;
		float num = float.MaxValue;
		Collider[] array2 = array;
		foreach (Collider val in array2)
		{
			if ((Object)(object)val.attachedRigidbody == (Object)null)
			{
				continue;
			}
			ItemDrop component = ((Component)val.attachedRigidbody).GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				continue;
			}
			ZNetView component2 = ((Component)component).GetComponent<ZNetView>();
			if (!((Object)(object)component2 == (Object)null) && component2.IsValid() && !(component.m_itemData.m_shared.m_name != itemName))
			{
				float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)component).transform.position);
				if (num2 < num)
				{
					num = num2;
					targetResource = component;
				}
			}
		}
		m_targetResource = targetResource;
	}

	private void CollectResource()
	{
		if ((Object)(object)m_targetResource == (Object)null)
		{
			CurrentState = WorkerState.Gathering;
			return;
		}
		if ((Object)(object)m_inventory == (Object)null)
		{
			CurrentState = WorkerState.Gathering;
			return;
		}
		GatherResourceDefinition currentResourceDefinition = GetCurrentResourceDefinition();
		if (m_inventory.IsFull(currentResourceDefinition.ItemName))
		{
			m_targetResource = null;
			CurrentState = WorkerState.Gathering;
			return;
		}
		if (m_inventory.AddItem(currentResourceDefinition.ItemName))
		{
			m_targetResource.RemoveOne();
		}
		m_targetResource = null;
		CurrentState = WorkerState.Gathering;
	}

	public bool SetState(WorkerState newState)
	{
		if ((Object)(object)m_tameable == (Object)null || !m_tameable.IsTamed())
		{
			return false;
		}
		if (newState != WorkerState.Inactive && (Object)(object)m_monsterAI.GetFollowTarget() != (Object)null)
		{
			return false;
		}
		CurrentState = newState;
		if (newState == WorkerState.Gathering)
		{
			m_searchTimer = 2f;
		}
		if (newState == WorkerState.Inactive)
		{
			if ((Object)(object)m_monsterAI != (Object)null)
			{
				((BaseAI)m_monsterAI).StopMoving();
			}
			m_targetResource = null;
			m_targetChest = null;
			m_targetSupplyChest = null;
			m_targetSmelter = null;
			m_targetOreChest = null;
			m_targetOreSmelter = null;
			m_targetOreItemName = null;
			m_targetFireplace = null;
			m_targetFireplaceFuelChest = null;
			m_targetFireplaceFuelItemName = null;
			m_oreSmelterWaitTimer = 0f;
			m_smelterWaitTimer = 0f;
			m_fireplaceWaitTimer = 0f;
			m_kilnWaitTimer = 0f;
			m_targetKiln = null;
			m_targetKilnChest = null;
			m_targetKilnItemName = null;
		}
		return true;
	}

	public void PreviousGatherResource()
	{
		ChangeGatherResource(-1);
	}

	public void NextGatherResource()
	{
		ChangeGatherResource(1);
	}

	public void CycleGatherResource()
	{
		NextGatherResource();
	}

	private void ChangeGatherResource(int direction)
	{
		int currentGatherResource = (int)(CurrentGatherResource + direction + 10) % 10;
		CurrentGatherResource = (GatherResourceType)currentGatherResource;
		bool flag = CurrentState != WorkerState.Inactive;
		m_targetResource = null;
		m_targetChest = null;
		m_targetSupplyChest = null;
		m_targetSmelter = null;
		m_targetKiln = null;
		m_targetKilnChest = null;
		m_targetKilnItemName = null;
		m_targetFireplace = null;
		m_targetFireplaceFuelChest = null;
		m_targetFireplaceFuelItemName = null;
		m_smelterWaitTimer = 0f;
		m_fireplaceWaitTimer = 0f;
		m_kilnWaitTimer = 0f;
		if (flag)
		{
			CurrentState = WorkerState.Gathering;
			m_searchTimer = 2f;
		}
		else
		{
			CurrentState = WorkerState.Inactive;
		}
	}

	private void UpdateSearchingForFireplace()
	{
		if ((Object)(object)m_inventory == (Object)null)
		{
			CurrentState = WorkerState.Inactive;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestFireplace();
			if ((Object)(object)m_targetFireplace != (Object)null)
			{
				CurrentState = WorkerState.MovingToFireplace;
				return;
			}
			m_fireplaceWaitTimer = 0f;
			CurrentState = WorkerState.WaitingForFireplace;
		}
	}

	private void FindNearestFireplace()
	{
		//IL_014c: 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)
		m_targetFireplace = null;
		m_targetFireplaceFuelItemName = null;
		Fireplace targetFireplace = null;
		float num = float.MaxValue;
		Fireplace[] array = Object.FindObjectsByType<Fireplace>((FindObjectsSortMode)0);
		Fireplace[] array2 = array;
		foreach (Fireplace val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || !val.m_canRefill || val.m_infiniteFuel || (Object)(object)val.m_fuelItem == (Object)null || val.m_fuelItem.m_itemData == null || val.m_fuelItem.m_itemData.m_shared == null)
			{
				continue;
			}
			string name = val.m_fuelItem.m_itemData.m_shared.m_name;
			if (string.IsNullOrEmpty(name))
			{
				continue;
			}
			ZNetView component = ((Component)val).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				continue;
			}
			float num2 = component.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);
			if ((float)Mathf.CeilToInt(num2) >= val.m_maxFuel)
			{
				continue;
			}
			float num3 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
			if (num3 > 30f)
			{
				continue;
			}
			if ((Object)(object)m_inventory != (Object)null && m_inventory.GetAmount(name) > 0)
			{
				if (num3 < num)
				{
					num = num3;
					targetFireplace = val;
					m_targetFireplaceFuelItemName = name;
				}
			}
			else if (num3 < num)
			{
				num = num3;
				targetFireplace = val;
				m_targetFireplaceFuelItemName = name;
			}
		}
		m_targetFireplace = targetFireplace;
	}

	private void UpdateMovingToFireplace()
	{
		//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetFireplace == (Object)null)
		{
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		if (!((Component)m_targetFireplace).gameObject.activeInHierarchy)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		if ((Object)(object)m_targetFireplace.m_fuelItem == (Object)null || m_targetFireplace.m_fuelItem.m_itemData == null || m_targetFireplace.m_fuelItem.m_itemData.m_shared == null)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		m_targetFireplaceFuelItemName = m_targetFireplace.m_fuelItem.m_itemData.m_shared.m_name;
		ZNetView component = ((Component)m_targetFireplace).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		float num = component.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);
		if ((float)Mathf.CeilToInt(num) >= m_targetFireplace.m_maxFuel)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
		}
		else if ((Object)(object)m_inventory != (Object)null && m_inventory.GetAmount(m_targetFireplaceFuelItemName) > 0)
		{
			if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetFireplace).transform.position, 2.5f))
			{
				CurrentState = WorkerState.DepositingToFireplace;
			}
		}
		else
		{
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
		}
	}

	private void UpdateSearchingForFireplaceFuel()
	{
		if ((Object)(object)m_inventory == (Object)null || string.IsNullOrEmpty(m_targetFireplaceFuelItemName))
		{
			CurrentState = WorkerState.SearchingForFireplace;
			return;
		}
		if (m_inventory.GetAmount(m_targetFireplaceFuelItemName) > 0)
		{
			CurrentState = WorkerState.MovingToFireplaceWithFuel;
			return;
		}
		m_searchTimer += Time.deltaTime;
		if (!(m_searchTimer < 5f))
		{
			m_searchTimer = 0f;
			FindNearestFireplaceFuelChest(m_targetFireplaceFuelItemName);
			if ((Object)(object)m_targetFireplaceFuelChest != (Object)null)
			{
				CurrentState = WorkerState.MovingToFireplaceFuelChest;
			}
		}
	}

	private void FindNearestFireplaceFuelChest(string itemName)
	{
		//IL_008c: 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)
		m_targetFireplaceFuelChest = null;
		if (string.IsNullOrEmpty(itemName))
		{
			return;
		}
		Container targetFireplaceFuelChest = null;
		float num = float.MaxValue;
		Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
		Container[] array2 = array;
		foreach (Container val in array2)
		{
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || !val.IsOwner() || val.IsInUse())
			{
				continue;
			}
			float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position);
			if (!(num2 > 30f))
			{
				Inventory inventory = val.GetInventory();
				if (inventory != null && inventory.ContainsItemByName(itemName) && num2 < num)
				{
					num = num2;
					targetFireplaceFuelChest = val;
				}
			}
		}
		m_targetFireplaceFuelChest = targetFireplaceFuelChest;
	}

	private void UpdateMovingToFireplaceFuelChest()
	{
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetFireplaceFuelChest == (Object)null)
		{
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
		}
		else if ((Object)(object)m_inventory == (Object)null || string.IsNullOrEmpty(m_targetFireplaceFuelItemName))
		{
			CurrentState = WorkerState.Inactive;
		}
		else if (m_inventory.GetAmount(m_targetFireplaceFuelItemName) > 0)
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.MovingToFireplaceWithFuel;
		}
		else if (!((Component)m_targetFireplaceFuelChest).gameObject.activeInHierarchy || m_targetFireplaceFuelChest.IsInUse())
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetFireplaceFuelChest).transform.position, 2.5f))
		{
			CurrentState = WorkerState.RetrievingFireplaceFuel;
		}
	}

	private void UpdateRetrievingFireplaceFuel()
	{
		if ((Object)(object)m_targetFireplaceFuelChest == (Object)null || (Object)(object)m_inventory == (Object)null || string.IsNullOrEmpty(m_targetFireplaceFuelItemName))
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.SearchingForFireplace;
			return;
		}
		Inventory inventory = m_targetFireplaceFuelChest.GetInventory();
		if (inventory == null)
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
			return;
		}
		ItemData item = inventory.GetItem(m_targetFireplaceFuelItemName, -1, false);
		if (item == null || item.m_stack <= 0)
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
			return;
		}
		int amount = m_inventory.GetAmount(m_targetFireplaceFuelItemName);
		int num = m_inventory.GetCapacity(m_targetFireplaceFuelItemName) - amount;
		if (num <= 0)
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.MovingToFireplaceWithFuel;
			return;
		}
		int num2 = Mathf.Min(num, item.m_stack);
		if (!m_inventory.AddItem(m_targetFireplaceFuelItemName, num2))
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
		}
		else if (!inventory.RemoveItem(item, num2))
		{
			m_inventory.RemoveItem(m_targetFireplaceFuelItemName, num2);
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
		}
		else
		{
			m_targetFireplaceFuelChest = null;
			CurrentState = WorkerState.MovingToFireplaceWithFuel;
		}
	}

	private void UpdateMovingToFireplaceWithFuel()
	{
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_targetFireplace == (Object)null || (Object)(object)m_inventory == (Object)null || string.IsNullOrEmpty(m_targetFireplaceFuelItemName))
		{
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
		}
		else if (m_inventory.GetAmount(m_targetFireplaceFuelItemName) <= 0)
		{
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
		}
		else if (!((Component)m_targetFireplace).gameObject.activeInHierarchy)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
		}
		else if (WorkerMovement.MoveTo(m_monsterAI, Time.deltaTime, ((Component)m_targetFireplace).transform.position, 2.5f))
		{
			CurrentState = WorkerState.DepositingToFireplace;
		}
	}

	private void UpdateDepositingToFireplace()
	{
		if ((Object)(object)m_targetFireplace == (Object)null || (Object)(object)m_inventory == (Object)null || string.IsNullOrEmpty(m_targetFireplaceFuelItemName))
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			return;
		}
		if (!((Component)m_targetFireplace).gameObject.activeInHierarchy)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		ZNetView component = ((Component)m_targetFireplace).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		float num = component.GetZDO().GetFloat(ZDOVars.s_fuel, 0f);
		if ((float)Mathf.CeilToInt(num) >= m_targetFireplace.m_maxFuel)
		{
			m_targetFireplace = null;
			m_targetFireplaceFuelItemName = null;
			CurrentState = WorkerState.SearchingForFireplace;
			m_searchTimer = 5f;
			return;
		}
		if (m_inventory.GetAmount(m_targetFireplaceFuelItemName) <= 0)
		{
			CurrentState = WorkerState.SearchingForFireplaceFuel;
			m_searchTimer = 5f;
			return;
		}
		Humanoid component2 = ((Component)this).GetComponent<Humanoid>();
		if ((Object)(object)component2 == (Object)null)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		Inventory inventory = component2.GetInventory();
		if (inventory == null)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		if ((Object)(object)m_targetFireplace.m_fuelItem == (Object)null || m_targetFireplace.m_fuelItem.m_itemData == null)
		{
			m_targetFireplace = null;
			CurrentState = WorkerState.Inactive;
			return;
		}
		I