using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.UI;
using ValheimVillages.Abilities;
using ValheimVillages.Attributes;
using ValheimVillages.Behaviors;
using ValheimVillages.Behaviors.Combat;
using ValheimVillages.Behaviors.Crafting;
using ValheimVillages.Behaviors.Farming;
using ValheimVillages.Behaviors.Patrol;
using ValheimVillages.Behaviors.Repair;
using ValheimVillages.Behaviors.Tidy;
using ValheimVillages.Behaviors.Work;
using ValheimVillages.Diagnostics;
using ValheimVillages.Enums;
using ValheimVillages.Interfaces;
using ValheimVillages.Items;
using ValheimVillages.Items.Icons;
using ValheimVillages.Items.VirtualRecipes;
using ValheimVillages.Items.WorkOrders;
using ValheimVillages.Patches;
using ValheimVillages.Schemas;
using ValheimVillages.Tags;
using ValheimVillages.TaskQueue;
using ValheimVillages.TaskQueue.ActivityLog;
using ValheimVillages.TaskQueue.Handlers;
using ValheimVillages.Testing;
using ValheimVillages.UI.ContextMenus;
using ValheimVillages.UI.Core;
using ValheimVillages.UI.Interaction;
using ValheimVillages.UI.Panels;
using ValheimVillages.UI.Tabs;
using ValheimVillages.Villager;
using ValheimVillages.Villager.AI;
using ValheimVillages.Villager.AI.Memory;
using ValheimVillages.Villager.AI.Navigation;
using ValheimVillages.Villager.AI.Pathfinding;
using ValheimVillages.Villager.AI.Work;
using ValheimVillages.Villager.Records;
using ValheimVillages.Villager.Registry;
using ValheimVillages.Villager.Station;
using ValheimVillages.Villages;
using ValheimVillages.Villages.Entity;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Valheim Villages")]
[assembly: AssemblyDescription("A village-building and NPC management mod for Valheim")]
[assembly: AssemblyCompany("Myrcutio")]
[assembly: AssemblyProduct("ValheimVillages")]
[assembly: AssemblyCopyright("Copyright © Myrcutio 2026")]
[assembly: AssemblyFileVersion("0.1.1")]
[assembly: InternalsVisibleTo("ValheimVillages.Tests")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.1.1.0")]
namespace ValheimVillages
{
	internal static class DebugLog
	{
		private sealed class ThrottleState
		{
			public bool EverEmitted;

			public TimeSpan LastEmitted;

			public int Suppressed;
		}

		private static int _captureCounter;

		private static DebugCaptureBehaviour _captureBehaviour;

		private static readonly string LogPath = Path.Combine(Paths.ConfigPath, "vv_dumps", "legacy_debug.ndjson");

		private static int _cycleNumber;

		private static readonly Dictionary<string, ThrottleState> _throttle = new Dictionary<string, ThrottleState>();

		private static readonly TimeSpan DefaultThrottleWindow = TimeSpan.FromSeconds(10.0);

		private static readonly Stopwatch _sessionClock = Stopwatch.StartNew();

		private static string SidecarDir
		{
			get
			{
				string path;
				try
				{
					path = Paths.ConfigPath;
				}
				catch
				{
					path = ".";
				}
				return Path.Combine(path, "vv_dumps");
			}
		}

		public static void Capture(string trigger)
		{
			Capture(CaptureRequest.Default(trigger));
		}

		public static void Capture(CaptureRequest request)
		{
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					if ((Object)(object)_captureBehaviour == (Object)null)
					{
						_captureBehaviour = ((Component)instance).gameObject.GetComponent<DebugCaptureBehaviour>() ?? ((Component)instance).gameObject.AddComponent<DebugCaptureBehaviour>();
					}
					_captureBehaviour.Enqueue(request);
				}
			}
			catch
			{
			}
		}

		internal static int NextCaptureCounter()
		{
			return Interlocked.Increment(ref _captureCounter);
		}

		public static string Vid(Guid id)
		{
			string text = id.ToString("N");
			if (text.Length < 8)
			{
				return text;
			}
			return text.Substring(0, 8);
		}

		public static string Vid(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return "unknown";
			}
			if (Guid.TryParse(id, out var result))
			{
				return Vid(result);
			}
			string text = id.Replace("-", "");
			if (text.Length < 8)
			{
				return text;
			}
			return text.Substring(0, 8);
		}

		public static string Tid(string taskName, int instanceId)
		{
			return (taskName ?? "task") + "#" + instanceId;
		}

		public static void Append(string location, string message, Dictionary<string, object> data, string hypothesisId, string runId)
		{
			try
			{
				long num = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append('{');
				stringBuilder.AppendFormat("\"timestamp\":{0}", num);
				stringBuilder.AppendFormat(",\"location\":\"{0}\"", Esc(location));
				stringBuilder.AppendFormat(",\"message\":\"{0}\"", Esc(message));
				stringBuilder.AppendFormat(",\"hypothesisId\":\"{0}\"", Esc(hypothesisId));
				stringBuilder.AppendFormat(",\"runId\":\"{0}\"", Esc(runId));
				stringBuilder.Append(",\"data\":{");
				bool flag = true;
				foreach (KeyValuePair<string, object> datum in data)
				{
					if (!flag)
					{
						stringBuilder.Append(',');
					}
					flag = false;
					stringBuilder.AppendFormat("\"{0}\":", Esc(datum.Key));
					if (datum.Value is string v)
					{
						stringBuilder.AppendFormat("\"{0}\"", Esc(v));
					}
					else if (datum.Value is bool flag2)
					{
						stringBuilder.Append(flag2 ? "true" : "false");
					}
					else if (datum.Value is float num2)
					{
						stringBuilder.Append(num2.ToString(CultureInfo.InvariantCulture));
					}
					else if (datum.Value is double num3)
					{
						stringBuilder.Append(num3.ToString(CultureInfo.InvariantCulture));
					}
					else
					{
						stringBuilder.Append(datum.Value?.ToString() ?? "null");
					}
				}
				stringBuilder.Append("}}");
				File.AppendAllText(LogPath, stringBuilder?.ToString() + "\n");
			}
			catch
			{
			}
		}

		private static string Esc(string v)
		{
			return v?.Replace("\\", "\\\\").Replace("\"", "\\\"") ?? "";
		}

		public static void BeginCycle(bool isHotReload)
		{
			int num = Interlocked.Increment(ref _cycleNumber);
			string arg = (isHotReload ? "true" : "false");
			string arg2 = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
			Plugin.Log.LogInfo((object)$"===== VV CYCLE n={num} hot={arg} t={arg2} =====");
		}

		public static void Event(string component, string eventName, params (string key, object val)[] kv)
		{
			StringBuilder stringBuilder = new StringBuilder(64 + ((kv != null) ? kv.Length : 0) * 16);
			stringBuilder.Append('[').Append(component).Append("] ")
				.Append(eventName);
			stringBuilder.Append(' ').Append(T());
			if (kv != null)
			{
				for (int i = 0; i < kv.Length; i++)
				{
					stringBuilder.Append(' ').Append(kv[i].key).Append('=');
					AppendValue(stringBuilder, kv[i].val);
				}
			}
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
		}

		private static void AppendValue(StringBuilder sb, object v)
		{
			if (v == null)
			{
				sb.Append("null");
				return;
			}
			string text = ((v is float num) ? num.ToString("0.###", CultureInfo.InvariantCulture) : ((v is double num2) ? num2.ToString("0.###", CultureInfo.InvariantCulture) : ((!(v is bool)) ? (v.ToString() ?? "") : (((bool)v) ? "true" : "false"))));
			bool flag = false;
			foreach (char c in text)
			{
				if (c == ' ' || c == '=' || c == '"')
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				sb.Append('"').Append(text.Replace("\"", "\\\"")).Append('"');
			}
			else
			{
				sb.Append(text);
			}
		}

		public static void List(string component, string name, IEnumerable<object> items)
		{
			string[] array = items?.Select((object i) => i?.ToString() ?? "null").ToArray() ?? new string[0];
			string text = ShortSha(string.Join(",", array));
			string sidecarDir = SidecarDir;
			string text2 = Path.Combine(sidecarDir, name + "_" + text + ".json");
			try
			{
				Directory.CreateDirectory(sidecarDir);
				if (!File.Exists(text2))
				{
					StringBuilder stringBuilder = new StringBuilder();
					stringBuilder.Append('[');
					for (int num = 0; num < array.Length; num++)
					{
						if (num > 0)
						{
							stringBuilder.Append(',');
						}
						stringBuilder.Append('"').Append(JsonEscape(array[num])).Append('"');
					}
					stringBuilder.Append(']');
					File.WriteAllText(text2, stringBuilder.ToString());
				}
			}
			catch
			{
			}
			Event(component, name, ("count", array.Length), ("sha", text), ("path", text2));
		}

		private static string ShortSha(string s)
		{
			using SHA1 sHA = SHA1.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(s ?? ""));
			StringBuilder stringBuilder = new StringBuilder(8);
			for (int i = 0; i < 4; i++)
			{
				stringBuilder.AppendFormat("{0:x2}", array[i]);
			}
			return stringBuilder.ToString();
		}

		private static string JsonEscape(string s)
		{
			return (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r")
				.Replace("\t", "\\t");
		}

		public static void Throttled(string key, string component, string eventName, params (string key, object val)[] kv)
		{
			ThrottledWindow(key, DefaultThrottleWindow, component, eventName, kv);
		}

		public static void ThrottledWindow(string key, TimeSpan window, string component, string eventName, params (string key, object val)[] kv)
		{
			if (string.IsNullOrEmpty(key))
			{
				Event(component, eventName, kv);
				return;
			}
			ThrottleState value;
			lock (_throttle)
			{
				if (!_throttle.TryGetValue(key, out value))
				{
					value = new ThrottleState();
					_throttle[key] = value;
				}
			}
			lock (value)
			{
				TimeSpan timeSpan = Elapsed();
				bool num = !value.EverEmitted;
				bool flag = timeSpan - value.LastEmitted >= window;
				if (num || flag)
				{
					if (value.Suppressed > 0)
					{
						(string, object)[] array = new(string, object)[kv.Length + 2];
						Array.Copy(kv, array, kv.Length);
						array[kv.Length] = ("suppressed", value.Suppressed);
						array[kv.Length + 1] = ("window_s", window.TotalSeconds);
						Event(component, eventName, array);
					}
					else
					{
						Event(component, eventName, kv);
					}
					value.LastEmitted = timeSpan;
					value.EverEmitted = true;
					value.Suppressed = 0;
				}
				else
				{
					value.Suppressed++;
				}
			}
		}

		public static TimeSpan Elapsed()
		{
			return _sessionClock.Elapsed;
		}

		public static string T()
		{
			return "t=+" + _sessionClock.Elapsed.TotalSeconds.ToString("0.00", CultureInfo.InvariantCulture) + "s";
		}
	}
	internal readonly struct CaptureRequest
	{
		public readonly string Trigger;

		public readonly string OutputSubdir;

		public readonly string OutputBaseName;

		public readonly Vector3? AnchorOverride;

		public readonly float AnchorClearance;

		public readonly bool IncludeDiagnostics;

		public CaptureRequest(string trigger, string outputSubdir, string outputBaseName, Vector3? anchorOverride, float anchorClearance, bool includeDiagnostics)
		{
			Trigger = trigger ?? "unknown";
			OutputSubdir = outputSubdir ?? "";
			OutputBaseName = (string.IsNullOrEmpty(outputBaseName) ? "last_capture" : outputBaseName);
			AnchorOverride = anchorOverride;
			AnchorClearance = anchorClearance;
			IncludeDiagnostics = includeDiagnostics;
		}

		public static CaptureRequest Default(string trigger)
		{
			return new CaptureRequest(trigger, "", "last_capture", null, 45f, includeDiagnostics: true);
		}

		public static CaptureRequest ForIncident(string trigger, string incidentSubdir, string baseName, Vector3 anchor, float clearance)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new CaptureRequest(trigger, incidentSubdir, baseName, anchor, clearance, includeDiagnostics: false);
		}
	}
	internal class DebugCaptureBehaviour : MonoBehaviour
	{
		private readonly ConcurrentQueue<CaptureRequest> _pending = new ConcurrentQueue<CaptureRequest>();

		private bool _processing;

		private static readonly HashSet<string> OrchestratedTriggers = new HashSet<string> { "repartition", "manual" };

		private void Update()
		{
			if (!_processing && !_pending.IsEmpty)
			{
				((MonoBehaviour)this).StartCoroutine(ProcessQueue());
			}
		}

		public void Enqueue(CaptureRequest req)
		{
			_pending.Enqueue(req);
		}

		private IEnumerator ProcessQueue()
		{
			_processing = true;
			try
			{
				CaptureRequest result;
				while (_pending.TryDequeue(out result))
				{
					int counter = DebugLog.NextCaptureCounter();
					yield return CaptureRoutine(result, counter);
					yield return null;
				}
			}
			finally
			{
				_processing = false;
			}
		}

		private IEnumerator CaptureRoutine(CaptureRequest req, int counter)
		{
			yield return (object)new WaitForSecondsRealtime(0.6f);
			Camera cam = Camera.main;
			if ((Object)(object)cam == (Object)null)
			{
				yield break;
			}
			OrchestrationSession session = null;
			if (OrchestratedTriggers.Contains(req.Trigger) || req.AnchorOverride.HasValue)
			{
				session = OrchestrationSession.TryBegin(req);
				session?.LogStarted(req.Trigger, session.AnchorPos);
			}
			try
			{
				if (session != null)
				{
					yield return null;
				}
				session?.ApplyCameraPose();
				Vector3 pos = ((Component)cam).transform.position;
				Vector3 euler = ((Component)cam).transform.eulerAngles;
				float worldTime = -1f;
				try
				{
					if ((Object)(object)EnvMan.instance != (Object)null)
					{
						worldTime = EnvMan.instance.GetDayFraction();
					}
				}
				catch
				{
				}
				yield return (object)new WaitForEndOfFrame();
				WritePngAndSidecar(req, counter, pos, euler, worldTime);
			}
			finally
			{
				session?.Restore();
			}
		}

		private static void WritePngAndSidecar(CaptureRequest req, int counter, Vector3 pos, Vector3 euler, float worldTime)
		{
			string text;
			try
			{
				string path;
				try
				{
					path = Paths.ConfigPath;
				}
				catch
				{
					path = ".";
				}
				text = Path.Combine(path, "vv_dumps");
				if (!string.IsNullOrEmpty(req.OutputSubdir))
				{
					text = Path.Combine(text, req.OutputSubdir);
				}
				Directory.CreateDirectory(text);
			}
			catch
			{
				return;
			}
			string path2 = Path.Combine(text, req.OutputBaseName + ".png");
			string path3 = Path.Combine(text, req.OutputBaseName + ".json");
			Texture2D val = null;
			try
			{
				val = ScreenCapture.CaptureScreenshotAsTexture();
				byte[] bytes = ImageConversion.EncodeToPNG(val);
				File.WriteAllBytes(path2, bytes);
			}
			catch
			{
			}
			finally
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder(2048);
				stringBuilder.Append('{');
				stringBuilder.Append("\"counter\":").Append(counter.ToString(CultureInfo.InvariantCulture)).Append(',');
				stringBuilder.Append("\"trigger\":\"").Append(JsonEscape(req.Trigger)).Append("\",");
				stringBuilder.Append("\"timestampUtc\":\"").Append(DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)).Append("\",");
				stringBuilder.Append("\"worldTimeOfDay\":").Append(worldTime.ToString("R", CultureInfo.InvariantCulture)).Append(',');
				stringBuilder.Append("\"cameraPos\":[").Append(pos.x.ToString("R", CultureInfo.InvariantCulture)).Append(',')
					.Append(pos.y.ToString("R", CultureInfo.InvariantCulture))
					.Append(',')
					.Append(pos.z.ToString("R", CultureInfo.InvariantCulture))
					.Append("],");
				stringBuilder.Append("\"cameraYaw\":").Append(euler.y.ToString("R", CultureInfo.InvariantCulture)).Append(',');
				stringBuilder.Append("\"cameraPitch\":").Append(euler.x.ToString("R", CultureInfo.InvariantCulture));
				if (req.IncludeDiagnostics)
				{
					AppendDiagnostics(stringBuilder);
				}
				stringBuilder.Append('}');
				File.WriteAllText(path3, stringBuilder.ToString());
			}
			catch
			{
			}
		}

		private static void AppendDiagnostics(StringBuilder sb)
		{
			sb.Append(",\"diagnostics\":{");
			sb.Append("\"lastRelaxation\":{\"available\":false},");
			sb.Append("\"villages\":[");
			bool flag = true;
			try
			{
				foreach (RegionGraph item in VillageRegistry.AllGraphs())
				{
					if (!flag)
					{
						sb.Append(',');
					}
					flag = false;
					sb.Append('{');
					sb.Append("\"key\":\"").Append(JsonEscape(item.RegisteredVillageKey ?? "")).Append("\",");
					sb.Append("\"regionCount\":").Append(item.RegionCount).Append(',');
					sb.Append("\"linkCount\":").Append(item.LinkCount).Append(',');
					sb.Append("\"bfsCells\":").Append(item.Diagnostics.LookupGridCellCount).Append(',');
					sb.Append("\"boundaryCells\":").Append(item.Diagnostics.BoundaryCellCount).Append(',');
					sb.Append("\"bfsBounds\":");
					AppendBounds(sb, item.Diagnostics.TryGetLookupGridBounds(out var minX, out var maxX, out var minZ, out var maxZ), minX, maxX, minZ, maxZ);
					sb.Append(",\"boundaryBounds\":");
					AppendBounds(sb, item.Diagnostics.TryGetBoundaryCellsBounds(out var minX2, out var maxX2, out var minZ2, out var maxZ2), minX2, maxX2, minZ2, maxZ2);
					sb.Append('}');
				}
			}
			catch
			{
			}
			sb.Append(']');
			sb.Append('}');
		}

		private static void AppendBounds(StringBuilder sb, bool ok, float minX, float maxX, float minZ, float maxZ)
		{
			if (!ok)
			{
				sb.Append("null");
			}
			else
			{
				sb.Append("{\"x\":[").Append(minX.ToString("R", CultureInfo.InvariantCulture)).Append(',')
					.Append(maxX.ToString("R", CultureInfo.InvariantCulture))
					.Append("],\"z\":[")
					.Append(minZ.ToString("R", CultureInfo.InvariantCulture))
					.Append(',')
					.Append(maxZ.ToString("R", CultureInfo.InvariantCulture))
					.Append("]}");
			}
		}

		private static string JsonFloat(float v)
		{
			if (float.IsNaN(v) || float.IsInfinity(v))
			{
				return "null";
			}
			return v.ToString("R", CultureInfo.InvariantCulture);
		}

		private static string JsonEscape(string s)
		{
			return (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r")
				.Replace("\t", "\\t");
		}
	}
	internal class OrchestrationSession
	{
		private readonly Player m_player;

		private readonly Vector3 m_savedPos;

		private readonly Quaternion m_savedRot;

		private readonly Hud m_hud;

		private readonly bool m_savedHudVisible;

		private readonly Vector3 m_savedCamPos;

		private readonly Quaternion m_savedCamRot;

		private readonly GameCamera m_gameCamera;

		private readonly bool m_savedGameCameraEnabled;

		private readonly Vector3 m_anchorPos;

		private readonly Quaternion m_anchorRot;

		public Vector3 AnchorPos => m_anchorPos;

		private OrchestrationSession(Player player, Vector3 savedPos, Quaternion savedRot, Hud hud, bool savedHudVisible, Vector3 savedCamPos, Quaternion savedCamRot, GameCamera gameCamera, bool savedGameCameraEnabled, Vector3 anchorPos, Quaternion anchorRot)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004e: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			m_player = player;
			m_savedPos = savedPos;
			m_savedRot = savedRot;
			m_hud = hud;
			m_savedHudVisible = savedHudVisible;
			m_savedCamPos = savedCamPos;
			m_savedCamRot = savedCamRot;
			m_gameCamera = gameCamera;
			m_savedGameCameraEnabled = savedGameCameraEnabled;
			m_anchorPos = anchorPos;
			m_anchorRot = anchorRot;
		}

		public void ApplyCameraPose()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			try
			{
				((Component)main).transform.position = m_anchorPos;
				((Component)main).transform.rotation = m_anchorRot;
			}
			catch
			{
			}
		}

		public static OrchestrationSession TryBegin(CaptureRequest req)
		{
			//IL_0054: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[Capture] Orchestration skipped: no local player. Falling back to passive capture.");
				}
				return null;
			}
			CaptureAnchor.Result result = ((!req.AnchorOverride.HasValue) ? CaptureAnchor.Resolve(((Component)localPlayer).transform.position) : CaptureAnchor.ResolveAt(req.AnchorOverride.Value, req.AnchorClearance));
			if (!result.HasAnchor)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[Capture] Orchestration skipped: " + result.Reason + ". Falling back to passive capture (no silent coordinate fabrication)."));
				}
				return null;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			Quaternion rotation = ((Component)localPlayer).transform.rotation;
			Hud instance = Hud.instance;
			bool flag = true;
			try
			{
				if ((Object)(object)instance != (Object)null)
				{
					flag = ((Component)instance).gameObject.activeSelf;
				}
			}
			catch
			{
			}
			Camera main = Camera.main;
			Vector3 savedCamPos = (((Object)(object)main != (Object)null) ? ((Component)main).transform.position : Vector3.zero);
			Quaternion savedCamRot = (((Object)(object)main != (Object)null) ? ((Component)main).transform.rotation : Quaternion.identity);
			GameCamera instance2 = GameCamera.instance;
			bool flag2 = (Object)(object)instance2 != (Object)null && ((Behaviour)instance2).enabled;
			Quaternion val = Quaternion.Euler(result.Pitch, result.Yaw, 0f);
			try
			{
				((Component)localPlayer).transform.position = result.Pos;
				((Component)localPlayer).transform.rotation = val;
				if ((Object)(object)main != (Object)null)
				{
					((Component)main).transform.position = result.Pos;
					((Component)main).transform.rotation = val;
				}
				if ((Object)(object)instance2 != (Object)null)
				{
					((Behaviour)instance2).enabled = false;
				}
				if ((Object)(object)instance != (Object)null)
				{
					((Component)instance).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[Capture] Orchestration apply failed: " + ex.GetType().Name + ": " + ex.Message + ". Restoring state and falling back to passive capture."));
				}
				try
				{
					((Component)localPlayer).transform.position = position;
					((Component)localPlayer).transform.rotation = rotation;
				}
				catch
				{
				}
				try
				{
					if ((Object)(object)instance2 != (Object)null)
					{
						((Behaviour)instance2).enabled = flag2;
					}
				}
				catch
				{
				}
				try
				{
					if ((Object)(object)instance != (Object)null)
					{
						((Component)instance).gameObject.SetActive(flag);
					}
				}
				catch
				{
				}
				return null;
			}
			return new OrchestrationSession(localPlayer, position, rotation, instance, flag, savedCamPos, savedCamRot, instance2, flag2, result.Pos, val);
		}

		public void LogStarted(string trigger, Vector3 anchorPos)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Capture] Orchestrated trigger='{trigger}' anchor=({anchorPos.x:F1},{anchorPos.y:F1},{anchorPos.z:F1}) yaw=0 pitch=90");
			}
		}

		public void Restore()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)m_player != (Object)null)
				{
					((Component)m_player).transform.position = m_savedPos;
					((Component)m_player).transform.rotation = m_savedRot;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)m_gameCamera != (Object)null)
				{
					((Behaviour)m_gameCamera).enabled = m_savedGameCameraEnabled;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)m_hud != (Object)null)
				{
					((Component)m_hud).gameObject.SetActive(m_savedHudVisible);
				}
			}
			catch
			{
			}
		}
	}
	public static class HotReloadHelper
	{
		private const string ModPrefix = "VV_";

		private const string ModPrefabPrefix = "vv_";

		private const string VillagerStationPrefix = "$vv_";

		private static readonly Assembly CurrentAssembly = typeof(HotReloadHelper).Assembly;

		public static void FullCleanup()
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[HotReload] Starting full cleanup...");
			}
			ResetAllStaticState();
			int num = DestroyStaleComponents();
			int num2 = DestroyOrphanedModObjects();
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)("[HotReload] Cleanup complete: " + $"{num} stale component(s), " + $"{num2} orphaned GameObject(s) destroyed."));
			}
		}

		public static string PurgeStaleObjects()
		{
			string arg = ReportModInstances();
			int num = DestroyStaleComponents();
			return $"{arg}\n[HotReload] Purged {num} stale component(s).";
		}

		public static string ReportModInstances()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>();
			MonoBehaviour[] array = Object.FindObjectsByType<MonoBehaviour>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (MonoBehaviour val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Type type = ((object)val).GetType();
					if (type.FullName != null && type.FullName.StartsWith("ValheimVillages."))
					{
						Dictionary<string, int> obj = ((type.Assembly == CurrentAssembly) ? dictionary : dictionary2);
						obj.TryGetValue(type.Name, out var value);
						obj[type.Name] = value + 1;
					}
				}
			}
			int num = 0;
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, int> item in dictionary2)
			{
				num += item.Value;
				list.Add($"  STALE {item.Key} x{item.Value}");
			}
			string text = $"[HotReload] Mod MonoBehaviours: {dictionary.Count} current type(s), " + $"{num} stale instance(s)";
			if (list.Count <= 0)
			{
				return text;
			}
			return text + "\n" + string.Join("\n", list);
		}

		private static void ResetAllStaticState()
		{
			AttributeScanner.InvokeAllCleanup(CurrentAssembly);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)"[HotReload] All static registries cleared.");
			}
		}

		private static int DestroyStaleComponents()
		{
			int num = 0;
			MonoBehaviour[] array = Object.FindObjectsByType<MonoBehaviour>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				string fullName = type.FullName;
				if (fullName != null && fullName.StartsWith("ValheimVillages.") && !(type.Assembly == CurrentAssembly))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)("[HotReload] Destroying stale component: " + fullName + " on \"" + ((Object)((Component)val).gameObject).name + "\""));
					}
					((Behaviour)val).enabled = false;
					Object.Destroy((Object)(object)val);
					num++;
				}
			}
			return num;
		}

		private static int DestroyOrphanedModObjects()
		{
			int num = 0;
			Transform[] array = Object.FindObjectsByType<Transform>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			List<GameObject> list = new List<GameObject>();
			Transform[] array2 = array;
			foreach (Transform val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					GameObject gameObject = ((Component)val).gameObject;
					string name = ((Object)gameObject).name;
					if ((AttributeScanner.GetModObjectNames(CurrentAssembly).Contains(name) || name.StartsWith("VV_") || name.StartsWith("vv_")) && !((Object)(object)gameObject.GetComponentInParent<ZNetView>(true) != (Object)null) && !HasCurrentAssemblyComponent(gameObject))
					{
						list.Add(gameObject);
					}
				}
			}
			foreach (GameObject item in list)
			{
				if (!((Object)(object)item == (Object)null))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)("[HotReload] Destroying orphaned mod object: \"" + ((Object)item).name + "\""));
					}
					item.SetActive(false);
					Object.Destroy((Object)(object)item);
					num++;
				}
			}
			return num;
		}

		private static bool HasCurrentAssemblyComponent(GameObject go)
		{
			MonoBehaviour[] components = go.GetComponents<MonoBehaviour>();
			foreach (MonoBehaviour val in components)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Type type = ((object)val).GetType();
					if (type.FullName != null && type.FullName.StartsWith("ValheimVillages.") && type.Assembly == CurrentAssembly)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static void FixupExistingNPCs()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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)
			int num = 0;
			ZNetView[] array = Object.FindObjectsOfType<ZNetView>();
			foreach (ZNetView val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				ZDO zDO = val.GetZDO();
				if (zDO == null || zDO.GetPrefab() == RecordPrefabFactory.RecordPrefabHash || NativeNpcStripper.IsPlayerOwned(((Component)val).gameObject) || (string.IsNullOrEmpty(zDO.GetString("vv_record_id", "")) && string.IsNullOrEmpty(zDO.GetString("vv_villager_type", ""))))
				{
					continue;
				}
				if (zDO.GetVec3("vv_home_position", Vector3.zero) == Vector3.zero)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)($"[HotReload] NPC at {((Component)val).transform.position} " + "has no anchor position stored, skipping"));
					}
					continue;
				}
				RemoveOrphanedCraftingStations(((Component)val).gameObject);
				VillagerRestoration.Restore(((Component)val).gameObject, zDO);
				num++;
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogDebug((object)$"[HotReload] Fixed up NPC at {((Component)val).transform.position}");
				}
			}
			if (num > 0)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)$"[HotReload] Fixed up {num} existing NPC(s)");
				}
			}
		}

		public static void FixupExistingRegistries()
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode("vv_village_registry");
			int num = 0;
			ZNetView[] array = Object.FindObjectsOfType<ZNetView>();
			foreach (ZNetView val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					ZDO zDO = val.GetZDO();
					if (zDO != null && zDO.GetPrefab() == stableHashCode)
					{
						PieceFactory.ReapplyInteractionToInstance(((Component)val).gameObject);
						num++;
					}
				}
			}
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[HotReload] Re-applied interaction to {num} placed registry station(s)");
				}
			}
		}

		private static void RemoveOrphanedCraftingStations(GameObject go)
		{
			CraftingStation[] components = go.GetComponents<CraftingStation>();
			foreach (CraftingStation val in components)
			{
				if (!((Object)(object)val == (Object)null) && val.m_name != null && val.m_name.StartsWith("$vv_"))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)("[HotReload] Removing orphaned CraftingStation '" + val.m_name + "' on \"" + ((Object)go).name + "\""));
					}
					((Behaviour)val).enabled = false;
					Object.Destroy((Object)(object)val);
				}
			}
		}
	}
	public static class PathTelemetry
	{
		[Serializable]
		private class HnaGraphData
		{
			public int regionCount;

			public int linkCount;

			public float minX;

			public float minZ;

			public float maxX;

			public float maxZ;

			public string regionCenters;

			public string linksSummary;
		}

		[Serializable]
		private class HnaPlayerDebugData
		{
			public float px;

			public float py;

			public float pz;

			public string regionId;

			public bool graphAvailable;

			public bool regionValid;

			public float solidHeightAtPosition;

			public float cellMinX;

			public float cellMaxX;

			public float cellMinZ;

			public float cellMaxZ;

			public float centerY;

			public float minY;

			public float maxY;

			public float verticalSpread;
		}

		private static readonly string LogPath = Path.Combine(Paths.ConfigPath, "vv_dumps", "path_telemetry.ndjson");

		private static readonly object Lock = new object();

		public static void LogRegionGraph(int regionCount, int linkCount, float minX, float minZ, float maxX, float maxZ, string regionCenters, string linksSummary)
		{
			HnaGraphData hnaGraphData = new HnaGraphData
			{
				regionCount = regionCount,
				linkCount = linkCount,
				minX = (float)Math.Round(minX, 2),
				minZ = (float)Math.Round(minZ, 2),
				maxX = (float)Math.Round(maxX, 2),
				maxZ = (float)Math.Round(maxZ, 2),
				regionCenters = (regionCenters ?? ""),
				linksSummary = (linksSummary ?? "")
			};
			Write("hna_graph", JsonUtility.ToJson((object)hnaGraphData), "hna");
		}

		public static void LogHnaPlayerDebug(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			float px = (float)Math.Round(position.x, 2);
			float py = (float)Math.Round(position.y, 2);
			float pz = (float)Math.Round(position.z, 2);
			RegionGraph regionGraph = VillageRegistry.GraphAt(position);
			string text = regionGraph?.PointToRegionId(position);
			float originX;
			float originZ;
			bool graphAvailable = regionGraph?.GetOrigin(out originX, out originZ) ?? false;
			bool flag = regionGraph != null && !string.IsNullOrEmpty(text) && regionGraph.IsValidRegion(text);
			float num = 0f;
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				ZoneSystem.instance.GetSolidHeight(new Vector3(position.x, 0f, position.z), ref num, 500);
			}
			float cellMinX = 0f;
			float cellMaxX = 0f;
			float cellMinZ = 0f;
			float cellMaxZ = 0f;
			float centerY = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float minX = 0f;
			float maxX = 0f;
			float minZ = 0f;
			float maxZ = 0f;
			if (flag && regionGraph.GetRegionBounds(text, out minX, out maxX, out minZ, out maxZ))
			{
				cellMinX = (float)Math.Round(minX, 2);
				cellMaxX = (float)Math.Round(maxX, 2);
				cellMinZ = (float)Math.Round(minZ, 2);
				cellMaxZ = (float)Math.Round(maxZ, 2);
			}
			float centerY2 = 0f;
			float minY = 0f;
			float maxY = 0f;
			if (flag && regionGraph.GetRegionSampleHeights(text, out centerY2, out minY, out maxY))
			{
				centerY = (float)Math.Round(centerY2, 2);
				num2 = (float)Math.Round(minY, 2);
				num3 = (float)Math.Round(maxY, 2);
			}
			HnaPlayerDebugData hnaPlayerDebugData = new HnaPlayerDebugData
			{
				px = px,
				py = py,
				pz = pz,
				regionId = (text ?? ""),
				graphAvailable = graphAvailable,
				regionValid = flag,
				solidHeightAtPosition = (float)Math.Round(num, 2),
				cellMinX = cellMinX,
				cellMaxX = cellMaxX,
				cellMinZ = cellMinZ,
				cellMaxZ = cellMaxZ,
				centerY = centerY,
				minY = num2,
				maxY = num3,
				verticalSpread = (float)Math.Round(num3 - num2, 2)
			};
			Write("hna_player_debug", JsonUtility.ToJson((object)hnaPlayerDebugData), "hna_debug");
		}

		private static void Write(string message, string dataJson, string runId)
		{
			try
			{
				long num = (long)(Time.time * 1000f);
				string text = "pt_" + num;
				string contents = "{\"id\":\"" + text + "\",\"timestamp\":" + num + ",\"location\":\"PathTelemetry\",\"message\":\"" + Escape(message) + "\",\"data\":" + dataJson + ",\"runId\":\"" + Escape(runId) + "\",\"hypothesisId\":\"path_compare\"}\n";
				lock (Lock)
				{
					File.AppendAllText(LogPath, contents);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[PathTelemetry] Write failed: " + ex.Message));
				}
			}
		}

		private static string Escape(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			return s.Replace("\\", "\\\\").Replace("\"", "\\\"");
		}
	}
	public static class PhysicsHelper
	{
		public static T GetFirstInRadius<T>(Vector3 center, float radius) where T : Component
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(center, radius);
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					T componentInParent = ((Component)val).gameObject.GetComponentInParent<T>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						return componentInParent;
					}
				}
			}
			return default(T);
		}

		public static List<T> GetAllInRadius<T>(Vector3 center, float radius) where T : Component
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			List<T> list = new List<T>();
			Collider[] array = Physics.OverlapSphere(center, radius);
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					T componentInParent = ((Component)val).gameObject.GetComponentInParent<T>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						list.Add(componentInParent);
					}
				}
			}
			return list;
		}
	}
	[BepInPlugin("com.valheimvillages.mod", "Valheim Villages", "0.1.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.valheimvillages.mod";

		public const string PluginName = "Valheim Villages";

		public const string PluginVersion = "0.1.1";

		private static bool _recipeRefreshEnqueued;

		private static bool _regionPartitionEnqueued;

		private static bool _recordIndexEnqueued;

		private static bool _villageIndexEnqueued;

		private static float _hotReloadAt;

		private Harmony _harmony;

		public static readonly DateTime AssemblyLoadedAt = DateTime.UtcNow;

		public static ManualLogSource Log { get; private set; }

		public static Plugin Instance { get; private set; }

		public static bool LastLoadWasHotReload { get; private set; }

		private void Awake()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			bool num = (LastLoadWasHotReload = (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count > 0);
			DebugLog.BeginCycle(num);
			RegionGraphPersistence.LogAction = delegate(string msg)
			{
				Log.LogInfo((object)msg);
			};
			Log.LogInfo((object)"Valheim Villages v0.1.1 loading...");
			Harmony.UnpatchID("com.valheimvillages.mod");
			_harmony = new Harmony("com.valheimvillages.mod");
			_harmony.PatchAll();
			LocalizationPatch.RegisterTokens();
			if (num)
			{
				Log.LogInfo((object)"Hot reload detected — running full cleanup");
				HotReloadHelper.FullCleanup();
			}
			TaskHandlerRegistry.Clear();
			AttributeScanner.ScanAndRegister(typeof(Plugin).Assembly);
			if (num)
			{
				Log.LogInfo((object)"Hot reload — re-registering items in ObjectDB");
				ItemFactory.RegisterAll(ObjectDB.instance);
				VirtualRecipeLoader.RegisterAll(ObjectDB.instance);
				AttributeScanner.InvokeObjectDBRegistrations(typeof(Plugin).Assembly, ObjectDB.instance);
			}
			if (num && (Object)(object)ZNetScene.instance != (Object)null)
			{
				Log.LogInfo((object)"Hot reload — re-registering prefabs in ZNetScene");
				ItemFactory.RegisterAllInZNetScene(ZNetScene.instance);
				PieceFactory.RegisterAllInZNetScene(ZNetScene.instance);
				RecordPrefabFactory.RegisterInZNetScene(ZNetScene.instance);
				VillagePrefabFactory.RegisterInZNetScene(ZNetScene.instance);
				Log.LogInfo((object)"Hot reload — fixing up existing NPC components");
				HotReloadHelper.FixupExistingNPCs();
				Log.LogInfo((object)"Hot reload — fixing up placed registry stations");
				HotReloadHelper.FixupExistingRegistries();
				_hotReloadAt = Time.realtimeSinceStartup;
				_regionPartitionEnqueued = false;
				_recordIndexEnqueued = false;
				_villageIndexEnqueued = false;
				Log.LogInfo((object)"Hot reload — armed hna_partition (will fire 5s after settle)");
			}
			Log.LogInfo((object)"Valheim Villages loaded successfully!");
			IncidentRecorder.ClearOnLoad();
			FreezeTime.ApplyAutoFreeze();
			if (num && ModTestRunner.AutoRunEnabled)
			{
				Log.LogInfo((object)"Scheduling integration tests (will defer until fixtures are ready)...");
				GlobalTaskQueue.Enqueue(new VillagerTask
				{
					Name = "integration_tests",
					SourceId = "system",
					Priority = TaskPriority.Low,
					TimeoutSeconds = 120f,
					Attributes = new Dictionary<string, string>()
				});
			}
		}

		private void Update()
		{
			if (!_recipeRefreshEnqueued && (Object)(object)ObjectDB.instance != (Object)null && (Object)(object)ZNetScene.instance != (Object)null && Time.realtimeSinceStartup > 3f)
			{
				_recipeRefreshEnqueued = true;
				GlobalTaskQueue.Enqueue(new VillagerTask
				{
					Name = "recipe_discovery_refresh",
					SourceId = "system",
					Priority = TaskPriority.Low,
					TimeoutSeconds = 30f,
					Attributes = new Dictionary<string, string>()
				});
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogDebug((object)"[Valheim Villages] Enqueued recipe_discovery_refresh (post–world load)");
				}
			}
			if (!_recordIndexEnqueued && (Object)(object)ObjectDB.instance != (Object)null && (Object)(object)ZNetScene.instance != (Object)null && Time.realtimeSinceStartup > 3f)
			{
				_recordIndexEnqueued = true;
				GlobalTaskQueue.Enqueue(new VillagerTask
				{
					Name = "villager_record_index",
					SourceId = "system",
					Priority = TaskPriority.High,
					TimeoutSeconds = 30f,
					Attributes = new Dictionary<string, string>()
				});
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogDebug((object)"[Valheim Villages] Enqueued villager_record_index (post–world load)");
				}
			}
			if (!_villageIndexEnqueued && (Object)(object)ObjectDB.instance != (Object)null && (Object)(object)ZNetScene.instance != (Object)null && Time.realtimeSinceStartup > 3f)
			{
				_villageIndexEnqueued = true;
				GlobalTaskQueue.Enqueue(new VillagerTask
				{
					Name = "village_index",
					SourceId = "system",
					Priority = TaskPriority.High,
					TimeoutSeconds = 30f,
					Attributes = new Dictionary<string, string>()
				});
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogDebug((object)"[Valheim Villages] Enqueued village_index (post–world load)");
				}
			}
			if (!_regionPartitionEnqueued && (Object)(object)ObjectDB.instance != (Object)null && (Object)(object)ZNetScene.instance != (Object)null && Time.realtimeSinceStartup > _hotReloadAt + 5f)
			{
				_regionPartitionEnqueued = true;
				GlobalTaskQueue.Enqueue(new VillagerTask
				{
					Name = "hna_partition",
					SourceId = "system",
					Priority = TaskPriority.Low,
					TimeoutSeconds = 30f,
					Attributes = new Dictionary<string, string>()
				});
				ManualLogSource log4 = Log;
				if (log4 != null)
				{
					log4.LogInfo((object)"[Valheim Villages] Enqueued hna_partition (low priority)");
				}
			}
			if (PieceChangePatch.IsDirty && Time.realtimeSinceStartup - PieceChangePatch.LastStructureChangeTime > 10f)
			{
				PieceChangePatch.IsDirty = false;
				_regionPartitionEnqueued = false;
				ManualLogSource log5 = Log;
				if (log5 != null)
				{
					log5.LogInfo((object)"[Valheim Villages] Structure change detected, will re-enqueue hna_partition");
				}
			}
			GlobalTaskQueue.ProcessBatch();
			PathDebugRenderer.AutoEnable();
			PlayerAvoidanceObstacle.Tick();
			foreach (VillagerAI value in VillagerAIManager.ActiveVillagers.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					((BaseAI)value).UpdateAI(Time.deltaTime);
				}
			}
		}
	}
	public static class VectorExtensions
	{
		public static float DistXZ(Vector3 a, Vector3 b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return (float)Math.Sqrt(num * num + num2 * num2);
		}
	}
}
namespace ValheimVillages.Villages
{
	[HarmonyPatch(typeof(BaseAI), "RandomMovement")]
	public static class EnemyAvoidancePatch
	{
		private const float AvoidanceRadius = 20f;

		private const int MaxRerollAttempts = 3;

		private static void Prefix(BaseAI __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			if (VillageAreaManager.AreaCount == 0)
			{
				return;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component == (Object)null || (int)component.m_faction == 0 || component.IsTamed())
			{
				return;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(BaseAI), "m_randomMoveTarget");
			if (fieldInfo == null)
			{
				return;
			}
			Vector3 val = (Vector3)fieldInfo.GetValue(__instance);
			if (!VillageAreaManager.IsNearAnyVillage(val, 20f))
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			float randomMoveRange = __instance.m_randomMoveRange;
			for (int i = 0; i < 3; i++)
			{
				float num = Random.Range(0f, 360f) * ((float)Math.PI / 180f);
				float num2 = Random.Range(randomMoveRange * 0.3f, randomMoveRange);
				Vector3 val2 = position + new Vector3(Mathf.Cos(num) * num2, 0f, Mathf.Sin(num) * num2);
				if (!VillageAreaManager.IsNearAnyVillage(val2, 20f))
				{
					fieldInfo.SetValue(__instance, val2);
					return;
				}
			}
			Vector3 val3 = position - val;
			Vector3 normalized = ((Vector3)(ref val3)).normalized;
			Vector3 val4 = position + normalized * randomMoveRange;
			fieldInfo.SetValue(__instance, val4);
		}
	}
	[HarmonyPatch(typeof(Piece), "SetCreator")]
	public static class StationBuildPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Piece __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				VillageStationRegistry.RegisterStation(((Component)__instance).gameObject);
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				ZDO val = ((component != null) ? component.GetZDO() : null);
				if (val != null && val.GetPrefab() == StringExtensionMethods.GetStableHashCode("vv_village_registry"))
				{
					LinkRegistryToVillage(val);
				}
			}
		}

		private static void LinkRegistryToVillage(ZDO registryZdo)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(registryZdo.GetString("vv_village_id", "")))
			{
				return;
			}
			Vector3 position = registryZdo.GetPosition();
			Village village = VillageRegistry.GetVillageCovering(position) ?? VillageRegistry.GetOrCreateAt(position);
			if (village != null)
			{
				registryZdo.Set("vv_village_id", village.VillageId);
				registryZdo.Persistent = true;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[StationBuildPatch] Registry at ({position.x:F1},{position.y:F1},{position.z:F1}) -> village {village.VillageId}");
				}
			}
		}
	}
	public class VillageArea
	{
		private readonly List<Vector2> m_polygon2D;

		private readonly List<Vector3> m_waypoints;

		public string VillageId { get; }

		public IReadOnlyList<Vector3> Waypoints => m_waypoints;

		public VillageArea(string villageId, List<Vector3> waypoints)
		{
			//IL_0035: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			VillageId = villageId;
			m_waypoints = new List<Vector3>(waypoints);
			m_polygon2D = new List<Vector2>(waypoints.Count);
			foreach (Vector3 waypoint in waypoints)
			{
				m_polygon2D.Add(new Vector2(waypoint.x, waypoint.z));
			}
		}

		public bool IsInsideArea(Vector3 position)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (m_polygon2D.Count < 3)
			{
				return false;
			}
			return IsPointInPolygon(new Vector2(position.x, position.z));
		}

		public bool IsNearBoundary(Vector3 position, float radius)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (m_polygon2D.Count < 3)
			{
				return false;
			}
			Vector2 point = default(Vector2);
			((Vector2)(ref point))..ctor(position.x, position.z);
			float num = radius * radius;
			for (int i = 0; i < m_polygon2D.Count; i++)
			{
				int index = (i + 1) % m_polygon2D.Count;
				if (PointToSegmentDistanceSq(point, m_polygon2D[i], m_polygon2D[index]) <= num)
				{
					return true;
				}
			}
			return false;
		}

		private bool IsPointInPolygon(Vector2 point)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			int count = m_polygon2D.Count;
			int num = 0;
			int index = count - 1;
			while (num < count)
			{
				Vector2 val = m_polygon2D[num];
				Vector2 val2 = m_polygon2D[index];
				if (val.y > point.y != val2.y > point.y && point.x < (val2.x - val.x) * (point.y - val.y) / (val2.y - val.y) + val.x)
				{
					flag = !flag;
				}
				index = num++;
			}
			return flag;
		}

		private static float PointToSegmentDistanceSq(Vector2 point, Vector2 segA, Vector2 segB)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = segB - segA;
			Vector2 val2 = point - segA;
			float sqrMagnitude = ((Vector2)(ref val)).sqrMagnitude;
			if (sqrMagnitude < 0.0001f)
			{
				return ((Vector2)(ref val2)).sqrMagnitude;
			}
			float num = Mathf.Clamp01(Vector2.Dot(val2, val) / sqrMagnitude);
			Vector2 val3 = segA + val * num;
			Vector2 val4 = point - val3;
			return ((Vector2)(ref val4)).sqrMagnitude;
		}
	}
	public static class VillageAreaManager
	{
		private static readonly Dictionary<string, VillageArea> s_areas = new Dictionary<string, VillageArea>();

		public static int AreaCount => s_areas.Count;

		public static IEnumerable<VillageArea> AllAreas => s_areas.Values;

		public static void RegisterArea(VillageArea area)
		{
			if (area != null)
			{
				s_areas[area.VillageId] = area;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[VillageArea] Registered area for {area.VillageId} with {area.Waypoints.Count} waypoints");
				}
				VillageStationRegistry.RefreshFor(area);
				VillagePoiRegistry.RefreshFor(area);
				VillageRoomCatalog.RefreshFor(area);
			}
		}

		public static void UnregisterArea(string villageId)
		{
			if (s_areas.Remove(villageId))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[VillageArea] Unregistered area for " + villageId));
				}
				VillageStationRegistry.RemoveFor(villageId);
				VillagePoiRegistry.RemoveFor(villageId);
				VillageRoomCatalog.RemoveFor(villageId);
			}
		}

		public static void RefreshFromVillage(Village village)
		{
			if (village == null || !village.HasGraph)
			{
				return;
			}
			string villageId = village.VillageId;
			List<Vector3> list = PatrolRouteBuilder.Build(village.Graph.GetBoundaryCells());
			if (list == null || list.Count < 3)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[VillageArea] Skipped registration for village={villageId}: insufficient boundary waypoints ({list?.Count ?? 0})");
				}
			}
			else
			{
				RegisterArea(new VillageArea(villageId, list));
			}
		}

		public static bool IsInsideAnyVillage(Vector3 position)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			foreach (VillageArea value in s_areas.Values)
			{
				if (value.IsInsideArea(position))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsNearAnyVillage(Vector3 position, float radius)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			foreach (VillageArea value in s_areas.Values)
			{
				if (value.IsInsideArea(position) || value.IsNearBoundary(position, radius))
				{
					return true;
				}
			}
			return false;
		}

		public static bool TryGetCombinedBounds(out float minX, out float minZ, out float maxX, out float maxZ)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			minX = (minZ = float.MaxValue);
			maxX = (maxZ = float.MinValue);
			if (s_areas.Count == 0)
			{
				return false;
			}
			foreach (VillageArea value in s_areas.Values)
			{
				foreach (Vector3 waypoint in value.Waypoints)
				{
					if (waypoint.x < minX)
					{
						minX = waypoint.x;
					}
					if (waypoint.x > maxX)
					{
						maxX = waypoint.x;
					}
					if (waypoint.z < minZ)
					{
						minZ = waypoint.z;
					}
					if (waypoint.z > maxZ)
					{
						maxZ = waypoint.z;
					}
				}
			}
			if (minX <= maxX)
			{
				return minZ <= maxZ;
			}
			return false;
		}

		[RegisterCleanup]
		public static void Clear()
		{
			s_areas.Clear();
			VillageStationRegistry.Clear();
			VillagePoiRegistry.Clear();
			VillageRoomCatalog.Clear();
		}
	}
	public static class VillagePoiRegistry
	{
		private static readonly Dictionary<string, List<KnownLocation>> s_poisByVillage = new Dictionary<string, List<KnownLocation>>();

		public static void RefreshFor(VillageArea area)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			if (area == null || area.Waypoints == null || area.Waypoints.Count < 3)
			{
				return;
			}
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			float num3 = float.MinValue;
			float num4 = float.MinValue;
			float num5 = float.MaxValue;
			float num6 = float.MinValue;
			foreach (Vector3 waypoint in area.Waypoints)
			{
				if (waypoint.x < num)
				{
					num = waypoint.x;
				}
				if (waypoint.x > num3)
				{
					num3 = waypoint.x;
				}
				if (waypoint.z < num2)
				{
					num2 = waypoint.z;
				}
				if (waypoint.z > num4)
				{
					num4 = waypoint.z;
				}
				if (waypoint.y < num5)
				{
					num5 = waypoint.y;
				}
				if (waypoint.y > num6)
				{
					num6 = waypoint.y;
				}
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor((num + num3) * 0.5f, (num5 + num6) * 0.5f, (num2 + num4) * 0.5f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor((num3 - num) * 0.5f + 1f, (num6 - num5) * 0.5f + 20f, (num4 - num2) * 0.5f + 1f);
			HashSet<long> outsideCells = RubberBandPrune.ComputeOutsideCellsForBake(new Bounds(val, new Vector3(val2.x * 2f, val2.y * 2f, val2.z * 2f)));
			List<KnownLocation> list = new List<KnownLocation>();
			Collider[] array = Physics.OverlapBox(val, val2, Quaternion.identity);
			foreach (Collider val3 in array)
			{
				if ((Object)(object)val3 == (Object)null || (Object)(object)((Component)val3).gameObject == (Object)null)
				{
					continue;
				}
				LocationType? locationType = ClassifyPoi(((Component)val3).gameObject);
				if (locationType.HasValue)
				{
					Vector3 position = ((Component)val3).gameObject.transform.position;
					if (!RubberBandPrune.IsOutsideCell(position, outsideCells))
					{
						bool hasShelter = VillagerBehaviorLogic.CheckShelter(position);
						float comfort = ComfortFor(locationType.Value, hasShelter);
						TryAddDeduped(list, position, locationType.Value, comfort, hasShelter);
					}
				}
			}
			s_poisByVillage[area.VillageId] = list;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[VillagePoiRegistry] {area.VillageId}: cached {list.Count} PoI(s) inside hull");
			}
		}

		public static void RemoveFor(string villageKey)
		{
			s_poisByVillage.Remove(villageKey);
		}

		public static IReadOnlyList<KnownLocation> GetPois(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Village villageAt = VillageRegistry.GetVillageAt(position);
			if (villageAt == null)
			{
				return Array.Empty<KnownLocation>();
			}
			if (!s_poisByVillage.TryGetValue(villageAt.VillageId, out var value))
			{
				return Array.Empty<KnownLocation>();
			}
			return value;
		}

		public static IEnumerable<KnownLocation> GetPois(Vector3 position, LocationType type)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			foreach (KnownLocation poi in GetPois(position))
			{
				if (poi.Type == type)
				{
					yield return poi;
				}
			}
		}

		private static LocationType? ClassifyPoi(GameObject obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return null;
			}
			if ((Object)(object)obj.GetComponent<Chair>() != (Object)null)
			{
				return LocationType.Chair;
			}
			if ((Object)(object)obj.GetComponent<Fireplace>() != (Object)null)
			{
				return LocationType.Fire;
			}
			string text = ((Object)obj).name.ToLowerInvariant();
			if (text.Contains("table") || text.Contains("bench"))
			{
				return LocationType.Table;
			}
			if (text.Contains("cultivat") || text.Contains("sapling") || text.Contains("plant_"))
			{
				return LocationType.Farm;
			}
			return null;
		}

		private static float ComfortFor(LocationType type, bool hasShelter)
		{
			if (type == LocationType.Fire)
			{
				return hasShelter ? 2f : 0.5f;
			}
			return 1f;
		}

		private static void TryAddDeduped(List<KnownLocation> list, Vector3 pos, LocationType type, float comfort, bool hasShelter)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			float minDistanceForType = KnownLocation.GetMinDistanceForType(type);
			int num = 0;
			foreach (KnownLocation item in list)
			{
				if (item.Type == type)
				{
					num++;
					if (Vector3.Distance(item.Position, pos) < minDistanceForType)
					{
						return;
					}
				}
			}
			if (num < KnownLocation.GetMaxLocationsForType(type))
			{
				list.Add(new KnownLocation
				{
					Position = pos,
					Type = type,
					ComfortValue = comfort,
					HasShelter = hasShelter
				});
			}
		}

		[DevCommand("List cached village PoIs (fire/table/chair/farm) for the village containing the player", Name = "vv_pois")]
		public static void DumpPois()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			StringBuilder stringBuilder = new StringBuilder();
			if ((Object)(object)localPlayer == (Object)null)
			{
				stringBuilder.AppendLine("[vv_pois] No local player.");
			}
			else
			{
				Vector3 position = ((Component)localPlayer).transform.position;
				Village villageAt = VillageRegistry.GetVillageAt(position);
				if (villageAt == null)
				{
					stringBuilder.AppendLine($"[vv_pois] player at ({position.x:F1},{position.z:F1}) is not inside any registered village.");
				}
				else
				{
					string villageId = villageAt.VillageId;
					List<KnownLocation> value;
					List<KnownLocation> list = (s_poisByVillage.TryGetValue(villageId, out value) ? value : null);
					stringBuilder.AppendLine($"[vv_pois] village {villageId}: {list?.Count ?? 0} PoI(s)");
					if (list != null)
					{
						foreach (KnownLocation item in list)
						{
							stringBuilder.AppendLine($"  [{item.Type}] @ ({item.Position.x:F1},{item.Position.y:F1},{item.Position.z:F1}) " + $"shelter={item.HasShelter} comfort={item.ComfortValue:F1} " + $"dist={Vector3.Distance(position, item.Position):F1}m");
						}
					}
				}
			}
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(stringBuilder.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)stringBuilder.ToString());
			}
		}

		[RegisterCleanup]
		public static void Clear()
		{
			s_poisByVillage.Clear();
		}
	}
	public static class VillageRoomCatalog
	{
		public enum Feature
		{
			Fire,
			Seat,
			Table,
			Bed,
			WorkStation,
			Storage,
			Farm
		}

		public sealed class RegionRoom
		{
			public string RegionId;

			public readonly Dictionary<Feature, int> Counts = new Dictionary<Feature, int>();

			public readonly List<string> Roles = new List<string>();

			public Vector3 Center;

			public int PieceCount;
		}

		private static readonly Dictionary<string, Dictionary<string, RegionRoom>> s_roomsByVillage = new Dictionary<string, Dictionary<string, RegionRoom>>();

		private const float ScanPadXZ = 12f;

		private static readonly Dictionary<Type, bool> s_sitTypeCache = new Dictionary<Type, bool>();

		public static void RefreshFor(VillageArea area)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: 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_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: 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)
			if (area == null || area.Waypoints == null || area.Waypoints.Count < 3)
			{
				return;
			}
			RegionGraph regionGraph = VillageRegistry.FindById(area.VillageId)?.Graph;
			if (regionGraph == null)
			{
				return;
			}
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			float num3 = float.MaxValue;
			float num4 = float.MinValue;
			float num5 = float.MinValue;
			float num6 = float.MinValue;
			foreach (Vector3 waypoint in area.Waypoints)
			{
				if (waypoint.x < num)
				{
					num = waypoint.x;
				}
				if (waypoint.x > num4)
				{
					num4 = waypoint.x;
				}
				if (waypoint.z < num2)
				{
					num2 = waypoint.z;
				}
				if (waypoint.z > num5)
				{
					num5 = waypoint.z;
				}
				if (waypoint.y < num3)
				{
					num3 = waypoint.y;
				}
				if (waypoint.y > num6)
				{
					num6 = waypoint.y;
				}
			}
			Vector3 val = new Vector3((num + num4) * 0.5f, (num3 + num6) * 0.5f, (num2 + num5) * 0.5f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor((num4 - num) * 0.5f + 12f, (num6 - num3) * 0.5f + 20f, (num5 - num2) * 0.5f + 12f);
			Dictionary<string, RegionRoom> dictionary = new Dictionary<string, RegionRoom>();
			HashSet<GameObject> hashSet = new HashSet<GameObject>();
			Collider[] array = Physics.OverlapBox(val, val2, Quaternion.identity);
			foreach (Collider val3 in array)
			{
				if ((Object)(object)val3 == (Object)null || (Object)(object)((Component)val3).gameObject == (Object)null)
				{
					continue;
				}
				Piece componentInParent = ((Component)val3).GetComponentInParent<Piece>();
				GameObject val4 = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).gameObject : ((Component)val3).gameObject);
				if (!hashSet.Add(val4) || !TryClassifyFeature(val4, out var feature))
				{
					continue;
				}
				Vector3 position = val4.transform.position;
				string regionId = regionGraph.PointToRegionId(position);
				if (string.IsNullOrEmpty(regionId))
				{
					regionGraph.TryFindNearestLookupCell(position, null, out var _, out regionId, 3f);
				}
				if (!string.IsNullOrEmpty(regionId))
				{
					if (!dictionary.TryGetValue(regionId, out var value))
					{
						string key = regionId;
						RegionRoom obj = new RegionRoom
						{
							RegionId = regionId
						};
						value = obj;
						dictionary[key] = obj;
					}
					value.Counts.TryGetValue(feature, out var value2);
					value.Counts[feature] = value2 + 1;
					RegionRoom regionRoom = value;
					regionRoom.Center += position;
					value.PieceCount++;
				}
			}
			foreach (RegionRoom value3 in dictionary.Values)
			{
				if (value3.PieceCount > 0)
				{
					value3.Center /= (float)value3.PieceCount;
				}
				AssignRoles(value3);
			}
			s_roomsByVillage[area.VillageId] = dictionary;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[VillageRoomCatalog] {area.VillageId}: {dictionary.Count} furnished region(s)");
			}
		}

		public static void RemoveFor(string villageKey)
		{
			s_roomsByVillage.Remove(villageKey);
		}

		public static IReadOnlyCollection<RegionRoom> GetRooms(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Village villageAt = VillageRegistry.GetVillageAt(position);
			if (villageAt == null)
			{
				return (IReadOnlyCollection<RegionRoom>)(object)Array.Empty<RegionRoom>();
			}
			if (!s_roomsByVillage.TryGetValue(villageAt.VillageId, out var value))
			{
				return (IReadOnlyCollection<RegionRoom>)(object)Array.Empty<RegionRoom>();
			}
			return value.Values;
		}

		private static int Count(RegionRoom r, Feature f)
		{
			if (!r.Counts.TryGetValue(f, out var value))
			{
				return 0;
			}
			return value;
		}

		private static void AssignRoles(RegionRoom r)
		{
			if (Count(r, Feature.Bed) >= 1)
			{
				r.Roles.Add("Bedroom");
			}
			if (Count(r, Feature.Table) >= 1 && Count(r, Feature.Seat) >= 1)
			{
				r.Roles.Add((Count(r, Feature.Fire) >= 1) ? "Dining Hall" : "Dining Room");
			}
			if (Count(r, Feature.WorkStation) >= 1)
			{
				r.Roles.Add("Workshop");
			}
			if (Count(r, Feature.Farm) >= 1)
			{
				r.Roles.Add("Garden");
			}
			if (Count(r, Feature.Storage) >= 1)
			{
				r.Roles.Add("Storage");
			}
			if (r.Roles.Count == 0 && Count(r, Feature.Fire) >= 1)
			{
				r.Roles.Add("Hearth");
			}
		}

		private static bool TryClassifyFeature(GameObject go, out Feature feature)
		{
			feature = Feature.Fire;
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			if ((Object)(object)go.GetComponentInParent<Bed>() != (Object)null)
			{
				feature = Feature.Bed;
				return true;
			}
			if (VillageStationRegistry.TryClassifyStation(go, out var _))
			{
				feature = Feature.WorkStation;
				return true;
			}
			if (IsSittable(go))
			{
				feature = Feature.Seat;
				return true;
			}
			if ((Object)(object)go.GetComponentInParent<Fireplace>() != (Object)null)
			{
				feature = Feature.Fire;
				return true;
			}
			if ((Object)(object)go.GetComponentInParent<Container>() != (Object)null)
			{
				feature = Feature.Storage;
				return true;
			}
			string text = ((Object)go).name.ToLowerInvariant();
			if (text.Contains("table"))
			{
				feature = Feature.Table;
				return true;
			}
			if (text.Contains("cultivat") || text.Contains("sapling") || text.Contains("plant_"))
			{
				feature = Feature.Farm;
				return true;
			}
			return false;
		}

		private static bool HasSitField(Type t)
		{
			if (s_sitTypeCache.TryGetValue(t, out var value))
			{
				return value;
			}
			value = t.GetField("m_attachAnimation", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null;
			s_sitTypeCache[t] = value;
			return value;
		}

		private static bool IsSittable(GameObject go)
		{
			Piece componentInParent = go.GetComponentInParent<Piece>();
			MonoBehaviour[] componentsInChildren = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).gameObject : go).GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (val is Chair)
					{
						return true;
					}
					if (HasSitField(((object)val).GetType()))
					{
						return true;
					}
				}
			}
			return false;
		}

		[DevCommand("List per-region room roles + furnishings for the village containing the player", Name = "vv_rooms")]
		public static void DumpRooms()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			StringBuilder stringBuilder = new StringBuilder();
			if ((Object)(object)localPlayer == (Object)null)
			{
				stringBuilder.AppendLine("[vv_rooms] No local player.");
			}
			else
			{
				Village villageAt = VillageRegistry.GetVillageAt(((Component)localPlayer).transform.position);
				Dictionary<string, RegionRoom> value;
				if (villageAt == null)
				{
					stringBuilder.AppendLine("[vv_rooms] player is not inside any registered village.");
				}
				else if (!s_roomsByVillage.TryGetValue(villageAt.VillageId, out value) || value.Count == 0)
				{
					stringBuilder.AppendLine("[vv_rooms] village " + villageAt.VillageId + ": no furnished regions cached.");
				}
				else
				{
					stringBuilder.AppendLine($"[vv_rooms] village {villageAt.VillageId}: {value.Count} furnished region(s)");
					foreach (RegionRoom value2 in value.Values)
					{
						string text = ((value2.Roles.Count > 0) ? string.Join(", ", value2.Roles) : "(unlabeled)");
						List<string> list = new List<string>();
						foreach (KeyValuePair<Feature, int> count in value2.Counts)
						{
							list.Add($"{count.Key}×{count.Value}");
						}
						stringBuilder.AppendLine($"  [{value2.RegionId}] {text} @ ({value2.Center.x:F1},{value2.Center.y:F1},{value2.Center.z:F1}) — " + string.Join(" ", list));
					}
				}
			}
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(stringBuilder.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)stringBuilder.ToString());
			}
		}

		[RegisterCleanup]
		public static void Clear()
		{
			s_roomsByVillage.Clear();
		}
	}
	public static class VillageStationRegistry
	{
		private static readonly Dictionary<string, List<Component>> s_stationsByVillage = new Dictionary<string, List<Component>>();

		private const float StationScanPadXZ = 12f;

		private const float StationVillageReachXZ = 3f;

		private static readonly Dictionary<Type, bool> s_conversionTypeCache = new Dictionary<Type, bool>();

		private const float MinApproachStandoffXZ = 1.5f;

		private const float PathSourceSnapMaxY = 3f;

		private const float ApproachMaxXzDist = 10f;

		private const float ApproachMaxYDelta = 3f;

		public static string LastApproachDiag = "(none)";

		private static readonly int s_losMask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "piece", "terrain" });

		private static bool HasConversionField(Type t)
		{
			if (s_conversionTypeCache.TryGetValue(t, out var value))
			{
				return value;
			}
			value = t.GetField("m_conversion", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null;
			s_conversionTypeCache[t] = value;
			return value;
		}

		public static bool TryClassifyStation(GameObject go, out Component station)
		{
			station = null;
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			CraftingStation componentInParent = go.GetComponentInParent<CraftingStation>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				station = (Component)(object)componentInParent;
				return true;
			}
			Piece componentInParent2 = go.GetComponentInParent<Piece>();
			MonoBehaviour[] componentsInChildren = (((Object)(object)componentInParent2 != (Object)null) ? ((Component)componentInParent2).gameObject : go).GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && HasConversionField(((object)val).GetType()))
				{
					station = (Component)(object)val;
					return true;
				}
			}
			return false;
		}

		private static bool BelongsToVillage(RegionGraph graph, Vector3 pos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (graph == null)
			{
				return false;
			}
			if (!string.IsNullOrEmpty(graph.PointToRegionId(pos)))
			{
				return true;
			}
			Vector3 worldPos;
			string regionId;
			return graph.TryFindNearestLookupCell(pos, null, out worldPos, out regionId, 3f);
		}

		public static void RegisterStation(GameObject go)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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)
			if (!TryClassifyStation(go, out var station))
			{
				return;
			}
			Vector3 position = station.transform.position;
			foreach (Village item in VillageRegistry.EnumerateWithGraph())
			{
				if (!BelongsToVillage(item.Graph, position))
				{
					continue;
				}
				string villageId = item.VillageId;
				if (string.IsNullOrEmpty(villageId))
				{
					continue;
				}
				if (!s_stationsByVillage.TryGetValue(villageId, out var value))
				{
					value = (s_stationsByVillage[villageId] = new List<Component>());
				}
				if (!value.Contains(station))
				{
					value.Add(station);
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)("[VillageStationRegistry] +" + ((object)station).GetType().Name + " " + ((Object)station.gameObject).name + " " + $"@ ({position.x:F1},{position.y:F1},{position.z:F1}) → {villageId} (on build)"));
					}
				}
				break;
			}
		}

		public static void RefreshFor(VillageArea area)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			if (area == null || area.Waypoints == null || area.Waypoints.Count < 3)
			{
				return;
			}
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			float num3 = float.MinValue;
			float num4 = float.MinValue;
			float num5 = float.MaxValue;
			float num6 = float.MinValue;
			foreach (Vector3 waypoint in area.Waypoints)
			{
				if (waypoint.x < num)
				{
					num = waypoint.x;
				}
				if (waypoint.x > num3)
				{
					num3 = waypoint.x;
				}
				if (waypoint.z < num2)
				{
					num2 = waypoint.z;
				}
				if (waypoint.z > num4)
				{
					num4 = waypoint.z;
				}
				if (waypoint.y < num5)
				{
					num5 = waypoint.y;
				}
				if (waypoint.y > num6)
				{
					num6 = waypoint.y;
				}
			}
			Vector3 val = new Vector3((num + num3) * 0.5f, (num5 + num6) * 0.5f, (num2 + num4) * 0.5f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor((num3 - num) * 0.5f + 12f, (num6 - num5) * 0.5f + 20f, (num4 - num2) * 0.5f + 12f);
			RegionGraph regionGraph = VillageRegistry.FindById(area.VillageId)?.Graph;
			List<Component> list = new List<Component>();
			HashSet<Component> hashSet = new HashSet<Component>();
			int num7 = 0;
			int num8 = 0;
			Collider[] array = Physics.OverlapBox(val, val2, Quaternion.identity);
			foreach (Collider val3 in array)
			{
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)((Component)val3).gameObject == (Object)null) && TryClassifyStation(((Component)val3).gameObject, out var station) && hashSet.Add(station))
				{
					num7++;
					if (regionGraph == null || BelongsToVillage(regionGraph, station.transform.position))
					{
						list.Add(station);
						num8++;
					}
				}
			}
			s_stationsByVillage[area.VillageId] = list;
			if (Plugin.Log == null)
			{
				return;
			}
			Plugin.Log.LogInfo((object)($"[VillageStationRegistry] {area.VillageId}: cached {list.Count} stations " + $"(candidates {num7} → kept {num8})"));
			foreach (Component item in list)
			{
				Vector3 position = item.transform.position;
				Plugin.Log.LogInfo((object)$"  [{((object)item).GetType().Name}] {((Object)item.gameObject).name} @ ({position.x:F1},{position.y:F1},{position.z:F1})");
			}
		}

		public static void RemoveFor(string villageKey)
		{
			s_stationsByVillage.Remove(villageKey);
		}

		public static bool HasVillageFor(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string villageId;
			return TryGetVillage(position, out villageId);
		}

		public static bool TryFindStation<T>(Vector3 position, Func<T, bool> filter, out Vector3 stationPos, out T component) where T : Component
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			stationPos = Vector3.zero;
			component = default(T);
			if (!TryGetVillage(position, out var villageId))
			{
				return false;
			}
			if (!s_stationsByVillage.TryGetValue(villageId, out var value))
			{
				return false;
			}
			T val = default(T);
			float num = float.MaxValue;
			foreach (Component item in value)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				T val2 = (T)(object)((item is T) ? item : null);
				if (!((Object)(object)val2 == (Object)null) && (filter == null || filter(val2)))
				{
					Vector3 val3 = ((Component)val2).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = val2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!TryResolveApproach(((Component)val).transform.position, position, out var approach))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[VillageStationRegistry] " + villageId + ": no HNA-valid approach to " + ((Object)((Component)val).gameObject).name + " " + $"@ ({((Component)val).transform.position.x:F1},{((Component)val).transform.position.y:F1},{((Component)val).transform.position.z:F1})"));
				}
				stationPos = Vector3.zero;
				component = default(T);
				return false;
			}
			stationPos = approach;
			component = val;
			return true;
		}

		public static bool TryResolveApproach(Vector3 target, Vector3 pathSource, out Vector3 approach, Vector3? villageAnchor = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			approach = Vector3.zero;
			RegionGraph regionGraph = VillageRegistry.GetVillageAt(villageAnchor.GetValueOrDefault(pathSource))?.Graph;
			if (regionGraph == null)
			{
				LastApproachDiag = $"no graph for source ({pathSource.x:F1},{pathSource.y:F1},{pathSource.z:F1})";
				return false;
			}
			bool flag = true;
			if (!regionGraph.TryFindNearestLookupCell(pathSource, (Vector3 cell) => Mathf.Abs(cell.y - pathSource.y) <= 3f, out var worldPos, out var regionId))
			{
				flag = false;
				if (!regionGraph.TryFindNearestLookupCell(pathSource, null, out worldPos, out regionId))
				{
					worldPos = pathSource;
				}
			}
			float minStandoffSq = 2.25f;
			int considered = 0;
			int levelPass = 0;
			int standoffPass = 0;
			int losPass = 0;
			bool flag2 = regionGraph.TryFindNearestLookupCell(target, delegate(Vector3 candidate)
			{
				//IL_0010: 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_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				considered++;
				if (Mathf.Abs(candidate.y - target.y) > 3f)
				{
					return false;
				}
				levelPass++;
				float num = candidate.x - target.x;
				float num2 = candidate.z - target.z;
				if (num * num + num2 * num2 < minStandoffSq)
				{
					return false;
				}
				standoffPass++;
				if (!HasClearLineToStation(candidate, target))
				{
					return false;
				}
				losPass++;
				return true;
			}, out approach, out regionId, 10f);
			LastApproachDiag = string.Format("src=({0:F1},{1:F1},{2:F1}) snap={3} ", pathSource.x, pathSource.y, pathSource.z, flag ? "y" : "fallback") + $"pathStart=({worldPos.x:F1},{worldPos.y:F1},{worldPos.z:F1}) " + $"tgt=({target.x:F1},{target.y:F1},{target.z:F1}) " + $"considered={considered} levelPass={levelPass} standoffPass={standoffPass} losPass={losPass} " + "result=" + (flag2 ? $"({approach.x:F1},{approach.y:F1},{approach.z:F1})" : "FAIL");
			return flag2;
		}

		private static bool HasClearLineToStation(Vector3 approach, Vector3 station)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = approach + Vector3.up * 1.2f;
			Vector3 val2 = station + Vector3.up * 1.2f - val;
			float magnitude = ((Vector3)(ref val2)).magnitude;
			if (magnitude < 0.01f)
			{
				return true;
			}
			Vector3 val3 = val2 / magnitude;
			RaycastHit[] array = Physics.RaycastAll(val, val3, magnitude, s_losMask, (QueryTriggerInteraction)1);
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val4 = array[i];
				if (!((Object)(object)((RaycastHit)(ref val4)).collider == (Object)null))
				{
					Bounds bounds = ((RaycastHit)(ref val4)).collider.bounds;
					if (!((Bounds)(ref bounds)).Contains(station))
					{
						return false;
					}
				}
			}
			return true;
		}

		[DevCommand("Diagnose HNA approach resolution to a target from a source (default player). Usage: vv_approach <tx> <tz> [<sx> <sz>]", Name = "vv_approach")]
		public static void ApproachDiag(ConsoleEventArgs args)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			if (args?.Args == null || args.Args.Length < 3 || !float.TryParse(args.Args[1], NumberStyles.Float, invariantCulture, out var result) || !float.TryParse(args.Args[2], NumberStyles.Float, invariantCulture, out var result2))
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("Usage: vv_approach <tx> <tz> [<sx> <sz>]");
				}
				return;
			}
			Vector3 val = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			if (args.Args.Length >= 5 && float.TryParse(args.Args[3], NumberStyles.Float, invariantCulture, out var result3) && float.TryParse(args.Args[4], NumberStyles.Float, invariantCulture, out var result4))
			{
				((Vector3)(ref val))..ctor(result3, val.y, result4);
			}
			float num = (((Object)(object)ZoneSystem.instance != (Object)null) ? ZoneSystem.instance.GetGroundHeight(new Vector3(result, 0f, result2)) : 0f);
			Vector3 approach;
			bool flag = TryResolveApproach(new Vector3(result, num, result2), val, out approach);
			string text = $"[vv_approach] ok={flag} approach=({approach.x:F1},{approach.y:F1},{approach.z:F1})\n  {LastApproachDiag}";
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}

		[DevCommand("Dump cached village stations + HNA approach resolution for each villager anchor", Name = "vv_stations")]
		public static void DumpStations()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			List<Vector3> allAnchorPositions = VillagerAIManager.GetAllAnchorPositions();
			stringBuilder.AppendLine($"[vv_stations] {allAnchorPositions.Count} anchor(s); {s_stationsByVillage.Count} village(s) cached");
			foreach (Vector3 item in allAnchorPositions)
			{
				if (!TryGetVillage(item, out var villageId))
				{
					stringBuilder.AppendLine($"  anchor=({item.x:F1},{item.y:F1},{item.z:F1}) → NO containing village");
					continue;
				}
				List<Component> value;
				List<Component> list = (s_stationsByVillage.TryGetValue(villageId, out value) ? value : null);
				stringBuilder.AppendLine($"  anchor=({item.x:F1},{item.y:F1},{item.z:F1}) → village {villageId}: " + $"{list?.Count ?? 0} station(s)");
				if (list == null)
				{
					continue;
				}
				foreach (Component item2 in list)
				{
					if (!((Object)(object)item2 == (Object)null))
					{
						Vector3 position = item2.transform.position;
						Vector3 approach;
						bool flag = TryResolveApproach(position, item, out approach);
						stringBuilder.AppendLine("    [" + ((object)item2).GetType().Name + "] " + ((Object)item2.gameObject).name + " " + $"@ ({position.x:F1},{position.y:F1},{position.z:F1}) dist={Vector3.Distance(item, position):F1}m " + "approach=" + (flag ? $"({approach.x:F1},{approach.y:F1},{approach.z:F1})" : "UNREACHABLE"));
					}
				}
			}
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(stringBuilder.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)stringBuilder.ToString());
			}
		}

		[RegisterCleanup]
		public static void Clear()
		{
			s_stationsByVillage.Clear();
		}

		private static bool TryGetVillage(Vector3 position, out string villageId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Village villageAt = VillageRegistry.GetVillageAt(position);
			villageId = villageAt?.VillageId;
			return villageAt != null;
		}
	}
	public static class WallDetection
	{
		private static readonly string[] WallPrefixes = new string[9] { "wood_wall", "stone_wall", "stakewall", "darkwood_gate", "iron_wall", "dungeon_wall", "goblin_wall", "dvergr_wall", "piece_wall" };

		private static readonly string[] DoorPrefixes = new string[5] { "wood_door", "iron_door", "darkwood_door", "dvergr_door", "door" };

		private static int? s_pieceMask;

		private static int PieceMask
		{
			get
			{
				int valueOrDefault = s_pieceMask.GetValueOrDefault();
				if (!s_pieceMask.HasValue)
				{
					valueOrDefault = LayerMask.GetMask(new string[3] { "piece", "static_solid", "Default" });
					s_pieceMask = valueOrDefault;
				}
				return s_pieceMask.Value;
			}
		}

		public static bool IsWallPiece(GameObject obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return false;
			}
			if ((Object)(object)obj.GetComponentInParent<Piece>() == (Object)null)
			{
				return false;
			}
			string lowerName = ((Object)obj).name.ToLower();
			if (!IsWallName(lowerName))
			{
				return IsDoorName(lowerName);
			}
			return true;
		}

		public static bool RaycastForWall(Vector3 origin, Vector3 direction, float maxDist, out RaycastHit wallHit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			wallHit = default(RaycastHit);
			RaycastHit[] array = Physics.RaycastAll(origin, ((Vector3)(ref direction)).normalized, maxDist, PieceMask);
			float num = float.MaxValue;
			bool result = false;
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val = array2[i];
				if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)null) && IsWallPiece(((Component)((RaycastHit)(ref val)).collider).gameObject) && ((RaycastHit)(ref val)).distance < num)
				{
					num = ((RaycastHit)(ref val)).distance;
					wallHit = val;
					result = true;
				}
			}
			return result;
		}

		private static bool IsWallName(string lowerName)
		{
			string[] wallPrefixes = WallPrefixes;
			foreach (string value in wallPrefixes)
			{
				if (lowerName.Contains(value))
				{
					return true;
				}
			}
			return lowerName.Contains("wall");
		}

		private static bool IsDoorName(string lowerName)
		{
			string[] doorPrefixes = DoorPrefixes;
			foreach (string value in doorPrefixes)
			{
				if (lowerName.Contains(value))
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace ValheimVillages.Villages.Entity
{
	public sealed class Village
	{
		public const string IdKey = "vv_village_id";

		public const string AnchorKey = "vv_village_anchor";

		public const string GraphKey = "vv_village_graph";

		private readonly ZDO m_zdo;

		private RegionGraph m_graph;

		private bool m_hydrated;

		public ZDO Zdo => m_zdo;

		public bool IsValid
		{
			get
			{
				if (m_zdo != null)
				{
					return !string.IsNullOrEmpty(VillageId);
				}
				return false;
			}
		}

		public string VillageId => m_zdo.GetString("vv_village_id", "");

		public Vector3 Anchor
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				return m_zdo.GetVec3("vv_village_anchor", Vector3.zero);
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				m_zdo.Set("vv_village_anchor", value);
				m_zdo.Persistent = true;
			}
		}

		public RegionGraph Graph
		{
			get
			{
				if (!m_hydrated)
				{
					HydrateGraphFromZdo();
				}
				return m_graph;
			}
		}

		public bool HasGraph
		{
			get
			{
				if (Graph != null)
				{
					return Graph.IsAvailable;
				}
				return false;
			}
		}

		public Village(ZDO zdo)
		{
			m_zdo = zdo;
		}

		public RegionGraph GetOrCreateGraph()
		{
			if (Graph == null)
			{
				m_graph = new RegionGraph
				{
					RegisteredVillageKey = VillageId
				};
				m_hydrated = true;
			}
			return m_graph;
		}

		public void HydrateGraphFromZdo()
		{
			m_hydrated = true;
			string text = m_zdo.GetString("vv_village_graph", "");
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			RegionGraph graph = new RegionGraph
			{
				RegisteredVillageKey = VillageId
			};
			if (RegionGraphPersistence.Restore(graph, text))
			{
				m_graph = graph;
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[Village] Wiping unparseable graph blob for village " + VillageId + " " + $"(bytes={text.Length}); will rebuild on next partition"));
			}
			m_zdo.Set("vv_village_graph", "");
			m_zdo.Persistent = true;
		}

		public void SaveGraph()
		{
			if (m_graph != null && m_graph.IsAvailable)
			{
				m_zdo.Set("vv_village_graph", RegionGraphPersistence.Serialize(m_graph));
				m_zdo.Persistent = true;
			}
		}
	}
	public static class VillagePrefabFactory
	{
		public const string VillagePrefabName = "vv_village";

		public static readonly int VillagePrefabHash = StringExtensionMethods.GetStableHashCode("vv_village");

		private static GameObject _prefab;

		public static void RegisterInZNetScene(ZNetScene zNetScene)
		{
			if ((Object)(object)zNetScene == (Object)null)
			{
				return;
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = zNetScene.GetPrefab("vv_village");
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = BuildPrefab();
			}
			if (!((Object)(object)_prefab == (Object)null))
			{
				if (!zNetScene.m_prefabs.Contains(_prefab))
				{
					zNetScene.m_prefabs.Add(_prefab);
				}
				Dictionary<int, GameObject> privateDictionary = GetPrivateDictionary<ZNetScene>(zNetScene, "m_namedPrefabs");
				if (privateDictionary != null)
				{
					privateDictionary[VillagePrefabHash] = _prefab;
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[VillagePrefabFactory] Registered 'vv_village' carrier in ZNetScene");
				}
			}
		}

		private static GameObject BuildPrefab()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			GameObject val = new GameObject("vv_village");
			val.SetActive(false);
			ZNetView obj = val.AddComponent<ZNetView>();
			obj.m_persistent = true;
			obj.m_type = (ObjectType)0;
			obj.m_distant = false;
			Object.DontDestroyOnLoad((Object)val);
			val.SetActive(true);
			return val;
		}

		private static Dictionary<int, GameObject> GetPrivateDictionary<T>(T instance, string fieldName)
		{
			return typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance) as Dictionary<int, GameObject>;
		}
	}
	public static class VillageRegistry
	{
		private static readonly Dictionary<string, Village> s_live = new Dictionary<string, Village>();

		public static bool IsAnyAvailable => EnumerateWithGraph().Any();

		public static Village Create(Vector3 anchor)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)"[VillageRegistry] Cannot create village: ZDOMan not ready");
				}
				return null;
			}
			ZDO obj = instance.CreateNewZDO(anchor, VillagePrefabFactory.VillagePrefabHash);
			obj.SetPrefab(VillagePrefabFactory.VillagePrefabHash);
			obj.Persistent = true;
			string text = Guid.NewGuid().ToString();
			obj.Set("vv_village_id", text);
			Village village = new Village(obj)
			{
				Anchor = anchor
			};
			s_live[text] = village;
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"[VillageRegistry] Created village {text} at ({anchor.x:F1},{anchor.y:F1},{anchor.z:F1})");
			}
			return village;
		}

		public static IEnumerable<Village> EnumerateAll()
		{
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				yield break;
			}
			Dictionary<ZDOID, ZDO> value = Traverse.Create((object)instance).Field<Dictionary<ZDOID, ZDO>>("m_objectsByID").Value;
			if (value == null)
			{
				yield break;
			}
			foreach (ZDO value3 in value.Values)
			{
				if (value3 == null || value3.GetPrefab() != VillagePrefabFactory.VillagePrefabHash)
				{
					continue;
				}
				string text = value3.GetString("vv_village_id", "");
				if (!string.IsNullOrEmpty(text))
				{
					if (!s_live.TryGetValue(text, out var value2))
					{
						value2 = new Village(value3);
						s_live[text] = value2;
					}
					yield return value2;
				}
			}
		}

		public static IEnumerable<Village> EnumerateWithGraph()
		{
			return from v in EnumerateAll()
				where v.HasGraph
				select v;
		}

		public static IEnumerable<RegionGraph> AllGraphs()
		{
			return from v in EnumerateWithGraph()
				select v.Graph;
		}

		public static RegionGraph GraphAt(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetVillageAt(pos)?.Graph;
		}

		public static Village FindById(string villageId)
		{
			if (string.IsNullOrEmpty(villageId))
			{
				return null;
			}
			if (s_live.TryGetValue(villageId, out var value) && value.IsValid)
			{
				return value;
			}
			foreach (Village item in EnumerateAll())
			{
				if (item.VillageId == villageId)
				{
					return item;
				}
			}
			return null;
		}

		public static Village GetVillageAt(Vector3 pos)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Village result = null;
			float num = float.MaxValue;
			foreach (Village item in EnumerateAll())
			{
				RegionGraph graph = item.Graph;
				if (graph == null || !graph.IsAvailable)
				{
					continue;
				}
				if (!string.IsNullOrEmpty(graph.PointToRegionId(pos)))
				{
					return item;
				}
				if (graph.GetOrigin(out var originX, out var originZ))
				{
					float num2 = pos.x - originX;
					float num3 = pos.z - originZ;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 < num)
					{
						num = num4;
						result = item;
					}
				}
			}
			return result;
		}

		public static Village FindNearAnchor(Vector3 anchor, float radius = 30f)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Village result = null;
			float num = radius * radius;
			foreach (Village item in EnumerateAll())
			{
				Vector3 anchor2 = item.Anchor;
				float num2 = anchor.x - anchor2.x;
				float num3 = anchor.z - anchor2.z;
				float num4 = num2 * num2 + num3 * num3;
				if (num4 <= num)
				{
					num = num4;
					result = item;
				}
			}
			return result;
		}

		public static Village GetVillageCovering(Vector3 pos)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			foreach (Village item in EnumerateAll())
			{
				RegionGraph graph = item.Graph;
				if (graph != null && graph.IsAvailable && !string.IsNullOrEmpty(graph.PointToRegionId(pos)))
				{
					return item;
				}
			}
			return null;
		}

		public static Village GetOrCreateAt(Vector3 anchor, float relinkRadius = 30f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return FindNearAnchor(anchor, relinkRadius) ?? Create(anchor);
		}

		public static (int villages, int withGraph) HydrateAll()
		{
			s_live.Clear();
			int num = 0;
			int num2 = 0;
			foreach (Village item in EnumerateAll())
			{
				num++;
				item.HydrateGraphFromZdo();
				if (item.HasGraph)
				{
					num2++;
				}
			}
			return (villages: num, withGraph: num2);
		}

		[RegisterCleanup]
		public static void ClearAll()
		{
			foreach (Village value in s_live.Values)
			{
				value.Graph?.Clear();
			}
			s_live.Clear();
		}
	}
}
namespace ValheimVillages.Villager
{
	public class Dialog
	{
		public static void ConfigureDialog(GameObject npcObject, VillagerDef villagerDef)
		{
			if (villagerDef == null)
			{
				return;
			}
			VillagerTalk component = npcObject.GetComponent<VillagerTalk>();
			if (!((Object)(object)component == (Object)null))
			{
				List<string> randomTalk = villagerDef.randomTalk;
				if (randomTalk != null && randomTalk.Count > 0)
				{
					component.randomTalk = new List<string>(villagerDef.randomTalk);
				}
				List<string> randomGreets = villagerDef.randomGreets;
				if (randomGreets != null && randomGreets.Count > 0)
				{
					component.randomGreets = new List<string>(villagerDef.randomGreets);
				}
				List<string> randomGoodbye = villagerDef.randomGoodbye;
				if (randomGoodbye != null && randomGoodbye.Count > 0)
				{
					component.randomGoodbye = new List<string>(villagerDef.randomGoodbye);
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Configured dialog for " + villagerDef.displayName));
				}
			}
		}
	}
	public static class NativeNpcStripper
	{
		private static readonly string[] BaseAiRpcs = new string[3] { "Alert", "OnNearProjectileHit", "SetAggravated" };

		public static bool IsPlayerOwned(GameObject go)
		{
			if ((Object)(object)go != (Object)null)
			{
				return (Object)(object)go.GetComponentInParent<Player>() != (Object)null;
			}
			return false;
		}

		public static bool IsPlayerOwned(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				return (Object)(object)((Component)character).GetComponentInParent<Player>() != (Object)null;
			}
			return false;
		}

		public static void Strip(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			if (IsPlayerOwned(go))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("[NativeNpcStripper] Refusing to strip native components on player-owned object '" + ((Object)go).name + "' — a villager lookup resolved to the player character."));
				}
				return;
			}
			Character component = go.GetComponent<Character>();
			UnregisterBaseAiRpcs(go.GetComponent<ZNetView>());
			PruneDeadHandlers(component);
			MonsterAI component2 = go.GetComponent<MonsterAI>();
			if ((Object)(object)component2 != (Object)null)
			{
				DetachHandlers(component, component2);
				Object.DestroyImmediate((Object)(object)component2);
			}
			Tameable component3 = go.GetComponent<Tameable>();
			if ((Object)(object)component3 != (Object)null)
			{
				DetachHandlers(component, component3);
				Object.DestroyImmediate((Object)(object)component3);
			}
			NpcTalk component4 = go.GetComponent<NpcTalk>();
			if ((Object)(object)component4 != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)component4);
			}
		}

		private static void UnregisterBaseAiRpcs(ZNetView nview)
		{
			if (!((Object)(object)nview == (Object)null))
			{
				string[] baseAiRpcs = BaseAiRpcs;
				foreach (string text in baseAiRpcs)
				{
					nview.Unregister(text);
				}
			}
		}

		private static void DetachHandlers(Character character, object component)
		{
			if (!((Object)(object)character == (Object)null) && component != null)
			{
				character.m_onDamaged = (Action<float, Character>)Prune(character.m_onDamaged, component);
				character.m_onDeath = (Action)Prune(character.m_onDeath, component);
			}
		}

		private static void PruneDeadHandlers(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				character.m_onDamaged = (Action<float, Character>)Prune(character.m_onDamaged, null);
				character.m_onDeath = (Action)Prune(character.m_onDeath, null);
			}
		}

		private static Delegate Prune(Delegate multicast, object component)
		{
			if ((object)multicast == null)
			{
				return null;
			}
			Delegate obj = multicast;
			Delegate[] invocationList = multicast.GetInvocationList();
			foreach (Delegate obj2 in invocationList)
			{
				object target = obj2.Target;
				Object val = (Object)((target is Object) ? target : null);
				bool flag = val != null && val == (Object)null;
				if ((component != null && target == component) || flag)
				{
					obj = Delegate.Remove(obj, obj2);
				}
			}
			return obj;
		}
	}
	public static class VillagerSpawner
	{
		public static void LogAvailableDvergrPrefabs()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"ZNetScene not available for prefab listing");
				}
				return;
			}
			List<string> list = (from p in ZNetScene.instance.m_prefabs
				where (Object)(object)p != (Object)null && ((Object)p).name.IndexOf("dvergr", StringComparison.OrdinalIgnoreCase) >= 0
				select ((Object)p).name into n
				orderby n
				select n).ToList();
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"Found {list.Count} Dvergr prefabs:");
			}
			foreach (string item in list)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)("  - " + item));
				}
			}
		}

		internal static GameObject SpawnVillagerNpc(VillagerDef villagerDef, string villagerType, string villagerPrefab, Vector3 anchorPos, ref VillagerRecord record, string contextVillageId = null)
		{
			//IL_003a: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(villagerPrefab) : null);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Failed to find prefab " + villagerPrefab));
				}
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, anchorPos + Vector3.up * 0.7f, Quaternion.identity);
			if ((Object)(object)val2 == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)"Failed to instantiate NPC");
				}
				return null;
			}
			if (NativeNpcStripper.IsPlayerOwned(val2))
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)("[SpawnVillagerNpc] Prefab '" + villagerPrefab + "' resolved to a player-owned object; aborting spawn."));
				}
				Object.Destroy((Object)(object)val2);
				return null;
			}
			Humanoid component = val2.GetComponent<Humanoid>();
			if ((Object)(object)component != (Object)null)
			{
				((Character)component).m_name = villagerDef.displayName;
				Character component2 = val2.GetComponent<Character>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.m_faction = (Faction)0;
				}
			}
			val2.AddComponent<VillagerTalk>();
			val2.AddComponent<DoorHandler>();
			Dialog.ConfigureDialog(val2, villagerDef);
			ZNetView component3 = val2.GetComponent<ZNetView>();
			if ((Object)(object)component3 == (Object)null || component3.GetZDO() == null)
			{
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogError((object)"Spawned NPC has no ZNetView/ZDO");
				}
				Object.Destroy((Object)(object)val2);
				return null;
			}
			ZDOID uid = component3.GetZDO().m_uid;
			string text = ((record != null && !string.IsNullOrEmpty(record.Village)) ? record.Village : contextVillageId);
			if (string.IsNullOrEmpty(text))
			{
				ManualLogSource log5 = Plugin.Log;
				if (log5 != null)
				{
					log5.LogError((object)"[SpawnVillagerNpc] No village to spawn into (villages are created only at a registry station). Aborting spawn.");
				}
				Object.Destroy((Object)(object)val2);
				return null;
			}
			if (record == null)
			{
				record = VillagerRecordTable.Create(villagerType, villagerDef.displayName, text, anchorPos, RecordStatus.Alive, uid);
				if (record == null)
				{
					ManualLogSource log6 = Plugin.Log;
					if (log6 != null)
					{
						log6.LogError((object)"Failed to mint villager record; aborting spawn");
					}
					Object.Destroy((Object)(object)val2);
					return null;
				}
			}
			else
			{
				record.Status = RecordStatus.Alive;
				record.NpcZdoId = uid;
				record.HomeAnchor = anchorPos;
			}
			component3.GetZDO().Set("vv_record_id", record.RecordId);
			component3.GetZDO().Set("vv_village_id", text);
			component3.GetZDO().Set("vv_home_position", anchorPos);
			component3.GetZDO().Persistent = true;
			NativeNpcStripper.Strip(val2);
			val2.AddComponent<Villager>();
			VillagerBehaviorBridge villagerBehaviorBridge = val2.AddComponent<VillagerBehaviorBridge>();
			villagerBehaviorBridge.villagerInstance = val2.GetComponent<Villager>();
			villagerBehaviorBridge.Initialize(record.RecordId);
			val2.AddComponent<VillagerInteract>();
			val2.AddComponent<VillagerStation>().Initialize(villagerType);
			return val2;
		}
	}
	public class Villager : MonoBehaviour
	{
		public string villagerName = "Villager";

		public string uid;

		public string villagerType;

		public ZNetView nView;

		public VillagerAI villagerAI;

		private Vector3 m_homeAnchor;

		private ZDO m_zdo;

		public Vector3 HomeAnchor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_homeAnchor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				m_homeAnchor = value;
				nView.GetZDO().Set("vv_home_position", m_homeAnchor);
			}
		}

		public void Awake()
		{
			nView = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)nView != (Object)null)
			{
				m_zdo = nView.GetZDO();
			}
			if (m_zdo != null)
			{
				LoadIdentityFromRecord();
			}
			if ((Object)(object)villagerAI == (Object)null)
			{
				villagerAI = ((Component)this).gameObject.AddComponent<VillagerAI>();
			}
			if (m_zdo != null && (Object)(object)villagerAI != (Object)null)
			{
				villagerAI.LoadMemories(m_zdo);
			}
		}

		private void LoadIdentityFromRecord()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			string text = m_zdo.GetString("vv_record_id", "");
			VillagerRecord villagerRecord = VillagerRecordTable.FindById(text);
			if (villagerRecord == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("[Villager] No record found for vv_record_id '" + text + "' on '" + villagerName + "' — identity unresolved (mint/migrate invariant violated)"));
				}
			}
			else
			{
				uid = villagerRecord.RecordId;
				villagerType = villagerRecord.Type;
				villagerName = villagerRecord.Name;
				m_homeAnchor = villagerRecord.HomeAnchor;
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogDebug((object)$"[Villager] '{villagerName}' home from record={villagerRecord.HomeAnchor}");
				}
			}
		}

		private void LoadFromZDO()
		{
			if (m_zdo != null)
			{
				LoadIdentityFromRecord();
				if ((Object)(object)villagerAI != (Object)null)
				{
					villagerAI.LoadMemories(m_zdo);
				}
			}
		}

		private void SaveToZDO()
		{
			villagerAI.SaveMemories(m_zdo);
		}
	}
	public class VillagerAdapter : IVillager
	{
		public Vector3 HomeAnchor { get; }

		public VillagerWaypoint CurrentWaypoint { get; }

		public string VillagerName { get; }

		public string VillagerType { get; }

		public string UniqueID { get; }

		public VillagerAdapter(Villager villagerInstance)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			VillagerName = villagerInstance.villagerName;
			VillagerType = villagerInstance.villagerType;
			UniqueID = villagerInstance.uid;
			HomeAnchor = villagerInstance.HomeAnchor;
			CurrentWaypoint = villagerInstance.villagerAI?.GetCurrentWaypoint();
		}
	}
	public static class VillagerRestoration
	{
		public static bool Restore(GameObject go, ZDO zdo)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null || zdo == null)
			{
				return false;
			}
			if (NativeNpcStripper.IsPlayerOwned(go))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("[VillagerRestoration] Refusing to restore player-owned object '" + ((Object)go).name + "'."));
				}
				return false;
			}
			if (zdo.GetPrefab() == RecordPrefabFactory.RecordPrefabHash)
			{
				return false;
			}
			VillagerRecord villagerRecord = ResolveOrMigrateRecord(zdo);
			if (villagerRecord == null)
			{
				return false;
			}
			string recordId = villagerRecord.RecordId;
			if ((Object)(object)go.GetComponent<Villager>() != (Object)null)
			{
				return false;
			}
			string type = villagerRecord.Type;
			VillagerDef villagerDef = VillagerRegistry.Get(type);
			if (villagerDef == null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[VillagerRestoration] No definition for type '" + type + "', skipping"));
				}
				return false;
			}
			zdo.Persistent = true;
			StripNativeComponents(go);
			RestoreIdentity(go, villagerDef);
			RestoreComponents(go, recordId, type);
			Dialog.ConfigureDialog(go, villagerDef);
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)$"[VillagerRestoration] Restored {villagerDef.displayName} ({type}) at {go.transform.position}");
			}
			return true;
		}

		private static VillagerRecord ResolveOrMigrateRecord(ZDO zdo)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			string text = zdo.GetString("vv_record_id", "");
			if (!string.IsNullOrEmpty(text))
			{
				VillagerRecord villagerRecord = VillagerRecordTable.FindById(text);
				if (villagerRecord != null)
				{
					return villagerRecord;
				}
			}
			string text2 = zdo.GetString("vv_villager_type", "");
			if (string.IsNullOrEmpty(text2))
			{
				if (!string.IsNullOrEmpty(text))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[VillagerRestoration] vv_record_id '" + text + "' has no record and no legacy identity to migrate; skipping"));
					}
				}
				return null;
			}
			string text3 = zdo.GetString("vv_villager_name", "");
			Vector3 vec = zdo.GetVec3("vv_home_position", Vector3.zero);
			string text4 = zdo.GetString("vv_village_id", "");
			string text5 = ((!string.IsNullOrEmpty(text4)) ? text4 : (VillageRegistry.GetVillageCovering(vec) ?? VillageRegistry.FindNearAnchor(vec))?.VillageId);
			if (string.IsNullOrEmpty(text5))
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)($"[VillagerRestoration] legacy villager '{text3}' ({text2}) at {vec} " + "resolves to no village; not migrating (villages are created only at a registry station)."));
				}
				return null;
			}
			VillagerRecord villagerRecord2 = VillagerRecordTable.Create(text2, string.IsNullOrEmpty(text3) ? text2 : text3, text5, vec, RecordStatus.Alive, zdo.m_uid);
			if (villagerRecord2 == null)
			{
				return null;
			}
			zdo.Set("vv_record_id", villagerRecord2.RecordId);
			zdo.Set("vv_village_id", text5);
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)("[VillagerRestoration] Migrated legacy villager '" + text3 + "' (" + text2 + ") -> record " + villagerRecord2.RecordId));
			}
			return villagerRecord2;
		}

		private static void StripNativeComponents(GameObject go)
		{
			NativeNpcStripper.Strip(go);
		}

		private static void RestoreIdentity(GameObject go, VillagerDef definition)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Humanoid component = go.GetComponent<Humanoid>();
			if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(definition?.displayName))
			{
				((Character)component).m_name = definition.displayName;
			}
			Character component2 = go.GetComponent<Character>();
			if ((Object)(object)component2 != (Object)null && !NativeNpcStripper.IsPlayerOwned(component2))
			{
				component2.m_faction = (Faction)0;
			}
		}

		private static void RestoreComponents(GameObject go, string uniqueId, string typeStr)
		{
			if ((Object)(object)go.GetComponent<Villager>() == (Object)null)
			{
				go.AddComponent<Villager>();
			}
			if ((Object)(object)go.GetComponent<VillagerTalk>() == (Object)null)
			{
				go.AddComponent<VillagerTalk>();
			}
			if ((Object)(object)go.GetComponent<DoorHandler>() == (Object)null)
			{
				go.AddComponent<DoorHandler>();
			}
			if ((Object)(object)go.GetComponent<VillagerBehaviorBridge>() == (Object)null)
			{
				VillagerBehaviorBridge villagerBehaviorBridge = go.AddComponent<VillagerBehaviorBridge>();
				villagerBehaviorBridge.villagerInstance = go.GetComponent<Villager>();
				villagerBehaviorBridge.Initialize(uniqueId);
			}
			if ((Object)(object)go.GetComponent<VillagerInteract>() == (Object)null)
			{
				go.AddComponent<VillagerInteract>();
			}
			if ((Object)(object)go.GetComponent<VillagerStation>() == (Object)null)
			{
				go.AddComponent<VillagerStation>().Initialize(typeStr);
			}
		}
	}
	public class VillagerTalk : MonoBehaviour
	{
		private static float s_lastTalkTime;

		public List<string> randomTalk = new List<string>();

		public List<string> randomGreets = new List<string>();

		public List<string> randomGoodbye = new List<string>();

		public float maxRange = 20f;

		public float greetRange = 10f;

		public float byeRange = 15f;

		public float offset = 2.2f;

		public float hideDialogDelay = 12f;

		public float randomTalkInterval = 12f;

		public float randomTalkChance = 0.3f;

		public float minTalkInterval = 24f;

		private bool m_didGoodbye;

		private bool m_didGreet;

		private float m_lastTargetUpdate;

		private float m_nextRandomTalk;

		private Player m_targetPlayer;

		private void Start()
		{
			m_nextRandomTalk = Time.time + Random.Range(4f, randomTalkInterval);
		}

		private void Update()
		{
			//IL_0020: 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)
			UpdateTarget();
			if ((Object)(object)m_targetPlayer == (Object)null)
			{
				return;
			}
			float num = Vector3.Distance(((Component)m_targetPlayer).transform.position, ((Component)this).transform.position);
			if (!m_didGreet && num < greetRange)
			{
				m_didGreet = true;
				m_didGoodbye = false;
				QueueSay(randomGreets);
			}
			if (m_didGreet && !m_didGoodbye && num > byeRange)
			{
				m_didGoodbye = true;
				QueueSay(randomGoodbye);
			}
			if (Time.time >= m_nextRandomTalk)
			{
				m_nextRandomTalk = Time.time + randomTalkInterval;
				if (Random.value < randomTalkChance)
				{
					QueueSay(randomTalk);
				}
			}
		}

		private void UpdateTarget()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!(Time.time - m_lastTargetUpdate < 1f))
			{
				m_lastTargetUpdate = Time.time;
				m_targetPlayer = null;
				Player closestPlayer = Player.GetClosestPlayer(((Component)this).transform.position, maxRange);
				if (!((Object)(object)closestPlayer == (Object)null))
				{
					m_targetPlayer = closestPlayer;
				}
			}
		}

		private void QueueSay(List<string> lines)
		{
			if (lines != null && lines.Count != 0 && !(Time.time - s_lastTalkTime < minTalkInterval))
			{
				string text = lines[Random.Range(0, lines.Count)];
				Say(text);
			}
		}

		private void Say(string text)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			s_lastTalkTime = Time.time;
			Chat instance = Chat.instance;
			if (instance != null)
			{
				instance.SetNpcText(((Component)this).gameObject, Vector3.up * offset, 20f, hideDialogDelay, "", text, false);
			}
		}
	}
}
namespace ValheimVillages.Villager.Station
{
	public class VillagerStation : MonoBehaviour
	{
		public const string GenericStationName = "$vv_villager";

		public CraftingStation Station { get; private set; }

		private static string GetVirtualStationName(string villagerType)
		{
			VillagerDef villagerDef = VillagerRegistry.Get(villagerType);
			if (string.IsNullOrEmpty(villagerDef?.stationName))
			{
				return null;
			}
			return villagerDef.stationName;
		}

		public static bool HasCraftingRecipes(string villagerType)
		{
			VillagerDef villagerDef = VillagerRegistry.Get(villagerType);
			if (villagerDef?.tags != null)
			{
				return TagParser.HasTag(villagerDef.tags, "tab", "workorder");
			}
			return false;
		}

		public static string GetStationName(string villagerType)
		{
			return GetVirtualStationName(villagerType) ?? "$vv_villager";
		}

		public static bool IsVirtualStation(string stationName)
		{
			return stationName?.StartsWith("$vv_") ?? false;
		}

		public void Initialize(string villagerType)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			string stationName = GetStationName(villagerType);
			Station = ((Component)this).gameObject.AddComponent<CraftingStation>();
			Station.m_name = stationName;
			Station.m_icon = GetStationIconFor(villagerType);
			Station.m_discoverRange = 0f;
			Station.m_rangeBuild = 0f;
			Station.m_craftRequireRoof = false;
			Station.m_craftRequireFire = false;
			Station.m_showBasicRecipies = false;
			Station.m_useDistance = 10f;
			Station.m_useAnimation = 0;
			Station.m_areaMarker = null;
			Station.m_inUseObject = null;
			Station.m_haveFireObject = null;
			Station.m_craftItemEffects = new EffectList();
			Station.m_craftItemDoneEffects = new EffectList();
			Station.m_repairItemDoneEffects = new EffectList();
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("VillagerStation: Initialized '" + stationName + "' for " + villagerType));
			}
		}

		private static Sprite GetStationIconFor(string villagerType)
		{
			string text = VillagerRegistry.Get(villagerType)?.stationIcon;
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			ObjectDB instance = ObjectDB.instance;
			GameObject val = ((instance != null) ? instance.GetItemPrefab(text) : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Sprite[] array = val.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0)
			{
				return null;
			}
			return array[0];
		}
	}
}
namespace ValheimVillages.Villager.Registry
{
	public static class VillagerRegistry
	{
		private static Dictionary<string, VillagerDef> _definitions;

		public static IReadOnlyDictionary<string, VillagerDef> Definitions
		{
			get
			{
				EnsureInitialized();
				return _definitions;
			}
		}

		public static IEnumerable<VillagerDef> EnabledDefinitions
		{
			get
			{
				EnsureInitialized();
				foreach (VillagerDef value in _definitions.Values)
				{
					if (!value.disabled)
					{
						yield return value;
					}
				}
			}
		}

		public static VillagerDef Get(string villagerType)
		{
			EnsureInitialized();
			if (!_definitions.TryGetValue(villagerType, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool IsEnabled(string villagerType)
		{
			VillagerDef villagerDef = Get(villagerType);
			if (villagerDef != null)
			{
				return !villagerDef.disabled;
			}
			return false;
		}

		private static void EnsureInitialized()
		{
			if (_definitions != null)
			{
				return;
			}
			_definitions = new Dictionary<string, VillagerDef>();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.Contains(".Villager.Registry.Definitions.") || !text.EndsWith(".json"))
				{
					continue;
				}
				try
				{
					using Stream stream = executingAssembly.GetManifestResourceStream(text);
					using StreamReader streamReader = new StreamReader(stream);
					VillagerDef villagerDef = JsonUtility.FromJson<VillagerDef>(streamReader.ReadToEnd());
					if (!string.IsNullOrEmpty(villagerDef?.type))
					{
						_definitions[villagerDef.type] = villagerDef;
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogInfo((object)("Loaded villager: " + villagerDef.displayName + " (" + villagerDef.category + ")"));
						}
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogError((object)("Failed to load villager definition " + text + ": " + ex.Message));
					}
				}
			}
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)$"VillagerRegistry initialized with {_definitions.Count} types");
			}
		}
	}
}
namespace ValheimVillages.Villager.Records
{
	public static class RecordPrefabFactory
	{
		public const string RecordPrefabName = "vv_villager_record";

		public static readonly int RecordPrefabHash = StringExtensionMethods.GetStableHashCode("vv_villager_record");

		private static GameObject _prefab;

		public static void RegisterInZNetScene(ZNetScene zNetScene)
		{
			if ((Object)(object)zNetScene == (Object)null)
			{
				return;
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = zNetScene.GetPrefab("vv_villager_record");
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = BuildPrefab();
			}
			if (!((Object)(object)_prefab == (Object)null))
			{
				if (!zNetScene.m_prefabs.Contains(_prefab))
				{
					zNetScene.m_prefabs.Add(_prefab);
				}
				Dictionary<int, GameObject> privateDictionary = GetPrivateDictionary<ZNetScene>(zNetScene, "m_namedPrefabs");
				if (privateDictionary != null)
				{
					privateDictionary[RecordPrefabHash] = _prefab;
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[RecordPrefabFactory] Registered 'vv_villager_record' carrier in ZNetScene");
				}
			}
		}

		private static GameObject BuildPrefab()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			GameObject val = new GameObject("vv_villager_record");
			val.SetActive(false);
			ZNetView obj = val.AddComponent<ZNetView>();
			obj.m_persistent = true;
			obj.m_type = (ObjectType)0;
			obj.m_distant = false;
			Object.DontDestroyOnLoad((Object)val);
			val.SetActive(true);
			return val;
		}

		private static Dictionary<int, GameObject> GetPrivateDictionary<T>(T instance, string fieldName)
		{
			return typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance) as Dictionary<int, GameObject>;
		}
	}
	public enum RecordStatus
	{
		Egg,
		Alive,
		Dead
	}
	public sealed class VillagerRecord
	{
		public const string IdKey = "vv_record_id";

		public const string TypeKey = "vv_record_type";

		public const string NameKey = "vv_record_name";

		public const string StatusKey = "vv_record_status";

		public const string VillageTag = "vv_record_village";

		public const string HomeKey = "vv_record_home";

		public const string EggPrefabKey = "vv_record_egg_prefab";

		public const string NpcKey = "vv_record_npc";

		private readonly ZDO m_zdo;

		public ZDO Zdo => m_zdo;

		public bool IsValid
		{
			get
			{
				if (m_zdo != null)
				{
					return !string.IsNullOrEmpty(RecordId);
				}
				return false;
			}
		}

		public string RecordId => m_zdo.GetString("vv_record_id", "");

		public string Type
		{
			get
			{
				return m_zdo.GetString("vv_record_type", "");
			}
			set
			{
				SetString("vv_record_type", value);
			}
		}

		public string Name
		{
			get
			{
				return m_zdo.GetString("vv_record_name", "");
			}
			set
			{
				SetString("vv_record_name", value);
			}
		}

		public RecordStatus Status
		{
			get
			{
				return (RecordStatus)m_zdo.GetInt("vv_record_status", 1);
			}
			set
			{
				m_zdo.Set("vv_record_status", (int)value);
				m_zdo.Persistent = true;
			}
		}

		public string Village
		{
			get
			{
				return m_zdo.GetString("vv_record_village", "");
			}
			set
			{
				SetString("vv_record_village", value);
			}
		}

		public Vector3 HomeAnchor
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				return m_zdo.GetVec3("vv_record_home", Vector3.zero);
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				m_zdo.Set("vv_record_home", value);
				m_zdo.Persistent = true;
			}
		}

		public string EggPrefab
		{
			get
			{
				return m_zdo.GetString("vv_record_egg_prefab", "");
			}
			set
			{
				SetString("vv_record_egg_prefab", value);
			}
		}

		public ZDOID NpcZdoId
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return m_zdo.GetZDOID("vv_record_npc");
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				m_zdo.Set("vv_record_npc", value);
				m_zdo.Persistent = true;
			}
		}

		public VillagerRecord(ZDO zdo)
		{
			m_zdo = zdo;
		}

		private void SetString(string key, string value)
		{
			m_zdo.Set(key, value ?? "");
			m_zdo.Persistent = true;
		}
	}
	public static class VillagerRecordCommands
	{
		[DevCommand("Dump villager records [alive|dead|egg|<villageKey>]", Name = "vv_records")]
		public static void Dump(ConsoleEventArgs args)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			string text = ((args.Length > 1) ? args[1] : null);
			List<VillagerRecord> list = (string.Equals(text, "alive", StringComparison.OrdinalIgnoreCase) ? Filter(RecordStatus.Alive) : (string.Equals(text, "dead", StringComparison.OrdinalIgnoreCase) ? Filter(RecordStatus.Dead) : (string.Equals(text, "egg", StringComparison.OrdinalIgnoreCase) ? Filter(RecordStatus.Egg) : (string.IsNullOrEmpty(text) ? VillagerRecordTable.EnumerateAll().ToList() : VillagerRecordTable.QueryByVillage(text).ToList()))));
			Print(string.Format("[vv_records] {0} record(s){1}", list.Count, (text != null) ? (" (filter: " + text + ")") : ""));
			foreach (VillagerRecord item in list)
			{
				Print($"  {item.Status,-5} {item.Name} ({item.Type})  village={item.Village}  id={item.RecordId}  npc={item.NpcZdoId}");
			}
		}

		[DevCommand("Kill nearest active villager (or by record id) to test the death->Dead flow", Name = "vv_kill_villager")]
		public static void KillVillager(ConsoleEventArgs args)
		{
			//IL_004f: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			string text = ((args.Length > 1) ? args[1] : null);
			VillagerAI value = null;
			if (!string.IsNullOrEmpty(text))
			{
				VillagerAIManager.ActiveVillagers.TryGetValue(text, out value);
			}
			else
			{
				Vector3 val = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
				float num = float.MaxValue;
				foreach (VillagerAI value2 in VillagerAIManager.ActiveVillagers.Values)
				{
					if (!((Object)(object)value2 == (Object)null))
					{
						Vector3 val2 = ((Component)value2).transform.position - val;
						float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
						if (sqrMagnitude < num)
						{
							num = sqrMagnitude;
							value = value2;
						}
					}
				}
			}
			if ((Object)(object)value == (Object)null)
			{
				Print("[vv_kill_villager] no matching active villager found");
				return;
			}
			Character component = ((Component)value).GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				Print("[vv_kill_villager] villager has no Character component");
				return;
			}
			try
			{
				HitData val3 = new HitData
				{
					m_point = ((Component)component).transform.position,
					m_dir = Vector3.up,
					m_hitType = (HitType)0
				};
				val3.m_damage.m_blunt = 100000f;
				component.Damage(val3);
				Print($"[vv_kill_villager] applied lethal damage to '{component.m_name}' at {((Component)component).transform.position}");
			}
			catch (Exception ex)
			{
				Print("[vv_kill_villager] Damage threw: " + ex.GetType().Name + ": " + ex.Message);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"[vv_kill_villager] Damage threw:\n{ex}");
				}
			}
		}

		[DevCommand("Set a record's status: vv_set_record_status <id> <alive|dead|egg>", Name = "vv_set_record_status")]
		public static void SetRecordStatus(ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				Print("usage: vv_set_record_status <id> <alive|dead|egg>");
				return;
			}
			if (!Enum.TryParse<RecordStatus>(args[2], ignoreCase: true, out var result))
			{
				Print("[vv_set_record_status] unknown status '" + args[2] + "' (alive|dead|egg)");
				return;
			}
			VillagerRecordTable.SetStatus(args[1], result);
			Print($"[vv_set_record_status] {args[1]} -> {result}");
		}

		[DevCommand("Recruit a villager of <type> at the player position (test): vv_recruit <type>", Name = "vv_recruit")]
		public static void Recruit(ConsoleEventArgs args)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (args.Length < 2)
			{
				Print("usage: vv_recruit <type>");
				return;
			}
			VillagerDef villagerDef = VillagerRegistry.Get(args[1]);
			if (villagerDef == null)
			{
				Print("[vv_recruit] unknown type '" + args[1] + "'");
				return;
			}
			Vector3 val = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			string text = (VillageRegistry.GetVillageCovering(val) ?? VillageRegistry.FindNearAnchor(val))?.VillageId;
			if (string.IsNullOrEmpty(text))
			{
				Print("[vv_recruit] no village here — place a registry station first (villages are minted only there)");
				return;
			}
			string villagerPrefab = ((!string.IsNullOrEmpty(villagerDef.preferredPrefab)) ? villagerDef.preferredPrefab : "DvergerMage");
			VillagerRecord record = null;
			Print(((Object)(object)VillagerSpawner.SpawnVillagerNpc(villagerDef, villagerDef.type, villagerPrefab, val, ref record, text) != (Object)null) ? $"[vv_recruit] recruited {villagerDef.type} at {val} into village {text}" : "[vv_recruit] failed");
		}

		[DevCommand("Revive a fallen villager by record id: vv_revive <id>", Name = "vv_revive")]
		public static void Revive(ConsoleEventArgs args)
		{
			if (args.Length < 2)
			{
				Print("usage: vv_revive <id>");
			}
			else
			{
				Print(VillagerReviveService.Revive(VillagerRecordTable.FindById(args[1]), out var error) ? ("[vv_revive] revived " + args[1]) : ("[vv_revive] failed: " + error));
			}
		}

		private static List<VillagerRecord> Filter(RecordStatus status)
		{
			return (from r in VillagerRecordTable.EnumerateAll()
				where r.Status == status
				select r).ToList();
		}

		private static void Print(string msg)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(msg);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)msg);
			}
		}
	}
	public static class VillagerRecordTable
	{
		public static VillagerRecord Create(string type, string name, string villageKey, Vector3 anchorPos, RecordStatus status, ZDOID npcZdoId)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)"[VillagerRecordTable] Cannot create record: ZDOMan not ready");
				}
				return null;
			}
			ZDO obj = instance.CreateNewZDO(anchorPos, RecordPrefabFactory.RecordPrefabHash);
			obj.SetPrefab(RecordPrefabFactory.RecordPrefabHash);
			obj.Persistent = true;
			string text = Guid.NewGuid().ToString();
			obj.Set("vv_record_id", text);
			VillagerRecord result = new VillagerRecord(obj)
			{
				Type = type,
				Name = name,
				Village = villageKey,
				HomeAnchor = anchorPos,
				Status = status,
				NpcZdoId = npcZdoId,
				EggPrefab = ""
			};
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"[VillagerRecordTable] Created record {text} ({status}) type={type} name={name} village={villageKey}");
			}
			return result;
		}

		public static IEnumerable<VillagerRecord> EnumerateAll()
		{
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				yield break;
			}
			Dictionary<ZDOID, ZDO> value = Traverse.Create((object)instance).Field<Dictionary<ZDOID, ZDO>>("m_objectsByID").Value;
			if (value == null)
			{
				yield break;
			}
			foreach (ZDO value2 in value.Values)
			{
				if (value2 != null && value2.GetPrefab() == RecordPrefabFactory.RecordPrefabHash)
				{
					yield return new VillagerRecord(value2);
				}
			}
		}

		public static VillagerRecord FindById(string recordId)
		{
			if (string.IsNullOrEmpty(recordId))
			{
				return null;
			}
			foreach (VillagerRecord item in EnumerateAll())
			{
				if (item.RecordId == recordId)
				{
					return item;
				}
			}
			return null;
		}

		public static IEnumerable<VillagerRecord> QueryByVillage(string villageKey)
		{
			foreach (VillagerRecord item in EnumerateAll())
			{
				if (KeysMatch(item.Village, villageKey))
				{
					yield return item;
				}
			}
		}

		public static IEnumerable<VillagerRecord> QueryByStatus(string villageKey, RecordStatus status)
		{
			foreach (VillagerRecord item in EnumerateAll())
			{
				if (item.Status == status && KeysMatch(item.Village, villageKey))
				{
					yield return item;
				}
			}
		}

		public static void SetStatus(string recordId, RecordStatus status)
		{
			VillagerRecord villagerRecord = FindById(recordId);
			if (villagerRecord == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[VillagerRecordTable] SetStatus: record " + recordId + " not found"));
				}
				return;
			}
			villagerRecord.Status = status;
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"[VillagerRecordTable] Record {recordId} -> {status}");
			}
		}

		public static int AuditOrphans()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				return 0;
			}
			int num = 0;
			foreach (VillagerRecord item in EnumerateAll())
			{
				if (item.Status != RecordStatus.Alive)
				{
					continue;
				}
				ZDOID npcZdoId = item.NpcZdoId;
				if (!(npcZdoId == ZDOID.None) && instance.GetZDO(npcZdoId) == null)
				{
					num++;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogError((object)("[VillagerRecordTable] ORPHANED Alive record " + item.RecordId + " (type=" + item.Type + " name=" + item.Name + " village=" + item.Village + "): its linked NPC " + $"ZDO {npcZdoId} no longer exists in the world. The record was left INTACT — this " + "is an invariant violation, not a cue to auto-delete. Investigate why the NPC vanished (link broken on reload, removed without a clean death, etc.)."));
					}
				}
			}
			if (num > 0)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)($"[VillagerRecordTable] {num} orphaned Alive record(s) detected (see errors " + "above). Records were NOT modified."));
				}
			}
			return num;
		}

		public static bool KeysMatch(string a, string b)
		{
			if (!string.IsNullOrEmpty(a))
			{
				return a == b;
			}
			return false;
		}
	}
	public static class VillagerReviveService
	{
		public const float CooldownSeconds = 30f;

		private const string DefaultPrefab = "DvergerMage";

		private static float s_lastReviveTime = -30f;

		public static bool IsOnCooldown => Time.time - s_lastReviveTime < 30f;

		public static float CooldownRemaining => Mathf.Max(0f, 30f - (Time.time - s_lastReviveTime));

		public static bool Revive(VillagerRecord record, out string error)
		{
			return Revive(record, null, out error);
		}

		public static bool Revive(VillagerRecord record, Vector3? anchor, out string error)
		{
			//IL_007e: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			error = null;
			if (record == null)
			{
				error = "no record";
				return false;
			}
			if (record.Status != RecordStatus.Dead)
			{
				error = "villager is not fallen";
				return false;
			}
			if (IsOnCooldown)
			{
				error = $"revive on cooldown ({CooldownRemaining:F0}s)";
				return false;
			}
			VillagerDef villagerDef = VillagerRegistry.Get(record.Type);
			if (villagerDef == null)
			{
				error = "unknown villager type '" + record.Type + "'";
				return false;
			}
			Vector3 val = (Vector3)(((??)anchor) ?? record.HomeAnchor);
			if (val == Vector3.zero)
			{
				error = "no anchor/home position to revive at";
				return false;
			}
			Vector3 val2 = val;
			if (RegistrySeedResolver.TryResolveWalkableSeed(val, out var seed))
			{
				val2 = seed;
			}
			else
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)($"[Revive] No walkable seed near anchor ({val.x:F1},{val.y:F1},{val.z:F1}) " + "for '" + record.Name + "'; reviving at the anchor as-is."));
				}
			}
			string villagerPrefab = ((!string.IsNullOrEmpty(villagerDef.preferredPrefab)) ? villagerDef.preferredPrefab : "DvergerMage");
			VillagerRecord record2 = record;
			if ((Object)(object)VillagerSpawner.SpawnVillagerNpc(villagerDef, record.Type, villagerPrefab, val2, ref record2) == (Object)null)
			{
				error = "failed to spawn villager";
				return false;
			}
			s_lastReviveTime = Time.time;
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)("[Revive] Revived '" + record.Name + "' (" + record.Type + ") record " + record.RecordId + " at " + $"({val2.x:F1},{val2.y:F1},{val2.z:F1})"));
			}
			return true;
		}
	}
}
namespace ValheimVillages.Villager.AI
{
	public static class VillagerBehaviorLogic
	{
		public static BehaviorContext GetCurrentContext(VillagerAI ai)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ai.Position;
			float dayFraction = (((Object)(object)EnvMan.instance != (Object)null) ? EnvMan.instance.GetDayFraction() : 0.5f);
			bool isRaining = (Object)(object)EnvMan.instance != (Object)null && (EnvMan.IsWet() || EnvMan.instance.IsEnvironment("Rain"));
			return new BehaviorContext
			{
				CurrentPosition = position,
				TimeOfDay = GetTimeOfDay(dayFraction),
				IsRaining = isRaining,
				InShelter = CheckShelter(position),
				CurrentComfort = 0f
			};
		}

		private static TimeOfDay GetTimeOfDay(float dayFraction)
		{
			if (dayFraction >= 0.875f || dayFraction < 0.25f)
			{
				return TimeOfDay.Evening;
			}
			if (dayFraction < 0.417f)
			{
				return TimeOfDay.Morning;
			}
			if (dayFraction < 0.708f)
			{
				return TimeOfDay.Day;
			}
			return TimeOfDay.Evening;
		}

		public static bool CheckShelter(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(position + Vector3.up * 0.5f, Vector3.up, ref val, 50f))
			{
				Collider collider = ((RaycastHit)(ref val)).collider;
				if ((Object)(object)((collider != null) ? ((Component)collider).GetComponentInParent<Piece>() : null) != (Object)null)
				{
					return true;
				}
				if ((Object)(object)((RaycastHit)(ref val)).collider != (Object)null && ((Component)((RaycastHit)(ref val)).collider).gameObject.isStatic)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class VillagerComfort
	{
		public static void UpdateExperiencedComfort(Transform transform, IVillagerMemory memory)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)transform == (Object)null) && memory != null)
			{
				Vector3 position = transform.position;
				memory.UpdateBestComfort(CalculateCurrentComfort(position), position);
			}
		}

		private static float CalculateCurrentComfort(Vector3 position)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if (VillagerBehaviorLogic.CheckShelter(position))
			{
				num += 1f;
			}
			Collider[] array = Physics.OverlapSphere(position, 10f);
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null) && (Object)(object)((Component)val).GetComponent<Fireplace>() != (Object)null)
				{
					num += 1f;
					break;
				}
			}
			return num;
		}
	}
	public class VillagerAI : BaseAI, IVillagerWorkContext, IVillagerStationLookup
	{
		private const float SaveInterval = 60f;

		private const float NavToSnapRadius = 2f;

		private NavMeshAgent m_navAgent;

		private Vector3 m_lastAgentDest = new Vector3(float.PositiveInfinity, 0f, 0f);

		private Vector3 m_homeAnchor;

		private List<IBehavior> m_behaviors = new List<IBehavior>();

		private VillagerWaypoint m_currentWaypoint;

		private DoorHandler m_doorHandler;

		private float m_explorationStartTime;

		private Vector3? m_explorationTarget;

		private float m_lastBehaviorUpdateTime;

		private float m_nextReselectOverride = -1f;

		private float m_lastDiscoveryTime;

		private float m_lastMemorySaveTime;

		private bool m_directOrderActive;

		private bool m_stallLogged;

		private float m_stallStartTime;

		internal readonly AiEventRing EventRing = new AiEventRing();

		private float m_stuckBackoffUntil;

		private string m_villagerName;

		private List<Vector3> m_waypointPath;

		private bool m_warnedNoHome;

		private bool m_rescuing;

		private float m_nextRescueCheck;

		private float m_strandedSince;

		private Vector3 m_rescueLastPos;

		private float m_rescueProgressTime;

		private const float RescueCheckInterval = 1f;

		private const float StrandConfirmSeconds = 2f;

		private const float RescueStuckSeconds = 3f;

		private const float RescueProgressEps = 0.5f;

		public float LingerUntilTime { get; set; }

		public Vector3 LingerAtPos { get; set; }

		public bool IsLingering => Time.time < LingerUntilTime;

		public bool IsCasualTravel { get; set; }

		private DoorHandler DoorHandler => m_doorHandler ?? (m_doorHandler = ((Component)this).GetComponent<DoorHandler>());

		public Villager Villager { get; private set; }

		public string NpcName => m_villagerName ?? Villager?.villagerName ?? "Unknown";

		public string UniqueId { get; private set; }

		public Vector3 Position
		{
			get
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)Villager != (Object)null))
				{
					return Vector3.zero;
				}
				return ((Component)Villager).transform.position;
			}
		}

		public VillagerMemory Memory { get; private set; }

		public BaseAI Instance => (BaseAI)(object)this;

		public ZNetView NView => Villager?.nView;

		public Character Character
		{
			get
			{
				if (!((Object)(object)Villager != (Object)null))
				{
					return null;
				}
				return ((Component)Villager).GetComponent<Character>();
			}
		}

		public Humanoid Humanoid
		{
			get
			{
				Character character = Character;
				return (Humanoid)(object)((character is Humanoid) ? character : null);
			}
		}

		public Vector3? CurrentTarget
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (m_currentWaypoint == null)
				{
					return null;
				}
				return m_currentWaypoint.Position;
			}
		}

		public CraftingBehaviorAdapter CraftingBehavior => GetBehavior<CraftingBehaviorAdapter>();

		public string VillagerType { get; private set; }

		Vector3 IVillagerStationLookup.HomeAnchor
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (Memory == null)
				{
					return default(Vector3);
				}
				return Memory.HomeAnchor;
			}
		}

		public Vector3 HomeAnchor => m_homeAnchor;

		string IVillagerWorkContext.NpcName => NpcName;

		Vector3 IVillagerWorkContext.Position => Position;

		public BehaviorState CurrentState { get; private set; }

		public IBehavior ActiveBehavior { get; private set; }

		public bool IsInBackoff => Time.time < m_stuckBackoffUntil;

		public bool IsPaused { get; private set; }

		public VillagerAI(Villager instance)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			Villager = instance;
			UniqueId = Villager.uid;
			m_homeAnchor = Villager.HomeAnchor;
			VillagerType = Villager.villagerType;
			m_villagerName = Villager.villagerName;
			Memory = new VillagerMemory(m_homeAnchor);
		}

		public VillagerAI()
		{
		}//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)


		protected override void Awake()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				((BaseAI)this).Awake();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[VillagerAI] base.Awake() threw: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			if ((Object)(object)base.m_character == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("[VillagerAI] base.Awake() did not complete (m_character is null) on '" + ((Object)this).name + "'; AI will not activate. Indicates a native-component cleanup or double-init regression."));
				}
				return;
			}
			if (VillagerAgentType.EnsureRegistered())
			{
				base.m_pathAgentType = VillagerAgentType.AgentType;
			}
			if ((Object)(object)Villager == (Object)null)
			{
				Villager = ((Component)this).GetComponent<Villager>();
				if ((Object)(object)Villager == (Object)null)
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogError((object)"[VillagerAI] No Villager component on this GameObject");
					}
					return;
				}
				UniqueId = Villager.uid;
				m_homeAnchor = Villager.HomeAnchor;
				VillagerType = Villager.villagerType;
				m_villagerName = Villager.villagerName;
				Memory = new VillagerMemory(m_homeAnchor);
				VillagerAIManager.RegisterActive(this);
			}
			m_doorHandler = ((Component)this).GetComponent<DoorHandler>();
			RegisterHome();
			RegisterBehaviors();
			m_lastBehaviorUpdateTime = Random.Range(0f, 11f);
		}

		private void OnDestroy()
		{
			try
			{
				ZNetView component = ((Component)this).GetComponent<ZNetView>();
				ZDO val = ((component != null) ? component.GetZDO() : null);
				if (val != null)
				{
					SaveMemories(val);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[VillagerAI] OnDestroy SaveMemories failed: " + ex.Message));
				}
			}
			VillagerAIManager.Unregister(this);
		}

		public void RegisterHome()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Memory.HomeAnchor = m_homeAnchor;
		}

		public override bool UpdateAI(float dt)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Villager == (Object)null)
			{
				return false;
			}
			if (!((BaseAI)this).UpdateAI(dt))
			{
				return false;
			}
			if (m_homeAnchor == Vector3.zero)
			{
				if (!m_warnedNoHome)
				{
					m_warnedNoHome = true;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AI:" + m_villagerName + "] No valid anchor position — skipping AI tick (broken/zombie villager)."));
					}
				}
				return false;
			}
			if ((double)m_lastBehaviorUpdateTime > 0.0)
			{
				m_lastBehaviorUpdateTime -= dt;
			}
			if (IsPaused)
			{
				return true;
			}
			if (VillageNavLock.IsHeld)
			{
				((BaseAI)this).StopMoving();
				if ((Object)(object)m_navAgent != (Object)null && m_navAgent.isOnNavMesh)
				{
					m_navAgent.ResetPath();
				}
				return true;
			}
			if (TryOffMeshRescue(dt))
			{
				return true;
			}
			if (Time.time - m_lastDiscoveryTime > 4f)
			{
				m_lastDiscoveryTime = Time.time;
				VillagerComfort.UpdateExperiencedComfort(((Component)this).transform, Memory);
			}
			if (m_lastBehaviorUpdateTime <= 0f)
			{
				if (!m_directOrderActive)
				{
					BehaviorContext ctx = default(BehaviorContext);
					bool flag = false;
					foreach (IBehavior behavior in m_behaviors)
					{
						if (behavior.WantsControl(ctx))
						{
							ActiveBehavior = behavior;
							behavior.Update(dt);
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						ActiveBehavior = null;
						if (CurrentState != BehaviorState.Working)
						{
							GetWorkScanner()?.TryScanForWork();
						}
						if (CurrentState != BehaviorState.Idle)
						{
							SetState(BehaviorState.Idle);
						}
					}
				}
				m_lastBehaviorUpdateTime = ((m_nextReselectOverride >= 0f) ? m_nextReselectOverride : 2f);
				m_nextReselectOverride = -1f;
			}
			if (Time.time - m_lastMemorySaveTime > 60f)
			{
				m_lastMemorySaveTime = Time.time;
				ZNetView component = ((Component)this).GetComponent<ZNetView>();
				ZDO val = ((component != null) ? component.GetZDO() : null);
				if (val != null)
				{
					SaveMemories(val);
				}
			}
			if (m_currentWaypoint != null && NeedsMovement(CurrentState))
			{
				Vector3 position = m_currentWaypoint.Position;
				float num = Vector3.Distance(((Component)this).transform.position, position);
				float lookahead = ((CurrentState == BehaviorState.Patrolling) ? 2f : 0f);
				if (AgentHasArrived(position, lookahead))
				{
					OnArrivedAtTarget(dt);
				}
				else
				{
					bool running = CurrentState == BehaviorState.Patrolling || (!IsCasualTravel && num > 5f);
					UpdateAgentMovement(position, running);
				}
			}
			return false;
		}

		public void LoadMemories(ZDO zdo)
		{
			Memory.LoadFromZDO(zdo);
			VillagerActivityLog.Instance.LoadFromZDO(UniqueId, zdo);
			foreach (IBehavior behavior in m_behaviors)
			{
				if (behavior is IBehaviorPersistence behaviorPersistence)
				{
					behaviorPersistence.Load(zdo);
				}
			}
		}

		public void SaveMemories(ZDO zdo)
		{
			Memory.SaveToZDO(zdo);
			VillagerActivityLog.Instance.SaveToZDO(UniqueId, zdo);
			VillagerActivityLog.Instance.MarkCommitted(UniqueId);
			VillagerActivityLog.Instance.TrimCommitted(UniqueId);
			foreach (IBehavior behavior in m_behaviors)
			{
				if (behavior is IBehaviorPersistence behaviorPersistence)
				{
					behaviorPersistence.Save(zdo);
				}
			}
		}

		private void RegisterBehaviors()
		{
			VillagerDef villagerDef = VillagerRegistry.Get(VillagerType);
			List<string> list = new List<string>();
			if (villagerDef?.behaviors != null)
			{
				list.AddRange(villagerDef.behaviors);
			}
			if (villagerDef?.tags != null)
			{
				list.AddRange(TagParser.GetValues(villagerDef.tags, "behavior"));
			}
			m_behaviors = BehaviorFactory.CreateBehaviors(this, list);
			bool flag = false;
			bool flag2 = false;
			foreach (IBehavior behavior3 in m_behaviors)
			{
				if (behavior3 is CombatBehavior)
				{
					flag = true;
				}
				if (behavior3 is FleeBehavior)
				{
					flag2 = true;
				}
			}
			if (!flag && !flag2)
			{
				m_behaviors.Add(new FleeBehavior(this));
				m_behaviors.Sort((IBehavior a, IBehavior b) => b.Priority.CompareTo(a.Priority));
			}
			CraftingBehaviorAdapter behavior = GetBehavior<CraftingBehaviorAdapter>();
			FarmBehaviorAdapter behavior2 = GetBehavior<FarmBehaviorAdapter>();
			if (behavior != null)
			{
				behavior2?.LinkToCraftingAdapter(behavior);
			}
		}

		private static bool NeedsMovement(BehaviorState state)
		{
			return state switch
			{
				BehaviorState.Traveling => true, 
				BehaviorState.Exploring => true, 
				BehaviorState.Wandering => true, 
				BehaviorState.Patrolling => true, 
				BehaviorState.Working => true, 
				BehaviorState.Alarmed => true, 
				_ => false, 
			};
		}

		public T GetBehavior<T>() where T : class, IBehavior
		{
			foreach (IBehavior behavior in m_behaviors)
			{
				if (behavior is T result)
				{
					return result;
				}
			}
			return null;
		}

		public IBehavior GetBehavior(string matchBehaviorTag)
		{
			foreach (IBehavior behavior in m_behaviors)
			{
				if (behavior.Tag == matchBehaviorTag)
				{
					return behavior;
				}
			}
			return null;
		}

		public VillagerMemory GetMemory()
		{
			return Memory;
		}

		public IWorkScanBehavior GetWorkScanner()
		{
			return GetBehavior<CraftingBehaviorAdapter>();
		}

		public void ClearWaypoint()
		{
			m_currentWaypoint = null;
			((BaseAI)this).StopMoving();
		}

		public void SetState(BehaviorState newState, Vector3? target = null)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			VillagerWaypoint waypoint = (target.HasValue ? VillagerWaypoint.WithDefault(target.Value) : null);
			SetState(newState, waypoint);
		}

		public void SetState(BehaviorState newState, VillagerWaypoint waypoint)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			BehaviorState currentState = CurrentState;
			CurrentState = newState;
			if (waypoint != null)
			{
				Vector3 prevTarget = ((m_currentWaypoint != null) ? m_currentWaypoint.Position : Vector3.zero);
				m_currentWaypoint = waypoint;
				IsCasualTravel = false;
				EventRing.RecordTargetSet(waypoint.Position, prevTarget, $"SetState({newState})");
			}
			if (currentState != newState)
			{
				EventRing.RecordStateChange(currentState.ToString(), newState.ToString(), (waypoint != null) ? "with_waypoint" : "no_waypoint");
			}
			if (newState == BehaviorState.Idle || newState == BehaviorState.NeedsHelp)
			{
				((BaseAI)this).StopMoving();
			}
			if (waypoint != null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)$"[AI:{m_villagerName}] State -> {newState}, target=({waypoint.Position.x:F1},{waypoint.Position.y:F1},{waypoint.Position.z:F1})");
				}
			}
			else
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogDebug((object)$"[AI:{m_villagerName}] State -> {newState}");
				}
			}
		}

		public void SetPaused(bool paused)
		{
			IsPaused = paused;
			if (paused)
			{
				((BaseAI)this).StopMoving();
			}
		}

		public void RequestFastReselect(float seconds)
		{
			m_nextReselectOverride = Mathf.Max(0f, seconds);
		}

		public VillagerWaypoint GetCurrentWaypoint()
		{
			return m_currentWaypoint;
		}

		public bool NavTo(Vector3 target, BehaviorState state, string label, bool snapToApproach = true, Func<Vector3, bool> hullPredicate = null, bool directOrder = false, bool resetPath = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			Vector3 approach = target;
			if (snapToApproach && !VillagerMovement.TryResolveApproach(target, ((Component)this).transform.position, hullPredicate, out approach))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[AI:" + m_villagerName + "] NavTo('" + label + "') found no reachable approach to " + $"({target.x:F1},{target.y:F1},{target.z:F1}); not moving."));
				}
				return false;
			}
			NavMeshHit val = default(NavMeshHit);
			if (VillagerAgentType.IsRegistered && NavMesh.SamplePosition(approach, ref val, 2f, AgentFilter()))
			{
				approach = ((NavMeshHit)(ref val)).position;
			}
			SetState(state, new VillagerWaypoint(approach, "default", label));
			if (resetPath && (Object)(object)m_navAgent != (Object)null && m_navAgent.isOnNavMesh)
			{
				m_navAgent.ResetPath();
			}
			m_directOrderActive = directOrder;
			return true;
		}

		private void EnsureAgent()
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_navAgent != (Object)null) && VillagerAgentType.IsRegistered)
			{
				m_navAgent = ((Component)this).gameObject.GetComponent<NavMeshAgent>() ?? ((Component)this).gameObject.AddComponent<NavMeshAgent>();
				m_navAgent.agentTypeID = VillagerAgentType.UnityAgentTypeID;
				m_navAgent.updatePosition = false;
				m_navAgent.updateRotation = false;
				m_navAgent.updateUpAxis = false;
				m_navAgent.baseOffset = 0f;
				m_navAgent.autoBraking = true;
				m_navAgent.autoRepath = true;
				m_navAgent.autoTraverseOffMeshLink = false;
				m_navAgent.speed = 5f;
				m_navAgent.acceleration = 12f;
				m_navAgent.angularSpeed = 1080f;
				m_navAgent.stoppingDistance = 0.3f;
				m_navAgent.obstacleAvoidanceType = (ObstacleAvoidanceType)3;
				m_navAgent.avoidancePriority = 20 + Mathf.Abs(UniqueId?.GetHashCode() ?? 0) % 61;
				NavMeshHit val = default(NavMeshHit);
				if (NavMesh.SamplePosition(((Component)this).transform.position, ref val, 3f, AgentFilter()))
				{
					m_navAgent.Warp(((NavMeshHit)(ref val)).position);
				}
			}
		}

		private static NavMeshQueryFilter AgentFilter()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			NavMeshQueryFilter result = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref result)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref result)).areaMask = -1;
			return result;
		}

		private bool AgentHasArrived(Vector3 targetPos, float lookahead = 0f)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_navAgent == (Object)null || !m_navAgent.isOnNavMesh)
			{
				return false;
			}
			if (m_navAgent.pathPending || !m_navAgent.hasPath)
			{
				return false;
			}
			Vector3 val = m_navAgent.destination - targetPos;
			if (((Vector3)(ref val)).sqrMagnitude > 0.25f)
			{
				return false;
			}
			if ((int)m_navAgent.pathStatus != 0)
			{
				return false;
			}
			return m_navAgent.remainingDistance <= m_navAgent.stoppingDistance + 0.25f + lookahead;
		}

		private bool TryOffMeshRescue(float dt)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
			if (!VillagerAgentType.IsRegistered)
			{
				return false;
			}
			bool flag = Time.time >= m_nextRescueCheck;
			if (m_rescuing)
			{
				if (flag)
				{
					m_nextRescueCheck = Time.time + 1f;
					if (!IsStranded())
					{
						m_rescuing = false;
						m_strandedSince = 0f;
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogInfo((object)("[AI:" + m_villagerName + "] Rescue complete — back on the village graph."));
						}
						if (CurrentState == BehaviorState.NeedsHelp)
						{
							SetState(BehaviorState.Idle);
						}
						ClearCachedPath();
						return false;
					}
				}
				Vector3 val = ((Component)this).transform.position - m_rescueLastPos;
				if (((Vector3)(ref val)).sqrMagnitude > 0.25f)
				{
					m_rescueLastPos = ((Component)this).transform.position;
					m_rescueProgressTime = Time.time;
				}
				else if (Time.time - m_rescueProgressTime > 3f)
				{
					TeleportHome();
					m_rescueLastPos = ((Component)this).transform.position;
					m_rescueProgressTime = Time.time;
					return true;
				}
			}
			else
			{
				if (!flag)
				{
					return false;
				}
				m_nextRescueCheck = Time.time + 1f;
				if (!IsStranded())
				{
					m_strandedSince = 0f;
					return false;
				}
				if (m_strandedSince <= 0f)
				{
					m_strandedSince = Time.time;
				}
				if (Time.time - m_strandedSince < 2f)
				{
					return false;
				}
				m_rescuing = true;
				m_rescueLastPos = ((Component)this).transform.position;
				m_rescueProgressTime = Time.time;
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[AI:" + m_villagerName + "] Stranded off the village graph at " + $"({((Component)this).transform.position.x:F1},{((Component)this).transform.position.z:F1}); recovering to anchor " + $"({m_homeAnchor.x:F1},{m_homeAnchor.z:F1})."));
				}
			}
			((BaseAI)this).MoveTo(dt, m_homeAnchor, 1f, true);
			return true;
		}

		private void TeleportHome()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = m_homeAnchor;
			NavMeshHit val2 = default(NavMeshHit);
			if (NavMesh.SamplePosition(m_homeAnchor, ref val2, 5f, AgentFilter()))
			{
				val = ((NavMeshHit)(ref val2)).position;
			}
			((Component)this).transform.position = val;
			if ((Object)(object)m_navAgent != (Object)null && m_navAgent.isOnNavMesh)
			{
				m_navAgent.Warp(val);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("[AI:" + m_villagerName + "] Rescue: pathing couldn't free it; teleported home to " + $"({val.x:F1},{val.y:F1},{val.z:F1})."));
			}
		}

		private bool IsStranded()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0083: Invalid comparison between Unknown and I4
			RegionGraph regionGraph = VillageRegistry.GraphAt(m_homeAnchor);
			if (regionGraph != null && regionGraph.PointToRegionId(((Component)this).transform.position) != null)
			{
				return false;
			}
			NavMeshQueryFilter val = AgentFilter();
			NavMeshHit val2 = default(NavMeshHit);
			if (!NavMesh.SamplePosition(((Component)this).transform.position, ref val2, 3f, val))
			{
				return true;
			}
			NavMeshHit val3 = default(NavMeshHit);
			if (!NavMesh.SamplePosition(m_homeAnchor, ref val3, 5f, val))
			{
				return false;
			}
			NavMeshPath val4 = new NavMeshPath();
			NavMesh.CalculatePath(((NavMeshHit)(ref val2)).position, ((NavMeshHit)(ref val3)).position, val, val4);
			return (int)val4.status > 0;
		}

		private void UpdateAgentMovement(Vector3 targetPos, bool running)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Invalid comparison between Unknown and I4
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			EnsureAgent();
			if ((Object)(object)m_navAgent == (Object)null)
			{
				((BaseAI)this).StopMoving();
				return;
			}
			if (m_navAgent.isOnNavMesh)
			{
				m_navAgent.nextPosition = ((Component)this).transform.position;
				if ((Object)(object)base.m_character != (Object)null)
				{
					Vector3 velocity = base.m_character.GetVelocity();
					velocity.y = 0f;
					m_navAgent.velocity = velocity;
				}
			}
			else
			{
				NavMeshHit val = default(NavMeshHit);
				if (!NavMesh.SamplePosition(((Component)this).transform.position, ref val, 3f, AgentFilter()))
				{
					((BaseAI)this).StopMoving();
					return;
				}
				m_navAgent.Warp(((NavMeshHit)(ref val)).position);
			}
			if (m_navAgent.hasPath)
			{
				Vector3 val2 = m_lastAgentDest - targetPos;
				if (!(((Vector3)(ref val2)).sqrMagnitude > 0.25f))
				{
					goto IL_00e8;
				}
			}
			m_navAgent.SetDestination(targetPos);
			m_lastAgentDest = targetPos;
			goto IL_00e8;
			IL_00e8:
			if (m_navAgent.pathPending && (CurrentState != BehaviorState.Patrolling || !m_navAgent.hasPath))
			{
				((BaseAI)this).StopMoving();
				return;
			}
			if ((int)m_navAgent.pathStatus == 2)
			{
				((BaseAI)this).StopMoving();
				return;
			}
			Vector3 moveDirection;
			if (m_navAgent.isOnOffMeshLink)
			{
				OffMeshLinkData currentOffMeshLinkData = m_navAgent.currentOffMeshLinkData;
				moveDirection = ((OffMeshLinkData)(ref currentOffMeshLinkData)).endPos - ((Component)this).transform.position;
				if (((Vector3)(ref moveDirection)).sqrMagnitude < 0.09f)
				{
					m_navAgent.CompleteOffMeshLink();
				}
			}
			else
			{
				moveDirection = m_navAgent.desiredVelocity;
			}
			moveDirection.y = 0f;
			if (((Vector3)(ref moveDirection)).sqrMagnitude < 0.0001f)
			{
				((BaseAI)this).StopMoving();
				return;
			}
			if ((Object)(object)DoorHandler != (Object)null)
			{
				Door blockingDoor = DoorHandler.GetBlockingDoor(moveDirection);
				if ((Object)(object)blockingDoor != (Object)null)
				{
					DoorHandler.OpenDoor(blockingDoor);
				}
			}
			((BaseAI)this).MoveTowards(((Vector3)(ref moveDirection)).normalized, running);
		}

		public void ClearCachedPath()
		{
			if ((Object)(object)m_navAgent != (Object)null && m_navAgent.isOnNavMesh)
			{
				m_navAgent.ResetPath();
			}
		}

		private void OnArrivedAtTarget(float dt)
		{
			m_directOrderActive = false;
			BehaviorContext ctx = default(BehaviorContext);
			foreach (IBehavior behavior in m_behaviors)
			{
				if (behavior.WantsControl(ctx))
				{
					behavior.OnArrival(dt);
					break;
				}
			}
		}

		[DevCommand("List active villagers with AI state, target, path status, and resolved region", Name = "vv_get_villagers")]
		public static void DumpVillagers()
		{
			Dictionary<string, VillagerAI> activeVillagers = VillagerAIManager.ActiveVillagers;
			StringBuilder stringBuilder = new StringBuilder();
			string arg = (VillageNavLock.IsHeld ? $" [nav hold {VillageNavLock.SecondsRemaining:F1}s — rebuild settle]" : "");
			stringBuilder.AppendLine($"[vv_get_villagers] {activeVillagers.Count} active villager(s):{arg}");
			foreach (KeyValuePair<string, VillagerAI> item in activeVillagers)
			{
				if ((Object)(object)item.Value == (Object)null)
				{
					stringBuilder.AppendLine("- <null> id=" + item.Key);
				}
				else
				{
					item.Value.AppendDebug(stringBuilder);
				}
			}
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(stringBuilder.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)stringBuilder.ToString());
			}
		}

		[DevCommand("Reset patrol discovery for all patrollers, forcing a fresh route rebuild from the region graph", Name = "vv_patrol_reset")]
		public static void ResetPatrols()
		{
			int num = 0;
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				PerimeterPatrolBehavior perimeterPatrolBehavior = activeVillager.Value?.GetBehavior<PerimeterPatrolBehavior>();
				if (perimeterPatrolBehavior != null)
				{
					perimeterPatrolBehavior.ResetDiscovery();
					num++;
				}
			}
			string text = $"[vv_patrol_reset] Reset discovery for {num} patroller(s)";
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}

		[DevCommand("List work orders in chests near each villager + how many outputs exist in chests (the real completion metric)", Name = "vv_workorders")]
		public static void DumpWorkOrders()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				VillagerAI value = activeVillager.Value;
				if ((Object)(object)value == (Object)null)
				{
					continue;
				}
				Vector3 homeAnchor = value.m_homeAnchor;
				List<Container> list = ContainerScanner.FindNearbyContainers(homeAnchor, 20f);
				List<WorkOrderMatch> list2 = ContainerScanner.FindAllWorkOrders(list, value.VillagerType);
				stringBuilder.AppendLine($"- {value.NpcName} [{value.VillagerType}] anchor=({homeAnchor.x:F0},{homeAnchor.z:F0}) " + $"containers={list.Count} orders={list2.Count}");
				foreach (WorkOrderMatch item in list2)
				{
					int num = ContainerScanner.CountAcrossContainers(list, item.ItemPrefabName);
					stringBuilder.AppendLine($"    order: {item.ItemPrefabName} x[{item.MinQuantity}-{item.MaxQuantity}] " + $"station={item.StationName} inChests={num}");
				}
			}
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(stringBuilder.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)stringBuilder.ToString());
			}
		}

		private void AppendDebug(StringBuilder sb)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: 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_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (((Object)(object)((Component)this).transform != (Object)null) ? ((Component)this).transform.position : Vector3.zero);
			string text = null;
			try
			{
				text = VillageRegistry.GraphAt(val)?.PointToRegionId(val);
			}
			catch
			{
			}
			sb.AppendLine("- " + NpcName + " [" + VillagerType + "] id=" + UniqueId);
			sb.AppendLine($"    pos=({val.x:F1},{val.y:F1},{val.z:F1})  state={CurrentState}  " + $"paused={IsPaused} lingering={IsLingering} casual={IsCasualTravel}");
			sb.AppendLine("    region@pos=" + (text ?? "UNRESOLVED") + "  " + $"anchor=({m_homeAnchor.x:F1},{m_homeAnchor.y:F1},{m_homeAnchor.z:F1})");
			if (m_currentWaypoint != null)
			{
				Vector3 position = m_currentWaypoint.Position;
				string text2 = (string.IsNullOrEmpty(m_currentWaypoint.Label) ? "" : (" \"" + m_currentWaypoint.Label + "\""));
				sb.AppendLine($"    target=({position.x:F1},{position.y:F1},{position.z:F1}) dist={Vector3.Distance(val, position):F1}m{text2}");
			}
			else
			{
				sb.AppendLine("    target=<none>");
			}
			if ((Object)(object)base.m_character == (Object)null)
			{
				sb.AppendLine("    char: m_character=NULL (anomalous — no movement data)");
			}
			else
			{
				Vector3 moveDir = base.m_character.GetMoveDir();
				Vector3 velocity = base.m_character.GetVelocity();
				object arg = moveDir.x;
				object arg2 = moveDir.z;
				Vector3 val2 = new Vector3(moveDir.x, 0f, moveDir.z);
				string text3 = $"    char: moveDir=({arg:F2},{arg2:F2}) |{((Vector3)(ref val2)).magnitude:F2}| ";
				val2 = new Vector3(velocity.x, 0f, velocity.z);
				sb.AppendLine(text3 + $"vel={((Vector3)(ref val2)).magnitude:F2} " + $"needsMove={NeedsMovement(CurrentState)} hasWaypoint={m_currentWaypoint != null}");
			}
			AppendAgentPathState(sb);
			if (m_behaviors == null || m_behaviors.Count <= 0)
			{
				return;
			}
			sb.Append("    behaviors: ");
			for (int i = 0; i < m_behaviors.Count; i++)
			{
				if (i > 0)
				{
					sb.Append(", ");
				}
				sb.Append(m_behaviors[i]?.Tag ?? "?");
			}
			sb.AppendLine();
			foreach (IBehavior behavior in m_behaviors)
			{
				string text4 = behavior?.GetStatusText();
				if (!string.IsNullOrEmpty(text4))
				{
					sb.AppendLine("    status[" + behavior.Tag + "]: " + text4);
				}
				if (behavior is CraftingBehaviorAdapter { Crafting: not null } craftingBehaviorAdapter)
				{
					sb.AppendLine("    note[" + behavior.Tag + "]: " + craftingBehaviorAdapter.Crafting.LastWorkNote);
				}
				if (behavior is PerimeterPatrolBehavior { HelpWaypointIndex: >=0, HelpPosition: var helpPosition } perimeterPatrolBehavior)
				{
					sb.AppendLine($"    patrol-help: W{perimeterPatrolBehavior.HelpWaypointIndex} @ " + $"({helpPosition.x:F1},{helpPosition.y:F1},{helpPosition.z:F1})");
				}
			}
		}

		private void AppendAgentPathState(StringBuilder sb)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_navAgent == (Object)null)
			{
				sb.AppendLine("    agent: <not created yet>");
				return;
			}
			if (!m_navAgent.isOnNavMesh)
			{
				sb.AppendLine("    agent: OFF-MESH — agent position not on the slot-31 navmesh; cannot path");
				return;
			}
			bool pathPending = m_navAgent.pathPending;
			float remainingDistance = m_navAgent.remainingDistance;
			string arg = (pathPending ? "pending" : (float.IsInfinity(remainingDistance) ? "∞" : $"{remainingDistance:F1}m"));
			Vector3 desiredVelocity = m_navAgent.desiredVelocity;
			float magnitude = ((Vector3)(ref desiredVelocity)).magnitude;
			Vector3 destination = m_navAgent.destination;
			sb.AppendLine($"    agent: status={m_navAgent.pathStatus} hasPath={m_navAgent.hasPath} " + $"pending={pathPending} onLink={m_navAgent.isOnOffMeshLink} " + $"corners={m_navAgent.path.corners.Length}");
			sb.AppendLine($"    agent: remaining={arg} stop={m_navAgent.stoppingDistance:F1}m " + $"desiredVel={magnitude:F2} dest=({destination.x:F1},{destination.y:F1},{destination.z:F1})");
			if (m_navAgent.hasPath && !pathPending && magnitude < 0.01f && !float.IsInfinity(remainingDistance) && remainingDistance > m_navAgent.stoppingDistance + 0.25f)
			{
				sb.AppendLine("    agent: ⚠ STALLED — has path, off target, zero desired velocity");
			}
			if (!pathPending && (int)m_navAgent.pathStatus != 0)
			{
				sb.AppendLine($"    agent: ⚠ path {m_navAgent.pathStatus} — target not fully reachable on the agent navmesh");
			}
		}

		public bool TryGetAgentPath(out Vector3[] corners, out NavMeshPathStatus status)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected I4, but got Unknown
			if ((Object)(object)m_navAgent != (Object)null && m_navAgent.isOnNavMesh && m_navAgent.hasPath)
			{
				corners = m_navAgent.path.corners;
				status = (NavMeshPathStatus)(int)m_navAgent.pathStatus;
				return true;
			}
			corners = Array.Empty<Vector3>();
			status = (NavMeshPathStatus)2;
			return false;
		}
	}
	public static class VillagerAIManager
	{
		public static readonly Dictionary<string, VillagerAI> ActiveVillagers = new Dictionary<string, VillagerAI>();

		public static void RegisterActive(VillagerAI ai)
		{
			if (!((Object)(object)ai == (Object)null) && !string.IsNullOrEmpty(ai.UniqueId))
			{
				ActiveVillagers[ai.UniqueId] = ai;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[VillagerAIManager] Registered villager " + ai.UniqueId + " (active)"));
				}
			}
		}

		public static void Unregister(string uniqueId)
		{
			ActiveVillagers.Remove(uniqueId);
		}

		public static void Unregister(VillagerAI ai)
		{
			if ((Object)(object)ai != (Object)null)
			{
				Unregister(ai.UniqueId);
			}
		}

		public static List<Vector3> GetAllAnchorPositions()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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)
			List<Vector3> list = new List<Vector3>();
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				return list;
			}
			Dictionary<ZDOID, ZDO> value = Traverse.Create((object)instance).Field<Dictionary<ZDOID, ZDO>>("m_objectsByID").Value;
			if (value == null)
			{
				return list;
			}
			foreach (ZDO value2 in value.Values)
			{
				if (value2 == null || (string.IsNullOrEmpty(value2.GetString("vv_record_id", "")) && string.IsNullOrEmpty(value2.GetString("vv_villager_type", ""))))
				{
					continue;
				}
				Vector3 vec = value2.GetVec3("vv_home_position", Vector3.zero);
				if (vec == Vector3.zero)
				{
					continue;
				}
				bool flag = false;
				foreach (Vector3 item in list)
				{
					Vector3 val = item - vec;
					if (((Vector3)(ref val)).sqrMagnitude < 1f)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(vec);
				}
			}
			return list;
		}

		public static int InvalidatePathsAfterRebake()
		{
			int num = 0;
			foreach (VillagerAI value in ActiveVillagers.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					value.ClearCachedPath();
					num++;
				}
			}
			return num;
		}

		public static int ResetPatrolRoutesAfterRepartition()
		{
			int num = 0;
			foreach (VillagerAI value in ActiveVillagers.Values)
			{
				PerimeterPatrolBehavior perimeterPatrolBehavior = value?.GetBehavior<PerimeterPatrolBehavior>();
				if (perimeterPatrolBehavior != null)
				{
					perimeterPatrolBehavior.ResetDiscovery();
					num++;
				}
			}
			return num;
		}

		[RegisterCleanup]
		public static void Clear()
		{
			ActiveVillagers.Clear();
		}
	}
}
namespace ValheimVillages.Villager.AI.Work
{
	public static class ContainerScanner
	{
		public static List<Container> FindNearbyContainers(Vector3 center, float radius)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			List<Container> list = new List<Container>();
			foreach (Container item in PhysicsHelper.GetAllInRadius<Container>(center, radius))
			{
				if (!((Object)(object)item == (Object)null) && !list.Contains(item))
				{
					ZNetView component = ((Component)item).GetComponent<ZNetView>();
					if (!((Object)(object)component == (Object)null) && component.GetZDO() != null)
					{
						list.Add(item);
					}
				}
			}
			return list;
		}

		public static List<WorkOrderMatch> FindAllWorkOrders(List<Container> containers, string villagerType)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			List<WorkOrderMatch> list = new List<WorkOrderMatch>();
			foreach (Container container in containers)
			{
				Inventory inventory = container.GetInventory();
				if (inventory == null)
				{
					continue;
				}
				List<ItemData> allItems = inventory.GetAllItems();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[ContainerScan] Checking container '" + container.m_name + "' " + $"at {((Component)container).transform.position} with {allItems.Count} items"));
				}
				foreach (ItemData item in allItems)
				{
					if (item?.m_customData == null)
					{
						continue;
					}
					GameObject dropPrefab = item.m_dropPrefab;
					string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? "null";
					if (!IsWorkOrderItem(item))
					{
						continue;
					}
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogDebug((object)("[ContainerScan] Found work order item: " + text + ", customData keys=[" + string.Join(",", item.m_customData.Keys) + "]"));
					}
					if (!item.m_customData.TryGetValue("wo_station", out var value))
					{
						ManualLogSource log3 = Plugin.Log;
						if (log3 != null)
						{
							log3.LogDebug((object)"[ContainerScan] Work order missing wo_station");
						}
						continue;
					}
					if (!StationMatcher.CanWorkStation(villagerType, value))
					{
						ManualLogSource log4 = Plugin.Log;
						if (log4 != null)
						{
							log4.LogDebug((object)("[ContainerScan] Station '" + value + "' not compatible with villager type " + villagerType));
						}
						continue;
					}
					if (!item.m_customData.TryGetValue("wo_item", out var value2))
					{
						ManualLogSource log5 = Plugin.Log;
						if (log5 != null)
						{
							log5.LogDebug((object)"[ContainerScan] Work order missing wo_item field (was this created before the update?)");
						}
						continue;
					}
					if (string.IsNullOrEmpty(value2))
					{
						ManualLogSource log6 = Plugin.Log;
						if (log6 != null)
						{
							log6.LogDebug((object)"[ContainerScan] Work order has empty wo_item");
						}
						continue;
					}
					int result = 1;
					int result2 = 10;
					if (item.m_customData.TryGetValue("wo_min", out var value3))
					{
						int.TryParse(value3, out result);
					}
					if (item.m_customData.TryGetValue("wo_max", out var value4))
					{
						int.TryParse(value4, out result2);
					}
					ManualLogSource log7 = Plugin.Log;
					if (log7 != null)
					{
						log7.LogDebug((object)("[ContainerScan] Work order matched! " + $"item={value2}, station={value}, qty={result}-{result2}"));
					}
					list.Add(new WorkOrderMatch
					{
						SourceContainer = container,
						ItemData = item,
						ItemPrefabName = value2,
						StationName = value,
						MinQuantity = result,
						MaxQuantity = result2
					});
				}
			}
			return list;
		}

		public static List<IngredientSource> FindIngredients(List<Container> containers, Recipe recipe)
		{
			if (recipe?.m_resources == null)
			{
				return null;
			}
			List<IngredientSource> list = new List<IngredientSource>();
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if ((Object)(object)val.m_resItem == (Object)null)
				{
					continue;
				}
				string name = ((Object)((Component)val.m_resItem).gameObject).name;
				int amount = val.m_amount;
				int num = 0;
				Container container = null;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)($"[IngredientScan] Looking for {amount}x '{name}' " + $"across {containers.Count} containers"));
				}
				foreach (Container container2 in containers)
				{
					Inventory inventory = container2.GetInventory();
					if (inventory == null)
					{
						continue;
					}
					int num2 = CountByPrefab(inventory, name);
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogDebug((object)("[IngredientScan] Container '" + container2.m_name + "': " + $"{num2}x '{name}'"));
					}
					if (num2 > 0)
					{
						container = container2;
						num += num2;
						if (num >= amount)
						{
							break;
						}
					}
				}
				if (num < amount)
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogDebug((object)($"[IngredientScan] MISSING: need {amount}x '{name}', " + $"found {num}"));
					}
					return null;
				}
				list.Add(new IngredientSource
				{
					PrefabName = name,
					Amount = amount,
					Container = container
				});
			}
			return list;
		}

		public static bool RemoveIngredients(List<IngredientSource> sources)
		{
			foreach (IngredientSource source in sources)
			{
				Container container = source.Container;
				Inventory val = ((container != null) ? container.GetInventory() : null);
				if (val == null)
				{
					return false;
				}
				RemoveByPrefab(val, source.PrefabName, source.Amount);
			}
			return true;
		}

		public static bool CanAcceptItem(Container container, string prefabName, int amount)
		{
			if ((Object)(object)container == (Object)null)
			{
				return false;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Inventory inventory = container.GetInventory();
			if (inventory != null)
			{
				return inventory.CanAddItem(val, amount);
			}
			return false;
		}

		public static bool TryDepositItem(Container container, string prefabName, int amount)
		{
			if (!CanAcceptItem(container, prefabName, amount))
			{
				return false;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Inventory inventory = container.GetInventory();
			ItemDrop component = val.GetComponent<ItemDrop>();
			if (inventory == null || (Object)(object)component == (Object)null)
			{
				return false;
			}
			ItemData val2 = component.m_itemData.Clone();
			val2.m_stack = amount;
			val2.m_dropPrefab = val;
			return inventory.AddItem(val2);
		}

		public static bool CanAcceptItemData(Container container, ItemData item)
		{
			Inventory val = ((container != null) ? container.GetInventory() : null);
			if (val != null && item != null)
			{
				return val.CanAddItem(item, item.m_stack);
			}
			return false;
		}

		public static bool TryDepositItemData(Container container, ItemData item)
		{
			if (!CanAcceptItemData(container, item))
			{
				return false;
			}
			return container.GetInventory().AddItem(item);
		}

		private static bool IsWorkOrderItem(ItemData item)
		{
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			ItemDefinition definition = ItemFactory.GetDefinition(text);
			if (definition != null)
			{
				return definition.itemType == "workorder";
			}
			return false;
		}

		public static int CountByPrefab(Inventory inv, string prefabName)
		{
			int num = 0;
			foreach (ItemData allItem in inv.GetAllItems())
			{
				if ((Object)(object)allItem?.m_dropPrefab != (Object)null && ((Object)allItem.m_dropPrefab).name == prefabName)
				{
					num += allItem.m_stack;
				}
			}
			return num;
		}

		public static int CountAcrossContainers(List<Container> containers, string prefabName)
		{
			int num = 0;
			foreach (Container container in containers)
			{
				Inventory val = ((container != null) ? container.GetInventory() : null);
				if (val != null)
				{
					num += CountByPrefab(val, prefabName);
				}
			}
			return num;
		}

		private static void RemoveByPrefab(Inventory inv, string prefabName, int amount)
		{
			int num = amount;
			List<ItemData> allItems = inv.GetAllItems();
			int num2 = allItems.Count - 1;
			while (num2 >= 0 && num > 0)
			{
				ItemData val = allItems[num2];
				if (!((Object)(object)val?.m_dropPrefab == (Object)null) && !(((Object)val.m_dropPrefab).name != prefabName))
				{
					int num3 = Mathf.Min(val.m_stack, num);
					inv.RemoveItem(val, num3);
					num -= num3;
				}
				num2--;
			}
		}
	}
	public static class StationFinder
	{
		private const float StationLookupRadius = 2f;

		private static readonly MethodInfo s_isFireLit = typeof(CookingStation).GetMethod("IsFireLit", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly MethodInfo s_getFuel = typeof(CookingStation).GetMethod("GetFuel", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly MethodInfo s_smelterGetFuel = typeof(Smelter).GetMethod("GetFuel", BindingFlags.Instance | BindingFlags.NonPublic);

		private static bool InvokeIsFireLit(CookingStation station)
		{
			if ((Object)(object)station == (Object)null || s_isFireLit == null)
			{
				return false;
			}
			try
			{
				return (bool)s_isFireLit.Invoke(station, null);
			}
			catch
			{
				return false;
			}
		}

		public static bool IsCookingStationFireLit(CookingStation station)
		{
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			if (!station.m_requireFire)
			{
				return true;
			}
			return InvokeIsFireLit(station);
		}

		public static bool IsCookingStationReady(CookingStation station)
		{
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			if (station.m_requireFire && InvokeIsFireLit(station))
			{
				return true;
			}
			if (station.m_useFuel && GetCookingStationFuel(station) > 0f)
			{
				return true;
			}
			return false;
		}

		public static Smelter GetSmelterPrefab(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return null;
			}
			ZNetScene instance = ZNetScene.instance;
			if (instance?.m_prefabs == null)
			{
				return null;
			}
			for (int i = 0; i < instance.m_prefabs.Count; i++)
			{
				GameObject val = instance.m_prefabs[i];
				if (!((Object)(object)val == (Object)null) && !(((Object)val).name != prefabName))
				{
					return val.GetComponent<Smelter>();
				}
			}
			return null;
		}

		public static bool IsSmelterReady(Smelter station)
		{
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			if ((Object)(object)station.m_fuelItem == (Object)null)
			{
				return true;
			}
			return GetSmelterFuel(station) > 0f;
		}

		public static float GetSmelterFuel(Smelter station)
		{
			if ((Object)(object)station == (Object)null || s_smelterGetFuel == null)
			{
				return 0f;
			}
			try
			{
				return (float)s_smelterGetFuel.Invoke(station, null);
			}
			catch
			{
				return 0f;
			}
		}

		public static float GetCookingStationFuel(CookingStation station)
		{
			if ((Object)(object)station == (Object)null || s_getFuel == null)
			{
				return 0f;
			}
			try
			{
				return (float)s_getFuel.Invoke(station, null);
			}
			catch
			{
				return 0f;
			}
		}

		public static bool HasFreeSlot(CookingStation station)
		{
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)station).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || component.GetZDO() == null)
			{
				return false;
			}
			int num = ((station.m_slots != null) ? station.m_slots.Length : 0);
			ZDO zDO = component.GetZDO();
			for (int i = 0; i < num; i++)
			{
				if (string.IsNullOrEmpty(zDO.GetString("slot" + i, "")))
				{
					return true;
				}
			}
			return false;
		}
	}
	public struct FuelNeed
	{
		public Vector3 FuelTargetPosition;

		public string FuelItemPrefab;

		public Fireplace FireplaceRef;

		public CookingStation CookingStationRef;

		public Smelter SmelterRef;

		public bool NeedsFireUnderneath;

		public bool NeedsInternalFuel;
	}
	public static class StationFuelHelper
	{
		private const float FireplaceSearchRadius = 3f;

		public static bool DiagnoseFuelNeed(CookingStation station, out FuelNeed need)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			need = default(FuelNeed);
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			bool flag = station.m_requireFire && !StationFinder.IsCookingStationFireLit(station);
			bool flag2 = station.m_useFuel && StationFinder.GetCookingStationFuel(station) <= 0f;
			if (!flag && !flag2)
			{
				return false;
			}
			need.CookingStationRef = station;
			if (flag && TryFindFireplaceNear(station, out var fireplace))
			{
				need.NeedsFireUnderneath = true;
				need.FireplaceRef = fireplace;
				need.FuelTargetPosition = ((Component)fireplace).transform.position;
				ItemDrop fuelItem = fireplace.m_fuelItem;
				object fuelItemPrefab;
				if (fuelItem == null)
				{
					fuelItemPrefab = null;
				}
				else
				{
					GameObject gameObject = ((Component)fuelItem).gameObject;
					fuelItemPrefab = ((gameObject != null) ? ((Object)gameObject).name : null);
				}
				need.FuelItemPrefab = (string)fuelItemPrefab;
			}
			else
			{
				if (!flag2)
				{
					return false;
				}
				need.NeedsInternalFuel = true;
				need.FuelTargetPosition = ((Component)station).transform.position;
				ItemDrop fuelItem2 = station.m_fuelItem;
				object fuelItemPrefab2;
				if (fuelItem2 == null)
				{
					fuelItemPrefab2 = null;
				}
				else
				{
					GameObject gameObject2 = ((Component)fuelItem2).gameObject;
					fuelItemPrefab2 = ((gameObject2 != null) ? ((Object)gameObject2).name : null);
				}
				need.FuelItemPrefab = (string)fuelItemPrefab2;
			}
			return !string.IsNullOrEmpty(need.FuelItemPrefab);
		}

		public static bool DiagnoseFuelNeed(Smelter station, out FuelNeed need)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			need = default(FuelNeed);
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			if ((Object)(object)station.m_fuelItem == (Object)null)
			{
				return false;
			}
			if (StationFinder.GetSmelterFuel(station) > 0f)
			{
				return false;
			}
			need.SmelterRef = station;
			need.NeedsInternalFuel = true;
			need.FuelTargetPosition = ((Component)station).transform.position;
			GameObject gameObject = ((Component)station.m_fuelItem).gameObject;
			need.FuelItemPrefab = ((gameObject != null) ? ((Object)gameObject).name : null);
			return !string.IsNullOrEmpty(need.FuelItemPrefab);
		}

		public static bool TryFindFireplaceNear(CookingStation station, out Fireplace fireplace)
		{
			//IL_0059: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			fireplace = null;
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			List<Vector3> list = new List<Vector3>();
			if (station.m_fireCheckPoints != null)
			{
				Transform[] fireCheckPoints = station.m_fireCheckPoints;
				foreach (Transform val in fireCheckPoints)
				{
					if ((Object)(object)val != (Object)null)
					{
						list.Add(val.position);
					}
				}
			}
			if (list.Count == 0)
			{
				list.Add(((Component)station).transform.position);
			}
			foreach (Vector3 item in list)
			{
				foreach (Fireplace item2 in PhysicsHelper.GetAllInRadius<Fireplace>(item, 3f))
				{
					if (!((Object)(object)item2 == (Object)null) && !item2.m_infiniteFuel)
					{
						fireplace = item2;
						return true;
					}
				}
			}
			return false;
		}

		public static bool FindFuelInContainers(List<Container> containers, string fuelPrefabName, out Container fuelContainer)
		{
			fuelContainer = null;
			if (containers == null || string.IsNullOrEmpty(fuelPrefabName))
			{
				return false;
			}
			foreach (Container container in containers)
			{
				Inventory val = ((container != null) ? container.GetInventory() : null);
				if (val != null && ContainerScanner.CountByPrefab(val, fuelPrefabName) > 0)
				{
					fuelContainer = container;
					return true;
				}
			}
			return false;
		}
	}
	public static class StationMatcher
	{
		public static string[] GetStationNames(string villagerType)
		{
			VillagerDef villagerDef = VillagerRegistry.Get(villagerType);
			if (villagerDef?.workStations == null || villagerDef.workStations.Count <= 0)
			{
				return Array.Empty<string>();
			}
			return villagerDef.workStations.ToArray();
		}

		public static bool CanWorkStation(string villagerType, string stationName)
		{
			VillagerDef villagerDef = VillagerRegistry.Get(villagerType);
			if (villagerDef?.workStations != null)
			{
				return villagerDef.workStations.Contains(stationName);
			}
			return false;
		}

		public static Recipe FindRecipe(string itemPrefabName, string stationName)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			return ((IEnumerable<Recipe>)ObjectDB.instance.m_recipes).FirstOrDefault((Func<Recipe, bool>)((Recipe r) => (Object)(object)r.m_item != (Object)null && ((Object)((Component)r.m_item).gameObject).name == itemPrefabName && (Object)(object)r.m_craftingStation != (Object)null && r.m_craftingStation.m_name == stationName && r.m_enabled));
		}

		public static Recipe FindRecipeForNpc(string itemPrefabName, string villagerType)
		{
			string[] stationNames = GetStationNames(villagerType);
			foreach (string stationName in stationNames)
			{
				Recipe val = FindRecipe(itemPrefabName, stationName);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
}
namespace ValheimVillages.Villager.AI.Pathfinding
{
	public class PathDebugRenderer : MonoBehaviour
	{
		private const float NodeMarkerSize = 0.15f;

		private const float LineYOffset = 0.1f;

		private static PathDebugRenderer s_instance;

		private static bool s_enabled = false;

		private static bool s_showTriangulation = false;

		private static string s_targetCameraName;

		public static readonly HashSet<string> HighlightedRegions = new HashSet<string>();

		public static readonly List<Vector3> DebugPolyline = new List<Vector3>();

		private static readonly Color ColorDebugPolyline = Color.magenta;

		private static readonly Color ColorComplete = Color.green;

		private static readonly Color ColorPartial = Color.yellow;

		private static readonly Color ColorNoPath = Color.red;

		private static readonly Color ColorTarget = new Color(1f, 0.4f, 0f);

		private Material m_lineMaterial;

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			m_lineMaterial = new Material(Shader.Find("Hidden/Internal-Colored"));
			((Object)m_lineMaterial).hideFlags = (HideFlags)61;
			m_lineMaterial.SetInt("_SrcBlend", 5);
			m_lineMaterial.SetInt("_DstBlend", 10);
			m_lineMaterial.SetInt("_Cull", 0);
			m_lineMaterial.SetInt("_ZWrite", 0);
			m_lineMaterial.SetInt("_ZTest", 8);
		}

		private void OnDestroy()
		{
			if ((Object)(object)m_lineMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)m_lineMaterial);
			}
		}

		private void OnRenderObject()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((!s_enabled && !s_showTriangulation && DebugPolyline.Count == 0) || (s_targetCameraName != null && ((Object)(object)Camera.current == (Object)null || ((Object)Camera.current).name != s_targetCameraName)))
			{
				return;
			}
			m_lineMaterial.SetPass(0);
			GL.PushMatrix();
			GL.MultMatrix(Matrix4x4.identity);
			if (s_enabled)
			{
				foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
				{
					VillagerAI value = activeVillager.Value;
					if (!((Object)(object)value == (Object)null))
					{
						DrawVillagerPath(value);
					}
				}
			}
			if (s_showTriangulation)
			{
				DrawTriangulation();
			}
			if (DebugPolyline.Count > 0)
			{
				DrawDebugPolyline();
			}
			GL.PopMatrix();
		}

		private void DrawDebugPolyline()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.up * 0.4f;
			GL.Begin(1);
			GL.Color(ColorDebugPolyline);
			for (int i = 0; i < DebugPolyline.Count - 1; i++)
			{
				GL.Vertex(DebugPolyline[i] + val);
				GL.Vertex(DebugPolyline[i + 1] + val);
			}
			GL.End();
			for (int j = 0; j < DebugPolyline.Count; j++)
			{
				DrawWireOctahedron(DebugPolyline[j] + val, 0.3f, ColorDebugPolyline);
			}
		}

		[DevCommand("Toggle villager path debug viz. Optional cam=<cameraName> restricts the overlay to that camera (cam=off clears).", Name = "vv_path_debug")]
		public static void Toggle(ConsoleEventArgs args)
		{
			if (TryApplyCameraArg(args, out var message))
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print(message);
				}
				return;
			}
			s_enabled = !s_enabled;
			if (s_enabled)
			{
				EnsureInstance();
			}
			else if ((Object)(object)s_instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)s_instance).gameObject);
				s_instance = null;
			}
			string text = (s_enabled ? "ON" : "OFF");
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print("Path debug rendering " + text + CamSuffix());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[PathDebug] Visualization " + text));
			}
		}

		[DevCommand("Overlay the raw slot-31 NavMesh path between two points (magenta). Usage: vv_drawpath <fromX> <fromZ> <toX> <toZ> | vv_drawpath off", Name = "vv_drawpath")]
		public static void DrawRawPath(ConsoleEventArgs args)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			if (args?.Args != null && args.Args.Length >= 2 && args.Args[1].Equals("off", StringComparison.OrdinalIgnoreCase))
			{
				DebugPolyline.Clear();
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("[vv_drawpath] cleared");
				}
				return;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			if (args?.Args == null || args.Args.Length < 5 || !float.TryParse(args.Args[1], NumberStyles.Float, invariantCulture, out var result) || !float.TryParse(args.Args[2], NumberStyles.Float, invariantCulture, out var result2) || !float.TryParse(args.Args[3], NumberStyles.Float, invariantCulture, out var result3) || !float.TryParse(args.Args[4], NumberStyles.Float, invariantCulture, out var result4))
			{
				Console instance2 = Console.instance;
				if (instance2 != null)
				{
					instance2.Print("Usage: vv_drawpath <fromX> <fromZ> <toX> <toZ> | vv_drawpath off");
				}
				return;
			}
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			NavMeshHit val3 = default(NavMeshHit);
			NavMeshHit val4 = default(NavMeshHit);
			if (!NavMesh.SamplePosition(new Vector3(result, 40f, result2), ref val3, 8f, val2) || !NavMesh.SamplePosition(new Vector3(result3, 40f, result4), ref val4, 8f, val2))
			{
				Console instance3 = Console.instance;
				if (instance3 != null)
				{
					instance3.Print("[vv_drawpath] endpoint sample failed");
				}
				return;
			}
			NavMeshPath val5 = new NavMeshPath();
			NavMesh.CalculatePath(((NavMeshHit)(ref val3)).position, ((NavMeshHit)(ref val4)).position, val2, val5);
			DebugPolyline.Clear();
			DebugPolyline.AddRange(val5.corners);
			EnsureInstance();
			Console instance4 = Console.instance;
			if (instance4 != null)
			{
				instance4.Print($"[vv_drawpath] status={val5.status} corners={val5.corners.Length} (magenta overlay)");
			}
		}

		[DevCommand("Toggle NavMesh triangulation wireframe. Optional cam=<cameraName> restricts the overlay to that camera (cam=off clears).", Name = "vv_tri_debug")]
		public static void ToggleTriangulation(ConsoleEventArgs args)
		{
			if (TryApplyCameraArg(args, out var message))
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print(message);
				}
				return;
			}
			s_showTriangulation = !s_showTriangulation;
			if (s_showTriangulation)
			{
				EnsureInstance();
			}
			string text = (s_showTriangulation ? "ON" : "OFF");
			int num = RegionBuilder.CachedTriangles?.Count ?? 0;
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print($"Triangulation wireframe {text} ({num} triangles){CamSuffix()}");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[PathDebug] Triangulation wireframe " + text));
			}
		}

		private static string CamSuffix()
		{
			if (s_targetCameraName == null)
			{
				return "";
			}
			return " [cam=" + s_targetCameraName + "]";
		}

		private static bool TryApplyCameraArg(ConsoleEventArgs args, out string message)
		{
			message = null;
			if (args?.Args == null)
			{
				return false;
			}
			string[] args2 = args.Args;
			foreach (string text in args2)
			{
				if (!string.IsNullOrEmpty(text) && text.StartsWith("cam="))
				{
					string text2 = text.Substring(4);
					if (text2.Length == 0 || text2.Equals("off", StringComparison.OrdinalIgnoreCase))
					{
						s_targetCameraName = null;
						message = "Debug overlay camera filter cleared (renders to all cameras).";
					}
					else
					{
						s_targetCameraName = text2;
						EnsureInstance();
						message = "Debug overlay restricted to camera '" + text2 + "'.";
					}
					return true;
				}
			}
			return false;
		}

		public static void AutoEnable()
		{
			if ((s_enabled || s_showTriangulation) && (Object)(object)s_instance == (Object)null)
			{
				EnsureInstance();
			}
		}

		private static void EnsureInstance()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			if (!((Object)(object)s_instance != (Object)null))
			{
				GameObject val = new GameObject("PathDebugRenderer");
				Object.DontDestroyOnLoad((Object)val);
				s_instance = val.AddComponent<PathDebugRenderer>();
			}
		}

		private void DrawVillagerPath(VillagerAI ai)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_01b4: 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_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: 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_0195: 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_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)ai).transform.position;
			Vector3 val = Vector3.up * 0.1f;
			if (!ai.TryGetAgentPath(out var corners, out var status) || corners.Length == 0)
			{
				if (ai.CurrentTarget.HasValue)
				{
					GL.Begin(1);
					GL.Color(ColorNoPath);
					GL.Vertex(position + val);
					GL.Vertex(ai.CurrentTarget.Value + val);
					GL.End();
					DrawWireOctahedron(ai.CurrentTarget.Value + val, 0.3f, ColorNoPath);
				}
				return;
			}
			Color val2 = (((int)status == 0) ? ColorComplete : ColorPartial);
			GL.Begin(1);
			GL.Color(val2);
			GL.Vertex(position + val);
			GL.Vertex(corners[0] + val);
			for (int i = 0; i < corners.Length - 1; i++)
			{
				GL.Vertex(corners[i] + val);
				GL.Vertex(corners[i + 1] + val);
			}
			GL.End();
			for (int j = 0; j < corners.Length; j++)
			{
				DrawWireOctahedron(corners[j] + val, 0.15f, val2);
			}
			if (ai.CurrentTarget.HasValue)
			{
				Vector3 value = ai.CurrentTarget.Value;
				Vector3 val3 = corners[^1];
				if (Vector3.Distance(value, val3) > 0.5f)
				{
					GL.Begin(1);
					GL.Color(ColorTarget);
					GL.Vertex(val3 + val);
					GL.Vertex(value + val);
					GL.End();
				}
				DrawWireOctahedron(value + val, 0.3f, ColorTarget);
			}
		}

		private static void DrawWireOctahedron(Vector3 center, float radius, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = center + Vector3.up * radius;
			Vector3 val2 = center - Vector3.up * radius;
			Vector3 val3 = center + Vector3.forward * radius;
			Vector3 val4 = center - Vector3.forward * radius;
			Vector3 val5 = center + Vector3.right * radius;
			Vector3 val6 = center - Vector3.right * radius;
			GL.Begin(1);
			GL.Color(color);
			GL.Vertex(val);
			GL.Vertex(val3);
			GL.Vertex(val);
			GL.Vertex(val4);
			GL.Vertex(val);
			GL.Vertex(val5);
			GL.Vertex(val);
			GL.Vertex(val6);
			GL.Vertex(val2);
			GL.Vertex(val3);
			GL.Vertex(val2);
			GL.Vertex(val4);
			GL.Vertex(val2);
			GL.Vertex(val5);
			GL.Vertex(val2);
			GL.Vertex(val6);
			GL.Vertex(val3);
			GL.Vertex(val5);
			GL.Vertex(val5);
			GL.Vertex(val4);
			GL.Vertex(val4);
			GL.Vertex(val6);
			GL.Vertex(val6);
			GL.Vertex(val3);
			GL.End();
		}

		private void DrawTriangulation()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			List<RegionBuilder.CachedTriangle> cachedTriangles = RegionBuilder.CachedTriangles;
			if (cachedTriangles == null || cachedTriangles.Count == 0)
			{
				return;
			}
			Vector3 val = Vector3.up * 0.1f;
			GL.Begin(1);
			foreach (RegionBuilder.CachedTriangle item in cachedTriangles)
			{
				GL.Color(RegionColor(item.RegionId));
				GL.Vertex(item.V0 + val);
				GL.Vertex(item.V1 + val);
				GL.Vertex(item.V1 + val);
				GL.Vertex(item.V2 + val);
				GL.Vertex(item.V2 + val);
				GL.Vertex(item.V0 + val);
			}
			GL.End();
			if (HighlightedRegions.Count == 0)
			{
				return;
			}
			Color val2 = new Color(1f, 1f, 1f, 0.95f);
			GL.Begin(1);
			GL.Color(val2);
			for (int i = 0; i < 5; i++)
			{
				float num = 0.15f + (float)i * 0.02f;
				Vector3 val3 = Vector3.up * num;
				foreach (RegionBuilder.CachedTriangle item2 in cachedTriangles)
				{
					if (HighlightedRegions.Contains(item2.RegionId))
					{
						GL.Vertex(item2.V0 + val3);
						GL.Vertex(item2.V1 + val3);
						GL.Vertex(item2.V1 + val3);
						GL.Vertex(item2.V2 + val3);
						GL.Vertex(item2.V2 + val3);
						GL.Vertex(item2.V0 + val3);
					}
				}
			}
			GL.End();
		}

		private static Color RegionColor(string regionId)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(regionId))
			{
				return new Color(1f, 1f, 1f, 0.3f);
			}
			int num = regionId.GetHashCode() & 0x7FFFFFFF;
			float num2 = (float)(num % 360) / 360f;
			float num3 = 0.6f + (float)(num / 360 % 4) * 0.1f;
			float num4 = 0.7f + (float)(num / 1440 % 3) * 0.1f;
			Color result = Color.HSVToRGB(num2, num3, num4);
			result.a = 0.7f;
			return result;
		}

		[DevCommand("Inspect village region graph (use near=x,z or near=player for position-filtered triangle detail)", Name = "vv_tri_inspect")]
		public static void TriInspect(ConsoleEventArgs args)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Vector3? val = ParseNearArg(args);
			if (val.HasValue)
			{
				InspectNearPosition(val.Value);
			}
			else
			{
				InspectVillage();
			}
		}

		private static Vector3? ParseNearArg(ConsoleEventArgs args)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			if (args?.Args == null)
			{
				return null;
			}
			for (int i = 1; i < args.Args.Length; i++)
			{
				string text = args.Args[i];
				if (string.IsNullOrEmpty(text) || !text.StartsWith("near=", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string text2 = text.Substring("near=".Length);
				if (text2.Equals("player", StringComparison.OrdinalIgnoreCase))
				{
					Player localPlayer = Player.m_localPlayer;
					if (!((Object)(object)localPlayer != (Object)null))
					{
						return null;
					}
					return ((Component)localPlayer).transform.position;
				}
				string[] array = text2.Split(new char[1] { ',' });
				if (array.Length >= 2 && float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					return new Vector3(result, 0f, result2);
				}
			}
			return null;
		}

		private static void InspectVillage()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			List<string> list = new List<string>();
			foreach (RegionGraph item2 in VillageRegistry.AllGraphs())
			{
				num2++;
				num3 += item2.RegionCount;
				num4 += item2.LinkCount;
				List<object> list2 = new List<object>();
				foreach (Vector3 allRegionCenter in item2.Diagnostics.GetAllRegionCenters())
				{
					list2.Add($"{allRegionCenter.x:F2},{allRegionCenter.y:F2},{allRegionCenter.z:F2}");
				}
				DebugLog.List("Region", $"village_{num}_centers", list2);
				item2.GetOrigin(out var originX, out var originZ);
				string item = $"  graph[{num}] regions={item2.RegionCount} " + $"links={item2.LinkCount} origin=({originX:F0},{originZ:F0})";
				list.Add(item);
				num++;
			}
			if (num2 == 0)
			{
				string text = "[TriInspect] No region graphs available. Run hna_partition (or move a Guard into a village).";
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print(text);
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)text);
				}
				return;
			}
			DebugLog.Event("TriInspect", "village_summary", ("graphs", num2), ("regions", num3), ("links", num4));
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[TriInspect] village graphs=").Append(num2).Append(" regions=")
				.Append(num3)
				.Append(" links=")
				.Append(num4)
				.AppendLine();
			foreach (string item3 in list)
			{
				stringBuilder.AppendLine(item3);
			}
			stringBuilder.AppendLine("  (per-region centroids written to <BepInEx>/config/vv_dumps/)");
			string text2 = stringBuilder.ToString();
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print(text2);
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)text2);
			}
		}

		private static void InspectNearPosition(Vector3 pos)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: 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_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0608: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_083f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0844: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_069f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_06db: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0707: Unknown result type (might be due to invalid IL or missing references)
			//IL_0718: Unknown result type (might be due to invalid IL or missing references)
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_0744: Unknown result type (might be due to invalid IL or missing references)
			//IL_0755: Unknown result type (might be due to invalid IL or missing references)
			//IL_0766: Unknown result type (might be due to invalid IL or missing references)
			//IL_077f: Unknown result type (might be due to invalid IL or missing references)
			//IL_078b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Unknown result type (might be due to invalid IL or missing references)
			//IL_0866: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Unknown result type (might be due to invalid IL or missing references)
			//IL_086d: Unknown result type (might be due to invalid IL or missing references)
			//IL_086f: Unknown result type (might be due to invalid IL or missing references)
			List<RegionBuilder.CachedTriangle> cachedTriangles = RegionBuilder.CachedTriangles;
			if (cachedTriangles == null || cachedTriangles.Count == 0)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("No cached triangles. Run vv_tri_debug first.");
				}
				return;
			}
			Dictionary<string, List<RegionBuilder.CachedTriangle>> dictionary = new Dictionary<string, List<RegionBuilder.CachedTriangle>>();
			Vector3 val;
			foreach (RegionBuilder.CachedTriangle item3 in cachedTriangles)
			{
				val = (item3.V0 + item3.V1 + item3.V2) / 3f - pos;
				if (!(((Vector3)(ref val)).sqrMagnitude > 4f))
				{
					string key = (string.IsNullOrEmpty(item3.RegionId) ? "(none)" : item3.RegionId);
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = (dictionary[key] = new List<RegionBuilder.CachedTriangle>());
					}
					value.Add(item3);
				}
			}
			if (dictionary.Count == 0)
			{
				Console instance2 = Console.instance;
				if (instance2 != null)
				{
					instance2.Print($"No triangles within {2f}m of ({pos.x:F1}, {pos.y:F1}, {pos.z:F1})");
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[TriInspect] No triangles within {2f}m of ({pos.x:F1}, {pos.y:F1}, {pos.z:F1})");
				}
				return;
			}
			RegionGraph regionGraph = VillageRegistry.GraphAt(pos);
			NavMeshQueryFilter val2 = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val2)).agentTypeID = VillagerAgentType.ResolveValheimHumanoidAgentTypeID();
			((NavMeshQueryFilter)(ref val2)).areaMask = -1;
			NavMeshQueryFilter val3 = val2;
			float num = 0f;
			bool flag = (Object)(object)ZoneSystem.instance != (Object)null;
			if (flag)
			{
				num = ZoneSystem.instance.GetGroundHeight(new Vector3(pos.x, 0f, pos.z));
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[TriInspect] Pos=({pos.x:F1}, {pos.y:F1}, {pos.z:F1})  " + $"Terrain={num:F1}  Δ={pos.y - num:F1}m above terrain");
			stringBuilder.AppendLine($"  {dictionary.Count} region(s) within {2f}m sphere:");
			Dictionary<string, List<(Vector3, int)>> dictionary2 = new Dictionary<string, List<(Vector3, int)>>();
			NavMeshHit val5 = default(NavMeshHit);
			foreach (KeyValuePair<string, List<RegionBuilder.CachedTriangle>> item4 in dictionary)
			{
				string key2 = item4.Key;
				List<RegionBuilder.CachedTriangle> value2 = item4.Value;
				float num2 = float.MaxValue;
				float num3 = float.MinValue;
				float num4 = 0f;
				float num5 = 0f;
				List<(Vector3, int)> list2 = new List<(Vector3, int)>();
				int num6 = 0;
				foreach (RegionBuilder.CachedTriangle item5 in value2)
				{
					float[] array = new float[3]
					{
						item5.V0.y,
						item5.V1.y,
						item5.V2.y
					};
					foreach (float num7 in array)
					{
						if (num7 < num2)
						{
							num2 = num7;
						}
						if (num7 > num3)
						{
							num3 = num7;
						}
					}
					float num8 = num4;
					val = Vector3.Cross(item5.V1 - item5.V0, item5.V2 - item5.V0);
					num4 = num8 + ((Vector3)(ref val)).magnitude * 0.5f;
					float num9 = Vector3.Distance(item5.V0, item5.V1);
					float num10 = Vector3.Distance(item5.V1, item5.V2);
					float num11 = Vector3.Distance(item5.V2, item5.V0);
					float num12 = Mathf.Max(num9, Mathf.Max(num10, num11));
					if (num12 > num5)
					{
						num5 = num12;
					}
					list2.Add((item5.V0, num6 * 3));
					list2.Add((item5.V1, num6 * 3 + 1));
					list2.Add((item5.V2, num6 * 3 + 2));
					num6++;
				}
				dictionary2[key2] = list2;
				Vector3 val4 = (value2[0].V0 + value2[0].V1 + value2[0].V2) / 3f;
				int num13 = Mathf.FloorToInt(val4.x / 3f);
				int num14 = Mathf.FloorToInt(val4.z / 3f);
				int num15 = Mathf.FloorToInt(val4.y / 2f);
				stringBuilder.AppendLine($"  --- Region {key2} ({value2.Count} tri) ---");
				stringBuilder.AppendLine($"    Y range: [{num2:F2}, {num3:F2}]  ΔY={num3 - num2:F2}m");
				stringBuilder.AppendLine($"    Area: {num4:F2}m²  MaxEdge: {num5:F2}m");
				stringBuilder.AppendLine($"    Cell: gx={num13} gz={num14} hb={num15}  " + $"(X[{(float)num13 * 3f:F0},{(float)(num13 + 1) * 3f:F0}] " + $"Z[{(float)num14 * 3f:F0},{(float)(num14 + 1) * 3f:F0}])");
				if (flag)
				{
					float num16 = (num2 + num3) * 0.5f;
					stringBuilder.AppendLine($"    Above terrain: {num16 - num:F2}m");
				}
				bool flag2 = CellValidator.HasGroundBelow(val4);
				stringBuilder.AppendLine($"    GroundBelow: {flag2}");
				if (NavMesh.FindClosestEdge(val4, ref val5, val3))
				{
					stringBuilder.AppendLine($"    EdgeDist: {((NavMeshHit)(ref val5)).distance:F3}m");
				}
				bool flag3 = CellValidator.IsSurfaceWideEnough(val4, val3);
				stringBuilder.AppendLine($"    SurfaceWide: {flag3}");
				if (regionGraph != null)
				{
					string text = regionGraph.PointToRegionId(val4);
					stringBuilder.AppendLine("    GraphLookup: " + (text ?? "(unresolved)"));
				}
				foreach (RegionBuilder.CachedTriangle item6 in value2)
				{
					Vector3 val6 = (item6.V0 + item6.V1 + item6.V2) / 3f;
					stringBuilder.AppendLine($"    Tri: ({item6.V0.x:F2},{item6.V0.y:F2},{item6.V0.z:F2}) " + $"({item6.V1.x:F2},{item6.V1.y:F2},{item6.V1.z:F2}) " + $"({item6.V2.x:F2},{item6.V2.y:F2},{item6.V2.z:F2})  " + $"cen=({val6.x:F2},{val6.y:F2},{val6.z:F2})");
				}
			}
			stringBuilder.AppendLine("  --- Edge sharing ---");
			List<string> list3 = new List<string>(dictionary2.Keys);
			bool flag4 = false;
			for (int j = 0; j < list3.Count; j++)
			{
				for (int k = j + 1; k < list3.Count; k++)
				{
					int num17 = 0;
					foreach (var item7 in dictionary2[list3[j]])
					{
						Vector3 item = item7.Item1;
						foreach (var item8 in dictionary2[list3[k]])
						{
							Vector3 item2 = item8.Item1;
							if (Vector3.Distance(item, item2) < 0.01f)
							{
								num17++;
							}
						}
					}
					if (num17 >= 2)
					{
						stringBuilder.AppendLine($"    {list3[j]} <-> {list3[k]}: {num17} shared vertices (CONNECTED)");
						flag4 = true;
					}
					else if (num17 == 1)
					{
						stringBuilder.AppendLine("    " + list3[j] + " <-> " + list3[k] + ": 1 shared vertex (TOUCHING, no shared edge)");
						flag4 = true;
					}
				}
			}
			if (!flag4)
			{
				stringBuilder.AppendLine("    No shared edges or vertices between nearby regions");
			}
			string text2 = stringBuilder.ToString();
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)text2);
			}
			Console instance3 = Console.instance;
			if (instance3 != null)
			{
				instance3.Print(text2);
			}
		}

		[RegisterCleanup]
		public static void Cleanup()
		{
			if ((Object)(object)s_instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)s_instance).gameObject);
				s_instance = null;
			}
		}
	}
	public static class VillagerAgentType
	{
		private const int AgentTypeValue = 31;

		private static int s_humanoidAgentTypeID = -1;

		public static AgentType AgentType => (AgentType)31;

		public static bool IsRegistered { get; private set; }

		public static int UnityAgentTypeID { get; private set; }

		public static NavMeshBuildSettings BuildSettings { get; private set; }

		public static bool TryGetSlope(out float slope)
		{
			if (!TryGetEffectiveSettings(out var settings))
			{
				slope = 0f;
				return false;
			}
			slope = ((NavMeshBuildSettings)(ref settings)).agentSlope;
			return true;
		}

		public static bool TryGetClimb(out float climb)
		{
			if (!TryGetEffectiveSettings(out var settings))
			{
				climb = 0f;
				return false;
			}
			climb = ((NavMeshBuildSettings)(ref settings)).agentClimb;
			return true;
		}

		public static bool TryGetEffectiveSettings(out NavMeshBuildSettings settings)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			int num = (IsRegistered ? UnityAgentTypeID : ResolveValheimHumanoidAgentTypeID());
			if (num == 0)
			{
				settings = default(NavMeshBuildSettings);
				return false;
			}
			settings = NavMesh.GetSettingsByID(num);
			return true;
		}

		public static bool EnsureRegistered()
		{
			if (IsRegistered)
			{
				return true;
			}
			Pathfinding instance = Pathfinding.instance;
			if ((Object)(object)instance == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[VillagerAgentType] Pathfinding.instance is null; deferring registration");
				}
				return false;
			}
			try
			{
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
				FieldInfo field = typeof(Pathfinding).GetField("m_agentSettings", bindingAttr);
				MethodInfo method = typeof(Pathfinding).GetMethod("AddAgent", bindingAttr);
				if (field == null || method == null)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogError((object)"[VillagerAgentType] Could not find m_agentSettings or AddAgent via reflection");
					}
					return false;
				}
				if (!(field.GetValue(instance) is IList { Count: >=2 } list))
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogError((object)"[VillagerAgentType] m_agentSettings is null or too small");
					}
					return false;
				}
				if (list.Count > 31 && list[31] != null)
				{
					CaptureAgentSlot(list[31]);
					IsRegistered = true;
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogInfo((object)($"[VillagerAgentType] Re-captured agent slot {31} " + $"(agentTypeID={UnityAgentTypeID}, settings cloned from Humanoid)"));
					}
					return true;
				}
				object obj = list[1];
				object obj2 = method.Invoke(instance, new object[2]
				{
					(object)(AgentType)31,
					obj
				});
				if (obj2 == null)
				{
					ManualLogSource log5 = Plugin.Log;
					if (log5 != null)
					{
						log5.LogError((object)"[VillagerAgentType] AddAgent returned null");
					}
					return false;
				}
				CaptureAgentSlot(obj2);
				IsRegistered = true;
				ManualLogSource log6 = Plugin.Log;
				if (log6 != null)
				{
					log6.LogInfo((object)($"[VillagerAgentType] Registered custom agent type {31} " + $"(agentTypeID={UnityAgentTypeID}, settings cloned from Humanoid verbatim)"));
				}
				return true;
			}
			catch (Exception arg)
			{
				ManualLogSource log7 = Plugin.Log;
				if (log7 != null)
				{
					log7.LogError((object)$"[VillagerAgentType] Registration failed: {arg}");
				}
				return false;
			}
		}

		private static void CaptureAgentSlot(object agentSettings)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			FieldInfo field = agentSettings.GetType().GetField("m_build");
			if (!(field == null))
			{
				NavMeshBuildSettings buildSettings = (NavMeshBuildSettings)field.GetValue(agentSettings);
				UnityAgentTypeID = ((NavMeshBuildSettings)(ref buildSettings)).agentTypeID;
				BuildSettings = buildSettings;
			}
		}

		public static int ResolveValheimHumanoidAgentTypeID()
		{
			//IL_00f2: 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)
			if (s_humanoidAgentTypeID >= 0)
			{
				return s_humanoidAgentTypeID;
			}
			try
			{
				Pathfinding instance = Pathfinding.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return 0;
				}
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
				FieldInfo field = typeof(Pathfinding).GetField("m_agentSettings", bindingAttr);
				if (field == null)
				{
					return 0;
				}
				if (!(field.GetValue(instance) is IList list))
				{
					return 0;
				}
				Type? nestedType = typeof(Pathfinding).GetNestedType("AgentSettings", BindingFlags.NonPublic);
				FieldInfo fieldInfo = nestedType?.GetField("m_agentType");
				FieldInfo fieldInfo2 = nestedType?.GetField("m_build");
				if (fieldInfo == null || fieldInfo2 == null)
				{
					return 0;
				}
				foreach (object item in list)
				{
					if (item != null && (int)fieldInfo.GetValue(item) == 1)
					{
						NavMeshBuildSettings val = (NavMeshBuildSettings)fieldInfo2.GetValue(item);
						s_humanoidAgentTypeID = ((NavMeshBuildSettings)(ref val)).agentTypeID;
						return s_humanoidAgentTypeID;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[VillagerAgentType] Failed to resolve Humanoid agentTypeID: " + ex.Message));
				}
			}
			return 0;
		}
	}
	public class VillagerWaypoint
	{
		public const string DefaultStrategyId = "default";

		public Vector3 Position { get; }

		public string StrategyId { get; }

		public string Label { get; }

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

		public VillagerWaypoint(Vector3 position, string strategyId, string label = null)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			StrategyId = (string.IsNullOrEmpty(strategyId) ? "default" : strategyId);
			Label = label ?? "";
		}

		public static VillagerWaypoint WithDefault(Vector3 position, string label = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return new VillagerWaypoint(position, "default", label);
		}
	}
}
namespace ValheimVillages.Villager.AI.Navigation
{
	public static class BakeAuditCommand
	{
		private const float Radius = 1.5f;

		private const float CharacterRadius = 3f;

		[DevCommand("Audit bake collider coverage at a position (defaults to player). Usage: vv_bake_audit [x z [y]]", Name = "vv_bake_audit")]
		public static void Audit(ConsoleEventArgs args)
		{
			//IL_0021: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			if (TryResolvePosition(args, out var pos, out var source))
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine($"[BakeAudit] pos=({pos.x:F2}, {pos.y:F2}, {pos.z:F2}) source={source} radius={1.5f:F1}m");
				stringBuilder.AppendLine($"--- agent-body waist probe ---\n  IsAgentBodyBlocked(pos)={NavMeshBakeManager.IsAgentBodyBlocked(pos)}");
				ReportNavMeshSample(stringBuilder, pos);
				ReportRuntimePhysics(stringBuilder, pos, out var hits);
				ReportBakeSources(stringBuilder, pos, out HashSet<GameObject> sourceMatches, out List<(int, string, Bounds)> phantomMatches);
				ReportCrossReference(stringBuilder, hits, sourceMatches, phantomMatches);
				ReportPhantomCoverage(stringBuilder, pos, phantomMatches);
				ReportCharacterOverlap(stringBuilder, pos);
				string text = stringBuilder.ToString();
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print(text);
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)text);
				}
			}
		}

		[DevCommand("Compare a NavMesh path on the villager (slot 31) bake vs Valheim's Humanoid agent. Usage: vv_pathcompare <fromX> <fromZ> <toX> <toZ>", Name = "vv_pathcompare")]
		public static void PathCompare(ConsoleEventArgs args)
		{
			//IL_0102: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			if (args?.Args == null || args.Args.Length < 5 || !float.TryParse(args.Args[1], NumberStyles.Float, invariantCulture, out var result) || !float.TryParse(args.Args[2], NumberStyles.Float, invariantCulture, out var result2) || !float.TryParse(args.Args[3], NumberStyles.Float, invariantCulture, out var result3) || !float.TryParse(args.Args[4], NumberStyles.Float, invariantCulture, out var result4))
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("Usage: vv_pathcompare <fromX> <fromZ> <toX> <toZ>");
				}
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[PathCompare] from=({result:F1},{result2:F1}) to=({result3:F1},{result4:F1})");
			AppendAgentPath(stringBuilder, "raw slot31", VillagerAgentType.UnityAgentTypeID, result, result2, result3, result4);
			AppendAgentPath(stringBuilder, "raw Humanoid", VillagerAgentType.ResolveValheimHumanoidAgentTypeID(), result, result2, result3, result4);
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			NavMeshHit val3 = default(NavMeshHit);
			float num = (NavMesh.SamplePosition(new Vector3(result, 40f, result2), ref val3, 8f, val2) ? ((NavMeshHit)(ref val3)).position.y : 37.4f);
			List<Vector3> list = new List<Vector3>();
			bool flag = VillagerMovement.TryFindCompletePath(new Vector3(result, num, result2), new Vector3(result3, num, result4), list);
			float num2 = 0f;
			for (int i = 1; i < list.Count; i++)
			{
				num2 += Vector3.Distance(list[i - 1], list[i]);
			}
			float num3 = Vector3.Distance(new Vector3(result, num, result2), new Vector3(result3, num, result4));
			stringBuilder.AppendLine($"  HNA corridor (villager): complete={flag} corners={list.Count} " + $"len={num2:F1}m straight={num3:F1}m " + $"detour={((num3 > 0.01f) ? (num2 / num3) : 1f):F2}x");
			string text = stringBuilder.ToString();
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}

		private static void AppendAgentPath(StringBuilder sb, string label, int agentTypeId, float fx, float fz, float tx, float tz)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = agentTypeId;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			NavMeshHit val3 = default(NavMeshHit);
			bool flag = NavMesh.SamplePosition(new Vector3(fx, 40f, fz), ref val3, 8f, val2);
			NavMeshHit val4 = default(NavMeshHit);
			bool flag2 = NavMesh.SamplePosition(new Vector3(tx, 40f, tz), ref val4, 8f, val2);
			if (!flag || !flag2)
			{
				sb.AppendLine($"  {label} (id={agentTypeId}): sample fail (from={flag}, to={flag2})");
				return;
			}
			NavMeshPath val5 = new NavMeshPath();
			NavMesh.CalculatePath(((NavMeshHit)(ref val3)).position, ((NavMeshHit)(ref val4)).position, val2, val5);
			Vector3[] corners = val5.corners;
			float num = 0f;
			for (int i = 1; i < corners.Length; i++)
			{
				num += Vector3.Distance(corners[i - 1], corners[i]);
			}
			float num2 = Vector3.Distance(((NavMeshHit)(ref val3)).position, ((NavMeshHit)(ref val4)).position);
			sb.AppendLine($"  {label} (id={agentTypeId}): status={val5.status} corners={corners.Length} " + $"len={num:F1}m straight={num2:F1}m " + $"detour={((num2 > 0.01f) ? (num / num2) : 1f):F2}x " + $"fromSnap=({((NavMeshHit)(ref val3)).position.x:F1},{((NavMeshHit)(ref val3)).position.y:F1},{((NavMeshHit)(ref val3)).position.z:F1}) " + $"toSnap=({((NavMeshHit)(ref val4)).position.x:F1},{((NavMeshHit)(ref val4)).position.y:F1},{((NavMeshHit)(ref val4)).position.z:F1})");
		}

		private static bool TryResolvePosition(ConsoleEventArgs args, out Vector3 pos, out string source)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (args?.Args != null && args.Args.Length >= 3)
			{
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				if (!float.TryParse(args.Args[1], NumberStyles.Float, invariantCulture, out var result) || !float.TryParse(args.Args[2], NumberStyles.Float, invariantCulture, out var result2))
				{
					Console instance = Console.instance;
					if (instance != null)
					{
						instance.Print("Usage: vv_bake_audit (no args = player pos) | vv_bake_audit <x> <z> [y]");
					}
					pos = default(Vector3);
					source = "";
					return false;
				}
				pos = new Vector3(result, MeshProbe.ResolveY(result, result2, args, 3, invariantCulture), result2);
				source = "args";
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)((Component)localPlayer).transform == (Object)null)
			{
				Console instance2 = Console.instance;
				if (instance2 != null)
				{
					instance2.Print("No local player; pass coords instead: vv_bake_audit <x> <z> [y]");
				}
				pos = default(Vector3);
				source = "";
				return false;
			}
			pos = ((Component)localPlayer).transform.position;
			source = "player";
			return true;
		}

		private static void ReportNavMeshSample(StringBuilder sb, Vector3 pos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: 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_01b5: 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)
			sb.AppendLine("--- NavMesh sample at this position ---");
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			NavMeshHit val3 = default(NavMeshHit);
			if (NavMesh.SamplePosition(pos, ref val3, 2f, val2))
			{
				sb.AppendLine($"  slot 31 ({VillagerAgentType.UnityAgentTypeID}): HIT at " + $"({((NavMeshHit)(ref val3)).position.x:F2},{((NavMeshHit)(ref val3)).position.y:F2},{((NavMeshHit)(ref val3)).position.z:F2}) " + $"dist={Vector3.Distance(((NavMeshHit)(ref val3)).position, pos):F2}m");
				NavMeshHit val4 = default(NavMeshHit);
				if (NavMesh.FindClosestEdge(pos, ref val4, val2))
				{
					sb.AppendLine($"  slot 31 closest edge: ({((NavMeshHit)(ref val4)).position.x:F2},{((NavMeshHit)(ref val4)).position.y:F2},{((NavMeshHit)(ref val4)).position.z:F2}) " + $"dist={((NavMeshHit)(ref val4)).distance:F2}m");
				}
			}
			else
			{
				sb.AppendLine("  slot 31: MISS within 2m");
			}
			int num = VillagerAgentType.ResolveValheimHumanoidAgentTypeID();
			val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = num;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val5 = val;
			NavMeshHit val6 = default(NavMeshHit);
			if (NavMesh.SamplePosition(pos, ref val6, 2f, val5))
			{
				sb.AppendLine($"  Humanoid ({num}): HIT at " + $"({((NavMeshHit)(ref val6)).position.x:F2},{((NavMeshHit)(ref val6)).position.y:F2},{((NavMeshHit)(ref val6)).position.z:F2}) " + $"dist={Vector3.Distance(((NavMeshHit)(ref val6)).position, pos):F2}m");
			}
			else
			{
				sb.AppendLine($"  Humanoid ({num}): MISS within 2m");
			}
		}

		private static void ReportRuntimePhysics(StringBuilder sb, Vector3 pos, out List<Collider> hits)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine($"--- Runtime physics (Physics.OverlapBox, half-extent {1.5f:F1}m, all layers) ---");
			Collider[] array = Physics.OverlapBox(pos, Vector3.one * 1.5f, Quaternion.identity, -1, (QueryTriggerInteraction)1);
			hits = new List<Collider>(array.Length);
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					hits.Add(val);
				}
			}
			if (hits.Count == 0)
			{
				sb.AppendLine("  (none)");
				return;
			}
			hits.Sort(delegate(Collider a, Collider b)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: 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)
				Bounds bounds2 = a.bounds;
				float num = Vector3.Distance(((Bounds)(ref bounds2)).center, pos);
				bounds2 = b.bounds;
				return num.CompareTo(Vector3.Distance(((Bounds)(ref bounds2)).center, pos));
			});
			foreach (Collider hit in hits)
			{
				GameObject gameObject = ((Component)hit).gameObject;
				string text = (((Object)(object)gameObject.transform.root != (Object)null) ? ((Object)gameObject.transform.root).name : "(no root)");
				string text2 = LayerMask.LayerToName(gameObject.layer);
				if (string.IsNullOrEmpty(text2))
				{
					text2 = "(unnamed)";
				}
				Bounds bounds = hit.bounds;
				string arg = "";
				MeshCollider val2 = (MeshCollider)(object)((hit is MeshCollider) ? hit : null);
				if (val2 != null)
				{
					Mesh sharedMesh = val2.sharedMesh;
					arg = (((Object)(object)sharedMesh != (Object)null) ? $" mesh[readable={sharedMesh.isReadable},convex={val2.convex},tris={(sharedMesh.isReadable ? (sharedMesh.triangles.Length / 3) : (-1))}]" : " mesh[null]");
				}
				sb.AppendLine($"  '{((Object)gameObject).name}' root='{text}' layer={gameObject.layer}:{text2} " + $"colliderType={((object)hit).GetType().Name} bounds=center({((Bounds)(ref bounds)).center.x:F1},{((Bounds)(ref bounds)).center.y:F1},{((Bounds)(ref bounds)).center.z:F1}) " + $"size({((Bounds)(ref bounds)).size.x:F2},{((Bounds)(ref bounds)).size.y:F2},{((Bounds)(ref bounds)).size.z:F2}) " + $"dist={Vector3.Distance(((Bounds)(ref bounds)).center, pos):F2}m{arg}");
			}
		}

		private static void ReportBakeSources(StringBuilder sb, Vector3 pos, out HashSet<GameObject> sourceMatches, out List<(int idx, string category, Bounds bounds)> phantomMatches)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: 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_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine("--- Bake sources whose bounds overlap this point ---");
			sourceMatches = new HashSet<GameObject>();
			phantomMatches = new List<(int, string, Bounds)>();
			IReadOnlyList<NavMeshBuildSource> terrainSources = NavMeshBakeManager.TerrainSources;
			IReadOnlyList<NavMeshBuildSource> pieceSources = NavMeshBakeManager.PieceSources;
			int piecePhantomCount = NavMeshBakeManager.PiecePhantomCount;
			int lastDoorPhantoms = NavMeshBakeManager.LastDoorPhantoms;
			int lastBedPhantoms = NavMeshBakeManager.LastBedPhantoms;
			sb.AppendLine($"  TerrainSources={terrainSources.Count} PieceSources={pieceSources.Count} (phantoms={piecePhantomCount})");
			Bounds val = default(Bounds);
			((Bounds)(ref val))..ctor(pos, Vector3.one * 3f);
			int num = 0;
			for (int i = 0; i < terrainSources.Count; i++)
			{
				if (TryGetSourceBounds(terrainSources[i], out var bounds) && ((Bounds)(ref bounds)).Intersects(val))
				{
					num++;
					NavMeshBuildSource val2 = terrainSources[i];
					string text = (((Object)(object)((NavMeshBuildSource)(ref val2)).component != (Object)null) ? ((Object)((NavMeshBuildSource)(ref val2)).component.gameObject).name : "(synth)");
					int num2 = (((Object)(object)((NavMeshBuildSource)(ref val2)).component != (Object)null) ? ((NavMeshBuildSource)(ref val2)).component.gameObject.layer : (-1));
					sb.AppendLine($"  terrain[#{i}] shape={((NavMeshBuildSource)(ref val2)).shape} area={((NavMeshBuildSource)(ref val2)).area} comp='{text}' " + $"layer={num2} bounds=center({((Bounds)(ref bounds)).center.x:F1},{((Bounds)(ref bounds)).center.y:F1},{((Bounds)(ref bounds)).center.z:F1}) " + $"size({((Bounds)(ref bounds)).size.x:F2},{((Bounds)(ref bounds)).size.y:F2},{((Bounds)(ref bounds)).size.z:F2})");
					if ((Object)(object)((NavMeshBuildSource)(ref val2)).component != (Object)null)
					{
						sourceMatches.Add(((NavMeshBuildSource)(ref val2)).component.gameObject);
					}
				}
			}
			int num3 = pieceSources.Count - piecePhantomCount;
			int num4 = 0;
			for (int j = 0; j < num3; j++)
			{
				if (TryGetSourceBounds(pieceSources[j], out var bounds2) && ((Bounds)(ref bounds2)).Intersects(val))
				{
					num4++;
					NavMeshBuildSource val3 = pieceSources[j];
					string text2 = (((Object)(object)((NavMeshBuildSource)(ref val3)).component != (Object)null) ? ((Object)((NavMeshBuildSource)(ref val3)).component.gameObject).name : "(synth)");
					int num5 = (((Object)(object)((NavMeshBuildSource)(ref val3)).component != (Object)null) ? ((NavMeshBuildSource)(ref val3)).component.gameObject.layer : (-1));
					sb.AppendLine($"  piece[#{j}] shape={((NavMeshBuildSource)(ref val3)).shape} area={((NavMeshBuildSource)(ref val3)).area} comp='{text2}' " + $"layer={num5} bounds=center({((Bounds)(ref bounds2)).center.x:F1},{((Bounds)(ref bounds2)).center.y:F1},{((Bounds)(ref bounds2)).center.z:F1}) " + $"size({((Bounds)(ref bounds2)).size.x:F2},{((Bounds)(ref bounds2)).size.y:F2},{((Bounds)(ref bounds2)).size.z:F2})");
					if ((Object)(object)((NavMeshBuildSource)(ref val3)).component != (Object)null)
					{
						sourceMatches.Add(((NavMeshBuildSource)(ref val3)).component.gameObject);
					}
				}
			}
			for (int k = num3; k < pieceSources.Count; k++)
			{
				if (TryGetSourceBounds(pieceSources[k], out var bounds3) && ((Bounds)(ref bounds3)).Intersects(val))
				{
					int num6 = k - num3;
					string item = ((num6 < lastDoorPhantoms) ? "door" : ((num6 >= lastDoorPhantoms + lastBedPhantoms) ? "outside_cell" : "bed"));
					phantomMatches.Add((k, item, bounds3));
				}
			}
			sb.AppendLine($"  → terrain matches: {num}, real piece matches: {num4}, phantom matches: {phantomMatches.Count}");
		}

		private static void ReportCrossReference(StringBuilder sb, List<Collider> runtimeHits, HashSet<GameObject> sourceMatches, List<(int idx, string category, Bounds bounds)> _phantomMatches)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine("--- Cross-reference: runtime collider → bake source ---");
			if (runtimeHits.Count == 0)
			{
				sb.AppendLine("  (no runtime colliders to cross-reference)");
				return;
			}
			NavMeshBuildSettings settingsByID = NavMesh.GetSettingsByID(VillagerAgentType.UnityAgentTypeID);
			float voxelSize = ((NavMeshBuildSettings)(ref settingsByID)).voxelSize;
			int mask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });
			int mask2 = LayerMask.GetMask(new string[1] { "terrain" });
			foreach (Collider runtimeHit in runtimeHits)
			{
				GameObject gameObject = ((Component)runtimeHit).gameObject;
				bool flag = ((1 << gameObject.layer) & (mask | mask2)) != 0;
				float[] array = new float[3];
				Bounds bounds = runtimeHit.bounds;
				array[0] = ((Bounds)(ref bounds)).size.x;
				bounds = runtimeHit.bounds;
				array[1] = ((Bounds)(ref bounds)).size.y;
				bounds = runtimeHit.bounds;
				array[2] = ((Bounds)(ref bounds)).size.z;
				float num = Mathf.Max(array);
				bool flag2 = num < voxelSize * 2f;
				if (sourceMatches.Contains(gameObject))
				{
					sb.AppendLine($"  [OK]   '{((Object)gameObject).name}' (layer {gameObject.layer}) - captured in bake");
				}
				else if (!flag)
				{
					sb.AppendLine($"  [MISS] '{((Object)gameObject).name}' (layer {gameObject.layer}:{LayerMask.LayerToName(gameObject.layer)}) - " + "layer NOT in bake mask (piece=" + LayerMaskToString(mask) + ", terrain=" + LayerMaskToString(mask2) + ")");
				}
				else if (flag2)
				{
					sb.AppendLine($"  [MISS] '{((Object)gameObject).name}' (layer {gameObject.layer}) - sub-voxel " + $"(maxSize {num:F2}m < {voxelSize * 2f:F2}m = 2x voxel); likely voxelized away");
				}
				else
				{
					sb.AppendLine($"  [MISS] '{((Object)gameObject).name}' (layer {gameObject.layer}) - in mask, not sub-voxel, " + "but absent from bake (collider inactive at bake time, or spawned/enabled after partition)");
				}
			}
		}

		private static void ReportPhantomCoverage(StringBuilder sb, Vector3 pos, List<(int idx, string category, Bounds bounds)> phantomMatches)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine("--- Phantom blockers covering this position ---");
			if (phantomMatches.Count == 0)
			{
				sb.AppendLine("  (none)");
				return;
			}
			foreach (var phantomMatch in phantomMatches)
			{
				var (num, text, val) = phantomMatch;
				sb.AppendLine($"  phantom[#{num}] category={text} bounds=center({((Bounds)(ref val)).center.x:F1},{((Bounds)(ref val)).center.y:F1},{((Bounds)(ref val)).center.z:F1}) " + $"size({((Bounds)(ref val)).size.x:F2},{((Bounds)(ref val)).size.y:F2},{((Bounds)(ref val)).size.z:F2}) dist={Vector3.Distance(((Bounds)(ref val)).center, pos):F2}m");
			}
		}

		private static void ReportCharacterOverlap(StringBuilder sb, Vector3 pos)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine($"--- Characters within {3f:F1}m (NEVER in bake; runtime obstacles) ---");
			int mask = LayerMask.GetMask(new string[4] { "character", "character_net", "character_noenv", "character_trigger" });
			Collider[] array = Physics.OverlapSphere(pos, 3f, mask, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				sb.AppendLine("  (none)");
				return;
			}
			HashSet<GameObject> hashSet = new HashSet<GameObject>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					GameObject val2 = (((Object)(object)((Component)val).transform.root != (Object)null) ? ((Component)((Component)val).transform.root).gameObject : ((Component)val).gameObject);
					if (hashSet.Add(val2))
					{
						float num = Vector3.Distance(val2.transform.position, pos);
						sb.AppendLine($"  '{((Object)val2).name}' at ({val2.transform.position.x:F1},{val2.transform.position.y:F1},{val2.transform.position.z:F1}) " + $"dist={num:F2}m");
					}
				}
			}
		}

		private static bool TryGetSourceBounds(NavMeshBuildSource src, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			NavMeshBuildSourceShape shape = ((NavMeshBuildSource)(ref src)).shape;
			Matrix4x4 transform;
			if ((int)shape != 0)
			{
				if ((int)shape == 2)
				{
					Vector3 val = ((NavMeshBuildSource)(ref src)).size * 0.5f;
					Vector3[] array = (Vector3[])(object)new Vector3[8];
					int num = 0;
					for (int i = -1; i <= 1; i += 2)
					{
						for (int j = -1; j <= 1; j += 2)
						{
							for (int k = -1; k <= 1; k += 2)
							{
								int num2 = num++;
								transform = ((NavMeshBuildSource)(ref src)).transform;
								array[num2] = ((Matrix4x4)(ref transform)).MultiplyPoint3x4(new Vector3((float)i * val.x, (float)j * val.y, (float)k * val.z));
							}
						}
					}
					Vector3 val2 = array[0];
					Vector3 val3 = array[0];
					for (int l = 1; l < 8; l++)
					{
						val2 = Vector3.Min(val2, array[l]);
						val3 = Vector3.Max(val3, array[l]);
					}
					bounds = new Bounds((val2 + val3) * 0.5f, val3 - val2);
					return true;
				}
				return false;
			}
			Object sourceObject = ((NavMeshBuildSource)(ref src)).sourceObject;
			Mesh val4 = (Mesh)(object)((sourceObject is Mesh) ? sourceObject : null);
			if ((Object)(object)val4 == (Object)null)
			{
				return false;
			}
			Bounds bounds2 = val4.bounds;
			Vector3 extents = ((Bounds)(ref bounds2)).extents;
			Vector3[] array2 = (Vector3[])(object)new Vector3[8];
			int num3 = 0;
			for (int m = -1; m <= 1; m += 2)
			{
				for (int n = -1; n <= 1; n += 2)
				{
					for (int num4 = -1; num4 <= 1; num4 += 2)
					{
						int num5 = num3++;
						transform = ((NavMeshBuildSource)(ref src)).transform;
						array2[num5] = ((Matrix4x4)(ref transform)).MultiplyPoint3x4(((Bounds)(ref bounds2)).center + new Vector3((float)m * extents.x, (float)n * extents.y, (float)num4 * extents.z));
					}
				}
			}
			Vector3 val5 = array2[0];
			Vector3 val6 = array2[0];
			for (int num6 = 1; num6 < 8; num6++)
			{
				val5 = Vector3.Min(val5, array2[num6]);
				val6 = Vector3.Max(val6, array2[num6]);
			}
			bounds = new Bounds((val5 + val6) * 0.5f, val6 - val5);
			return true;
		}

		private static string LayerMaskToString(int mask)
		{
			List<string> list = new List<string>();
			for (int i = 0; i < 32; i++)
			{
				if ((mask & (1 << i)) != 0)
				{
					string text = LayerMask.LayerToName(i);
					list.Add(string.IsNullOrEmpty(text) ? $"#{i}" : text);
				}
			}
			if (list.Count != 0)
			{
				return string.Join("|", list);
			}
			return "(empty)";
		}
	}
	[Flags]
	public enum BfsEdgeKind
	{
		None = 0,
		InPassEdge = 1,
		CrossVert = 2,
		CrossProx = 4,
		Pass3Step = 8
	}
	public struct BfsEdgeMeta
	{
		public BfsEdgeKind Kinds;

		public Vector3? RepresentativePos;

		public float ProxMinDist;
	}
	public static class BfsAdjacencyStore
	{
		public static Dictionary<string, HashSet<string>> Adjacency { get; private set; } = new Dictionary<string, HashSet<string>>();

		public static HashSet<string> Seeds { get; private set; } = new HashSet<string>();

		public static Dictionary<string, BfsEdgeMeta> EdgeMeta { get; private set; } = new Dictionary<string, BfsEdgeMeta>();

		public static string EdgeKey(string a, string b)
		{
			if (string.CompareOrdinal(a, b) <= 0)
			{
				return a + "|" + b;
			}
			return b + "|" + a;
		}

		public static void Set(Dictionary<string, HashSet<string>> adjacency, HashSet<string> seeds, Dictionary<string, BfsEdgeMeta> edgeMeta)
		{
			Adjacency = adjacency ?? new Dictionary<string, HashSet<string>>();
			Seeds = seeds ?? new HashSet<string>();
			EdgeMeta = edgeMeta ?? new Dictionary<string, BfsEdgeMeta>();
		}

		public static List<string> PathToSeed(string targetRegionId)
		{
			if (string.IsNullOrEmpty(targetRegionId))
			{
				return null;
			}
			if (Adjacency == null || Adjacency.Count == 0)
			{
				return null;
			}
			if (Seeds == null || Seeds.Count == 0)
			{
				return null;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string> { { targetRegionId, null } };
			Queue<string> queue = new Queue<string>();
			queue.Enqueue(targetRegionId);
			while (queue.Count > 0)
			{
				string text = queue.Dequeue();
				if (Seeds.Contains(text))
				{
					List<string> list = new List<string>();
					string value = text;
					while (value != null)
					{
						list.Add(value);
						dictionary.TryGetValue(value, out value);
					}
					list.Reverse();
					return list;
				}
				if (!Adjacency.TryGetValue(text, out var value2))
				{
					continue;
				}
				foreach (string item in value2)
				{
					if (!dictionary.ContainsKey(item))
					{
						dictionary[item] = text;
						queue.Enqueue(item);
					}
				}
			}
			return null;
		}

		[RegisterCleanup]
		public static void Clear()
		{
			Adjacency = new Dictionary<string, HashSet<string>>();
			Seeds = new HashSet<string>();
			EdgeMeta = new Dictionary<string, BfsEdgeMeta>();
		}
	}
	internal static class BfsTraceCommand
	{
		[DevCommand("Highlight BFS path from region (or player) to anchor seed. Args: [regionId | off]", Name = "vv_bfs_trace")]
		public static void Trace(ConsoleEventArgs args)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: 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_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			string text = null;
			if (args?.Args != null && args.Args.Length >= 2)
			{
				text = args.Args[1];
			}
			if (!string.IsNullOrEmpty(text) && (text.Equals("off", StringComparison.OrdinalIgnoreCase) || text.Equals("clear", StringComparison.OrdinalIgnoreCase) || text == "0"))
			{
				PathDebugRenderer.HighlightedRegions.Clear();
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("[vv_bfs_trace] highlight cleared");
				}
				return;
			}
			string text2 = text;
			if (string.IsNullOrEmpty(text2))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					Console instance2 = Console.instance;
					if (instance2 != null)
					{
						instance2.Print("[vv_bfs_trace] no player and no region arg");
					}
					return;
				}
				RegionGraph regionGraph = VillageRegistry.GraphAt(((Component)localPlayer).transform.position);
				if (regionGraph == null)
				{
					Console instance3 = Console.instance;
					if (instance3 != null)
					{
						instance3.Print("[vv_bfs_trace] no RegionGraph available");
					}
					return;
				}
				text2 = regionGraph.PointToRegionId(((Component)localPlayer).transform.position);
				if (string.IsNullOrEmpty(text2))
				{
					Console instance4 = Console.instance;
					if (instance4 != null)
					{
						instance4.Print("[vv_bfs_trace] PointToRegionId unresolved at player " + $"({((Component)localPlayer).transform.position.x:F1},{((Component)localPlayer).transform.position.y:F1},{((Component)localPlayer).transform.position.z:F1})");
					}
					return;
				}
			}
			List<string> list = BfsAdjacencyStore.PathToSeed(text2);
			if (list == null)
			{
				Console instance5 = Console.instance;
				if (instance5 != null)
				{
					instance5.Print("[vv_bfs_trace] no BFS path from " + text2 + " back to any seed " + $"(adjacency size={BfsAdjacencyStore.Adjacency.Count}, " + $"seeds={BfsAdjacencyStore.Seeds.Count})");
				}
				return;
			}
			PathDebugRenderer.HighlightedRegions.Clear();
			foreach (string item in list)
			{
				PathDebugRenderer.HighlightedRegions.Add(item);
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[vv_bfs_trace] ").Append(text2).Append(" -> seed: ");
			stringBuilder.Append(list.Count).Append(" hops [");
			for (int i = 0; i < list.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(" -> ");
				}
				stringBuilder.Append(list[i]);
			}
			stringBuilder.Append("]");
			Console instance6 = Console.instance;
			if (instance6 != null)
			{
				instance6.Print(stringBuilder.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)stringBuilder.ToString());
			}
			List<RegionBuilder.CachedTriangle> cachedTriangles = RegionBuilder.CachedTriangles;
			if (cachedTriangles == null)
			{
				return;
			}
			Dictionary<string, Bounds> dictionary = new Dictionary<string, Bounds>(list.Count);
			Bounds value2 = default(Bounds);
			foreach (RegionBuilder.CachedTriangle item2 in cachedTriangles)
			{
				if (Enumerable.Contains(list, item2.RegionId))
				{
					if (dictionary.TryGetValue(item2.RegionId, out var value))
					{
						((Bounds)(ref value)).Encapsulate(item2.V0);
						((Bounds)(ref value)).Encapsulate(item2.V1);
						((Bounds)(ref value)).Encapsulate(item2.V2);
						dictionary[item2.RegionId] = value;
					}
					else
					{
						((Bounds)(ref value2))..ctor(item2.V0, Vector3.zero);
						((Bounds)(ref value2)).Encapsulate(item2.V1);
						((Bounds)(ref value2)).Encapsulate(item2.V2);
						dictionary[item2.RegionId] = value2;
					}
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				string text3 = list[j];
				string text4 = "";
				if (j > 0)
				{
					string key = BfsAdjacencyStore.EdgeKey(list[j - 1], text3);
					text4 = ((!BfsAdjacencyStore.EdgeMeta.TryGetValue(key, out var value3)) ? "  via [?]" : ("  via [" + FormatEdgeMeta(value3) + "]"));
				}
				if (!dictionary.TryGetValue(text3, out var value4))
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)("[vv_bfs_trace]   " + text3 + ": (no cached tris)" + text4));
					}
					continue;
				}
				Vector3 center = ((Bounds)(ref value4)).center;
				Vector3 size = ((Bounds)(ref value4)).size;
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)($"[vv_bfs_trace]   {text3}: centroid=({center.x:F1},{center.y:F1},{center.z:F1}) " + $"size=({size.x:F1}x{size.y:F1}x{size.z:F1}) " + $"y=[{((Bounds)(ref value4)).min.y:F2}..{((Bounds)(ref value4)).max.y:F2}]{text4}"));
				}
			}
		}

		private static string FormatEdgeMeta(BfsEdgeMeta meta)
		{
			//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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>(3);
			if ((meta.Kinds & BfsEdgeKind.InPassEdge) != BfsEdgeKind.None)
			{
				list.Add("InPassEdge");
			}
			if ((meta.Kinds & BfsEdgeKind.CrossVert) != BfsEdgeKind.None)
			{
				if (meta.RepresentativePos.HasValue)
				{
					Vector3 value = meta.RepresentativePos.Value;
					list.Add($"CrossVert @ ({value.x:F1},{value.y:F1},{value.z:F1})");
				}
				else
				{
					list.Add("CrossVert");
				}
			}
			if ((meta.Kinds & BfsEdgeKind.CrossProx) != BfsEdgeKind.None)
			{
				if (meta.RepresentativePos.HasValue)
				{
					Vector3 value2 = meta.RepresentativePos.Value;
					list.Add($"CrossProx @ ({value2.x:F1},{value2.y:F1},{value2.z:F1}) d={meta.ProxMinDist:F2}m");
				}
				else
				{
					list.Add($"CrossProx d={meta.ProxMinDist:F2}m");
				}
			}
			if ((meta.Kinds & BfsEdgeKind.Pass3Step) != BfsEdgeKind.None)
			{
				list.Add("Pass3Step");
			}
			if (list.Count != 0)
			{
				return string.Join(" | ", list);
			}
			return "None";
		}
	}
	public static class BoundaryDump
	{
		private static readonly string OutputPath = Path.Combine(Paths.ConfigPath, "vv_dumps", "hna_boundary_dump.json");

		[DevCommand("Dump region-graph boundary cells + the derived patrol route to JSON for offline pipeline testing", Name = "vv_hna_boundary_dump")]
		public static void Dump()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: 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)
			if (!VillageRegistry.IsAnyAvailable)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("Region graph not available. Spawn a patroller or run vv_repartition first.");
				}
				return;
			}
			List<Vector3> allAnchorPositions = VillagerAIManager.GetAllAnchorPositions();
			Vector3 val = ((allAnchorPositions != null && allAnchorPositions.Count > 0) ? allAnchorPositions[0] : Vector3.zero);
			RegionGraph regionGraph = VillageRegistry.GraphAt(val);
			if (regionGraph == null || !regionGraph.IsAvailable)
			{
				Console instance2 = Console.instance;
				if (instance2 != null)
				{
					instance2.Print("No graph near anchor position.");
				}
				return;
			}
			List<(string, Vector3, Vector3)> boundaryCells = regionGraph.GetBoundaryCells();
			if (boundaryCells.Count == 0)
			{
				Console instance3 = Console.instance;
				if (instance3 != null)
				{
					instance3.Print("No boundary cells found.");
				}
				return;
			}
			List<Vector3> list = PatrolRouteBuilder.Build(boundaryCells);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{\n");
			stringBuilder.Append($"  \"cellSize\": {3f:F2},\n");
			stringBuilder.Append($"  \"regionCount\": {regionGraph.RegionCount},\n");
			stringBuilder.Append($"  \"anchorPosition\": [{val.x:F2}, {val.y:F2}, {val.z:F2}],\n");
			stringBuilder.Append("  \"boundaryCells\": [\n");
			for (int i = 0; i < boundaryCells.Count; i++)
			{
				(string, Vector3, Vector3) tuple = boundaryCells[i];
				Vector3 item = tuple.Item2;
				Vector3 item2 = tuple.Item3;
				stringBuilder.Append("    {");
				stringBuilder.Append($" \"center\": [{item.x:F2}, {item.y:F2}, {item.z:F2}],");
				stringBuilder.Append($" \"outwardDir\": [{item2.x:F3}, {item2.y:F3}, {item2.z:F3}] ");
				stringBuilder.Append((i < boundaryCells.Count - 1) ? "},\n" : "}\n");
			}
			stringBuilder.Append("  ],\n");
			stringBuilder.Append("  \"route\": [\n");
			for (int j = 0; j < list.Count; j++)
			{
				Vector3 val2 = list[j];
				stringBuilder.Append($"    [{val2.x:F2}, {val2.y:F2}, {val2.z:F2}]");
				stringBuilder.Append((j < list.Count - 1) ? ",\n" : "\n");
			}
			stringBuilder.Append("  ]\n");
			stringBuilder.Append("}\n");
			File.WriteAllText(OutputPath, stringBuilder.ToString());
			Console instance4 = Console.instance;
			if (instance4 != null)
			{
				instance4.Print($"Boundary dump: {boundaryCells.Count} cells -> {list.Count} route waypoints -> {OutputPath}");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Region] Boundary dump: {boundaryCells.Count} cells -> {list.Count} waypoints -> {OutputPath}");
			}
		}
	}
	public class DoorHandler : MonoBehaviour
	{
		private const float DoorCloseBlockRadius = 3f;

		private readonly List<Door> m_nearbyDoors = new List<Door>();

		private readonly Dictionary<Door, float> m_pendingCloseDoors = new Dictionary<Door, float>();

		private Character m_character;

		private float m_lastDoorScanTime;

		private ZNetView m_znetView;

		private const float DoorCrossLookahead = 3f;

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

		private void Update()
		{
			ProcessPendingDoorClosures();
			if (Time.time - m_lastDoorScanTime > 0.5f)
			{
				m_lastDoorScanTime = Time.time;
				ScanForNearbyDoors();
			}
		}

		private void OnDestroy()
		{
			foreach (KeyValuePair<Door, float> pendingCloseDoor in m_pendingCloseDoors)
			{
				if ((Object)(object)pendingCloseDoor.Key != (Object)null)
				{
					CloseDoor(pendingCloseDoor.Key);
				}
			}
			m_pendingCloseDoors.Clear();
		}

		public Door GetBlockingDoor(Vector3 moveDirection)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (m_nearbyDoors.Count == 0)
			{
				return null;
			}
			Vector3 position = ((Component)this).transform.position;
			Vector3 val = moveDirection;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return null;
			}
			Vector3 b = position + ((Vector3)(ref val)).normalized * 3f;
			foreach (Door nearbyDoor in m_nearbyDoors)
			{
				if (!((Object)(object)nearbyDoor == (Object)null) && IsDoorClosed(nearbyDoor) && IsPlayerBuiltDoor(nearbyDoor))
				{
					Vector3 position2 = ((Component)nearbyDoor).transform.position;
					Vector3 val2 = position2 - position;
					if (!(((Vector3)(ref val2)).sqrMagnitude > 9f) && SegmentCrossesDoor(position, b, position2, ((Component)nearbyDoor).transform.forward, DoorwayHalfWidth(nearbyDoor)))
					{
						return nearbyDoor;
					}
				}
			}
			return null;
		}

		private static float DoorwayHalfWidth(Door door)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			Collider[] componentsInChildren = ((Component)door).GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !val.isTrigger)
				{
					BoxCollider val2 = (BoxCollider)(object)((val is BoxCollider) ? val : null);
					if (val2 != null)
					{
						Vector3 lossyScale = ((Component)val2).transform.lossyScale;
						num = Mathf.Max(num, Mathf.Max(Mathf.Abs(val2.size.x * lossyScale.x), Mathf.Abs(val2.size.z * lossyScale.z)));
					}
				}
			}
			if (num <= 0f)
			{
				num = 1.2f;
			}
			return num * 0.5f + 0.3f;
		}

		private static bool SegmentCrossesDoor(Vector3 a, Vector3 b, Vector3 doorMidpoint, Vector3 doorForward, float doorwayHalfWidth)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			float num = Vector3.Dot(a - doorMidpoint, doorForward);
			float num2 = Vector3.Dot(b - doorMidpoint, doorForward);
			if (num >= 0f == num2 >= 0f)
			{
				return false;
			}
			float num3 = num - num2;
			if (Mathf.Abs(num3) < 1E-05f)
			{
				return false;
			}
			float num4 = num / num3;
			Vector3 val = Vector3.Lerp(a, b, num4);
			float num5 = val.x - doorMidpoint.x;
			float num6 = val.z - doorMidpoint.z;
			return num5 * num5 + num6 * num6 <= doorwayHalfWidth * doorwayHalfWidth;
		}

		public void OpenDoor(Door door)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)door == (Object)null)
			{
				return;
			}
			ZNetView doorZNetView = GetDoorZNetView(door);
			if (!((Object)(object)doorZNetView == (Object)null) && doorZNetView.GetZDO() != null && IsDoorClosed(door))
			{
				Vector3 val = ((Component)this).transform.position - ((Component)door).transform.position;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				bool flag = Vector3.Dot(((Component)door).transform.forward, normalized) < 0f;
				int num = (flag ? 1 : (-1));
				Dictionary<string, object> dictionary = new Dictionary<string, object>();
				val = ((Component)this).transform.position;
				dictionary.Add("npcPos", ((Vector3)(ref val)).ToString("F2"));
				val = ((Component)door).transform.position;
				dictionary.Add("doorPos", ((Vector3)(ref val)).ToString("F2"));
				val = ((Component)door).transform.forward;
				dictionary.Add("doorFwd", ((Vector3)(ref val)).ToString("F2"));
				dictionary.Add("userDir", ((Vector3)(ref normalized)).ToString("F2"));
				dictionary.Add("dot", Vector3.Dot(((Component)door).transform.forward, normalized));
				dictionary.Add("forward", flag);
				dictionary.Add("openState", num);
				DebugLog.Append("DoorHandler.cs:open", "open_door", dictionary, "direction", "run1");
				doorZNetView.GetZDO().Set(ZDOVars.s_state, num, false);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)$"NPC opened door at {((Component)door).transform.position} (state={num})");
				}
				ScheduleClose(door);
			}
		}

		private void ScheduleClose(Door door)
		{
			float value = Time.time + 1.5f;
			if (m_pendingCloseDoors.ContainsKey(door))
			{
				m_pendingCloseDoors[door] = value;
			}
			else
			{
				m_pendingCloseDoors.Add(door, value);
			}
		}

		private void ProcessPendingDoorClosures()
		{
			if (m_pendingCloseDoors.Count == 0)
			{
				return;
			}
			List<Door> list = new List<Door>();
			List<Door> list2 = new List<Door>();
			foreach (Door item in new List<Door>(m_pendingCloseDoors.Keys))
			{
				if (m_pendingCloseDoors.TryGetValue(item, out var value) && !(Time.time < value))
				{
					if ((Object)(object)item == (Object)null)
					{
						list.Add(item);
					}
					else if (IsSafeToCLoseDoor(item))
					{
						CloseDoor(item);
						list.Add(item);
					}
					else
					{
						list2.Add(item);
					}
				}
			}
			foreach (Door item2 in list2)
			{
				m_pendingCloseDoors[item2] = Time.time + 0.5f;
			}
			foreach (Door item3 in list)
			{
				m_pendingCloseDoors.Remove(item3);
			}
		}

		private bool IsSafeToCLoseDoor(Door door)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(((Component)door).transform.position, 3f);
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null) && (Object)(object)((Component)val).GetComponentInParent<Character>() != (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		private void CloseDoor(Door door)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)door == (Object)null)
			{
				return;
			}
			ZNetView doorZNetView = GetDoorZNetView(door);
			if (!((Object)(object)doorZNetView == (Object)null) && doorZNetView.GetZDO() != null)
			{
				doorZNetView.GetZDO().Set(ZDOVars.s_state, 0, false);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)$"NPC closed door at {((Component)door).transform.position}");
				}
			}
		}

		private void ScanForNearbyDoors()
		{
			//IL_0011: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			m_nearbyDoors.Clear();
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 6f);
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					Door componentInParent = ((Component)val).GetComponentInParent<Door>();
					if ((Object)(object)componentInParent != (Object)null && !m_nearbyDoors.Contains(componentInParent))
					{
						m_nearbyDoors.Add(componentInParent);
					}
				}
			}
			if (m_nearbyDoors.Count > 0)
			{
				Dictionary<string, object> dictionary = new Dictionary<string, object>();
				Vector3 position = ((Component)this).transform.position;
				dictionary.Add("npcPos", ((Vector3)(ref position)).ToString("F2"));
				dictionary.Add("doorsFound", m_nearbyDoors.Count);
				dictionary.Add("scanRadius", 6f);
				DebugLog.Append("DoorHandler.cs:scan", "scan_result", dictionary, "H4", "run1");
			}
		}

		private bool IsDoorClosed(Door door)
		{
			if ((Object)(object)door == (Object)null)
			{
				return false;
			}
			ZNetView doorZNetView = GetDoorZNetView(door);
			if ((Object)(object)doorZNetView == (Object)null || doorZNetView.GetZDO() == null)
			{
				return false;
			}
			return doorZNetView.GetZDO().GetInt(ZDOVars.s_state, 0) == 0;
		}

		private ZNetView GetDoorZNetView(Door door)
		{
			if ((Object)(object)door == (Object)null)
			{
				return null;
			}
			return ((Component)door).GetComponent<ZNetView>();
		}

		private bool IsPlayerBuiltDoor(Door door)
		{
			if ((Object)(object)door == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)door).GetComponent<Piece>() != (Object)null;
		}
	}
	public static class MeshProbe
	{
		private const float SampleRadius = 5f;

		private const float ColliderRadius = 1f;

		internal static float ResolveY(float x, float z, ConsoleEventArgs args, int yIndex, CultureInfo inv)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (args?.Args != null && args.Args.Length > yIndex && float.TryParse(args.Args[yIndex], NumberStyles.Float, inv, out var result))
			{
				return result;
			}
			if (!((Object)(object)ZoneSystem.instance != (Object)null))
			{
				return 0f;
			}
			return ZoneSystem.instance.GetGroundHeight(new Vector3(x, 0f, z));
		}

		[DevCommand("Probe NavMesh + colliders at the player's position (or pass x z [y] to override)", Name = "vv_probe")]
		public static void Probe(ConsoleEventArgs args)
		{
			//IL_00bd: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: 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_01ad: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = default(Vector3);
			bool flag;
			if (args?.Args != null && args.Args.Length >= 3)
			{
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				if (!float.TryParse(args.Args[1], NumberStyles.Float, invariantCulture, out var result) || !float.TryParse(args.Args[2], NumberStyles.Float, invariantCulture, out var result2))
				{
					Console instance = Console.instance;
					if (instance != null)
					{
						instance.Print("Usage: vv_probe (no args = player pos) | vv_probe <x> <z> [y]");
					}
					return;
				}
				((Vector3)(ref position))..ctor(result, ResolveY(result, result2, args, 3, invariantCulture), result2);
				flag = false;
			}
			else
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)((Component)localPlayer).transform == (Object)null)
				{
					Console instance2 = Console.instance;
					if (instance2 != null)
					{
						instance2.Print("No local player; pass coords instead: vv_probe <x> <z> [y]");
					}
					return;
				}
				position = ((Component)localPlayer).transform.position;
				flag = true;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[vv_probe] pos=({position.x:F2}, {position.y:F2}, {position.z:F2}) " + "source=" + (flag ? "player" : "args"));
			stringBuilder.AppendLine($"--- agent slot 31 (agentTypeID={VillagerAgentType.UnityAgentTypeID}, registered={VillagerAgentType.IsRegistered}) ---");
			ReportNavMeshSample(stringBuilder, position, VillagerAgentType.UnityAgentTypeID);
			int num = VillagerAgentType.ResolveValheimHumanoidAgentTypeID();
			stringBuilder.AppendLine($"--- Humanoid (agentTypeID={num}) ---");
			ReportNavMeshSample(stringBuilder, position, num);
			stringBuilder.AppendLine($"--- colliders within {1f:F1}m ---");
			ReportColliders(stringBuilder, position);
			stringBuilder.AppendLine("--- capsule-hit colliders (would trigger rej_blocked) ---");
			ReportCapsuleHits(stringBuilder, position);
			stringBuilder.AppendLine("--- RegionBuilder.CachedTriangles within 2m ---");
			ReportCachedTriangles(stringBuilder, position);
			stringBuilder.AppendLine("--- NavMesh bake sources (within 5m) ---");
			ReportBakeSources(stringBuilder, position);
			stringBuilder.AppendLine("--- raw extracted triangles (within 5m, pre-filter) ---");
			ReportRawExtracted(stringBuilder, position);
			stringBuilder.AppendLine("--- filter trace: upward-facing triangles within 3m ---");
			ReportFilterTrace(stringBuilder, position);
			stringBuilder.AppendLine("--- RegionGraph at this point ---");
			ReportRegionGraph(stringBuilder, position);
			stringBuilder.AppendLine("--- Pass 1 flood reachability at this cell ---");
			ReportFloodReachability(stringBuilder, position);
			string text = stringBuilder.ToString();
			Console instance3 = Console.instance;
			if (instance3 != null)
			{
				instance3.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}

		private static void ReportNavMeshSample(StringBuilder sb, Vector3 pos, int agentTypeID)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = agentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			NavMeshHit val3 = default(NavMeshHit);
			if (NavMesh.SamplePosition(pos, ref val3, 5f, val2))
			{
				float num = Vector3.Distance(((NavMeshHit)(ref val3)).position, pos);
				sb.AppendLine($"  SamplePosition: HIT at ({((NavMeshHit)(ref val3)).position.x:F2}, {((NavMeshHit)(ref val3)).position.y:F2}, {((NavMeshHit)(ref val3)).position.z:F2}) " + $"dist={num:F2}m");
			}
			else
			{
				sb.AppendLine($"  SamplePosition: MISS (no triangle within {5f:F1}m)");
			}
			NavMeshHit val4 = default(NavMeshHit);
			if (NavMesh.FindClosestEdge(pos, ref val4, val2))
			{
				float num2 = Vector3.Distance(((NavMeshHit)(ref val4)).position, pos);
				sb.AppendLine($"  FindClosestEdge: at ({((NavMeshHit)(ref val4)).position.x:F2}, {((NavMeshHit)(ref val4)).position.y:F2}, {((NavMeshHit)(ref val4)).position.z:F2}) " + $"dist={num2:F2}m");
			}
			else
			{
				sb.AppendLine("  FindClosestEdge: no edge found");
			}
		}

		private static void ReportColliders(StringBuilder sb, Vector3 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(pos, 1f, -1, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				sb.AppendLine("  (none — this point has NO collider, no geometry to bake)");
				return;
			}
			Array.Sort(array, delegate(Collider a, Collider b)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = a.ClosestPoint(pos) - pos;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				val2 = b.ClosestPoint(pos) - pos;
				float sqrMagnitude2 = ((Vector3)(ref val2)).sqrMagnitude;
				return sqrMagnitude.CompareTo(sqrMagnitude2);
			});
			int num = Mathf.Min(array.Length, 8);
			for (int num2 = 0; num2 < num; num2++)
			{
				Collider val = array[num2];
				string text = LayerMask.LayerToName(((Component)val).gameObject.layer);
				if (string.IsNullOrEmpty(text))
				{
					text = "(unnamed)";
				}
				float num3 = Vector3.Distance(val.ClosestPoint(pos), pos);
				sb.AppendLine($"  [layer={((Component)val).gameObject.layer}:{text}] {((Object)((Component)val).gameObject).name} " + $"({((object)val).GetType().Name}) dist={num3:F2}m");
			}
			if (array.Length > 8)
			{
				sb.AppendLine($"  ... and {array.Length - 8} more");
			}
		}

		private static void ReportCapsuleHits(StringBuilder sb, Vector3 pos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			int mask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });
			Vector3 val = pos + Vector3.up * 0.55f;
			Vector3 val2 = pos + Vector3.up * 1.3499999f;
			Collider[] array = Physics.OverlapCapsule(val, val2, 0.3f, mask, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				sb.AppendLine("  (capsule clear — no rej_blocked at this position)");
				return;
			}
			sb.AppendLine($"  capsule p0=({val.x:F2},{val.y:F2},{val.z:F2}) " + $"p1=({val2.x:F2},{val2.y:F2},{val2.z:F2}) r={0.3f:F2}");
			foreach (Collider val3 in array)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					string text = LayerMask.LayerToName(((Component)val3).gameObject.layer);
					if (string.IsNullOrEmpty(text))
					{
						text = "(unnamed)";
					}
					string text2 = "(no Piece)";
					Piece componentInParent = ((Component)val3).GetComponentInParent<Piece>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						text2 = ((Object)((Component)componentInParent).gameObject).name;
					}
					Bounds bounds = val3.bounds;
					sb.AppendLine("  HIT [" + text + "] go=" + ((Object)((Component)val3).gameObject).name + " prefab=" + text2 + " type=" + ((object)val3).GetType().Name + " " + $"bounds_y=[{((Bounds)(ref bounds)).min.y:F2}..{((Bounds)(ref bounds)).max.y:F2}] " + $"yAbovePos={((Bounds)(ref bounds)).max.y - pos.y:F2}m");
				}
			}
		}

		private static void ReportCachedTriangles(StringBuilder sb, Vector3 pos)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			List<RegionBuilder.CachedTriangle> cachedTriangles = RegionBuilder.CachedTriangles;
			if (cachedTriangles == null || cachedTriangles.Count == 0)
			{
				sb.AppendLine("  CachedTriangles is empty — RegionBuilder has not run, or last run produced 0 triangles");
				return;
			}
			sb.AppendLine($"  (total in cache: {cachedTriangles.Count})");
			float num = float.MaxValue;
			Vector3 val = Vector3.zero;
			string text = "";
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			foreach (RegionBuilder.CachedTriangle item in cachedTriangles)
			{
				Vector3 val2 = (item.V0 + item.V1 + item.V2) / 3f;
				float num5 = Vector3.Distance(val2, pos);
				if (num5 < num)
				{
					num = num5;
					val = val2;
					text = item.RegionId ?? "(none)";
				}
				if (num5 <= 2f)
				{
					num3++;
				}
				if (num5 <= 5f)
				{
					num4++;
				}
				if (Mathf.Abs(val2.y - pos.y) <= 2f && Mathf.Sqrt((val2.x - pos.x) * (val2.x - pos.x) + (val2.z - pos.z) * (val2.z - pos.z)) <= 10f)
				{
					num2++;
				}
			}
			sb.AppendLine($"  closest cached: ({val.x:F2}, {val.y:F2}, {val.z:F2}) dist={num:F2}m region={text}");
			sb.AppendLine($"  within 2m: {num3}    within 5m: {num4}    same-altitude (±2m Y) within 10m XZ: {num2}");
			if (num3 == 0)
			{
				sb.AppendLine("  → RegionBuilder filter rejected this surface (see [Region] triangulation rej_* counters)");
			}
		}

		private static void ReportBakeSources(StringBuilder sb, Vector3 pos)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_00a2: Expected I4, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<NavMeshBuildSource> lastSources = NavMeshBakeManager.LastSources;
			if (lastSources == null || lastSources.Count == 0)
			{
				sb.AppendLine("  No baked sources cached");
				return;
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			float num9 = 2f;
			foreach (NavMeshBuildSource item in lastSources)
			{
				NavMeshBuildSource current = item;
				Matrix4x4 transform = ((NavMeshBuildSource)(ref current)).transform;
				Vector3 val = ((Matrix4x4)(ref transform)).MultiplyPoint3x4(Vector3.zero);
				if (Vector3.Distance(val, pos) > 5f)
				{
					continue;
				}
				num++;
				NavMeshBuildSourceShape shape = ((NavMeshBuildSource)(ref current)).shape;
				switch ((int)shape)
				{
				case 2:
					num2++;
					if (Mathf.Abs(val.y - pos.y) <= num9)
					{
						num8++;
					}
					break;
				case 0:
					num3++;
					break;
				case 3:
					num4++;
					break;
				case 4:
					num5++;
					break;
				case 5:
					num6++;
					break;
				default:
					num7++;
					break;
				}
			}
			sb.AppendLine($"  {num} source(s) within {5f:F0}m " + $"(Mesh={num3} Box={num2} Sphere={num4} Capsule={num5} ModBox={num6} Other={num7})");
			sb.AppendLine($"  Box sources at this altitude (±{num9:F0}m Y): {num8}");
		}

		private static void ReportRawExtracted(StringBuilder sb, Vector3 pos)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			var (array, array2, _) = NavMeshBakeManager.ExtractBakedTriangles();
			if (array == null || array.Length == 0)
			{
				sb.AppendLine("  Extractor produced 0 vertices");
				return;
			}
			int num = array2.Length / 3;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			float num5 = 2f;
			for (int i = 0; i < num; i++)
			{
				Vector3 val = array[array2[i * 3]];
				Vector3 val2 = array[array2[i * 3 + 1]];
				Vector3 val3 = array[array2[i * 3 + 2]];
				Vector3 val4 = (val + val2 + val3) / 3f;
				if (!(Vector3.Distance(val4, pos) > 5f))
				{
					num2++;
					Vector3 val5 = Vector3.Cross(val2 - val, val3 - val);
					if (((Vector3)(ref val5)).normalized.y >= 0.5f)
					{
						num3++;
					}
					if (Mathf.Abs(val4.y - pos.y) <= num5)
					{
						num4++;
					}
				}
			}
			sb.AppendLine($"  total extracted: {num}; within {5f:F0}m: {num2} " + $"(upward-facing: {num3}, at this altitude ±{num5:F0}m: {num4})");
		}

		private static void ReportFilterTrace(StringBuilder sb, Vector3 pos)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			var (array, array2, _) = NavMeshBakeManager.ExtractBakedTriangles();
			if (array == null || array.Length == 0)
			{
				sb.AppendLine("  No extracted triangles");
				return;
			}
			float num = pos.x - 40f;
			float num2 = pos.x + 40f;
			float num3 = pos.z - 40f;
			float num4 = pos.z + 40f;
			List<Vector3> list = VillagerAIManager.GetAllAnchorPositions() ?? new List<Vector3>();
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			int num5 = array2.Length / 3;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			int num12 = 0;
			int num13 = 0;
			int num14 = 0;
			int mask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });
			NavMeshHit val8 = default(NavMeshHit);
			NavMeshHit val9 = default(NavMeshHit);
			NavMeshHit val10 = default(NavMeshHit);
			for (int i = 0; i < num5; i++)
			{
				Vector3 val3 = array[array2[i * 3]];
				Vector3 val4 = array[array2[i * 3 + 1]];
				Vector3 val5 = array[array2[i * 3 + 2]];
				Vector3 val6 = (val3 + val4 + val5) / 3f;
				if (Vector3.Distance(val6, pos) > 3f)
				{
					continue;
				}
				Vector3 val7 = Vector3.Cross(val4 - val3, val5 - val3);
				Vector3 normalized = ((Vector3)(ref val7)).normalized;
				if (normalized.y < 0.5f)
				{
					continue;
				}
				num6++;
				bool flag = val6.x >= num && val6.x <= num2 && val6.z >= num3 && val6.z <= num4;
				if (flag)
				{
					num7++;
				}
				bool flag2 = false;
				foreach (Vector3 item in list)
				{
					float num15 = val6.x - item.x;
					float num16 = val6.z - item.z;
					if (num15 * num15 + num16 * num16 <= 900f)
					{
						flag2 = true;
						break;
					}
				}
				if (flag2)
				{
					num8++;
				}
				bool flag3 = NavMesh.SamplePosition(val6, ref val8, 0.5f, val2) && Vector3.Distance(((NavMeshHit)(ref val8)).position, val6) <= 0.5f;
				bool flag4 = NavMesh.SamplePosition(val6, ref val9, 1f, val2) && Vector3.Distance(((NavMeshHit)(ref val9)).position, val6) <= 1f;
				bool flag5 = NavMesh.SamplePosition(val6, ref val10, 2f, val2) && Vector3.Distance(((NavMeshHit)(ref val10)).position, val6) <= 2f;
				if (flag3)
				{
					num9++;
				}
				if (flag4)
				{
					num10++;
				}
				if (flag5)
				{
					num11++;
				}
				bool flag6 = normalized.y >= 0.891007f;
				if (flag6)
				{
					num12++;
				}
				Vector3 val11 = val6 + Vector3.up * 0.55f;
				Vector3 val12 = val6 + Vector3.up * 1.3499999f;
				bool flag7 = !Physics.CheckCapsule(val11, val12, 0.3f, mask);
				if (flag7)
				{
					num13++;
				}
				if (num14 < 8)
				{
					string text = (flag3 ? $"HIT@{Vector3.Distance(((NavMeshHit)(ref val8)).position, val6):F2}" : "miss");
					string text2 = (flag4 ? $"HIT@{Vector3.Distance(((NavMeshHit)(ref val9)).position, val6):F2}" : "miss");
					string text3 = (flag5 ? $"HIT@{Vector3.Distance(((NavMeshHit)(ref val10)).position, val6):F2}" : "miss");
					sb.AppendLine($"  tri@({val6.x:F2},{val6.y:F2},{val6.z:F2}) " + "bounds=" + (flag ? "Y" : "n") + " dist=" + (flag2 ? "Y" : "n") + " agent[0.5]=" + text + " [1.0]=" + text2 + " [2.0]=" + text3 + " steep=" + (flag6 ? "Y" : "n") + " capsule=" + (flag7 ? "Y" : "BLOCKED"));
					num14++;
				}
			}
			if (num6 == 0)
			{
				sb.AppendLine($"  No upward-facing triangles within {3f:F1}m");
				return;
			}
			sb.AppendLine($"  totals (of {num6}): " + $"bounds={num7} dist={num8} agent[0.5]={num9} agent[1.0]={num10} agent[2.0]={num11} " + $"steep_ok={num12} capsule_ok={num13}");
			sb.AppendLine($"  anchors in scene: {list.Count}");
		}

		private static void ReportRegionGraph(StringBuilder sb, Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00b8: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			RegionGraph regionGraph = VillageRegistry.GraphAt(pos);
			if (regionGraph == null)
			{
				sb.AppendLine("  No RegionGraph available (none built/restored yet)");
				return;
			}
			string text = regionGraph.PointToRegionId(pos);
			sb.AppendLine("  PointToRegionId: " + (text ?? "(unresolved)"));
			if (!string.IsNullOrEmpty(text))
			{
				int num = 0;
				float num2 = 0f;
				float num3 = float.MaxValue;
				float num4 = float.MinValue;
				List<RegionBuilder.CachedTriangle> cachedTriangles = RegionBuilder.CachedTriangles;
				if (cachedTriangles != null)
				{
					foreach (RegionBuilder.CachedTriangle item in cachedTriangles)
					{
						if (!(item.RegionId != text))
						{
							num++;
							float num5 = num2;
							Vector3 val = Vector3.Cross(item.V1 - item.V0, item.V2 - item.V0);
							num2 = num5 + ((Vector3)(ref val)).magnitude * 0.5f;
							float num6 = Mathf.Min(item.V0.y, Mathf.Min(item.V1.y, item.V2.y));
							float num7 = Mathf.Max(item.V0.y, Mathf.Max(item.V1.y, item.V2.y));
							if (num6 < num3)
							{
								num3 = num6;
							}
							if (num7 > num4)
							{
								num4 = num7;
							}
						}
					}
				}
				int num8 = 0;
				IReadOnlyList<RegionLink> linksFromRegion = regionGraph.GetLinksFromRegion(text);
				if (linksFromRegion != null)
				{
					num8 = linksFromRegion.Count;
				}
				SurfaceKind regionKind = regionGraph.GetRegionKind(text);
				sb.AppendLine($"  Resolved region {text}: kind={regionKind}, tris={num}, " + string.Format("area={0:F2}m², Y=[{1}, ", num2, (num > 0) ? num3.ToString("F2") : "?") + string.Format("{0}], links={1}", (num > 0) ? num4.ToString("F2") : "?", num8));
				if (linksFromRegion != null && num8 > 0)
				{
					foreach (RegionLink item2 in linksFromRegion)
					{
						string toRegionId = item2.ToRegionId;
						SurfaceKind regionKind2 = regionGraph.GetRegionKind(toRegionId);
						string text2 = (regionGraph.IsValidRegion(toRegionId) ? "alive" : "DROPPED");
						sb.AppendLine($"    link -> {toRegionId} ({regionKind2}, {item2.LinkType}, {text2}) " + $"at ({item2.PositionEnd.x:F1}, {item2.PositionEnd.y:F1}, {item2.PositionEnd.z:F1})");
					}
				}
			}
			float num9 = float.MaxValue;
			Vector3 val2 = Vector3.zero;
			string text3 = "";
			List<Vector3> allRegionCenters = regionGraph.Diagnostics.GetAllRegionCenters();
			int num10 = 0;
			foreach (Vector3 item3 in allRegionCenters)
			{
				float num11 = Vector3.Distance(item3, pos);
				if (num11 < num9)
				{
					num9 = num11;
					val2 = item3;
					text3 = $"#{num10}";
				}
				num10++;
			}
			if (allRegionCenters.Count == 0)
			{
				sb.AppendLine("  No centroids in graph");
				return;
			}
			sb.AppendLine("  Closest centroid " + text3 + ": " + $"({val2.x:F2}, {val2.y:F2}, {val2.z:F2}) " + $"dist3d={num9:F2}m " + $"(graph has {regionGraph.RegionCount} regions, {regionGraph.LinkCount} links)");
		}

		private static void ReportFloodReachability(StringBuilder sb, Vector3 pos)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!RubberBandPrune.HasSnapshot || RubberBandPrune.LastOutsideCells == null || RubberBandPrune.LastXzMaxY == null || RubberBandPrune.LastCell <= 0f)
			{
				sb.AppendLine("  No RubberBandPrune snapshot — run vv_repartition first");
				return;
			}
			float lastCell = RubberBandPrune.LastCell;
			int lastPieceMask = RubberBandPrune.LastPieceMask;
			int num = Mathf.FloorToInt(pos.x / lastCell);
			int num2 = Mathf.FloorToInt(pos.z / lastCell);
			long num3 = RubberBandPrune.DiagnoseXzKey(num, num2);
			bool flag = RubberBandPrune.LastOutsideCells.Contains(num3);
			bool flag2 = RubberBandPrune.LastXzMaxY.ContainsKey(num3);
			float num4 = RubberBandPrune.DiagnoseCellY(num, num2);
			sb.AppendLine($"  cell gx={num} gz={num2}  Y={num4:F2}  " + "populated=" + (flag2 ? "yes" : "no") + "  in_outsideCells=" + (flag ? "YES" : "NO"));
			sb.AppendLine($"  bake bounds gx=[{RubberBandPrune.LastGxMin}..{RubberBandPrune.LastGxMax}] " + $"gz=[{RubberBandPrune.LastGzMin}..{RubberBandPrune.LastGzMax}] " + $"cell={lastCell:F2}m  pieceMask=0x{lastPieceMask:X}");
			string[] array = new string[4] { "E ", "W ", "N ", "S " };
			int[] array2 = new int[4] { 1, -1, 0, 0 };
			int[] array3 = new int[4] { 0, 0, 1, -1 };
			string[] array4 = new string[4] { "NE", "NW", "SE", "SW" };
			int[] array5 = new int[4] { 1, -1, 1, -1 };
			int[] array6 = new int[4] { 1, 1, -1, -1 };
			sb.AppendLine("  4-connected neighbors (used by Pass 1):");
			for (int i = 0; i < 4; i++)
			{
				ReportNeighbor(sb, array[i], num, num2, array2[i], array3[i], lastCell, lastPieceMask);
			}
			sb.AppendLine("  8-connected diagonal neighbors (NOT used by Pass 1 today):");
			for (int j = 0; j < 4; j++)
			{
				ReportNeighbor(sb, array4[j], num, num2, array5[j], array6[j], lastCell, lastPieceMask);
			}
		}

		private static void ReportNeighbor(StringBuilder sb, string label, int gx, int gz, int dx, int dz, float cell, int mask)
		{
			int num = gx + dx;
			int num2 = gz + dz;
			long num3 = RubberBandPrune.DiagnoseXzKey(num, num2);
			bool flag = RubberBandPrune.LastOutsideCells.Contains(num3);
			bool flag2 = RubberBandPrune.LastXzMaxY.ContainsKey(num3);
			float yA = RubberBandPrune.DiagnoseCellY(gx, gz);
			float num4 = RubberBandPrune.DiagnoseCellY(num, num2);
			string hitNames;
			bool flag3 = RubberBandPrune.Diagnose(gx, gz, num, num2, yA, num4, cell, mask, out hitNames);
			sb.AppendLine($"    {label} gx={num} gz={num2}  Y={num4:F2}  " + "populated=" + (flag2 ? "y" : "n") + "  outside=" + (flag ? "YES" : "no ") + "  WallBlocks=" + (flag3 ? "TRUE" : "false") + (flag3 ? ("  hits=[" + hitNames + "]") : ""));
		}
	}
	public static class NavMeshBakeManager
	{
		public struct BakeResult
		{
			public bool Success;

			public int SourceCount;

			public int DoorsBlocked;

			public int DoorPiecesDropped;

			public int BedsBlocked;

			public int OutsideCellsBlocked;

			public int OutsideCellsCount;

			public float DurationMs;

			public string FailureReason;

			public int TerrainSourceCount;

			public int PieceSourceCount;

			public float TerrainDurationMs;

			public float PieceDurationMs;
		}

		private const string HolderName = "VV_NavMeshBakeHolder";

		private static NavMeshBakeHolder s_holder;

		private static readonly List<NavMeshBuildSource> s_terrainSources = new List<NavMeshBuildSource>();

		private static readonly List<NavMeshBuildSource> s_pieceSources = new List<NavMeshBuildSource>();

		private static int s_piecePhantomCount;

		private static int s_lastDoorPhantoms;

		private static int s_lastBedPhantoms;

		private static int s_lastOutsidePhantoms;

		private static readonly int s_terrainMask = LayerMask.GetMask(new string[1] { "terrain" });

		private static readonly int s_pieceMask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });

		private const float NavMeshBakeMaxSlopeDegrees = 27f;

		private const float NavMeshBakeMaxClimb = 0.2f;

		private static readonly int s_bodyBlockMask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });

		private static readonly Collider[] s_bodyBlockBuf = (Collider[])(object)new Collider[16];

		private const float SubdivFaceMinNormalY = 0.5f;

		public static IReadOnlyList<NavMeshBuildSource> TerrainSources => s_terrainSources;

		public static IReadOnlyList<NavMeshBuildSource> PieceSources => s_pieceSources;

		public static int PiecePhantomCount => s_piecePhantomCount;

		public static int LastDoorPhantoms => s_lastDoorPhantoms;

		public static int LastBedPhantoms => s_lastBedPhantoms;

		public static int LastOutsidePhantoms => s_lastOutsidePhantoms;

		private static NavMeshBakeHolder Holder
		{
			get
			{
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)s_holder != (Object)null)
				{
					return s_holder;
				}
				GameObject val = GameObject.Find("VV_NavMeshBakeHolder");
				if ((Object)(object)val != (Object)null)
				{
					NavMeshBakeHolder navMeshBakeHolder = val.GetComponent<NavMeshBakeHolder>();
					if ((Object)(object)navMeshBakeHolder == (Object)null)
					{
						MonoBehaviour[] components = val.GetComponents<MonoBehaviour>();
						foreach (MonoBehaviour val2 in components)
						{
							if ((Object)(object)val2 != (Object)null && ((object)val2).GetType().Name == "NavMeshBakeHolder")
							{
								Object.DestroyImmediate((Object)(object)val2);
							}
						}
						navMeshBakeHolder = val.AddComponent<NavMeshBakeHolder>();
					}
					s_holder = navMeshBakeHolder;
					return s_holder;
				}
				GameObject val3 = new GameObject("VV_NavMeshBakeHolder");
				Object.DontDestroyOnLoad((Object)val3);
				((Object)val3).hideFlags = (HideFlags)1;
				s_holder = val3.AddComponent<NavMeshBakeHolder>();
				return s_holder;
			}
		}

		public static bool HasBakedData => Holder.HasAny;

		public static IReadOnlyList<NavMeshBuildSource> LastSources
		{
			get
			{
				List<NavMeshBuildSource> list = new List<NavMeshBuildSource>(s_terrainSources.Count + s_pieceSources.Count);
				list.AddRange(s_terrainSources);
				list.AddRange(s_pieceSources);
				return list;
			}
		}

		public static BakeResult BakeVillage(Bounds bounds)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			BakeResult result = default(BakeResult);
			Stopwatch stopwatch = Stopwatch.StartNew();
			if (!VillagerAgentType.IsRegistered)
			{
				result.FailureReason = "agent_not_registered";
				stopwatch.Stop();
				result.DurationMs = (float)stopwatch.Elapsed.TotalMilliseconds;
				return result;
			}
			Holder.RemoveAll();
			NavMeshBuildSettings buildSettings = VillagerAgentType.BuildSettings;
			((NavMeshBuildSettings)(ref buildSettings)).agentRadius = ((NavMeshBuildSettings)(ref buildSettings)).agentRadius + 0.025f;
			((NavMeshBuildSettings)(ref buildSettings)).agentSlope = 27f;
			((NavMeshBuildSettings)(ref buildSettings)).agentClimb = 0.2f;
			Stopwatch stopwatch2 = Stopwatch.StartNew();
			List<NavMeshBuildSource> list = new List<NavMeshBuildSource>();
			NavMeshBuilder.CollectSources(bounds, s_terrainMask, (NavMeshCollectGeometry)1, 0, new List<NavMeshBuildMarkup>(), list);
			s_terrainSources.Clear();
			s_terrainSources.AddRange(list);
			result.TerrainSourceCount = list.Count;
			stopwatch2.Stop();
			result.TerrainDurationMs = (float)stopwatch2.Elapsed.TotalMilliseconds;
			Stopwatch stopwatch3 = Stopwatch.StartNew();
			List<NavMeshBuildSource> list2 = new List<NavMeshBuildSource>();
			NavMeshBuilder.CollectSources(bounds, s_pieceMask, (NavMeshCollectGeometry)1, 0, new List<NavMeshBuildMarkup>(), list2);
			int doorPiecesDropped = list2.RemoveAll((NavMeshBuildSource s) => (Object)(object)((NavMeshBuildSource)(ref s)).component != (Object)null && (Object)(object)((NavMeshBuildSource)(ref s)).component.GetComponentInParent<Door>() != (Object)null);
			result.DoorPiecesDropped = doorPiecesDropped;
			result.DoorsBlocked = 0;
			list2.RemoveAll((NavMeshBuildSource s) => (Object)(object)((NavMeshBuildSource)(ref s)).component != (Object)null && (Object)(object)((NavMeshBuildSource)(ref s)).component.GetComponentInParent<Bed>() != (Object)null);
			int num = (result.BedsBlocked = AddBedBlockers(list2, bounds));
			HashSet<long> hashSet = RubberBandPrune.ComputeOutsideCellsForBake(bounds);
			int num2 = (result.OutsideCellsBlocked = AddOutsideCellBlockers(list2, hashSet, bounds));
			result.OutsideCellsCount = hashSet.Count;
			s_pieceSources.Clear();
			s_pieceSources.AddRange(list2);
			s_piecePhantomCount = num + num2;
			s_lastDoorPhantoms = 0;
			s_lastBedPhantoms = num;
			s_lastOutsidePhantoms = num2;
			result.PieceSourceCount = list2.Count;
			List<NavMeshBuildSource> list3 = new List<NavMeshBuildSource>(list.Count + list2.Count);
			list3.AddRange(list);
			list3.AddRange(list2);
			if (list3.Count > 0)
			{
				NavMeshData val = NavMeshBuilder.BuildNavMeshData(buildSettings, list3, bounds, Vector3.zero, Quaternion.identity);
				if ((Object)(object)val != (Object)null)
				{
					Holder.SetCombined(NavMesh.AddNavMeshData(val));
				}
			}
			stopwatch3.Stop();
			result.PieceDurationMs = (float)stopwatch3.Elapsed.TotalMilliseconds;
			result.SourceCount = result.TerrainSourceCount + result.PieceSourceCount;
			if (result.SourceCount == 0)
			{
				result.FailureReason = "no_sources_collected";
				stopwatch.Stop();
				result.DurationMs = (float)stopwatch.Elapsed.TotalMilliseconds;
				return result;
			}
			result.Success = Holder.HasAny;
			if (!result.Success)
			{
				result.FailureReason = "build_returned_null";
			}
			stopwatch.Stop();
			result.DurationMs = (float)stopwatch.Elapsed.TotalMilliseconds;
			return result;
		}

		public static (Vector3[] vertices, int[] indices, int[] triangleLayers) ExtractBakedTriangles()
		{
			var (array, array2, array3) = ExtractBakedTriangles(SurfaceKind.Terrain);
			var (array4, array5, array6) = ExtractBakedTriangles(SurfaceKind.Piece);
			if (array.Length == 0)
			{
				return (vertices: array4, indices: array5, triangleLayers: array6);
			}
			if (array4.Length == 0)
			{
				return (vertices: array, indices: array2, triangleLayers: array3);
			}
			Vector3[] array7 = (Vector3[])(object)new Vector3[array.Length + array4.Length];
			Array.Copy(array, 0, array7, 0, array.Length);
			Array.Copy(array4, 0, array7, array.Length, array4.Length);
			int[] array8 = new int[array2.Length + array5.Length];
			Array.Copy(array2, 0, array8, 0, array2.Length);
			for (int i = 0; i < array5.Length; i++)
			{
				array8[array2.Length + i] = array5[i] + array.Length;
			}
			int[] array9 = new int[array3.Length + array6.Length];
			Array.Copy(array3, 0, array9, 0, array3.Length);
			Array.Copy(array6, 0, array9, array3.Length, array6.Length);
			return (vertices: array7, indices: array8, triangleLayers: array9);
		}

		public static (Vector3[] vertices, int[] indices, int[] triangleLayers) ExtractBakedTriangles(SurfaceKind kind)
		{
			return ExtractBakedTriangles(kind, float.NegativeInfinity, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity);
		}

		public static (Vector3[] vertices, int[] indices, int[] triangleLayers) ExtractBakedTriangles(SurfaceKind kind, float minX, float minZ, float maxX, float maxZ)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_00bf: Invalid comparison between Unknown and I4
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			List<NavMeshBuildSource> list = ((kind == SurfaceKind.Terrain) ? s_terrainSources : s_pieceSources);
			int num = ((kind == SurfaceKind.Piece) ? s_piecePhantomCount : 0);
			if (list.Count == 0)
			{
				return (vertices: Array.Empty<Vector3>(), indices: Array.Empty<int>(), triangleLayers: Array.Empty<int>());
			}
			List<Vector3> list2 = new List<Vector3>(list.Count * 32);
			List<int> list3 = new List<int>(list.Count * 96);
			List<int> list4 = new List<int>(list.Count * 32);
			int num2 = 0;
			int num3 = 0;
			int num4 = list.Count - num;
			for (int i = 0; i < num4; i++)
			{
				NavMeshBuildSource val = list[i];
				int layer = (((Object)(object)((NavMeshBuildSource)(ref val)).component != (Object)null) ? ((NavMeshBuildSource)(ref val)).component.gameObject.layer : (-1));
				NavMeshBuildSourceShape shape = ((NavMeshBuildSource)(ref val)).shape;
				if ((int)shape != 0)
				{
					if ((int)shape == 2)
					{
						AppendBox(list2, list3, list4, layer, ((NavMeshBuildSource)(ref val)).transform, ((NavMeshBuildSource)(ref val)).size, minX, minZ, maxX, maxZ, kind == SurfaceKind.Piece);
					}
					else
					{
						num3++;
					}
					continue;
				}
				Object sourceObject = ((NavMeshBuildSource)(ref val)).sourceObject;
				Mesh val2 = (Mesh)(object)((sourceObject is Mesh) ? sourceObject : null);
				if ((Object)(object)val2 == (Object)null)
				{
					num3++;
				}
				else if (!val2.isReadable)
				{
					num2++;
				}
				else
				{
					AppendMesh(list2, list3, list4, layer, ((NavMeshBuildSource)(ref val)).transform, val2, minX, minZ, maxX, maxZ);
				}
			}
			if (num2 > 0 || num3 > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)($"[NavMeshBake] extract({kind}): {num2} unreadable mesh(es) skipped, " + $"{num3} non-Mesh/Box source(s) skipped"));
				}
			}
			if (kind == SurfaceKind.Terrain)
			{
				WeldCoincidentVertices(list2, list3);
			}
			return (vertices: list2.ToArray(), indices: list3.ToArray(), triangleLayers: list4.ToArray());
		}

		private static void WeldCoincidentVertices(List<Vector3> verts, List<int> idx)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (verts.Count == 0 || idx.Count == 0)
			{
				return;
			}
			Dictionary<long, int> dictionary = new Dictionary<long, int>(verts.Count);
			int[] array = new int[verts.Count];
			for (int i = 0; i < verts.Count; i++)
			{
				Vector3 val = verts[i];
				long num = Mathf.RoundToInt(val.x / 0.05f);
				long num2 = Mathf.RoundToInt(val.y / 0.05f);
				long num3 = Mathf.RoundToInt(val.z / 0.05f);
				long key = (((num + 1048576) & 0x1FFFFF) << 42) | (((num2 + 1048576) & 0x1FFFFF) << 21) | ((num3 + 1048576) & 0x1FFFFF);
				if (dictionary.TryGetValue(key, out var value))
				{
					array[i] = value;
					continue;
				}
				dictionary[key] = i;
				array[i] = i;
			}
			int num4 = 0;
			for (int j = 0; j < idx.Count; j++)
			{
				int num5 = idx[j];
				int num6 = array[num5];
				if (num6 != num5)
				{
					idx[j] = num6;
					num4++;
				}
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[NavMeshBake] terrain weld: {num4} index refs re-pointed across " + $"{verts.Count - dictionary.Count} merged vertex positions " + $"({verts.Count} total verts, {dictionary.Count} unique positions)"));
			}
		}

		private static int AddDoorBlockers(List<NavMeshBuildSource> sources, Bounds bounds)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Door[] array = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Door val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).transform == (Object)null) && ((Bounds)(ref bounds)).Contains(((Component)val).transform.position))
				{
					Matrix4x4 transform = Matrix4x4.TRS(((Component)val).transform.position, ((Component)val).transform.rotation, Vector3.one);
					NavMeshBuildSource item = default(NavMeshBuildSource);
					((NavMeshBuildSource)(ref item)).shape = (NavMeshBuildSourceShape)2;
					((NavMeshBuildSource)(ref item)).size = new Vector3(1.2f, 2f, 0.3f);
					((NavMeshBuildSource)(ref item)).transform = transform;
					((NavMeshBuildSource)(ref item)).area = 1;
					sources.Add(item);
					num++;
				}
			}
			return num;
		}

		internal static bool IsAgentBodyBlocked(Vector3 surfacePos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = surfacePos + Vector3.up * 1f;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(0.9f, 0.3f, 0.9f);
			int num = Physics.OverlapBoxNonAlloc(val, val2, s_bodyBlockBuf, Quaternion.identity, s_bodyBlockMask, (QueryTriggerInteraction)1);
			for (int i = 0; i < num; i++)
			{
				Collider val3 = s_bodyBlockBuf[i];
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)((Component)val3).GetComponentInParent<Bed>() != (Object)null))
				{
					return true;
				}
			}
			return false;
		}

		private static int AddBedBlockers(List<NavMeshBuildSource> sources, Bounds bounds)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a4: 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_00cb: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Bed[] array = Object.FindObjectsByType<Bed>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Bed val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).transform == (Object)null) && ((Bounds)(ref bounds)).Contains(((Component)val).transform.position))
				{
					Collider componentInChildren = ((Component)val).GetComponentInChildren<Collider>();
					if (!((Object)(object)componentInChildren == (Object)null))
					{
						Bounds bounds2 = componentInChildren.bounds;
						float num2 = ((Bounds)(ref bounds2)).min.y - 0.6f;
						float num3 = ((Bounds)(ref bounds2)).max.y + 0.4f;
						NavMeshBuildSource item = default(NavMeshBuildSource);
						((NavMeshBuildSource)(ref item)).shape = (NavMeshBuildSourceShape)5;
						((NavMeshBuildSource)(ref item)).size = new Vector3(((Bounds)(ref bounds2)).size.x + 0.2f, num3 - num2, ((Bounds)(ref bounds2)).size.z + 0.2f);
						((NavMeshBuildSource)(ref item)).transform = Matrix4x4.TRS(new Vector3(((Bounds)(ref bounds2)).center.x, (num2 + num3) * 0.5f, ((Bounds)(ref bounds2)).center.z), Quaternion.identity, Vector3.one);
						((NavMeshBuildSource)(ref item)).area = 1;
						sources.Add(item);
						num++;
					}
				}
			}
			return num;
		}

		private static int AddOutsideCellBlockers(List<NavMeshBuildSource> sources, HashSet<long> outsideCells, Bounds bounds)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if (outsideCells == null || outsideCells.Count == 0)
			{
				return 0;
			}
			float num = 1f;
			float num2 = ((Bounds)(ref bounds)).size.y + 4f;
			float y = ((Bounds)(ref bounds)).center.y;
			List<RubberBandPrune.CellRect> list = RubberBandPrune.DecomposeToRectangles(outsideCells);
			foreach (RubberBandPrune.CellRect item2 in list)
			{
				float num3 = (float)(item2.Gx1 - item2.Gx0 + 1) * num;
				float num4 = (float)(item2.Gz1 - item2.Gz0 + 1) * num;
				float num5 = (float)(item2.Gx0 + item2.Gx1 + 1) * 0.5f * num;
				float num6 = (float)(item2.Gz0 + item2.Gz1 + 1) * 0.5f * num;
				NavMeshBuildSource item = default(NavMeshBuildSource);
				((NavMeshBuildSource)(ref item)).shape = (NavMeshBuildSourceShape)5;
				((NavMeshBuildSource)(ref item)).size = new Vector3(num3 + 0.4f, num2, num4 + 0.4f);
				((NavMeshBuildSource)(ref item)).transform = Matrix4x4.TRS(new Vector3(num5, y, num6), Quaternion.identity, Vector3.one);
				((NavMeshBuildSource)(ref item)).area = 1;
				sources.Add(item);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[NavMeshBake] OutsideCellBlockers: {outsideCells.Count} cells -> " + $"{list.Count} ModifierBox rectangles"));
			}
			return list.Count;
		}

		private static void AppendMesh(List<Vector3> verts, List<int> idx, List<int> triLayers, int layer, Matrix4x4 t, Mesh mesh, float minX, float minZ, float maxX, float maxZ)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] vertices;
			int[] triangles;
			try
			{
				vertices = mesh.vertices;
				triangles = mesh.triangles;
			}
			catch
			{
				return;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[vertices.Length];
			for (int i = 0; i < vertices.Length; i++)
			{
				array[i] = ((Matrix4x4)(ref t)).MultiplyPoint3x4(vertices[i]);
			}
			int[] array2 = new int[vertices.Length];
			for (int j = 0; j < array2.Length; j++)
			{
				array2[j] = -1;
			}
			for (int k = 0; k < triangles.Length; k += 3)
			{
				int num = triangles[k];
				int num2 = triangles[k + 1];
				int num3 = triangles[k + 2];
				Vector3 val = array[num];
				Vector3 val2 = array[num2];
				Vector3 val3 = array[num3];
				float num4 = (val.x + val2.x + val3.x) * (1f / 3f);
				float num5 = (val.z + val2.z + val3.z) * (1f / 3f);
				if (!(num4 < minX) && !(num4 > maxX) && !(num5 < minZ) && !(num5 > maxZ))
				{
					if (array2[num] < 0)
					{
						array2[num] = verts.Count;
						verts.Add(val);
					}
					if (array2[num2] < 0)
					{
						array2[num2] = verts.Count;
						verts.Add(val2);
					}
					if (array2[num3] < 0)
					{
						array2[num3] = verts.Count;
						verts.Add(val3);
					}
					idx.Add(array2[num]);
					idx.Add(array2[num2]);
					idx.Add(array2[num3]);
					triLayers.Add(layer);
				}
			}
		}

		private static void AppendBox(List<Vector3> verts, List<int> idx, List<int> triLayers, int layer, Matrix4x4 t, Vector3 size, float minX, float minZ, float maxX, float maxZ, bool subdivide)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Matrix4x4)(ref t)).MultiplyPoint3x4(Vector3.zero);
			if (!(val.x < minX) && !(val.x > maxX) && !(val.z < minZ) && !(val.z > maxZ))
			{
				Vector3 val2 = size * 0.5f;
				Vector3 uLocal = default(Vector3);
				((Vector3)(ref uLocal))..ctor(2f * val2.x, 0f, 0f);
				Vector3 vLocal = default(Vector3);
				((Vector3)(ref vLocal))..ctor(0f, 2f * val2.y, 0f);
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(0f, 0f, 2f * val2.z);
				AppendBoxFace(verts, idx, triLayers, layer, t, new Vector3(0f - val2.x, val2.y, 0f - val2.z), uLocal, val3, Vector3.up, subdivide);
				AppendBoxFace(verts, idx, triLayers, layer, t, new Vector3(0f - val2.x, 0f - val2.y, 0f - val2.z), uLocal, val3, Vector3.down, subdivide);
				AppendBoxFace(verts, idx, triLayers, layer, t, new Vector3(0f - val2.x, 0f - val2.y, val2.z), uLocal, vLocal, Vector3.forward, subdivide);
				AppendBoxFace(verts, idx, triLayers, layer, t, new Vector3(0f - val2.x, 0f - val2.y, 0f - val2.z), uLocal, vLocal, Vector3.back, subdivide);
				AppendBoxFace(verts, idx, triLayers, layer, t, new Vector3(val2.x, 0f - val2.y, 0f - val2.z), val3, vLocal, Vector3.right, subdivide);
				AppendBoxFace(verts, idx, triLayers, layer, t, new Vector3(0f - val2.x, 0f - val2.y, 0f - val2.z), val3, vLocal, Vector3.left, subdivide);
			}
		}

		private static void AppendBoxFace(List<Vector3> verts, List<int> idx, List<int> triLayers, int layer, Matrix4x4 t, Vector3 originLocal, Vector3 uLocal, Vector3 vLocal, Vector3 axisLocal, bool subdivide)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Matrix4x4)(ref t)).MultiplyVector(axisLocal);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			int num = 1;
			int num2 = 1;
			if (subdivide && normalized.y >= 0.5f)
			{
				float num3 = 1f;
				val = ((Matrix4x4)(ref t)).MultiplyVector(uLocal);
				float magnitude = ((Vector3)(ref val)).magnitude;
				val = ((Matrix4x4)(ref t)).MultiplyVector(vLocal);
				float magnitude2 = ((Vector3)(ref val)).magnitude;
				num = Mathf.Max(1, Mathf.CeilToInt(magnitude / num3));
				num2 = Mathf.Max(1, Mathf.CeilToInt(magnitude2 / num3));
			}
			int count = verts.Count;
			for (int i = 0; i <= num2; i++)
			{
				float num4 = (float)i / (float)num2;
				for (int j = 0; j <= num; j++)
				{
					float num5 = (float)j / (float)num;
					verts.Add(((Matrix4x4)(ref t)).MultiplyPoint3x4(originLocal + uLocal * num5 + vLocal * num4));
				}
			}
			int num6 = num + 1;
			for (int k = 0; k < num2; k++)
			{
				for (int l = 0; l < num; l++)
				{
					int num7 = count + k * num6 + l;
					int num8 = num7 + 1;
					int num9 = num7 + num6;
					int num10 = num9 + 1;
					if (Vector3.Dot(Vector3.Cross(verts[num8] - verts[num7], verts[num10] - verts[num7]), normalized) >= 0f)
					{
						idx.Add(num7);
						idx.Add(num8);
						idx.Add(num10);
						idx.Add(num7);
						idx.Add(num10);
						idx.Add(num9);
					}
					else
					{
						idx.Add(num7);
						idx.Add(num10);
						idx.Add(num8);
						idx.Add(num7);
						idx.Add(num9);
						idx.Add(num10);
					}
					triLayers.Add(layer);
					triLayers.Add(layer);
				}
			}
		}

		[RegisterCleanup]
		public static void Clear()
		{
			Holder.RemoveAll();
			s_terrainSources.Clear();
			s_pieceSources.Clear();
			s_piecePhantomCount = 0;
			s_lastDoorPhantoms = 0;
			s_lastBedPhantoms = 0;
			s_lastOutsidePhantoms = 0;
		}
	}
	internal class NavMeshBakeHolder : MonoBehaviour
	{
		private NavMeshDataInstance m_combined;

		internal bool HasAny => ((NavMeshDataInstance)(ref m_combined)).valid;

		private void OnDestroy()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (((NavMeshDataInstance)(ref m_combined)).valid)
			{
				((NavMeshDataInstance)(ref m_combined)).Remove();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[NavMeshBakeHolder] OnDestroy: removed orphaned NavMesh instance");
				}
			}
			m_combined = default(NavMeshDataInstance);
		}

		internal void SetCombined(NavMeshDataInstance instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			RemoveAll();
			m_combined = instance;
		}

		internal void RemoveAll()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (((NavMeshDataInstance)(ref m_combined)).valid)
			{
				((NavMeshDataInstance)(ref m_combined)).Remove();
			}
			m_combined = default(NavMeshDataInstance);
		}
	}
	internal static class PlayerAvoidanceObstacle
	{
		private const float Radius = 0.5f;

		private const float Height = 1.8f;

		private static NavMeshObstacle s_obstacle;

		private static Player s_player;

		internal static void Tick()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				s_obstacle = null;
				s_player = null;
				return;
			}
			if ((Object)(object)s_obstacle == (Object)null || (Object)(object)s_player != (Object)(object)localPlayer)
			{
				s_player = localPlayer;
				s_obstacle = ((Component)localPlayer).GetComponent<NavMeshObstacle>() ?? ((Component)localPlayer).gameObject.AddComponent<NavMeshObstacle>();
				s_obstacle.carving = false;
				s_obstacle.shape = (NavMeshObstacleShape)0;
				s_obstacle.radius = 0.5f;
				s_obstacle.height = 1.8f;
				s_obstacle.center = new Vector3(0f, 0.9f, 0f);
			}
			Vector3 velocity = ((Character)localPlayer).GetVelocity();
			velocity.y = 0f;
			s_obstacle.velocity = velocity;
		}
	}
	internal static class RegionBuilder
	{
		internal struct CachedTriangle
		{
			public Vector3 V0;

			public Vector3 V1;

			public Vector3 V2;

			public string RegionId;

			public SurfaceKind Kind;

			public int Layer;
		}

		internal struct BuildResult
		{
			public HashSet<string> RegionIds;

			public Dictionary<string, Vector3> Centroids;

			public List<RegionLink> Links;

			public Dictionary<long, string> LookupGrid;

			public List<(string id, Vector3 center, Vector3 outDir)> BoundaryCells;

			public List<CachedTriangle> Triangles;

			public SurfaceKind Kind;

			public Dictionary<string, HashSet<string>> Adjacency;

			public Dictionary<string, HashSet<long>> RegionVertexPositions;

			public Dictionary<string, Bounds> RegionBounds;

			public Dictionary<string, List<Vector3>> RegionVertexList;
		}

		private const float SubdivCellSize = 3f;

		private const float HeightBandSize = 2f;

		private const float AgentFilterRadius = 0.5f;

		private const float MaxBelowTerrain = 1.5f;

		private const float MinRegionArea = 0.25f;

		private const float MinCentroidEdgeDist = 0f;

		private const float CoplanarMergeMaxDeltaY = 1.5f;

		private const float EnclosurePlaneDeltaY = 0.2f;

		private const float EnclosureMaxBelow = 0.5f;

		private const float MinWalkableNormalY = 0.891007f;

		private const float CapsuleRadius = 0.2f;

		private const float CapsuleHeight = 1.4f;

		private const float CapsuleLift = 0.25f;

		private const float PieceWaistProbeLift = 1f;

		private const float PieceWaistProbeRadius = 0.1f;

		private const float TerrainIsolatedMaxArea = 16f;

		private static readonly int s_blockMask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });

		internal const float QuantumStep = 0.25f;

		internal static List<CachedTriangle> CachedTriangles { get; set; } = new List<CachedTriangle>();

		[RegisterCleanup]
		public static void ClearCachedState()
		{
			CachedTriangles.Clear();
		}

		internal static void CombineTerrainAndPiece(BuildResult terrainResult, BuildResult pieceResult, out HashSet<string> combinedRegionIds, out Dictionary<string, Vector3> combinedCentroids, out List<RegionLink> combinedLinks, out Dictionary<long, string> combinedLookup, out List<(string, Vector3, Vector3)> combinedBoundary, out List<CachedTriangle> combinedTriangles, out Dictionary<string, SurfaceKind> kindMap)
		{
			//IL_004a: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: 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_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_051f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0600: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: Unknown result type (might be due to invalid IL or missing references)
			combinedRegionIds = new HashSet<string>(terrainResult.RegionIds);
			combinedRegionIds.UnionWith(pieceResult.RegionIds);
			combinedCentroids = new Dictionary<string, Vector3>(terrainResult.Centroids);
			foreach (KeyValuePair<string, Vector3> centroid in pieceResult.Centroids)
			{
				combinedCentroids[centroid.Key] = centroid.Value;
			}
			combinedLinks = new List<RegionLink>(terrainResult.Links.Count + pieceResult.Links.Count);
			combinedLinks.AddRange(terrainResult.Links);
			combinedLinks.AddRange(pieceResult.Links);
			combinedLookup = new Dictionary<long, string>(terrainResult.LookupGrid);
			foreach (KeyValuePair<long, string> item2 in pieceResult.LookupGrid)
			{
				combinedLookup[item2.Key] = item2.Value;
			}
			float num = 1f;
			Dictionary<long, List<float>> pieceYsByXz = new Dictionary<long, List<float>>();
			foreach (CachedTriangle triangle in pieceResult.Triangles)
			{
				Vector3 v = triangle.V0;
				Vector3 v2 = triangle.V1;
				Vector3 v3 = triangle.V2;
				float num2 = Mathf.Min(v.x, Mathf.Min(v2.x, v3.x));
				float num3 = Mathf.Max(v.x, Mathf.Max(v2.x, v3.x));
				float num4 = Mathf.Min(v.z, Mathf.Min(v2.z, v3.z));
				float num5 = Mathf.Max(v.z, Mathf.Max(v2.z, v3.z));
				int num6 = Mathf.FloorToInt(num2 / num);
				int num7 = Mathf.FloorToInt(num3 / num);
				int num8 = Mathf.FloorToInt(num4 / num);
				int num9 = Mathf.FloorToInt(num5 / num);
				for (int i = num6; i <= num7; i++)
				{
					for (int j = num8; j <= num9; j++)
					{
						float px = ((float)i + 0.5f) * num;
						float pz = ((float)j + 0.5f) * num;
						if (PointInTri2D(px, pz, v.x, v.z, v2.x, v2.z, v3.x, v3.z))
						{
							float item = InterpHeight(px, pz, v, v2, v3);
							long key = (long)i * 1000003L + j;
							if (!pieceYsByXz.TryGetValue(key, out var value))
							{
								value = (pieceYsByXz[key] = new List<float>());
							}
							value.Add(item);
						}
					}
				}
			}
			List<long> list2 = new List<long>();
			bool flag = (Object)(object)ZoneSystem.instance != (Object)null;
			foreach (KeyValuePair<long, string> item3 in terrainResult.LookupGrid)
			{
				RegionGraph.UnpackLookup(item3.Key, out var gx, out var gz, out var _);
				float num10 = ((float)gx + 0.5f) * num;
				float num11 = ((float)gz + 0.5f) * num;
				float terrainYAtCell = (flag ? ZoneSystem.instance.GetGroundHeight(new Vector3(num10, 0f, num11)) : 0f);
				if (IsTerrainFlushWithPieceAtCell(gx, gz, terrainYAtCell))
				{
					list2.Add(item3.Key);
				}
			}
			HashSet<string> regionIds = terrainResult.RegionIds;
			foreach (long item4 in list2)
			{
				if (combinedLookup.TryGetValue(item4, out var value2) && regionIds.Contains(value2))
				{
					combinedLookup.Remove(item4);
				}
			}
			combinedBoundary = new List<(string, Vector3, Vector3)>(terrainResult.BoundaryCells.Count + pieceResult.BoundaryCells.Count);
			combinedBoundary.AddRange(terrainResult.BoundaryCells);
			combinedBoundary.AddRange(pieceResult.BoundaryCells);
			kindMap = new Dictionary<string, SurfaceKind>(combinedRegionIds.Count);
			foreach (string regionId in terrainResult.RegionIds)
			{
				kindMap[regionId] = SurfaceKind.Terrain;
			}
			foreach (string regionId2 in pieceResult.RegionIds)
			{
				kindMap[regionId2] = SurfaceKind.Piece;
			}
			combinedTriangles = new List<CachedTriangle>(terrainResult.Triangles.Count + pieceResult.Triangles.Count);
			HashSet<string> hashSet = new HashSet<string>();
			int num12 = 0;
			foreach (CachedTriangle triangle2 in terrainResult.Triangles)
			{
				Vector3 v4 = triangle2.V0;
				Vector3 v5 = triangle2.V1;
				Vector3 v6 = triangle2.V2;
				float num13 = Mathf.Min(v4.x, Mathf.Min(v5.x, v6.x));
				float num14 = Mathf.Max(v4.x, Mathf.Max(v5.x, v6.x));
				float num15 = Mathf.Min(v4.z, Mathf.Min(v5.z, v6.z));
				float num16 = Mathf.Max(v4.z, Mathf.Max(v5.z, v6.z));
				int num17 = Mathf.FloorToInt(num13 / num);
				int num18 = Mathf.FloorToInt(num14 / num);
				int num19 = Mathf.FloorToInt(num15 / num);
				int num20 = Mathf.FloorToInt(num16 / num);
				bool flag2 = false;
				bool flag3 = false;
				for (int k = num17; k <= num18; k++)
				{
					if (flag2)
					{
						break;
					}
					for (int l = num19; l <= num20; l++)
					{
						if (flag2)
						{
							break;
						}
						float px2 = ((float)k + 0.5f) * num;
						float pz2 = ((float)l + 0.5f) * num;
						if (PointInTri2D(px2, pz2, v4.x, v4.z, v5.x, v5.z, v6.x, v6.z))
						{
							flag3 = true;
							float terrainYAtCell2 = InterpHeight(px2, pz2, v4, v5, v6);
							if (!IsTerrainFlushWithPieceAtCell(k, l, terrainYAtCell2))
							{
								flag2 = true;
							}
						}
					}
				}
				if (flag3 && !flag2)
				{
					num12++;
					continue;
				}
				combinedTriangles.Add(triangle2);
				if (!string.IsNullOrEmpty(triangle2.RegionId))
				{
					hashSet.Add(triangle2.RegionId);
				}
			}
			combinedTriangles.AddRange(pieceResult.Triangles);
			CachedTriangles = combinedTriangles;
			int num21 = 0;
			int num22 = 0;
			HashSet<string> hashSet2 = new HashSet<string>();
			foreach (string regionId3 in terrainResult.RegionIds)
			{
				if (!hashSet.Contains(regionId3))
				{
					hashSet2.Add(regionId3);
				}
			}
			if (hashSet2.Count > 0)
			{
				num21 = hashSet2.Count;
				foreach (string item5 in hashSet2)
				{
					combinedRegionIds.Remove(item5);
					combinedCentroids.Remove(item5);
					kindMap.Remove(item5);
				}
				for (int num23 = combinedLinks.Count - 1; num23 >= 0; num23--)
				{
					RegionLink regionLink = combinedLinks[num23];
					if (hashSet2.Contains(regionLink.FromRegionId) || hashSet2.Contains(regionLink.ToRegionId))
					{
						combinedLinks.RemoveAt(num23);
						num22++;
					}
				}
				for (int num24 = combinedBoundary.Count - 1; num24 >= 0; num24--)
				{
					if (hashSet2.Contains(combinedBoundary[num24].Item1))
					{
						combinedBoundary.RemoveAt(num24);
					}
				}
			}
			DebugLog.Event("RegionPartition", "shadow_suppression", ("terrain_cells", terrainResult.LookupGrid.Count), ("piece_cells", pieceResult.LookupGrid.Count), ("shadowed_cells_dropped", list2.Count), ("shadowed_tris_dropped", num12), ("cascaded_regions_dropped", num21), ("cascaded_links_dropped", num22), ("combined_cells", combinedLookup.Count));
			bool IsTerrainFlushWithPieceAtCell(int num25, int num26, float num27)
			{
				long key2 = (long)num25 * 1000003L + num26;
				if (!pieceYsByXz.TryGetValue(key2, out var value3))
				{
					return false;
				}
				for (int m = 0; m < value3.Count; m++)
				{
					if (Mathf.Abs(value3[m] - num27) < 0.3f)
					{
						return true;
					}
				}
				return false;
			}
		}

		internal static BuildResult BuildFromTriangulation(SurfaceKind kind, float minX, float minZ, float maxX, float maxZ, List<Vector3> anchors)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: 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)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: 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_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: 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_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07da: Unknown result type (might be due to invalid IL or missing references)
			//IL_090b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0910: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_092e: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_094c: Unknown result type (might be due to invalid IL or missing references)
			//IL_095f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0965: Unknown result type (might be due to invalid IL or missing references)
			//IL_096c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0971: Unknown result type (might be due to invalid IL or missing references)
			//IL_0976: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_09af: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c97: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f80: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f85: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f91: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fa4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fa6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0faf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ff0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ff7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ffe: Unknown result type (might be due to invalid IL or missing references)
			//IL_1011: Unknown result type (might be due to invalid IL or missing references)
			//IL_1018: Unknown result type (might be due to invalid IL or missing references)
			//IL_101f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1110: Unknown result type (might be due to invalid IL or missing references)
			//IL_1121: Unknown result type (might be due to invalid IL or missing references)
			//IL_1132: Unknown result type (might be due to invalid IL or missing references)
			//IL_1150: Unknown result type (might be due to invalid IL or missing references)
			//IL_1161: Unknown result type (might be due to invalid IL or missing references)
			//IL_1172: Unknown result type (might be due to invalid IL or missing references)
			//IL_1190: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_11b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1046: Unknown result type (might be due to invalid IL or missing references)
			//IL_1048: Unknown result type (might be due to invalid IL or missing references)
			//IL_104f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1051: Unknown result type (might be due to invalid IL or missing references)
			//IL_105a: Unknown result type (might be due to invalid IL or missing references)
			//IL_105c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e25: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e32: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e46: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e4b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e58: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eab: Unknown result type (might be due to invalid IL or missing references)
			BuildResult result = new BuildResult
			{
				RegionIds = new HashSet<string>(),
				Centroids = new Dictionary<string, Vector3>(),
				Links = new List<RegionLink>(),
				LookupGrid = new Dictionary<long, string>(),
				BoundaryCells = new List<(string, Vector3, Vector3)>(),
				Triangles = new List<CachedTriangle>(),
				Kind = kind,
				Adjacency = new Dictionary<string, HashSet<string>>(),
				RegionVertexPositions = new Dictionary<string, HashSet<long>>(),
				RegionBounds = new Dictionary<string, Bounds>(),
				RegionVertexList = new Dictionary<string, List<Vector3>>()
			};
			if (anchors == null || anchors.Count == 0)
			{
				return result;
			}
			int agentTypeID = (VillagerAgentType.IsRegistered ? VillagerAgentType.UnityAgentTypeID : VillagerAgentType.ResolveValheimHumanoidAgentTypeID());
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = agentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			var (array, array2, array3) = NavMeshBakeManager.ExtractBakedTriangles(kind, minX, minZ, maxX, maxZ);
			if (array == null || array2 == null || array2.Length < 3)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"[Region] No baked sources to extract triangles from (kind={kind}) — has NavMeshBakeManager.BakeVillage run?");
				}
				return result;
			}
			int num = array2.Length / 3;
			List<int> list = new List<int>();
			Vector3[] array4 = (Vector3[])(object)new Vector3[num];
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			NavMeshHit val10 = default(NavMeshHit);
			for (int i = 0; i < num; i++)
			{
				Vector3 val3 = array[array2[i * 3]];
				Vector3 val4 = array[array2[i * 3 + 1]];
				Vector3 val5 = array[array2[i * 3 + 2]];
				Vector3 val6 = (array4[i] = (val3 + val4 + val5) / 3f);
				Vector3 val7 = Vector3.Cross(val4 - val3, val5 - val3);
				Vector3 normalized = ((Vector3)(ref val7)).normalized;
				if (normalized.y < 0.5f)
				{
					num2++;
					continue;
				}
				if (normalized.y < 0.891007f)
				{
					num6++;
					continue;
				}
				if (val6.x < minX || val6.x > maxX || val6.z < minZ || val6.z > maxZ)
				{
					num3++;
					continue;
				}
				if (kind == SurfaceKind.Terrain)
				{
					Vector3 val8 = val6 + Vector3.up * 0.45f;
					Vector3 val9 = val6 + Vector3.up * 1.4499999f;
					if (Physics.CheckCapsule(val8, val9, 0.2f, s_blockMask))
					{
						num7++;
						continue;
					}
				}
				else if (Physics.CheckSphere(val6 + Vector3.up * 1f, 0.1f, s_blockMask, (QueryTriggerInteraction)1))
				{
					num7++;
					continue;
				}
				if (!NavMesh.SamplePosition(val6, ref val10, 0.5f, val2) || Vector3.Distance(((NavMeshHit)(ref val10)).position, val6) > 0.5f)
				{
					num4++;
				}
				else if (IsAnyVertexBelowTerrain(val3, val4, val5))
				{
					num5++;
				}
				else
				{
					list.Add(i);
				}
			}
			List<int> list2 = new List<int>(list.Count);
			HashSet<(int, int, int)> hashSet = new HashSet<(int, int, int)>();
			foreach (int item3 in list)
			{
				Vector3 val11 = array4[item3];
				(int, int, int) item = (Mathf.RoundToInt(val11.x * 100f), Mathf.RoundToInt(val11.y * 100f), Mathf.RoundToInt(val11.z * 100f));
				if (hashSet.Add(item))
				{
					list2.Add(item3);
				}
			}
			int num8 = list.Count - list2.Count;
			DebugLog.Event("Region", "triangulation", ("kind", kind), ("total", num), ("filtered", list.Count), ("accepted", list2.Count), ("rej_normal", num2), ("rej_bounds", num3), ("rej_agent", num4), ("rej_terrain", num5), ("rej_steep", num6), ("rej_blocked", num7), ("rej_dedup", num8));
			if (list2.Count == 0)
			{
				return result;
			}
			Dictionary<long, List<int>> dictionary = new Dictionary<long, List<int>>();
			foreach (int item4 in list2)
			{
				int num9 = array2[item4 * 3];
				int num10 = array2[item4 * 3 + 1];
				int num11 = array2[item4 * 3 + 2];
				AddEdge(dictionary, num9, num10, item4);
				AddEdge(dictionary, num10, num11, item4);
				AddEdge(dictionary, num11, num9, item4);
			}
			int num12 = 0;
			if (kind == SurfaceKind.Terrain)
			{
				List<long> list3 = new List<long>();
				foreach (KeyValuePair<long, List<int>> item5 in dictionary)
				{
					long key = item5.Key;
					int num13 = (int)(key >> 32);
					int num14 = (int)(key & 0xFFFFFFFFu);
					Vector3 val12 = (array[num13] + array[num14]) * 0.5f;
					Vector3 val13 = val12 + Vector3.up * 0.45f;
					Vector3 val14 = val12 + Vector3.up * 1.4499999f;
					if (Physics.CheckCapsule(val13, val14, 0.2f, s_blockMask))
					{
						list3.Add(key);
					}
				}
				foreach (long item6 in list3)
				{
					dictionary.Remove(item6);
				}
				num12 = list3.Count;
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)($"[Region] Edge-midpoint capsule break (kind={kind}): " + $"removed {num12}/{num12 + dictionary.Count} edges " + $"({100f * (float)num12 / (float)Mathf.Max(1, num12 + dictionary.Count):F1}%)"));
				}
			}
			int[] array5 = new int[num];
			int[] rank = new int[num];
			foreach (int item7 in list2)
			{
				array5[item7] = item7;
			}
			foreach (List<int> value15 in dictionary.Values)
			{
				for (int j = 0; j < value15.Count; j++)
				{
					for (int k = j + 1; k < value15.Count; k++)
					{
						Union(array5, rank, value15[j], value15[k]);
					}
				}
			}
			Dictionary<long, List<int>> dictionary2 = new Dictionary<long, List<int>>();
			foreach (int item8 in list2)
			{
				int root = Find(array5, item8);
				Vector3 val15 = array4[item8];
				int gx = Mathf.FloorToInt(val15.x / 3f);
				int gz = Mathf.FloorToInt(val15.z / 3f);
				int hb = Mathf.FloorToInt(val15.y / 2f);
				long key2 = PackGroup(root, gx, gz, hb);
				if (!dictionary2.TryGetValue(key2, out var value))
				{
					value = (dictionary2[key2] = new List<int>());
				}
				value.Add(item8);
			}
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)$"[Region] Components → {dictionary2.Count} regions (kind={kind}, subdiv {3f}m)");
			}
			int num15 = 0;
			string arg = ((kind == SurfaceKind.Terrain) ? "t" : "p");
			Dictionary<int, string> dictionary3 = new Dictionary<int, string>();
			Dictionary<string, int> dictionary4 = new Dictionary<string, int>();
			foreach (KeyValuePair<long, List<int>> item9 in dictionary2)
			{
				string text = $"{arg}{num15++}";
				List<int> value2 = item9.Value;
				if (value2.Count > 0)
				{
					dictionary4[text] = Find(array5, value2[0]);
				}
				float num16 = 0f;
				Vector3 val16 = Vector3.zero;
				foreach (int item10 in value2)
				{
					float num17 = TriArea(array[array2[item10 * 3]], array[array2[item10 * 3 + 1]], array[array2[item10 * 3 + 2]]);
					num16 += num17;
					val16 += array4[item10] * num17;
				}
				Vector3 value3 = ((num16 > 0.001f) ? (val16 / num16) : array4[value2[0]]);
				result.RegionIds.Add(text);
				result.Centroids[text] = value3;
				foreach (int item11 in value2)
				{
					dictionary3[item11] = text;
				}
			}
			MergeCoplanarRegions(list2, array2, array, array4, dictionary3, result, dictionary4);
			PruneSmallRegions(list2, array2, array, dictionary3, result);
			PruneNarrowRegions(list2, array2, array, dictionary3, result, val2);
			PruneEnclosedRegions(list2, array2, array, dictionary3, result);
			if (kind == SurfaceKind.Terrain)
			{
				PruneIsolatedSmallTerrain(list2, array2, array, dictionary, dictionary3, result);
			}
			foreach (string regionId in result.RegionIds)
			{
				result.Adjacency[regionId] = new HashSet<string>();
			}
			foreach (List<int> value16 in dictionary.Values)
			{
				string text2 = null;
				HashSet<string> hashSet2 = null;
				foreach (int item12 in value16)
				{
					if (!dictionary3.TryGetValue(item12, out var value4))
					{
						continue;
					}
					if (text2 == null)
					{
						text2 = value4;
					}
					else if (!(value4 == text2))
					{
						if (hashSet2 == null)
						{
							hashSet2 = new HashSet<string> { text2 };
						}
						hashSet2.Add(value4);
					}
				}
				if (hashSet2 == null)
				{
					continue;
				}
				List<string> list5 = new List<string>(hashSet2);
				for (int l = 0; l < list5.Count; l++)
				{
					for (int m = l + 1; m < list5.Count; m++)
					{
						if (result.Adjacency.TryGetValue(list5[l], out var value5))
						{
							value5.Add(list5[m]);
						}
						if (result.Adjacency.TryGetValue(list5[m], out var value6))
						{
							value6.Add(list5[l]);
						}
					}
				}
			}
			foreach (int item13 in list2)
			{
				if (!dictionary3.TryGetValue(item13, out var value7))
				{
					continue;
				}
				if (!result.RegionVertexPositions.TryGetValue(value7, out var value8))
				{
					value8 = new HashSet<long>();
					result.RegionVertexPositions[value7] = value8;
				}
				for (int n = 0; n < 3; n++)
				{
					Vector3 val17 = array[array2[item13 * 3 + n]];
					value8.Add(PackQuantizedPos(val17));
					if (result.RegionBounds.TryGetValue(value7, out var value9))
					{
						((Bounds)(ref value9)).Encapsulate(val17);
						result.RegionBounds[value7] = value9;
					}
					else
					{
						result.RegionBounds[value7] = new Bounds(val17, Vector3.zero);
					}
					if (!result.RegionVertexList.TryGetValue(value7, out var value10))
					{
						value10 = new List<Vector3>();
						result.RegionVertexList[value7] = value10;
					}
					value10.Add(val17);
				}
			}
			HashSet<string> hashSet3 = new HashSet<string>();
			foreach (KeyValuePair<long, List<int>> item14 in dictionary)
			{
				List<int> value11 = item14.Value;
				for (int num18 = 0; num18 < value11.Count; num18++)
				{
					for (int num19 = num18 + 1; num19 < value11.Count; num19++)
					{
						if (dictionary3.TryGetValue(value11[num18], out var value12) && dictionary3.TryGetValue(value11[num19], out var value13) && !(value12 == value13))
						{
							string item2 = ((string.CompareOrdinal(value12, value13) < 0) ? (value12 + "|" + value13) : (value13 + "|" + value12));
							if (hashSet3.Add(item2))
							{
								int num20 = array2[value11[num18] * 3];
								int num21 = array2[value11[num18] * 3 + 1];
								int num22 = array2[value11[num18] * 3 + 2];
								int num23 = array2[value11[num19] * 3];
								int num24 = array2[value11[num19] * 3 + 1];
								int num25 = array2[value11[num19] * 3 + 2];
								Vector3 positionStart = (array[num20] + array[num21] + array[num22]) / 3f;
								Vector3 positionEnd = (array[num23] + array[num24] + array[num25]) / 3f;
								result.Links.Add(new RegionLink
								{
									FromRegionId = value12,
									ToRegionId = value13,
									LinkType = RegionLinkType.Slope,
									PositionStart = positionStart,
									PositionEnd = positionEnd
								});
							}
						}
					}
				}
			}
			DetectBoundary(dictionary, dictionary3, array2, array, result);
			BuildLookupGrid(list2, array2, array, dictionary3, result);
			List<CachedTriangle> triangles = result.Triangles;
			triangles.Capacity = list2.Count;
			float num26 = float.MaxValue;
			float num27 = float.MinValue;
			float num28 = 0f;
			foreach (int item15 in list2)
			{
				if (dictionary3.TryGetValue(item15, out var value14))
				{
					Vector3 val18 = array[array2[item15 * 3]];
					Vector3 val19 = array[array2[item15 * 3 + 1]];
					Vector3 val20 = array[array2[item15 * 3 + 2]];
					triangles.Add(new CachedTriangle
					{
						V0 = val18,
						V1 = val19,
						V2 = val20,
						RegionId = value14,
						Kind = kind,
						Layer = ((array3 != null && item15 < array3.Length) ? array3[item15] : (-1))
					});
					float num29 = Mathf.Min(val18.y, Mathf.Min(val19.y, val20.y));
					float num30 = Mathf.Max(val18.y, Mathf.Max(val19.y, val20.y));
					if (num29 < num26)
					{
						num26 = num29;
					}
					if (num30 > num27)
					{
						num27 = num30;
					}
					float num31 = Vector3.Distance(val18, val19);
					float num32 = Vector3.Distance(val19, val20);
					float num33 = Vector3.Distance(val20, val18);
					float num34 = Mathf.Max(num31, Mathf.Max(num32, num33));
					if (num34 > num28)
					{
						num28 = num34;
					}
				}
			}
			if (triangles.Count > 0)
			{
				CachedTriangle cachedTriangle = triangles[0];
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogInfo((object)($"[Region] TriCache (kind={kind}): {triangles.Count} tris, " + $"Y range [{num26:F1}, {num27:F1}], max edge {num28:F1}m. " + $"Sample tri: ({cachedTriangle.V0.x:F1},{cachedTriangle.V0.y:F1},{cachedTriangle.V0.z:F1}) " + $"({cachedTriangle.V1.x:F1},{cachedTriangle.V1.y:F1},{cachedTriangle.V1.z:F1}) " + $"({cachedTriangle.V2.x:F1},{cachedTriangle.V2.y:F1},{cachedTriangle.V2.z:F1})"));
				}
			}
			ManualLogSource log5 = Plugin.Log;
			if (log5 != null)
			{
				log5.LogInfo((object)($"[Region] Built {result.RegionIds.Count} regions (kind={kind}), " + $"{result.Links.Count} links, {result.LookupGrid.Count} lookup cells, " + $"{result.BoundaryCells.Count} boundary regions"));
			}
			return result;
		}

		internal static void CollectDoorLinks(RegionGraph graph, float minX, float minZ, float maxX, float maxZ, List<RegionLink> links)
		{
			//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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			Door[] array = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			if (array == null || graph == null)
			{
				return;
			}
			float num = 1.8000001f;
			int num2 = 0;
			Door[] array2 = array;
			foreach (Door val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				if (position.x < minX - 3f || position.x > maxX + 3f || position.z < minZ - 3f || position.z > maxZ + 3f || (Object)(object)((Component)val).GetComponentInParent<Piece>() == (Object)null)
				{
					continue;
				}
				Vector3 forward = ((Component)val).transform.forward;
				forward.y = 0f;
				if (!(((Vector3)(ref forward)).sqrMagnitude < 0.01f))
				{
					((Vector3)(ref forward)).Normalize();
					Vector3 val2 = position - forward * num;
					Vector3 val3 = position + forward * num;
					string text = graph.PointToRegionId(val2);
					string text2 = graph.PointToRegionId(val3);
					if (text != null && text2 != null && !(text == text2))
					{
						num2++;
						links.Add(new RegionLink
						{
							FromRegionId = text,
							ToRegionId = text2,
							LinkType = RegionLinkType.Door,
							PositionStart = val2,
							PositionEnd = val3
						});
					}
				}
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Region] Door links: {num2} added");
			}
		}

		private static void MergeCoplanarRegions(List<int> accepted, int[] idx, Vector3[] verts, Vector3[] triCentroids, Dictionary<int, string> triToRegion, BuildResult result, Dictionary<string, int> regionToComponentRoot)
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, (float, float)> dictionary = new Dictionary<string, (float, float)>();
			foreach (int item in accepted)
			{
				if (triToRegion.TryGetValue(item, out var value))
				{
					float y = verts[idx[item * 3]].y;
					float y2 = verts[idx[item * 3 + 1]].y;
					float y3 = verts[idx[item * 3 + 2]].y;
					float num = Mathf.Min(y, Mathf.Min(y2, y3));
					float num2 = Mathf.Max(y, Mathf.Max(y2, y3));
					if (dictionary.TryGetValue(value, out var value2))
					{
						dictionary[value] = (Mathf.Min(num, value2.Item1), Mathf.Max(num2, value2.Item2));
					}
					else
					{
						dictionary[value] = (num, num2);
					}
				}
			}
			Dictionary<(int, int, int), HashSet<string>> dictionary2 = new Dictionary<(int, int, int), HashSet<string>>();
			foreach (int item2 in accepted)
			{
				if (!triToRegion.TryGetValue(item2, out var value3))
				{
					continue;
				}
				for (int i = 0; i < 3; i++)
				{
					Vector3 val = verts[idx[item2 * 3 + i]];
					(int, int, int) key = (Mathf.RoundToInt(val.x / 0.05f), Mathf.RoundToInt(val.y / 0.05f), Mathf.RoundToInt(val.z / 0.05f));
					if (!dictionary2.TryGetValue(key, out var value4))
					{
						value4 = (dictionary2[key] = new HashSet<string>());
					}
					value4.Add(value3);
				}
			}
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			foreach (string regionId in result.RegionIds)
			{
				dictionary3[regionId] = regionId;
			}
			foreach (HashSet<string> value12 in dictionary2.Values)
			{
				if (value12.Count < 2)
				{
					continue;
				}
				List<string> list = new List<string>(value12);
				for (int j = 0; j < list.Count; j++)
				{
					for (int k = j + 1; k < list.Count; k++)
					{
						string text = FindRoot(dictionary3, list[j]);
						string text2 = FindRoot(dictionary3, list[k]);
						if (!(text == text2) && (result.Kind != SurfaceKind.Terrain || !regionToComponentRoot.TryGetValue(text, out var value5) || !regionToComponentRoot.TryGetValue(text2, out var value6) || value5 == value6) && dictionary.TryGetValue(text, out var value7) && dictionary.TryGetValue(text2, out var value8))
						{
							float num3 = Mathf.Min(value7.Item1, value8.Item1);
							float num4 = Mathf.Max(value7.Item2, value8.Item2);
							if (!(num4 - num3 > 1.5f))
							{
								dictionary3[text2] = text;
								dictionary[text] = (num3, num4);
							}
						}
					}
				}
			}
			int num5 = 0;
			foreach (int item3 in accepted)
			{
				if (triToRegion.TryGetValue(item3, out var value9))
				{
					string text3 = FindRoot(dictionary3, value9);
					if (text3 != value9)
					{
						triToRegion[item3] = text3;
						num5++;
					}
				}
			}
			if (num5 == 0)
			{
				return;
			}
			result.RegionIds.Clear();
			result.Centroids.Clear();
			Dictionary<string, List<int>> dictionary4 = new Dictionary<string, List<int>>();
			foreach (int item4 in accepted)
			{
				if (triToRegion.TryGetValue(item4, out var value10))
				{
					if (!dictionary4.TryGetValue(value10, out var value11))
					{
						value11 = (dictionary4[value10] = new List<int>());
					}
					value11.Add(item4);
				}
			}
			foreach (KeyValuePair<string, List<int>> item5 in dictionary4)
			{
				string key2 = item5.Key;
				result.RegionIds.Add(key2);
				float num6 = 0f;
				Vector3 val2 = Vector3.zero;
				foreach (int item6 in item5.Value)
				{
					float num7 = TriArea(verts[idx[item6 * 3]], verts[idx[item6 * 3 + 1]], verts[idx[item6 * 3 + 2]]);
					num6 += num7;
					val2 += triCentroids[item6] * num7;
				}
				result.Centroids[key2] = ((num6 > 0.001f) ? (val2 / num6) : triCentroids[item5.Value[0]]);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Region] Coplanar merge: {num5} tris reassigned, " + $"{dictionary4.Count} regions after merge"));
			}
		}

		private static void PruneSmallRegions(List<int> accepted, int[] idx, Vector3[] verts, Dictionary<int, string> triToRegion, BuildResult result)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, float> regionArea = new Dictionary<string, float>();
			foreach (int item in accepted)
			{
				if (triToRegion.TryGetValue(item, out var value))
				{
					float num = TriArea(verts[idx[item * 3]], verts[idx[item * 3 + 1]], verts[idx[item * 3 + 2]]);
					if (regionArea.TryGetValue(value, out var value2))
					{
						regionArea[value] = value2 + num;
					}
					else
					{
						regionArea[value] = num;
					}
				}
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (KeyValuePair<string, float> item2 in regionArea)
			{
				if (item2.Value < 0.25f)
				{
					hashSet.Add(item2.Key);
				}
			}
			if (hashSet.Count == 0)
			{
				return;
			}
			Dictionary<string, Vector3> dictionary = new Dictionary<string, Vector3>();
			foreach (string item3 in hashSet)
			{
				if (result.Centroids.TryGetValue(item3, out var value3))
				{
					dictionary[item3] = value3;
				}
			}
			foreach (string item4 in hashSet)
			{
				result.RegionIds.Remove(item4);
				result.Centroids.Remove(item4);
			}
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, string> item5 in triToRegion)
			{
				if (hashSet.Contains(item5.Value))
				{
					list.Add(item5.Key);
				}
			}
			foreach (int item6 in list)
			{
				triToRegion.Remove(item6);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Region] Area pruning: dropped {hashSet.Count} regions < {0.25f}m², " + $"{result.RegionIds.Count} regions remaining"));
			}
			DebugLog.List("RegionPrune", "area_dropped", ((IEnumerable<KeyValuePair<string, Vector3>>)dictionary).Select((Func<KeyValuePair<string, Vector3>, object>)((KeyValuePair<string, Vector3> kv) => $"{kv.Key}:{kv.Value.x:F1},{kv.Value.y:F1},{kv.Value.z:F1}:area={regionArea[kv.Key]:F2}")));
		}

		private static void PruneNarrowRegions(List<int> accepted, int[] idx, Vector3[] verts, Dictionary<int, string> triToRegion, BuildResult result, NavMeshQueryFilter filter)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>();
			NavMeshHit val = default(NavMeshHit);
			foreach (string regionId in result.RegionIds)
			{
				if (result.Centroids.TryGetValue(regionId, out var value) && NavMesh.FindClosestEdge(value, ref val, filter) && ((NavMeshHit)(ref val)).distance < 0f)
				{
					hashSet.Add(regionId);
				}
			}
			if (hashSet.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>();
			NavMeshHit val2 = default(NavMeshHit);
			foreach (string item in hashSet)
			{
				if (result.Centroids.TryGetValue(item, out var value2))
				{
					NavMesh.FindClosestEdge(value2, ref val2, filter);
					list.Add($"{item}:{value2.x:F1},{value2.y:F1},{value2.z:F1}:edge={((NavMeshHit)(ref val2)).distance:F3}");
				}
			}
			foreach (string item2 in hashSet)
			{
				result.RegionIds.Remove(item2);
				result.Centroids.Remove(item2);
			}
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<int, string> item3 in triToRegion)
			{
				if (hashSet.Contains(item3.Value))
				{
					list2.Add(item3.Key);
				}
			}
			foreach (int item4 in list2)
			{
				triToRegion.Remove(item4);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Region] Narrow pruning: dropped {hashSet.Count} regions " + $"(edge dist < {0f}m), " + $"{result.RegionIds.Count} regions remaining"));
			}
			DebugLog.List("RegionPrune", "narrow_dropped", list);
		}

		private static void PruneEnclosedRegions(List<int> accepted, int[] idx, Vector3[] verts, Dictionary<int, string> triToRegion, BuildResult result)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, (float, float, float, float, float, float)> dictionary = new Dictionary<string, (float, float, float, float, float, float)>();
			foreach (int item in accepted)
			{
				if (triToRegion.TryGetValue(item, out var value))
				{
					Vector3 val = verts[idx[item * 3]];
					Vector3 val2 = verts[idx[item * 3 + 1]];
					Vector3 val3 = verts[idx[item * 3 + 2]];
					float num = Mathf.Min(val.x, Mathf.Min(val2.x, val3.x));
					float num2 = Mathf.Max(val.x, Mathf.Max(val2.x, val3.x));
					float num3 = Mathf.Min(val.z, Mathf.Min(val2.z, val3.z));
					float num4 = Mathf.Max(val.z, Mathf.Max(val2.z, val3.z));
					float num5 = Mathf.Min(val.y, Mathf.Min(val2.y, val3.y));
					float num6 = Mathf.Max(val.y, Mathf.Max(val2.y, val3.y));
					if (dictionary.TryGetValue(value, out var value2))
					{
						dictionary[value] = (Mathf.Min(num5, value2.Item1), Mathf.Max(num6, value2.Item2), Mathf.Min(num, value2.Item3), Mathf.Max(num2, value2.Item4), Mathf.Min(num3, value2.Item5), Mathf.Max(num4, value2.Item6));
					}
					else
					{
						dictionary[value] = (num5, num6, num, num2, num3, num4);
					}
				}
			}
			HashSet<string> hashSet = new HashSet<string>();
			List<string> list = new List<string>(dictionary.Keys);
			for (int i = 0; i < list.Count; i++)
			{
				(float, float, float, float, float, float) tuple = dictionary[list[i]];
				if (tuple.Item2 - tuple.Item1 >= 0.2f)
				{
					continue;
				}
				float num7 = (tuple.Item1 + tuple.Item2) * 0.5f;
				for (int j = 0; j < list.Count; j++)
				{
					if (i == j || hashSet.Contains(list[j]))
					{
						continue;
					}
					(float, float, float, float, float, float) tuple2 = dictionary[list[j]];
					if (!(tuple2.Item2 - tuple2.Item1 >= 0.2f))
					{
						float num8 = (tuple2.Item1 + tuple2.Item2) * 0.5f;
						if (!(num7 > num8) && !(num8 - num7 > 0.5f) && !(tuple.Item3 > tuple2.Item3) && !(tuple.Item4 < tuple2.Item4) && !(tuple.Item5 > tuple2.Item5) && !(tuple.Item6 < tuple2.Item6))
						{
							hashSet.Add(list[j]);
						}
					}
				}
			}
			if (hashSet.Count == 0)
			{
				return;
			}
			List<string> list2 = new List<string>();
			foreach (string item2 in hashSet)
			{
				if (result.Centroids.TryGetValue(item2, out var value3))
				{
					list2.Add($"{item2}:{value3.x:F1},{value3.y:F1},{value3.z:F1}");
				}
			}
			foreach (string item3 in hashSet)
			{
				result.RegionIds.Remove(item3);
				result.Centroids.Remove(item3);
			}
			List<int> list3 = new List<int>();
			foreach (KeyValuePair<int, string> item4 in triToRegion)
			{
				if (hashSet.Contains(item4.Value))
				{
					list3.Add(item4.Key);
				}
			}
			foreach (int item5 in list3)
			{
				triToRegion.Remove(item5);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Region] Enclosure pruning: dropped {hashSet.Count} regions enclosed by " + $"larger coplanar regions, {result.RegionIds.Count} remaining"));
			}
			DebugLog.List("RegionPrune", "enclosed_dropped", list2);
		}

		private static string FindRoot(Dictionary<string, string> parent, string id)
		{
			while (parent[id] != id)
			{
				parent[id] = parent[parent[id]];
				id = parent[id];
			}
			return id;
		}

		internal static long PackQuantizedPos(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			long num = Mathf.RoundToInt(v.x / 0.25f);
			long num2 = Mathf.RoundToInt(v.y / 0.25f);
			long num3 = Mathf.RoundToInt(v.z / 0.25f);
			return (((num + 1048576) & 0x1FFFFF) << 42) | (((num2 + 1048576) & 0x1FFFFF) << 21) | ((num3 + 1048576) & 0x1FFFFF);
		}

		private static void PruneIsolatedSmallTerrain(List<int> accepted, int[] idx, Vector3[] verts, Dictionary<long, List<int>> edgeToTris, Dictionary<int, string> triToRegion, BuildResult result)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>();
			foreach (List<int> value5 in edgeToTris.Values)
			{
				string text = null;
				foreach (int item in value5)
				{
					if (triToRegion.TryGetValue(item, out var value))
					{
						if (text == null)
						{
							text = value;
						}
						else if (value != text)
						{
							hashSet.Add(text);
							hashSet.Add(value);
						}
					}
				}
			}
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			foreach (int item2 in accepted)
			{
				if (triToRegion.TryGetValue(item2, out var value2))
				{
					float num = TriArea(verts[idx[item2 * 3]], verts[idx[item2 * 3 + 1]], verts[idx[item2 * 3 + 2]]);
					if (dictionary.TryGetValue(value2, out var value3))
					{
						dictionary[value2] = value3 + num;
					}
					else
					{
						dictionary[value2] = num;
					}
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>();
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, float> item3 in dictionary)
			{
				if (!(item3.Value >= 16f) && !hashSet.Contains(item3.Key))
				{
					hashSet2.Add(item3.Key);
					if (result.Centroids.TryGetValue(item3.Key, out var value4))
					{
						list.Add($"{item3.Key}:{value4.x:F1},{value4.y:F1},{value4.z:F1}:area={item3.Value:F2}");
					}
				}
			}
			if (hashSet2.Count == 0)
			{
				return;
			}
			foreach (string item4 in hashSet2)
			{
				result.RegionIds.Remove(item4);
				result.Centroids.Remove(item4);
			}
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<int, string> item5 in triToRegion)
			{
				if (hashSet2.Contains(item5.Value))
				{
					list2.Add(item5.Key);
				}
			}
			foreach (int item6 in list2)
			{
				triToRegion.Remove(item6);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Region] Isolated terrain pruning: dropped {hashSet2.Count} regions " + $"(<{16f}m², no shared edges), " + $"{result.RegionIds.Count} regions remaining"));
			}
			DebugLog.List("RegionPrune", "isolated_terrain_dropped", list);
		}

		private static bool IsAnyVertexBelowTerrain(Vector3 v0, Vector3 v1, Vector3 v2)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!IsVertexBelowTerrain(v0) && !IsVertexBelowTerrain(v1))
			{
				return IsVertexBelowTerrain(v2);
			}
			return true;
		}

		private static bool IsVertexBelowTerrain(Vector3 v)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			float groundHeight = ZoneSystem.instance.GetGroundHeight(new Vector3(v.x, 0f, v.z));
			if (groundHeight == 0f)
			{
				return false;
			}
			return v.y < groundHeight - 1.5f;
		}

		private static long EdgeKey(int a, int b)
		{
			if (a >= b)
			{
				return ((long)b << 32) | (uint)a;
			}
			return ((long)a << 32) | (uint)b;
		}

		private static void AddEdge(Dictionary<long, List<int>> map, int v1, int v2, int tri)
		{
			long key = EdgeKey(v1, v2);
			if (!map.TryGetValue(key, out var value))
			{
				value = (map[key] = new List<int>(2));
			}
			value.Add(tri);
		}

		private static int Find(int[] parent, int x)
		{
			while (parent[x] != x)
			{
				parent[x] = parent[parent[x]];
				x = parent[x];
			}
			return x;
		}

		private static void Union(int[] parent, int[] rank, int a, int b)
		{
			int num = Find(parent, a);
			int num2 = Find(parent, b);
			if (num != num2)
			{
				if (rank[num] < rank[num2])
				{
					parent[num] = num2;
					return;
				}
				if (rank[num] > rank[num2])
				{
					parent[num2] = num;
					return;
				}
				parent[num2] = num;
				rank[num]++;
			}
		}

		private static long PackGroup(int root, int gx, int gz, int hb)
		{
			return ((long)root * 1000003L + gx) * 1000003 * 1000003 + (long)gz * 1000003L + hb;
		}

		private static float TriArea(Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.Cross(b - a, c - a);
			return ((Vector3)(ref val)).magnitude * 0.5f;
		}

		internal static bool PointInTri2D(float px, float pz, float ax, float az, float bx, float bz, float cx, float cz)
		{
			float num = (px - bx) * (az - bz) - (ax - bx) * (pz - bz);
			float num2 = (px - cx) * (bz - cz) - (bx - cx) * (pz - cz);
			float num3 = (px - ax) * (cz - az) - (cx - ax) * (pz - az);
			if (num < 0f || num2 < 0f || num3 < 0f)
			{
				if (!(num > 0f) && !(num2 > 0f))
				{
					return !(num3 > 0f);
				}
				return false;
			}
			return true;
		}

		internal static float InterpHeight(float px, float pz, Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			float num = (b.z - c.z) * (a.x - c.x) + (c.x - b.x) * (a.z - c.z);
			if (Mathf.Abs(num) < 0.0001f)
			{
				return (a.y + b.y + c.y) / 3f;
			}
			float num2 = ((b.z - c.z) * (px - c.x) + (c.x - b.x) * (pz - c.z)) / num;
			float num3 = ((c.z - a.z) * (px - c.x) + (a.x - c.x) * (pz - c.z)) / num;
			return num2 * a.y + num3 * b.y + (1f - num2 - num3) * c.y;
		}

		private static void DetectBoundary(Dictionary<long, List<int>> edgeToTris, Dictionary<int, string> triToRegion, int[] idx, Vector3[] verts, BuildResult result)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val5 = default(Vector3);
			foreach (KeyValuePair<long, List<int>> edgeToTri in edgeToTris)
			{
				List<int> value = edgeToTri.Value;
				int num = 0;
				int num2 = -1;
				string text = null;
				foreach (int item2 in value)
				{
					if (triToRegion.TryGetValue(item2, out var value2))
					{
						num++;
						num2 = item2;
						text = value2;
					}
				}
				if (num != 1 || text == null || num2 < 0)
				{
					continue;
				}
				int num3 = (int)(edgeToTri.Key >> 32);
				int num4 = (int)(edgeToTri.Key & 0xFFFFFFFFu);
				if (num3 >= 0 && num4 >= 0 && num3 < verts.Length && num4 < verts.Length)
				{
					Vector3 val = verts[num3];
					Vector3 val2 = verts[num4];
					Vector3 val3 = (val + val2) * 0.5f;
					Vector3 val4 = (verts[idx[num2 * 3]] + verts[idx[num2 * 3 + 1]] + verts[idx[num2 * 3 + 2]]) / 3f;
					((Vector3)(ref val5))..ctor(0f - (val2.z - val.z), 0f, val2.x - val.x);
					if (val5.x * (val3.x - val4.x) + val5.z * (val3.z - val4.z) < 0f)
					{
						val5 = -val5;
					}
					Vector3 item = ((((Vector3)(ref val5)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref val5)).normalized : Vector3.forward);
					result.BoundaryCells.Add((text, val3, item));
				}
			}
		}

		private static void BuildLookupGrid(List<int> accepted, int[] indices, Vector3[] verts, Dictionary<int, string> triToRegion, BuildResult result)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			float num = 1f;
			foreach (int item in accepted)
			{
				if (!triToRegion.TryGetValue(item, out var value))
				{
					continue;
				}
				Vector3 val = verts[indices[item * 3]];
				Vector3 val2 = verts[indices[item * 3 + 1]];
				Vector3 val3 = verts[indices[item * 3 + 2]];
				float num2 = Mathf.Min(val.x, Mathf.Min(val2.x, val3.x));
				float num3 = Mathf.Max(val.x, Mathf.Max(val2.x, val3.x));
				float num4 = Mathf.Min(val.z, Mathf.Min(val2.z, val3.z));
				float num5 = Mathf.Max(val.z, Mathf.Max(val2.z, val3.z));
				int num6 = Mathf.FloorToInt(num2 / num);
				int num7 = Mathf.FloorToInt(num3 / num);
				int num8 = Mathf.FloorToInt(num4 / num);
				int num9 = Mathf.FloorToInt(num5 / num);
				for (int i = num6; i <= num7; i++)
				{
					for (int j = num8; j <= num9; j++)
					{
						float px = ((float)i + 0.5f) * num;
						float pz = ((float)j + 0.5f) * num;
						if (PointInTri2D(px, pz, val.x, val.z, val2.x, val2.z, val3.x, val3.z))
						{
							int hb = RegionGraph.HeightBucket(InterpHeight(px, pz, val, val2, val3));
							long key = RegionGraph.PackLookup(i, j, hb);
							result.LookupGrid[key] = value;
						}
					}
				}
			}
		}
	}
	public static class RegionDebugVisualization
	{
		private const string LinkTorchPrefabName = "piece_groundtorch_mist";

		private const string RegionTorchPrefabName = "piece_groundtorch_wood";

		[DevCommand("Remove ALL persisted torch markers from the world", Name = "vv_hna_cleanup")]
		public static void CleanupPersistedMarkers()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("ZNetScene not available. Load into a world first.");
				}
				return;
			}
			string text = "piece_groundtorch_mist(Clone)";
			string text2 = "piece_groundtorch_wood(Clone)";
			ZNetView[] array = Object.FindObjectsByType<ZNetView>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			int num = 0;
			ZNetView[] array2 = array;
			foreach (ZNetView val in array2)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
				{
					continue;
				}
				string name = ((Object)((Component)val).gameObject).name;
				if (name != text && name != text2 && name != "piece_groundtorch_mist" && name != "piece_groundtorch_wood")
				{
					continue;
				}
				if (val.IsValid())
				{
					if (!val.IsOwner())
					{
						ZDO zDO = val.GetZDO();
						if (zDO != null)
						{
							zDO.SetOwner(ZDOMan.GetSessionID());
						}
					}
					ZNetScene.instance.Destroy(((Component)val).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				num++;
			}
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print($"Cleaned up {num} torch marker(s). Save to persist.");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Region] Torch cleanup: {num} removed");
			}
		}
	}
	public enum SurfaceKind
	{
		Terrain,
		Piece
	}
	public enum RegionLinkType
	{
		Door,
		Stair,
		Slope
	}
	public struct RegionLink
	{
		public string FromRegionId;

		public string ToRegionId;

		public RegionLinkType LinkType;

		public Vector3 PositionStart;

		public Vector3 PositionEnd;
	}
	public class RegionGraph
	{
		public readonly struct DiagnosticsAccess
		{
			private readonly RegionGraph m_g;

			public int LookupGridCellCount
			{
				get
				{
					if (m_g == null || !m_g.m_initialized)
					{
						return 0;
					}
					return m_g.m_lookupGrid.Count;
				}
			}

			public int BoundaryCellCount
			{
				get
				{
					if (m_g == null || !m_g.m_initialized)
					{
						return 0;
					}
					return m_g.m_boundaryCells.Count;
				}
			}

			internal DiagnosticsAccess(RegionGraph g)
			{
				m_g = g;
			}

			public List<Vector3> GetAllRegionCenters()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				List<Vector3> list = new List<Vector3>();
				if (m_g == null || !m_g.m_initialized)
				{
					return list;
				}
				foreach (Vector3 value in m_g.m_regionCentroids.Values)
				{
					list.Add(value);
				}
				return list;
			}

			public List<Vector3> GetLookupCellCenters()
			{
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				List<Vector3> list = new List<Vector3>();
				if (m_g == null || !m_g.m_initialized)
				{
					return list;
				}
				float num = 0.5f;
				float num2 = 1f;
				foreach (long key in m_g.m_lookupGrid.Keys)
				{
					UnpackLookup(key, out var gx, out var gz, out var hb);
					list.Add(new Vector3((float)gx * 1f + num, (float)hb * 2f + num2, (float)gz * 1f + num));
				}
				return list;
			}

			public bool TryGetLookupGridBounds(out float minX, out float maxX, out float minZ, out float maxZ)
			{
				minX = (maxX = (minZ = (maxZ = 0f)));
				if (m_g == null || !m_g.m_initialized || m_g.m_lookupGrid.Count == 0)
				{
					return false;
				}
				minX = (minZ = float.PositiveInfinity);
				maxX = (maxZ = float.NegativeInfinity);
				float num = 0.5f;
				foreach (long key in m_g.m_lookupGrid.Keys)
				{
					UnpackLookup(key, out var gx, out var gz, out var _);
					float num2 = (float)gx * 1f + num;
					float num3 = (float)gz * 1f + num;
					if (num2 < minX)
					{
						minX = num2;
					}
					if (num2 > maxX)
					{
						maxX = num2;
					}
					if (num3 < minZ)
					{
						minZ = num3;
					}
					if (num3 > maxZ)
					{
						maxZ = num3;
					}
				}
				return true;
			}

			public bool TryGetBoundaryCellsBounds(out float minX, out float maxX, out float minZ, out float maxZ)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: 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)
				minX = (maxX = (minZ = (maxZ = 0f)));
				if (m_g == null || !m_g.m_initialized || m_g.m_boundaryCells.Count == 0)
				{
					return false;
				}
				minX = (minZ = float.PositiveInfinity);
				maxX = (maxZ = float.NegativeInfinity);
				foreach (var boundaryCell in m_g.m_boundaryCells)
				{
					Vector3 item = boundaryCell.center;
					if (item.x < minX)
					{
						minX = item.x;
					}
					if (item.x > maxX)
					{
						maxX = item.x;
					}
					if (item.z < minZ)
					{
						minZ = item.z;
					}
					if (item.z > maxZ)
					{
						maxZ = item.z;
					}
				}
				return true;
			}
		}

		public const float CellSize = 3f;

		internal const float HeightBucketSize = 2f;

		internal const float LookupCellSize = 1f;

		private float m_originX;

		private float m_originZ;

		private readonly HashSet<string> m_regionIds = new HashSet<string>();

		private readonly List<RegionLink> m_links = new List<RegionLink>();

		private bool m_initialized;

		private readonly Dictionary<string, Vector3> m_regionCentroids = new Dictionary<string, Vector3>();

		private readonly Dictionary<long, string> m_lookupGrid = new Dictionary<long, string>();

		private readonly List<(string id, Vector3 center, Vector3 outDir)> m_boundaryCells = new List<(string, Vector3, Vector3)>();

		private readonly Dictionary<string, SurfaceKind> m_regionKinds = new Dictionary<string, SurfaceKind>();

		private readonly List<Vector3> m_gates = new List<Vector3>();

		private readonly HashSet<long> m_outsideCellsXz = new HashSet<long>();

		private readonly HashSet<long> m_anchorReachableCellsXz = new HashSet<long>();

		private readonly HashSet<long> m_prunedPieceKeys = new HashSet<long>();

		private bool m_hasClassification;

		public bool IsAvailable
		{
			get
			{
				if (m_initialized)
				{
					return m_regionIds.Count > 0;
				}
				return false;
			}
		}

		public int RegionCount => m_regionIds.Count;

		public int LinkCount => m_links.Count;

		public string RegisteredVillageKey { get; internal set; }

		public DiagnosticsAccess Diagnostics => new DiagnosticsAccess(this);

		public bool HasClassification
		{
			get
			{
				if (m_initialized)
				{
					return m_hasClassification;
				}
				return false;
			}
		}

		internal IReadOnlyCollection<long> OutsideCellsXz => m_outsideCellsXz;

		internal IReadOnlyCollection<long> AnchorReachableCellsXz => m_anchorReachableCellsXz;

		internal IReadOnlyCollection<long> PrunedPieceKeys => m_prunedPieceKeys;

		public void SetGraph(HashSet<string> regionIds, List<RegionLink> links, Dictionary<string, Vector3> regionCentroids, Dictionary<long, string> lookupGrid, List<(string id, Vector3 center, Vector3 outDir)> boundaryCells = null, Dictionary<string, SurfaceKind> regionKinds = null)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			ClearInternal();
			if (regionIds != null)
			{
				foreach (string regionId in regionIds)
				{
					m_regionIds.Add(regionId);
				}
			}
			if (links != null)
			{
				m_links.AddRange(links);
			}
			if (regionCentroids != null)
			{
				foreach (KeyValuePair<string, Vector3> regionCentroid in regionCentroids)
				{
					m_regionCentroids[regionCentroid.Key] = regionCentroid.Value;
				}
			}
			if (lookupGrid != null)
			{
				foreach (KeyValuePair<long, string> item in lookupGrid)
				{
					m_lookupGrid[item.Key] = item.Value;
				}
			}
			if (boundaryCells != null)
			{
				m_boundaryCells.AddRange(boundaryCells);
			}
			if (regionKinds != null)
			{
				foreach (KeyValuePair<string, SurfaceKind> regionKind in regionKinds)
				{
					m_regionKinds[regionKind.Key] = regionKind.Value;
				}
			}
			if (regionCentroids != null && regionCentroids.Count > 0)
			{
				float num = 0f;
				float num2 = 0f;
				foreach (Vector3 value in regionCentroids.Values)
				{
					num += value.x;
					num2 += value.z;
				}
				m_originX = num / (float)regionCentroids.Count;
				m_originZ = num2 / (float)regionCentroids.Count;
			}
			m_initialized = true;
		}

		private void ClearInternal()
		{
			m_regionIds.Clear();
			m_links.Clear();
			m_regionCentroids.Clear();
			m_lookupGrid.Clear();
			m_boundaryCells.Clear();
			m_regionKinds.Clear();
			m_gates.Clear();
			m_outsideCellsXz.Clear();
			m_anchorReachableCellsXz.Clear();
			m_prunedPieceKeys.Clear();
			m_hasClassification = false;
			m_initialized = false;
		}

		public static bool GetSolidHeightAt(float worldX, float worldZ, out float height)
		{
			//IL_0022: 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)
			height = 0f;
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			float num = default(float);
			bool solidHeight = ZoneSystem.instance.GetSolidHeight(new Vector3(worldX, 500f, worldZ), ref num, 550);
			float num2 = default(float);
			bool solidHeight2 = ZoneSystem.instance.GetSolidHeight(new Vector3(worldX, 0f, worldZ), ref num2, 500);
			if (solidHeight && solidHeight2)
			{
				height = Mathf.Max(num, num2);
				return true;
			}
			if (solidHeight)
			{
				height = num;
				return true;
			}
			if (solidHeight2)
			{
				height = num2;
				return true;
			}
			return false;
		}

		public static int HeightBucket(float y)
		{
			return Mathf.FloorToInt(y / 2f);
		}

		internal static long PackLookup(int gx, int gz, int hb)
		{
			return (long)gx * 1000003L * 1000003 + (long)gz * 1000003L + hb;
		}

		internal static long PackXz(int gx, int gz)
		{
			return (long)(((ulong)(uint)gx << 32) | (uint)gz);
		}

		internal static void UnpackXz(long key, out int gx, out int gz)
		{
			gx = (int)(key >> 32);
			gz = (int)(key & 0xFFFFFFFFu);
		}

		public string PointToRegionId(Vector3 worldPosition)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!m_initialized)
			{
				return null;
			}
			int gx = Mathf.FloorToInt(worldPosition.x / 1f);
			int gz = Mathf.FloorToInt(worldPosition.z / 1f);
			int num = HeightBucket(worldPosition.y);
			for (int i = 0; i <= 1; i++)
			{
				if (m_lookupGrid.TryGetValue(PackLookup(gx, gz, num + i), out var value))
				{
					return value;
				}
				if (i > 0 && m_lookupGrid.TryGetValue(PackLookup(gx, gz, num - i), out value))
				{
					return value;
				}
			}
			return null;
		}

		public bool TryFindNearestLookupCell(Vector3 target, Func<Vector3, bool> validator, out Vector3 worldPos, out string regionId, float maxXzDist = float.MaxValue)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			worldPos = Vector3.zero;
			regionId = null;
			if (!m_initialized || m_lookupGrid.Count == 0)
			{
				return false;
			}
			List<(long, Vector3, string, float)> list = new List<(long, Vector3, string, float)>(m_lookupGrid.Count);
			float num = 0.5f;
			float num2 = 1f;
			Vector3 item = default(Vector3);
			foreach (KeyValuePair<long, string> item4 in m_lookupGrid)
			{
				UnpackLookup(item4.Key, out var gx, out var gz, out var hb);
				float num3 = (float)gx * 1f + num;
				float num4 = (float)gz * 1f + num;
				float num5 = (float)hb * 2f + num2;
				((Vector3)(ref item))..ctor(num3, num5, num4);
				float num6 = num3 - target.x;
				float num7 = num4 - target.z;
				list.Add((item4.Key, item, item4.Value, num6 * num6 + num7 * num7));
			}
			list.Sort(((long key, Vector3 pos, string id, float distSq) a, (long key, Vector3 pos, string id, float distSq) b) => a.distSq.CompareTo(b.distSq));
			float num8 = ((maxXzDist >= float.MaxValue) ? float.MaxValue : (maxXzDist * maxXzDist));
			foreach (var item5 in list)
			{
				Vector3 item2 = item5.Item2;
				string item3 = item5.Item3;
				if (item5.Item4 > num8)
				{
					break;
				}
				if (validator == null || validator(item2))
				{
					worldPos = item2;
					regionId = item3;
					return true;
				}
			}
			return false;
		}

		internal static void UnpackLookup(long key, out int gx, out int gz, out int hb)
		{
			long num = (key % 1000003 + 1000003) % 1000003;
			hb = (int)num;
			if ((long)hb > 500001L)
			{
				hb -= 1000003;
			}
			long num2 = (key - hb) / 1000003;
			long num3 = (num2 % 1000003 + 1000003) % 1000003;
			gz = (int)num3;
			if ((long)gz > 500001L)
			{
				gz -= 1000003;
			}
			gx = (int)((num2 - gz) / 1000003);
		}

		public bool IsValidRegion(string regionId)
		{
			if (m_initialized && !string.IsNullOrEmpty(regionId))
			{
				return m_regionIds.Contains(regionId);
			}
			return false;
		}

		public SurfaceKind GetRegionKind(string regionId)
		{
			if (m_regionKinds.TryGetValue(regionId, out var value))
			{
				return value;
			}
			return SurfaceKind.Piece;
		}

		public bool TryGetCellHeight(string cellId, out float height)
		{
			//IL_0025: 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)
			height = 0f;
			if (!m_initialized || cellId == null)
			{
				return false;
			}
			if (m_regionCentroids.TryGetValue(cellId, out var value))
			{
				return (height = value.y) == value.y;
			}
			return false;
		}

		public bool GetOrigin(out float originX, out float originZ)
		{
			originX = m_originX;
			originZ = m_originZ;
			return m_initialized;
		}

		public bool GetCellWorldXZ(string cellId, out float wx, out float wz)
		{
			//IL_0031: 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)
			wx = (wz = 0f);
			if (!m_initialized || string.IsNullOrEmpty(cellId))
			{
				return false;
			}
			if (!m_regionCentroids.TryGetValue(cellId, out var value))
			{
				return false;
			}
			wx = value.x;
			wz = value.z;
			return true;
		}

		public bool GetRegionBounds(string regionId, out float minX, out float maxX, out float minZ, out float maxZ)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			minX = (maxX = (minZ = (maxZ = 0f)));
			if (!m_initialized || string.IsNullOrEmpty(regionId))
			{
				return false;
			}
			if (!m_regionCentroids.TryGetValue(regionId, out var value))
			{
				return false;
			}
			float num = 1.5f;
			minX = value.x - num;
			maxX = value.x + num;
			minZ = value.z - num;
			maxZ = value.z + num;
			return true;
		}

		public bool GetRegionSampleHeights(string regionId, out float centerY, out float minY, out float maxY)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			centerY = (minY = (maxY = 0f));
			if (!m_initialized || string.IsNullOrEmpty(regionId))
			{
				return false;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			if (!m_regionCentroids.TryGetValue(regionId, out var value))
			{
				return false;
			}
			float x = value.x;
			float z = value.z;
			float num = 1.2f;
			(float, float)[] obj = new(float, float)[5]
			{
				(x, z),
				(x + num, z),
				(x - num, z),
				(x, z + num),
				(x, z - num)
			};
			minY = float.MaxValue;
			maxY = float.MinValue;
			bool result = false;
			(float, float)[] array = obj;
			for (int i = 0; i < array.Length; i++)
			{
				var (num2, num3) = array[i];
				if (GetSolidHeightAt(num2, num3, out var height))
				{
					result = true;
					if (Mathf.Abs(num2 - x) < 0.01f && Mathf.Abs(num3 - z) < 0.01f)
					{
						centerY = height;
					}
					if (height < minY)
					{
						minY = height;
					}
					if (height > maxY)
					{
						maxY = height;
					}
				}
			}
			return result;
		}

		public IReadOnlyList<RegionLink> GetLinksFromRegion(string regionId)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (!m_initialized || string.IsNullOrEmpty(regionId))
			{
				return null;
			}
			List<RegionLink> list = new List<RegionLink>();
			foreach (RegionLink link in m_links)
			{
				if (link.FromRegionId == regionId)
				{
					list.Add(link);
				}
				else if (link.ToRegionId == regionId)
				{
					list.Add(new RegionLink
					{
						FromRegionId = link.ToRegionId,
						ToRegionId = link.FromRegionId,
						LinkType = link.LinkType,
						PositionStart = link.PositionEnd,
						PositionEnd = link.PositionStart
					});
				}
			}
			return list;
		}

		public IReadOnlyList<RegionLink> GetAllLinks()
		{
			if (!m_initialized)
			{
				return new List<RegionLink>();
			}
			return m_links;
		}

		internal IEnumerable<string> GetRegionIds()
		{
			return m_regionIds;
		}

		public void Clear()
		{
			ClearInternal();
		}

		public List<(string cellId, Vector3 worldCenter, Vector3 outwardDir)> GetBoundaryCells()
		{
			if (!m_initialized)
			{
				return new List<(string, Vector3, Vector3)>();
			}
			return new List<(string, Vector3, Vector3)>(m_boundaryCells);
		}

		public void SetGates(IEnumerable<Vector3> gates)
		{
			m_gates.Clear();
			if (gates != null)
			{
				m_gates.AddRange(gates);
			}
		}

		public List<Vector3> GetGates()
		{
			return new List<Vector3>(m_gates);
		}

		public void SetClassification(HashSet<long> outsideXz, HashSet<long> anchorReachableXz, HashSet<long> prunedPieceKeys)
		{
			m_outsideCellsXz.Clear();
			m_anchorReachableCellsXz.Clear();
			m_prunedPieceKeys.Clear();
			if (outsideXz != null)
			{
				foreach (long item in outsideXz)
				{
					m_outsideCellsXz.Add(item);
				}
			}
			if (anchorReachableXz != null)
			{
				foreach (long item2 in anchorReachableXz)
				{
					m_anchorReachableCellsXz.Add(item2);
				}
			}
			if (prunedPieceKeys != null)
			{
				foreach (long prunedPieceKey in prunedPieceKeys)
				{
					m_prunedPieceKeys.Add(prunedPieceKey);
				}
			}
			m_hasClassification = m_outsideCellsXz.Count > 0 || m_anchorReachableCellsXz.Count > 0 || m_prunedPieceKeys.Count > 0;
		}

		public bool IsOutsideCell(int gx, int gz)
		{
			return m_outsideCellsXz.Contains(PackXz(gx, gz));
		}

		public bool IsAnchorReachableCell(int gx, int gz)
		{
			return m_anchorReachableCellsXz.Contains(PackXz(gx, gz));
		}

		public bool IsPieceKeyPruned(long lookupKey)
		{
			return m_prunedPieceKeys.Contains(lookupKey);
		}
	}
	internal static class RegionGraphPersistence
	{
		private const string LinkSectionDelimiter = "||";

		private const string ClassSectionDelimiter = "|#|";

		private const string V4Header = "v4";

		private const int ClassTile = 16;

		private const int ClassTileCells = 256;

		private const int ClassMaskBytes = 32;

		internal static Action<string> LogAction;

		private static char KindToChar(SurfaceKind k)
		{
			if (k != SurfaceKind.Terrain)
			{
				return 'P';
			}
			return 'T';
		}

		private static SurfaceKind CharToKind(char c)
		{
			if (c != 'T')
			{
				return SurfaceKind.Piece;
			}
			return SurfaceKind.Terrain;
		}

		private static char LinkTypeToChar(RegionLinkType t)
		{
			return t switch
			{
				RegionLinkType.Door => 'D', 
				RegionLinkType.Stair => 'S', 
				RegionLinkType.Slope => 'L', 
				_ => 'L', 
			};
		}

		private static RegionLinkType CharToLinkType(char c)
		{
			return c switch
			{
				'D' => RegionLinkType.Door, 
				'S' => RegionLinkType.Stair, 
				_ => RegionLinkType.Slope, 
			};
		}

		internal static string Serialize(RegionGraph graph)
		{
			if (graph == null || !graph.IsAvailable)
			{
				return "";
			}
			return SerializeV4(graph);
		}

		private static string SerializeV4(RegionGraph graph)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("v4");
			foreach (string regionId in graph.GetRegionIds())
			{
				stringBuilder.Append(';').Append(regionId).Append(':');
				if (graph.GetCellWorldXZ(regionId, out var wx, out var wz) && graph.TryGetCellHeight(regionId, out var height))
				{
					stringBuilder.Append(wx.ToString("F2", invariantCulture)).Append(',').Append(height.ToString("F2", invariantCulture))
						.Append(',')
						.Append(wz.ToString("F2", invariantCulture))
						.Append(',')
						.Append(KindToChar(graph.GetRegionKind(regionId)));
				}
				else
				{
					stringBuilder.Append('?');
				}
			}
			AppendLinks(stringBuilder, graph);
			AppendClassification(stringBuilder, graph);
			return stringBuilder.ToString();
		}

		private static void AppendLinks(StringBuilder sb, RegionGraph graph)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			IReadOnlyList<RegionLink> allLinks = graph.GetAllLinks();
			if (allLinks == null || allLinks.Count == 0)
			{
				return;
			}
			sb.Append("||");
			for (int i = 0; i < allLinks.Count; i++)
			{
				if (i > 0)
				{
					sb.Append(';');
				}
				RegionLink regionLink = allLinks[i];
				sb.Append(regionLink.FromRegionId).Append(',').Append(regionLink.ToRegionId)
					.Append(',')
					.Append(LinkTypeToChar(regionLink.LinkType))
					.Append(',')
					.Append(regionLink.PositionStart.x.ToString("F2", invariantCulture))
					.Append(',')
					.Append(regionLink.PositionStart.y.ToString("F2", invariantCulture))
					.Append(',')
					.Append(regionLink.PositionStart.z.ToString("F2", invariantCulture))
					.Append(',')
					.Append(regionLink.PositionEnd.x.ToString("F2", invariantCulture))
					.Append(',')
					.Append(regionLink.PositionEnd.y.ToString("F2", invariantCulture))
					.Append(',')
					.Append(regionLink.PositionEnd.z.ToString("F2", invariantCulture));
			}
		}

		internal static bool Restore(RegionGraph graph, string data)
		{
			if (graph == null || string.IsNullOrEmpty(data))
			{
				return false;
			}
			if (!data.StartsWith("v4"))
			{
				LogInfo("[Region] Legacy non-v4 graph in ZDO; purging (caller will wipe + rebuild)");
				return false;
			}
			return RestoreV4(graph, data);
		}

		private static bool RestoreV4(RegionGraph graph, string data)
		{
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			string text = data;
			string text2 = null;
			int num = data.IndexOf("|#|", StringComparison.Ordinal);
			if (num >= 0)
			{
				text = data.Substring(0, num);
				text2 = data.Substring(num + "|#|".Length);
			}
			string text3 = text;
			string linkSection = null;
			int num2 = text.IndexOf("||", StringComparison.Ordinal);
			if (num2 >= 0)
			{
				text3 = text.Substring(0, num2);
				linkSection = text.Substring(num2 + "||".Length);
			}
			string[] array = text3.Split(new char[1] { ';' });
			if (array.Length < 2)
			{
				return false;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			HashSet<string> hashSet = new HashSet<string>();
			Dictionary<string, Vector3> dictionary = new Dictionary<string, Vector3>();
			Dictionary<string, SurfaceKind> dictionary2 = new Dictionary<string, SurfaceKind>();
			for (int i = 1; i < array.Length; i++)
			{
				string text4 = array[i];
				int num3 = text4.IndexOf(':');
				if (num3 <= 0)
				{
					continue;
				}
				string text5 = text4.Substring(0, num3);
				string text6 = text4.Substring(num3 + 1);
				hashSet.Add(text5);
				if (text6 == "?")
				{
					continue;
				}
				string[] array2 = text6.Split(new char[1] { ',' });
				if (array2.Length >= 4 && float.TryParse(array2[0], NumberStyles.Float, invariantCulture, out var result) && float.TryParse(array2[1], NumberStyles.Float, invariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, invariantCulture, out var result3))
				{
					dictionary[text5] = new Vector3(result, result2, result3);
					if (array2[3].Length > 0)
					{
						dictionary2[text5] = CharToKind(array2[3][0]);
					}
				}
			}
			if (hashSet.Count == 0)
			{
				return false;
			}
			List<RegionLink> list = DeserializeLinks(linkSection);
			Dictionary<long, string> dictionary3 = new Dictionary<long, string>();
			foreach (KeyValuePair<string, Vector3> item in dictionary)
			{
				int num4 = Mathf.FloorToInt(item.Value.x / 1f);
				int num5 = Mathf.FloorToInt(item.Value.z / 1f);
				int hb = RegionGraph.HeightBucket(item.Value.y);
				for (int j = -1; j <= 1; j++)
				{
					for (int k = -1; k <= 1; k++)
					{
						long key = RegionGraph.PackLookup(num4 + j, num5 + k, hb);
						dictionary3[key] = item.Key;
					}
				}
			}
			graph.SetGraph(hashSet, list, dictionary, dictionary3, null, dictionary2);
			if (!string.IsNullOrEmpty(text2))
			{
				RestoreClassification(graph, text2);
			}
			LogInfo($"[Region] Restored v4 graph from ZDO: {hashSet.Count} regions, {list.Count} links, " + string.Format("{0} kinded, classification={1}", dictionary2.Count, graph.HasClassification ? "yes" : "no"));
			return true;
		}

		private static void LogInfo(string message)
		{
			LogAction?.Invoke(message);
		}

		private static void AppendClassification(StringBuilder sb, RegionGraph graph)
		{
			if (graph.HasClassification)
			{
				sb.Append("|#|");
				AppendXzBitmask(sb, graph.OutsideCellsXz);
				sb.Append('~');
				AppendXzBitmask(sb, graph.AnchorReachableCellsXz);
				sb.Append('~');
				AppendPieceKeys(sb, graph.PrunedPieceKeys);
			}
		}

		private static void RestoreClassification(RegionGraph graph, string classSection)
		{
			string[] array = classSection.Split(new char[1] { '~' });
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<long> hashSet2 = new HashSet<long>();
			HashSet<long> hashSet3 = new HashSet<long>();
			if (array.Length != 0)
			{
				ParseXzBitmask(array[0], hashSet);
			}
			if (array.Length > 1)
			{
				ParseXzBitmask(array[1], hashSet2);
			}
			if (array.Length > 2)
			{
				ParsePieceKeys(array[2], hashSet3);
			}
			graph.SetClassification(hashSet, hashSet2, hashSet3);
		}

		private static void AppendXzBitmask(StringBuilder sb, IReadOnlyCollection<long> cells)
		{
			if (cells == null || cells.Count == 0)
			{
				return;
			}
			Dictionary<long, byte[]> dictionary = new Dictionary<long, byte[]>();
			foreach (long cell in cells)
			{
				RegionGraph.UnpackXz(cell, out var gx, out var gz);
				int num = FloorDiv(gx, 16);
				int num2 = FloorDiv(gz, 16);
				long key = RegionGraph.PackXz(num, num2);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = new byte[32]);
				}
				int num3 = gx - num * 16;
				int num4 = gz - num2 * 16;
				int num5 = num3 * 16 + num4;
				value[num5 >> 3] |= (byte)(1 << (num5 & 7));
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			bool flag = true;
			foreach (KeyValuePair<long, byte[]> item in dictionary)
			{
				RegionGraph.UnpackXz(item.Key, out var gx2, out var gz2);
				if (!flag)
				{
					sb.Append('!');
				}
				flag = false;
				sb.Append(gx2.ToString(invariantCulture)).Append(',').Append(gz2.ToString(invariantCulture))
					.Append(',')
					.Append(Convert.ToBase64String(item.Value));
			}
		}

		private static void ParseXzBitmask(string section, HashSet<long> outSet)
		{
			if (string.IsNullOrEmpty(section))
			{
				return;
			}
			string[] array = section.Split(new char[1] { '!' });
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				string[] array2 = text.Split(new char[1] { ',' });
				if (array2.Length < 3 || !int.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
				{
					continue;
				}
				byte[] array3;
				try
				{
					array3 = Convert.FromBase64String(array2[2]);
				}
				catch
				{
					continue;
				}
				for (int j = 0; j < 256 && j >> 3 < array3.Length; j++)
				{
					if ((array3[j >> 3] & (1 << (j & 7))) != 0)
					{
						int gx = result * 16 + j / 16;
						int gz = result2 * 16 + j % 16;
						outSet.Add(RegionGraph.PackXz(gx, gz));
					}
				}
			}
		}

		private static void AppendPieceKeys(StringBuilder sb, IReadOnlyCollection<long> keys)
		{
			if (keys == null || keys.Count == 0)
			{
				return;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			bool flag = true;
			foreach (long key in keys)
			{
				RegionGraph.UnpackLookup(key, out var gx, out var gz, out var hb);
				if (!flag)
				{
					sb.Append('!');
				}
				flag = false;
				sb.Append(gx.ToString(invariantCulture)).Append(',').Append(gz.ToString(invariantCulture))
					.Append(',')
					.Append(hb.ToString(invariantCulture));
			}
		}

		private static void ParsePieceKeys(string section, HashSet<long> outSet)
		{
			if (string.IsNullOrEmpty(section))
			{
				return;
			}
			string[] array = section.Split(new char[1] { '!' });
			foreach (string text in array)
			{
				if (!string.IsNullOrEmpty(text))
				{
					string[] array2 = text.Split(new char[1] { ',' });
					if (array2.Length >= 3 && int.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
					{
						outSet.Add(RegionGraph.PackLookup(result, result2, result3));
					}
				}
			}
		}

		private static int FloorDiv(int a, int b)
		{
			int num = a / b;
			if (a % b != 0 && a < 0 != b < 0)
			{
				num--;
			}
			return num;
		}

		private static List<RegionLink> DeserializeLinks(string linkSection)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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)
			List<RegionLink> list = new List<RegionLink>();
			if (string.IsNullOrEmpty(linkSection))
			{
				return list;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			string[] array = linkSection.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				string[] array2 = text.Split(new char[1] { ',' });
				if (array2.Length < 9)
				{
					continue;
				}
				string text2 = array2[0];
				string text3 = array2[1];
				if (!string.IsNullOrEmpty(text2) && !string.IsNullOrEmpty(text3) && array2[2].Length >= 1)
				{
					RegionLinkType linkType = CharToLinkType(array2[2][0]);
					if (float.TryParse(array2[3], NumberStyles.Float, invariantCulture, out var result) && float.TryParse(array2[4], NumberStyles.Float, invariantCulture, out var result2) && float.TryParse(array2[5], NumberStyles.Float, invariantCulture, out var result3) && float.TryParse(array2[6], NumberStyles.Float, invariantCulture, out var result4) && float.TryParse(array2[7], NumberStyles.Float, invariantCulture, out var result5) && float.TryParse(array2[8], NumberStyles.Float, invariantCulture, out var result6))
					{
						list.Add(new RegionLink
						{
							FromRegionId = text2,
							ToRegionId = text3,
							LinkType = linkType,
							PositionStart = new Vector3(result, result2, result3),
							PositionEnd = new Vector3(result4, result5, result6)
						});
					}
				}
			}
			return list;
		}
	}
	public static class RegistrySeedResolver
	{
		private const float CapsuleRadius = 0.3f;

		private const float CapsuleHeight = 1.4f;

		private const float CapsuleLift = 0.25f;

		private const float RaycastUp = 3f;

		private const float RaycastDown = 8f;

		private const float HumanoidSnapRadius = 1f;

		private static readonly float[] SearchRadii = new float[6] { 0f, 1.5f, 2f, 2.5f, 3f, 4f };

		private const int Directions = 12;

		public static bool TryResolveWalkableSeed(Vector3 anchor, out Vector3 seed)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			seed = anchor;
			int num = VillagerAgentType.ResolveValheimHumanoidAgentTypeID();
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = num;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			float[] searchRadii = SearchRadii;
			NavMeshHit val4 = default(NavMeshHit);
			foreach (float num2 in searchRadii)
			{
				int num3 = ((num2 == 0f) ? 1 : 12);
				Vector3? val3 = null;
				float num4 = float.MaxValue;
				for (int j = 0; j < num3; j++)
				{
					float num5 = 360f / (float)num3 * (float)j * ((float)Math.PI / 180f);
					if (!TryGroundPoint(anchor + new Vector3(Mathf.Cos(num5) * num2, 0f, Mathf.Sin(num5) * num2), anchor.y, out var ground) || !CapsuleClear(ground))
					{
						continue;
					}
					if (num != 0)
					{
						if (!NavMesh.SamplePosition(ground, ref val4, 1f, val2))
						{
							continue;
						}
						ground = ((NavMeshHit)(ref val4)).position;
					}
					Vector3 val5 = ground - anchor;
					float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
					if (sqrMagnitude < num4)
					{
						num4 = sqrMagnitude;
						val3 = ground;
					}
				}
				if (val3.HasValue)
				{
					seed = val3.Value;
					return true;
				}
			}
			return false;
		}

		private static bool TryGroundPoint(Vector3 xz, float refY, out Vector3 ground)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			ground = xz;
			int mask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "piece", "terrain" });
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(new Vector3(xz.x, refY + 3f, xz.z), Vector3.down, ref val, 11f, mask, (QueryTriggerInteraction)1))
			{
				ground = ((RaycastHit)(ref val)).point;
				return true;
			}
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				ground = new Vector3(xz.x, ZoneSystem.instance.GetGroundHeight(xz), xz.z);
				return true;
			}
			return false;
		}

		private static bool CapsuleClear(Vector3 ground)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			int mask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });
			Vector3 val = ground + Vector3.up * 0.55f;
			Vector3 val2 = ground + Vector3.up * 1.3499999f;
			return !Physics.CheckCapsule(val, val2, 0.3f, mask, (QueryTriggerInteraction)1);
		}
	}
	internal static class RubberBandPrune
	{
		public readonly struct CellRect
		{
			public readonly int Gx0;

			public readonly int Gz0;

			public readonly int Gx1;

			public readonly int Gz1;

			public CellRect(int gx0, int gz0, int gx1, int gz1)
			{
				Gx0 = gx0;
				Gz0 = gz0;
				Gx1 = gx1;
				Gz1 = gz1;
			}
		}

		internal readonly struct GateSeal
		{
			public readonly Vector3 Mid;

			public readonly Vector3 Forward;

			public readonly float HalfWidth;

			public GateSeal(Vector3 mid, Vector3 forward, float halfWidth)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Mid = mid;
				Forward = forward;
				HalfWidth = halfWidth;
			}
		}

		public struct Stats
		{
			public int OutsideTerrainCells;

			public int Pass2Seeds;

			public int AnchorReachableTerrainCells;

			public int Pass3Seeds;

			public int AnchorReachablePieceKeys;

			public int Pass3PieceKeysDropped;

			public int Pass3LinksAdded;

			public int Pass4BoundaryVertsSnapped;

			public int Pass4SnapMisses;

			public int Pass4LinksSnapped;

			public int Pass5ChainsConsolidated;

			public int Pass5RegionsConsumed;

			public int Pass5LinksRemoved;

			public int RegionsDropped;

			public int PerimeterSeeds;

			public int LookupCellsDropped;

			public int TrianglesDropped;

			public int StaticSolidTrianglesDropped;
		}

		private const float WaistMin = 0.7f;

		private const float WaistMax = 1.3f;

		private const long PackK = 1000003L;

		private const long PackKHalf = 500001L;

		internal static HashSet<long> LastOutsideCells;

		internal static Dictionary<long, float> LastXzMaxY;

		internal static int LastGxMin;

		internal static int LastGzMin;

		internal static int LastGxMax;

		internal static int LastGzMax;

		internal static float LastCell;

		internal static int LastPieceMask;

		internal static bool HasSnapshot;

		private static readonly Collider[] s_waistProbeBuf = (Collider[])(object)new Collider[64];

		[RegisterCleanup]
		public static void ClearDiagnosticState()
		{
			LastOutsideCells = null;
			LastXzMaxY = null;
			LastGxMin = (LastGzMin = (LastGxMax = (LastGzMax = 0)));
			LastCell = 0f;
			LastPieceMask = 0;
			HasSnapshot = false;
		}

		public static Stats Apply(HashSet<string> regionIds, Dictionary<string, Vector3> centroids, Dictionary<long, string> lookupGrid, List<(string id, Vector3 center, Vector3 outwardDir)> boundaryCells, List<RegionLink> links, Dictionary<string, SurfaceKind> kindMap, List<RegionBuilder.CachedTriangle> triangles, List<Vector3> anchors, float minX, float minZ, float maxX, float maxZ, out HashSet<string> droppedRegionIds, out List<(string fromRid, string toRid, Vector3 startPos, Vector3 endPos)> pass3DiscoveredEdgeList, out HashSet<long> anchorReachableCellsOut, out HashSet<long> outsideCellsOut, out HashSet<long> prunedPieceKeysOut, out List<Vector3> gateMarkersOut)
		{
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_071b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_079c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cda: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cdc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d71: Unknown result type (might be due to invalid IL or missing references)
			//IL_105f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fbb: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> dropped = new HashSet<string>();
			droppedRegionIds = dropped;
			pass3DiscoveredEdgeList = new List<(string, string, Vector3, Vector3)>();
			anchorReachableCellsOut = new HashSet<long>();
			outsideCellsOut = new HashSet<long>();
			prunedPieceKeysOut = new HashSet<long>();
			gateMarkersOut = new List<Vector3>();
			Stats stats = default(Stats);
			if (regionIds == null || regionIds.Count == 0)
			{
				return stats;
			}
			if (lookupGrid == null || lookupGrid.Count == 0)
			{
				return stats;
			}
			int pieceMask = LayerMask.GetMask(new string[1] { "piece" });
			if (pieceMask == 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[RubberBand] Skipped: 'piece' layer not found");
				}
				return stats;
			}
			int staticSolidLayer = LayerMask.NameToLayer("static_solid");
			float cell = 1f;
			int num = Mathf.FloorToInt(minX / cell) - 1;
			int num2 = Mathf.FloorToInt(minZ / cell) - 1;
			int num3 = Mathf.FloorToInt(maxX / cell) + 1;
			int num4 = Mathf.FloorToInt(maxZ / cell) + 1;
			Dictionary<long, float> xzMaxYTerrain = new Dictionary<long, float>();
			Dictionary<long, float> xzMaxYPiece = new Dictionary<long, float>();
			Dictionary<string, List<long>> dictionary = new Dictionary<string, List<long>>();
			Dictionary<string, HashSet<long>> dictionary2 = new Dictionary<string, HashSet<long>>();
			Dictionary<long, List<long>> xzToLookupKeysTerrain = new Dictionary<long, List<long>>();
			Dictionary<long, List<long>> xzToLookupKeysPiece = new Dictionary<long, List<long>>();
			foreach (KeyValuePair<long, string> item7 in lookupGrid)
			{
				UnpackLookup(item7.Key, out var gx, out var gz, out var _);
				if (gx < num || gx > num3 || gz < num2 || gz > num4)
				{
					continue;
				}
				long num5 = XzKey(gx, gz);
				SurfaceKind value;
				bool num6 = ((kindMap != null && kindMap.TryGetValue(item7.Value, out value)) ? value : SurfaceKind.Terrain) == SurfaceKind.Piece;
				Dictionary<long, float> dictionary3 = (num6 ? xzMaxYPiece : xzMaxYTerrain);
				Dictionary<long, List<long>> dictionary4 = (num6 ? xzToLookupKeysPiece : xzToLookupKeysTerrain);
				if (centroids.TryGetValue(item7.Value, out var value2))
				{
					if (!dictionary3.TryGetValue(num5, out var value3) || value2.y > value3)
					{
						dictionary3[num5] = value2.y;
					}
				}
				else if (!dictionary3.ContainsKey(num5))
				{
					dictionary3[num5] = 0f;
				}
				if (!dictionary.TryGetValue(item7.Value, out var value4))
				{
					value4 = new List<long>(4);
					dictionary[item7.Value] = value4;
				}
				value4.Add(num5);
				if (!dictionary4.TryGetValue(num5, out var value5))
				{
					value5 = (dictionary4[num5] = new List<long>(4));
				}
				value5.Add(item7.Key);
				if (num6)
				{
					if (!dictionary2.TryGetValue(item7.Value, out var value6))
					{
						value6 = new HashSet<long>();
						dictionary2[item7.Value] = value6;
					}
					value6.Add(item7.Key);
				}
			}
			List<GateSeal> gateSeals = GatherGateSeals(minX, minZ, maxX, maxZ);
			foreach (GateSeal item8 in gateSeals)
			{
				gateMarkersOut.Add(item8.Mid);
			}
			int perimeterSeedCount;
			HashSet<long> outsideCells = PerimeterOutsideFlood(num, num2, num3, num4, (int gx4, int gz4) => GetCellY(gx4, gz4, xzMaxYTerrain, cell), (int ax, int az, int bx, int bz, float ya, float yb) => WallBlocks(ax, az, bx, bz, ya, yb, cell, pieceMask) || GateBlocksStep(ax, az, bx, bz, cell, gateSeals), out perimeterSeedCount);
			stats.PerimeterSeeds = perimeterSeedCount;
			int[] array = new int[4] { 1, -1, 0, 0 };
			int[] array2 = new int[4] { 0, 0, 1, -1 };
			foreach (KeyValuePair<long, float> item9 in xzMaxYTerrain)
			{
				if (outsideCells.Contains(item9.Key))
				{
					stats.OutsideTerrainCells++;
				}
			}
			HashSet<long> anchorReachableCells = new HashSet<long>();
			Dictionary<long, float> anchorReachableCellY = new Dictionary<long, float>();
			int seedCount = 0;
			if (anchors != null && anchors.Count > 0 && (Object)(object)ZoneSystem.instance != (Object)null)
			{
				AnchorReachableFlood(num, num2, num3, num4, anchors, outsideCells, cell, 6, (long ck) => xzMaxYTerrain.ContainsKey(ck) || xzMaxYPiece.ContainsKey(ck), (long xzKey, int gx4, int gz4) => SurfaceY(xzKey, gx4, gz4, out var _), (int ax, int az, int bx, int bz, float ya, float yb) => WallBlocks(ax, az, bx, bz, ya, yb, cell, pieceMask), out anchorReachableCells, out anchorReachableCellY, out seedCount, delegate(string msg)
				{
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogWarning((object)msg);
					}
				});
			}
			stats.Pass2Seeds = seedCount;
			stats.AnchorReachableTerrainCells = anchorReachableCells.Count;
			HashSet<long> pieceReachableKeys = new HashSet<long>();
			int num7 = 0;
			HashSet<string> pass3DiscoveredEdges = new HashSet<string>();
			List<(string fromRid, string toRid, Vector3 startPos, Vector3 endPos)> pass3EdgePairs = new List<(string, string, Vector3, Vector3)>();
			if (xzToLookupKeysPiece.Count > 0 && anchorReachableCells.Count > 0 && (Object)(object)ZoneSystem.instance != (Object)null)
			{
				float num8 = cell * 0.5f;
				HashSet<long> hashSet = new HashSet<long>();
				Queue<(long, float, bool, string)> queue = new Queue<(long, float, bool, string)>();
				foreach (long item10 in anchorReachableCells)
				{
					UnpackXz(item10, out var gx2, out var gz2);
					float num9 = (float)gx2 * cell + num8;
					float num10 = (float)gz2 * cell + num8;
					float value7;
					float item = (anchorReachableCellY.TryGetValue(item10, out value7) ? value7 : ZoneSystem.instance.GetGroundHeight(new Vector3(num9, 0f, num10)));
					queue.Enqueue((item10, item, true, null));
				}
				while (queue.Count > 0)
				{
					var (num11, num12, flag, text) = queue.Dequeue();
					if (flag && !hashSet.Add(num11))
					{
						continue;
					}
					UnpackXz(num11, out var gx3, out var gz3);
					for (int num13 = 0; num13 < 4; num13++)
					{
						int num14 = gx3 + array[num13];
						int num15 = gz3 + array2[num13];
						long num16 = XzKey(num14, num15);
						if (anchorReachableCells.Contains(num16) && !hashSet.Contains(num16))
						{
							float num17 = (float)num14 * cell + num8;
							float num18 = (float)num15 * cell + num8;
							float value8;
							float num19 = (anchorReachableCellY.TryGetValue(num16, out value8) ? value8 : ZoneSystem.instance.GetGroundHeight(new Vector3(num17, 0f, num18)));
							if (Mathf.Abs(num19 - num12) <= 1f)
							{
								queue.Enqueue((num16, num19, true, null));
							}
						}
						if (!xzToLookupKeysPiece.TryGetValue(num16, out var value9))
						{
							continue;
						}
						string text2 = null;
						foreach (long item11 in value9)
						{
							if (!pieceReachableKeys.Contains(item11) && lookupGrid.TryGetValue(item11, out var value10) && centroids.TryGetValue(value10, out var value11) && !(Mathf.Abs(value11.y - num12) > 1f) && !outsideCells.Contains(num16))
							{
								pieceReachableKeys.Add(item11);
								queue.Enqueue((num16, value11.y, false, value10));
								num7++;
								string text3 = text ?? TerrainRegionAtCell(num11) ?? PieceAtCellInReachable(num11, num12) ?? text2;
								ComputePieceStepLinkPositions(num11, num16, num12, value11.y, cell, text3 == text2, out var startPos, out var endPos);
								RecordPass3Edge(text3, value10, startPos, endPos);
								text2 = value10;
							}
						}
					}
				}
			}
			stats.Pass3Seeds = num7;
			stats.AnchorReachablePieceKeys = pieceReachableKeys.Count;
			pass3DiscoveredEdgeList = pass3EdgePairs;
			HashSet<long> hashSet2 = new HashSet<long>();
			foreach (KeyValuePair<long, List<long>> item12 in xzToLookupKeysPiece)
			{
				foreach (long item13 in item12.Value)
				{
					if (!pieceReachableKeys.Contains(item13))
					{
						hashSet2.Add(item13);
					}
				}
			}
			prunedPieceKeysOut = hashSet2;
			if (staticSolidLayer >= 0 && outsideCells.Count > 0 && triangles != null && triangles.Count > 0)
			{
				int count = triangles.Count;
				triangles.RemoveAll(delegate(RegionBuilder.CachedTriangle t)
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0028: 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_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_0052: Unknown result type (might be due to invalid IL or missing references)
					if (t.Layer != staticSolidLayer)
					{
						return false;
					}
					float num30 = (t.V0.x + t.V1.x + t.V2.x) / 3f;
					float num31 = (t.V0.z + t.V1.z + t.V2.z) / 3f;
					int gx4 = Mathf.FloorToInt(num30 / cell);
					int gz4 = Mathf.FloorToInt(num31 / cell);
					return outsideCells.Contains(XzKey(gx4, gz4));
				});
				stats.StaticSolidTrianglesDropped = count - triangles.Count;
			}
			int num20 = 0;
			foreach (KeyValuePair<long, List<long>> item14 in xzToLookupKeysTerrain)
			{
				if (anchorReachableCells.Contains(item14.Key))
				{
					continue;
				}
				foreach (long item15 in item14.Value)
				{
					if (lookupGrid.Remove(item15))
					{
						num20++;
					}
				}
			}
			int num21 = 0;
			int num22 = 0;
			foreach (KeyValuePair<long, List<long>> item16 in xzToLookupKeysPiece)
			{
				foreach (long item17 in item16.Value)
				{
					if (!pieceReachableKeys.Contains(item17))
					{
						num22++;
						if (lookupGrid.Remove(item17))
						{
							num21++;
						}
					}
				}
			}
			stats.LookupCellsDropped = num20 + num21;
			stats.Pass3PieceKeysDropped = num22;
			if (triangles != null && triangles.Count > 0)
			{
				int count2 = triangles.Count;
				triangles.RemoveAll(delegate(RegionBuilder.CachedTriangle t)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: 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_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: 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)
					float num30 = (t.V0.x + t.V1.x + t.V2.x) / 3f;
					float num31 = (t.V0.z + t.V1.z + t.V2.z) / 3f;
					int gx4 = Mathf.FloorToInt(num30 / cell);
					int gz4 = Mathf.FloorToInt(num31 / cell);
					if (((kindMap != null && !string.IsNullOrEmpty(t.RegionId) && kindMap.TryGetValue(t.RegionId, out var value17)) ? value17 : SurfaceKind.Terrain) == SurfaceKind.Piece)
					{
						int hb3 = RegionGraph.HeightBucket((t.V0.y + t.V1.y + t.V2.y) / 3f);
						long item6 = RegionGraph.PackLookup(gx4, gz4, hb3);
						return !pieceReachableKeys.Contains(item6);
					}
					return !anchorReachableCells.Contains(XzKey(gx4, gz4));
				});
				stats.TrianglesDropped = count2 - triangles.Count;
			}
			foreach (string regionId in regionIds)
			{
				bool flag2 = false;
				List<long> value14;
				if (((kindMap != null && kindMap.TryGetValue(regionId, out var value12)) ? value12 : SurfaceKind.Terrain) == SurfaceKind.Piece)
				{
					if (dictionary2.TryGetValue(regionId, out var value13))
					{
						foreach (long item18 in value13)
						{
							if (pieceReachableKeys.Contains(item18))
							{
								flag2 = true;
								break;
							}
						}
					}
				}
				else if (dictionary.TryGetValue(regionId, out value14))
				{
					foreach (long item19 in value14)
					{
						if (anchorReachableCells.Contains(item19))
						{
							flag2 = true;
							break;
						}
					}
				}
				if (!flag2)
				{
					dropped.Add(regionId);
				}
			}
			if (dropped.Count > 0)
			{
				regionIds.RemoveWhere((string r) => dropped.Contains(r));
				foreach (string item20 in dropped)
				{
					centroids?.Remove(item20);
					kindMap?.Remove(item20);
				}
				links?.RemoveAll((RegionLink l) => dropped.Contains(l.FromRegionId) || dropped.Contains(l.ToRegionId));
				boundaryCells?.RemoveAll(((string id, Vector3 center, Vector3 outwardDir) b) => dropped.Contains(b.id));
			}
			stats.RegionsDropped = dropped.Count;
			if (links != null && pass3EdgePairs.Count > 0)
			{
				HashSet<string> hashSet3 = new HashSet<string>(links.Count);
				foreach (RegionLink link in links)
				{
					hashSet3.Add(CanonicalPair(link.FromRegionId, link.ToRegionId));
				}
				int num23 = 0;
				foreach (var (text4, text5, positionStart, positionEnd) in pass3EdgePairs)
				{
					if (!dropped.Contains(text4) && !dropped.Contains(text5))
					{
						string item2 = CanonicalPair(text4, text5);
						if (hashSet3.Add(item2) && centroids != null && centroids.ContainsKey(text4) && centroids.ContainsKey(text5))
						{
							links.Add(new RegionLink
							{
								FromRegionId = text4,
								ToRegionId = text5,
								LinkType = RegionLinkType.Slope,
								PositionStart = positionStart,
								PositionEnd = positionEnd
							});
							num23++;
						}
					}
				}
				stats.Pass3LinksAdded = num23;
			}
			ConsolidateLinearChains(regionIds, centroids, lookupGrid, boundaryCells, links, kindMap, triangles, pass3EdgePairs, ref stats);
			SnapBordersToAgentNavMesh(regionIds, links, triangles, ref stats);
			LastOutsideCells = new HashSet<long>(outsideCells);
			Dictionary<long, float> dictionary5 = new Dictionary<long, float>(xzMaxYTerrain.Count + xzMaxYPiece.Count);
			foreach (KeyValuePair<long, float> item21 in xzMaxYTerrain)
			{
				dictionary5[item21.Key] = item21.Value;
			}
			foreach (KeyValuePair<long, float> item22 in xzMaxYPiece)
			{
				if (!dictionary5.TryGetValue(item22.Key, out var value15) || item22.Value > value15)
				{
					dictionary5[item22.Key] = item22.Value;
				}
			}
			LastXzMaxY = dictionary5;
			LastGxMin = num;
			LastGzMin = num2;
			LastGxMax = num3;
			LastGzMax = num4;
			LastCell = cell;
			LastPieceMask = pieceMask;
			HasSnapshot = true;
			if (anchorReachableCells.Count > 0)
			{
				int[] array3 = new int[4] { 1, -1, 0, 0 };
				int[] array4 = new int[4] { 0, 0, 1, -1 };
				List<(string, Vector3, Vector3)> list2 = new List<(string, Vector3, Vector3)>();
				Vector3 item4 = default(Vector3);
				for (int num24 = num; num24 <= num3; num24++)
				{
					for (int num25 = num2; num25 <= num4; num25++)
					{
						long num26 = XzKey(num24, num25);
						if (!anchorReachableCells.Contains(num26))
						{
							continue;
						}
						Vector3 val = Vector3.zero;
						for (int num27 = 0; num27 < 4; num27++)
						{
							for (int num28 = 1; num28 <= 4; num28++)
							{
								long item3 = XzKey(num24 + array3[num27] * num28, num25 + array4[num27] * num28);
								if (anchorReachableCells.Contains(item3))
								{
									break;
								}
								if (outsideCells.Contains(item3))
								{
									val += new Vector3((float)array3[num27], 0f, (float)array4[num27]);
									break;
								}
							}
						}
						if (!(((Vector3)(ref val)).sqrMagnitude < 1E-06f))
						{
							bool populated;
							float num29 = SurfaceY(num26, num24, num25, out populated);
							((Vector3)(ref item4))..ctor((float)num24 * cell + cell * 0.5f, num29, (float)num25 * cell + cell * 0.5f);
							int hb2 = RegionGraph.HeightBucket(num29);
							string value16;
							string item5 = (lookupGrid.TryGetValue(RegionGraph.PackLookup(num24, num25, hb2), out value16) ? value16 : "frontier");
							list2.Add((item5, item4, ((Vector3)(ref val)).normalized));
						}
					}
				}
				if (list2.Count >= 3)
				{
					boundaryCells.Clear();
					boundaryCells.AddRange(list2);
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"[RubberBand] Boundary cells from flood frontier: {list2.Count} outer cells");
					}
				}
				else
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogWarning((object)($"[RubberBand] Flood frontier degenerate ({list2.Count} cells); " + "keeping upstream region-edge boundary cells"));
					}
				}
			}
			anchorReachableCellsOut = new HashSet<long>(anchorReachableCells);
			outsideCellsOut = new HashSet<long>(outsideCells);
			return stats;
			static string CanonicalPair(string a, string b)
			{
				if (string.CompareOrdinal(a, b) >= 0)
				{
					return b + "|" + a;
				}
				return a + "|" + b;
			}
			static void ComputePieceStepLinkPositions(long fromXz, long toXz, float fromY, float toY, float cellSize, bool sameCell, out Vector3 reference, out Vector3 reference2)
			{
				//IL_00b8: 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_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				UnpackXz(fromXz, out var gx4, out var gz4);
				UnpackXz(toXz, out var gx5, out var gz5);
				float num30 = cellSize * 0.5f;
				float num31 = (float)gx4 * cellSize + num30;
				float num32 = (float)gz4 * cellSize + num30;
				float num33 = (float)gx5 * cellSize + num30;
				float num34 = (float)gz5 * cellSize + num30;
				if (sameCell)
				{
					reference = new Vector3(num31, fromY, num32);
					reference2 = new Vector3(num31, toY, num32);
				}
				else
				{
					float num35 = (num31 + num33) * 0.5f;
					float num36 = (num32 + num34) * 0.5f;
					float num37 = Mathf.Sign(num33 - num31);
					float num38 = Mathf.Sign(num34 - num32);
					reference = new Vector3(num35 - num37 * 0.1f, fromY, num36 - num38 * 0.1f);
					reference2 = new Vector3(num35 + num37 * 0.1f, toY, num36 + num38 * 0.1f);
				}
			}
			string PieceAtCellInReachable(long xz, float targetY)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				if (!xzToLookupKeysPiece.TryGetValue(xz, out var value17))
				{
					return null;
				}
				string result = null;
				float num30 = float.MaxValue;
				foreach (long item23 in value17)
				{
					if (pieceReachableKeys.Contains(item23) && lookupGrid.TryGetValue(item23, out var value18) && centroids.TryGetValue(value18, out var value19))
					{
						float num31 = Mathf.Abs(value19.y - targetY);
						if (!(num31 > 1f) && num31 < num30)
						{
							num30 = num31;
							result = value18;
						}
					}
				}
				return result;
			}
			void RecordPass3Edge(string fromRid, string toRid, Vector3 item7, Vector3 item8)
			{
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				if (!string.IsNullOrEmpty(fromRid) && !string.IsNullOrEmpty(toRid) && !(fromRid == toRid))
				{
					string item6 = CanonicalPair(fromRid, toRid);
					if (pass3DiscoveredEdges.Add(item6))
					{
						pass3EdgePairs.Add((fromRid, toRid, item7, item8));
					}
				}
			}
			float SurfaceY(long xzKey, int num31, int num32, out bool reference)
			{
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				float num30 = float.MinValue;
				if (xzMaxYTerrain.TryGetValue(xzKey, out var value17))
				{
					num30 = value17;
				}
				if (xzMaxYPiece.TryGetValue(xzKey, out var value18) && value18 > num30)
				{
					num30 = value18;
				}
				reference = num30 > float.MinValue;
				if (reference)
				{
					return num30;
				}
				if (!((Object)(object)ZoneSystem.instance != (Object)null))
				{
					return 0f;
				}
				return ZoneSystem.instance.GetGroundHeight(new Vector3((float)num31 * cell + cell * 0.5f, 0f, (float)num32 * cell + cell * 0.5f));
			}
			string TerrainRegionAtCell(long xz)
			{
				if (!xzToLookupKeysTerrain.TryGetValue(xz, out var value17))
				{
					return null;
				}
				foreach (long item24 in value17)
				{
					if (lookupGrid.TryGetValue(item24, out var value18))
					{
						return value18;
					}
				}
				return null;
			}
		}

		internal static long DiagnoseXzKey(int gx, int gz)
		{
			return XzKey(gx, gz);
		}

		internal static float DiagnoseCellY(int gx, int gz)
		{
			if (LastXzMaxY == null)
			{
				return 0f;
			}
			return GetCellY(gx, gz, LastXzMaxY, (LastCell > 0f) ? LastCell : 1f);
		}

		internal static HashSet<long> PerimeterOutsideFlood(int gxMin, int gzMin, int gxMax, int gzMax, Func<int, int, float> cellY, Func<int, int, int, int, float, float, bool> wallBlocks, out int perimeterSeedCount)
		{
			HashSet<long> hashSet = new HashSet<long>();
			Queue<long> queue = new Queue<long>();
			for (int i = gxMin; i <= gxMax; i++)
			{
				EnqueuePerimeterSeed(i, gzMin, hashSet, queue);
				EnqueuePerimeterSeed(i, gzMax, hashSet, queue);
			}
			for (int j = gzMin + 1; j <= gzMax - 1; j++)
			{
				EnqueuePerimeterSeed(gxMin, j, hashSet, queue);
				EnqueuePerimeterSeed(gxMax, j, hashSet, queue);
			}
			perimeterSeedCount = hashSet.Count;
			int[] array = new int[4] { 1, -1, 0, 0 };
			int[] array2 = new int[4] { 0, 0, 1, -1 };
			while (queue.Count > 0)
			{
				UnpackXz(queue.Dequeue(), out var gx, out var gz);
				float arg = cellY(gx, gz);
				for (int k = 0; k < 4; k++)
				{
					int num = gx + array[k];
					int num2 = gz + array2[k];
					if (num < gxMin || num > gxMax || num2 < gzMin || num2 > gzMax)
					{
						continue;
					}
					long item = XzKey(num, num2);
					if (!hashSet.Contains(item))
					{
						float arg2 = cellY(num, num2);
						if (!wallBlocks(gx, gz, num, num2, arg, arg2))
						{
							hashSet.Add(item);
							queue.Enqueue(item);
						}
					}
				}
			}
			return hashSet;
		}

		internal static void AnchorReachableFlood(int gxMin, int gzMin, int gxMax, int gzMax, IReadOnlyList<Vector3> anchors, HashSet<long> outsideCells, float cell, int anchorSnapRingMax, Func<long, bool> isPopulated, Func<long, int, int, float> surfaceY, Func<int, int, int, int, float, float, bool> wallBlocks, out HashSet<long> anchorReachableCells, out Dictionary<long, float> anchorReachableCellY, out int seedCount, Action<string> warn = null)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			anchorReachableCells = new HashSet<long>();
			anchorReachableCellY = new Dictionary<long, float>();
			seedCount = 0;
			if (anchors == null || anchors.Count == 0)
			{
				return;
			}
			Queue<(long, float)> queue = new Queue<(long, float)>();
			foreach (Vector3 anchor in anchors)
			{
				int num = Mathf.FloorToInt(anchor.x / cell);
				int num2 = Mathf.FloorToInt(anchor.z / cell);
				int num3 = num;
				int num4 = num2;
				bool flag = false;
				for (int i = 0; i <= anchorSnapRingMax; i++)
				{
					if (flag)
					{
						break;
					}
					for (int j = -i; j <= i; j++)
					{
						if (flag)
						{
							break;
						}
						for (int k = -i; k <= i; k++)
						{
							if (flag)
							{
								break;
							}
							if (Mathf.Max(Mathf.Abs(j), Mathf.Abs(k)) != i)
							{
								continue;
							}
							int num5 = num + j;
							int num6 = num2 + k;
							if (num5 >= gxMin && num5 <= gxMax && num6 >= gzMin && num6 <= gzMax)
							{
								long num7 = XzKey(num5, num6);
								if (!outsideCells.Contains(num7) && isPopulated(num7))
								{
									num3 = num5;
									num4 = num6;
									flag = true;
								}
							}
						}
					}
				}
				if (!flag)
				{
					warn?.Invoke($"[RubberBand] Pass 2 anchor skipped: anchor=({anchor.x:F1},{anchor.z:F1}) " + $"cell=({num},{num2}) — no populated, non-outside cell within " + $"{anchorSnapRingMax} cells (anchor walled off or outside the village?).");
					continue;
				}
				long num8 = XzKey(num3, num4);
				if (anchorReachableCells.Add(num8))
				{
					float num9 = surfaceY(num8, num3, num4);
					anchorReachableCellY[num8] = num9;
					queue.Enqueue((num8, num9));
					seedCount++;
				}
			}
			int[] array = new int[4] { 1, -1, 0, 0 };
			int[] array2 = new int[4] { 0, 0, 1, -1 };
			while (queue.Count > 0)
			{
				var (key, arg) = queue.Dequeue();
				UnpackXz(key, out var gx, out var gz);
				for (int l = 0; l < 4; l++)
				{
					int num10 = gx + array[l];
					int num11 = gz + array2[l];
					if (num10 < gxMin || num10 > gxMax || num11 < gzMin || num11 > gzMax)
					{
						continue;
					}
					long num12 = XzKey(num10, num11);
					if (!anchorReachableCells.Contains(num12) && !outsideCells.Contains(num12))
					{
						float num13 = surfaceY(num12, num10, num11);
						if (!wallBlocks(gx, gz, num10, num11, arg, num13))
						{
							anchorReachableCells.Add(num12);
							anchorReachableCellY[num12] = num13;
							queue.Enqueue((num12, num13));
						}
					}
				}
			}
		}

		public static HashSet<long> ComputeOutsideCellsForBake(Bounds bounds)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			int pieceMask = LayerMask.GetMask(new string[1] { "piece" });
			if (pieceMask == 0)
			{
				return new HashSet<long>();
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return new HashSet<long>();
			}
			float cell = 1f;
			int gxMin = Mathf.FloorToInt(((Bounds)(ref bounds)).min.x / cell) - 1;
			int gzMin = Mathf.FloorToInt(((Bounds)(ref bounds)).min.z / cell) - 1;
			int gxMax = Mathf.FloorToInt(((Bounds)(ref bounds)).max.x / cell) + 1;
			int gzMax = Mathf.FloorToInt(((Bounds)(ref bounds)).max.z / cell) + 1;
			float half = cell * 0.5f;
			List<GateSeal> gateSeals = GatherGateSeals(((Bounds)(ref bounds)).min.x, ((Bounds)(ref bounds)).min.z, ((Bounds)(ref bounds)).max.x, ((Bounds)(ref bounds)).max.z);
			int perimeterSeedCount;
			return PerimeterOutsideFlood(gxMin, gzMin, gxMax, gzMax, (int gx, int gz) => ZoneSystem.instance.GetGroundHeight(new Vector3((float)gx * cell + half, 0f, (float)gz * cell + half)), (int ax, int az, int bx, int bz, float ya, float yb) => WallBlocks(ax, az, bx, bz, ya, yb, cell, pieceMask) || GateBlocksStep(ax, az, bx, bz, cell, gateSeals), out perimeterSeedCount);
		}

		public static void UnpackOutsideCellKey(long key, out int gx, out int gz)
		{
			UnpackXz(key, out gx, out gz);
		}

		public static bool IsOutsideCell(Vector3 worldPos, HashSet<long> outsideCells)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (outsideCells == null || outsideCells.Count == 0)
			{
				return false;
			}
			float num = 1f;
			int gx = Mathf.FloorToInt(worldPos.x / num);
			int gz = Mathf.FloorToInt(worldPos.z / num);
			return outsideCells.Contains(XzKey(gx, gz));
		}

		public static long PackXzKey(int gx, int gz)
		{
			return XzKey(gx, gz);
		}

		public static List<CellRect> DecomposeToRectangles(HashSet<long> cells)
		{
			List<CellRect> list = new List<CellRect>();
			if (cells == null || cells.Count == 0)
			{
				return list;
			}
			HashSet<long> hashSet = new HashSet<long>(cells);
			List<long> list2 = new List<long>(hashSet);
			list2.Sort();
			foreach (long item in list2)
			{
				if (!hashSet.Contains(item))
				{
					continue;
				}
				UnpackXz(item, out var gx, out var gz);
				int i;
				for (i = gx; hashSet.Contains(XzKey(i + 1, gz)); i++)
				{
				}
				int num = gz;
				while (true)
				{
					int num2 = num + 1;
					bool flag = true;
					for (int j = gx; j <= i; j++)
					{
						if (!hashSet.Contains(XzKey(j, num2)))
						{
							flag = false;
							break;
						}
					}
					if (!flag)
					{
						break;
					}
					num = num2;
				}
				for (int k = gz; k <= num; k++)
				{
					for (int l = gx; l <= i; l++)
					{
						hashSet.Remove(XzKey(l, k));
					}
				}
				list.Add(new CellRect(gx, gz, i, num));
			}
			return list;
		}

		private static void EnqueuePerimeterSeed(int gx, int gz, HashSet<long> outsideCells, Queue<long> queue)
		{
			long item = XzKey(gx, gz);
			if (outsideCells.Add(item))
			{
				queue.Enqueue(item);
			}
		}

		private static float GetCellY(int gx, int gz, Dictionary<long, float> xzMaxY, float cell)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			long key = XzKey(gx, gz);
			if (xzMaxY.TryGetValue(key, out var value))
			{
				return value;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return 0f;
			}
			float num = (float)gx * cell + cell * 0.5f;
			float num2 = (float)gz * cell + cell * 0.5f;
			return ZoneSystem.instance.GetGroundHeight(new Vector3(num, 0f, num2));
		}

		private static bool WallBlocks(int gxA, int gzA, int gxB, int gzB, float yA, float yB, float cell, int mask)
		{
			if (!ProbeAtWaist(gxA, gzA, gxB, gzB, yA, cell, mask))
			{
				if (yA != yB)
				{
					return ProbeAtWaist(gxA, gzA, gxB, gzB, yB, cell, mask);
				}
				return false;
			}
			return true;
		}

		private static bool ProbeAtWaist(int gxA, int gzA, int gxB, int gzB, float floorY, float cell, int mask)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			ComputeWaistProbeBox(gxA, gzA, gxB, gzB, floorY, cell, out var center, out var halfExtents);
			int num = Physics.OverlapBoxNonAlloc(center, halfExtents, s_waistProbeBuf, Quaternion.identity, mask, (QueryTriggerInteraction)1);
			for (int i = 0; i < num; i++)
			{
				Collider val = s_waistProbeBuf[i];
				if (!((Object)(object)val == (Object)null) && !IsBedCollider(val))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsBedCollider(Collider col)
		{
			return (Object)(object)((Component)col).GetComponentInParent<Bed>() != (Object)null;
		}

		internal static List<GateSeal> GatherGateSeals(float minX, float minZ, float maxX, float maxZ)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			List<GateSeal> list = new List<GateSeal>();
			Door[] array = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Door val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).transform == (Object)null)
				{
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				if (!(position.x < minX) && !(position.x > maxX) && !(position.z < minZ) && !(position.z > maxZ))
				{
					Vector3 forward = ((Component)val).transform.forward;
					forward.y = 0f;
					if (!(((Vector3)(ref forward)).sqrMagnitude < 0.0001f))
					{
						((Vector3)(ref forward)).Normalize();
						list.Add(new GateSeal(position, forward, GateHalfWidth(val)));
					}
				}
			}
			return list;
		}

		private static float GateHalfWidth(Door door)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			Collider[] componentsInChildren = ((Component)door).GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !val.isTrigger)
				{
					BoxCollider val2 = (BoxCollider)(object)((val is BoxCollider) ? val : null);
					if (val2 != null)
					{
						Vector3 lossyScale = ((Component)val2).transform.lossyScale;
						num = Mathf.Max(num, Mathf.Max(Mathf.Abs(val2.size.x * lossyScale.x), Mathf.Abs(val2.size.z * lossyScale.z)));
					}
				}
			}
			if (num <= 0f)
			{
				num = 1.2f;
			}
			return num * 0.5f + 0.5f;
		}

		private static bool GateBlocksStep(int gxA, int gzA, int gxB, int gzB, float cell, List<GateSeal> seals)
		{
			if (seals == null || seals.Count == 0)
			{
				return false;
			}
			float num = cell * 0.5f;
			float ax = (float)gxA * cell + num;
			float az = (float)gzA * cell + num;
			float bx = (float)gxB * cell + num;
			float bz = (float)gzB * cell + num;
			foreach (GateSeal seal in seals)
			{
				if (SegmentCrossesGateXz(ax, az, bx, bz, seal))
				{
					return true;
				}
			}
			return false;
		}

		private static bool SegmentCrossesGateXz(float ax, float az, float bx, float bz, GateSeal s)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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)
			float num = (ax - s.Mid.x) * s.Forward.x + (az - s.Mid.z) * s.Forward.z;
			float num2 = (bx - s.Mid.x) * s.Forward.x + (bz - s.Mid.z) * s.Forward.z;
			if (num >= 0f == num2 >= 0f)
			{
				return false;
			}
			float num3 = num - num2;
			if (Mathf.Abs(num3) < 1E-05f)
			{
				return false;
			}
			float num4 = num / num3;
			float num5 = ax + (bx - ax) * num4;
			float num6 = az + (bz - az) * num4;
			float num7 = num5 - s.Mid.x;
			float num8 = num6 - s.Mid.z;
			return num7 * num7 + num8 * num8 <= s.HalfWidth * s.HalfWidth;
		}

		private static void ConsolidateLinearChains(HashSet<string> regionIds, Dictionary<string, Vector3> centroids, Dictionary<long, string> lookupGrid, List<(string id, Vector3 center, Vector3 outwardDir)> boundaryCells, List<RegionLink> links, Dictionary<string, SurfaceKind> kindMap, List<RegionBuilder.CachedTriangle> triangles, List<(string fromRid, string toRid, Vector3 startPos, Vector3 endPos)> pass3EdgePairs, ref Stats stats)
		{
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: 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_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0722: Unknown result type (might be due to invalid IL or missing references)
			//IL_0729: 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_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06db: Unknown result type (might be due to invalid IL or missing references)
			if (links == null || links.Count == 0 || regionIds == null || regionIds.Count == 0)
			{
				return;
			}
			Dictionary<string, HashSet<string>> dictionary = new Dictionary<string, HashSet<string>>();
			foreach (RegionLink link in links)
			{
				if (kindMap == null)
				{
					break;
				}
				if (kindMap.TryGetValue(link.FromRegionId, out var value) && kindMap.TryGetValue(link.ToRegionId, out var value2) && value == SurfaceKind.Piece && value2 == SurfaceKind.Piece)
				{
					if (!dictionary.TryGetValue(link.FromRegionId, out var value3))
					{
						value3 = new HashSet<string>();
						dictionary[link.FromRegionId] = value3;
					}
					value3.Add(link.ToRegionId);
					if (!dictionary.TryGetValue(link.ToRegionId, out var value4))
					{
						value4 = new HashSet<string>();
						dictionary[link.ToRegionId] = value4;
					}
					value4.Add(link.FromRegionId);
				}
			}
			if (dictionary.Count == 0)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>();
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			int num = 0;
			int num2 = 0;
			foreach (string key in dictionary.Keys)
			{
				if (hashSet.Contains(key) || dictionary[key].Count != 1)
				{
					continue;
				}
				List<string> list = new List<string> { key };
				hashSet.Add(key);
				string text = null;
				string text2 = key;
				while (true)
				{
					string text3 = null;
					foreach (string item3 in dictionary[text2])
					{
						if (item3 != text)
						{
							text3 = item3;
							break;
						}
					}
					if (text3 == null || hashSet.Contains(text3) || !dictionary.TryGetValue(text3, out var value5) || value5.Count > 2)
					{
						break;
					}
					list.Add(text3);
					hashSet.Add(text3);
					if (value5.Count == 1)
					{
						break;
					}
					text = text2;
					text2 = text3;
				}
				if (list.Count < 2)
				{
					continue;
				}
				Vector3 val = Vector3.zero;
				int num3 = 0;
				while (true)
				{
					Vector3 val3;
					if (num3 < list.Count - 1)
					{
						if (!centroids.TryGetValue(list[num3], out var value6) || !centroids.TryGetValue(list[num3 + 1], out var value7))
						{
							break;
						}
						Vector3 val2 = val;
						val3 = value7 - value6;
						val = val2 + ((Vector3)(ref val3)).normalized;
						num3++;
						continue;
					}
					val3 = val / (float)(list.Count - 1);
					val = ((Vector3)(ref val3)).normalized;
					if (Mathf.Abs(val.y) < 0.1f)
					{
						break;
					}
					bool flag = true;
					for (int i = 0; i < list.Count - 1; i++)
					{
						val3 = centroids[list[i + 1]] - centroids[list[i]];
						if (Vector3.Dot(((Vector3)(ref val3)).normalized, val) < 0.94f)
						{
							flag = false;
							break;
						}
					}
					if (!flag)
					{
						break;
					}
					string text4 = list[0];
					Vector3 val4 = Vector3.zero;
					foreach (string item4 in list)
					{
						val4 += centroids[item4];
					}
					centroids[text4] = val4 / (float)list.Count;
					for (int j = 1; j < list.Count; j++)
					{
						dictionary2[list[j]] = text4;
						num2++;
					}
					num++;
					break;
				}
			}
			if (dictionary2.Count == 0)
			{
				stats.Pass5ChainsConsolidated = 0;
				stats.Pass5RegionsConsumed = 0;
				stats.Pass5LinksRemoved = 0;
				return;
			}
			foreach (string key2 in dictionary2.Keys)
			{
				regionIds.Remove(key2);
				centroids?.Remove(key2);
				kindMap?.Remove(key2);
			}
			if (triangles != null)
			{
				for (int k = 0; k < triangles.Count; k++)
				{
					RegionBuilder.CachedTriangle value8 = triangles[k];
					if (dictionary2.TryGetValue(value8.RegionId, out var value9))
					{
						value8.RegionId = value9;
						triangles[k] = value8;
					}
				}
			}
			if (lookupGrid != null)
			{
				List<long> list2 = new List<long>();
				foreach (KeyValuePair<long, string> item5 in lookupGrid)
				{
					if (dictionary2.ContainsKey(item5.Value))
					{
						list2.Add(item5.Key);
					}
				}
				foreach (long item6 in list2)
				{
					lookupGrid[item6] = dictionary2[lookupGrid[item6]];
				}
			}
			int num4 = 0;
			if (links != null)
			{
				HashSet<string> hashSet2 = new HashSet<string>();
				for (int num5 = links.Count - 1; num5 >= 0; num5--)
				{
					RegionLink value10 = links[num5];
					string value11;
					string text5 = (dictionary2.TryGetValue(value10.FromRegionId, out value11) ? value11 : value10.FromRegionId);
					string value12;
					string text6 = (dictionary2.TryGetValue(value10.ToRegionId, out value12) ? value12 : value10.ToRegionId);
					if (text5 == text6)
					{
						links.RemoveAt(num5);
						num4++;
					}
					else
					{
						string item = ((string.CompareOrdinal(text5, text6) < 0) ? (text5 + "|" + text6) : (text6 + "|" + text5));
						if (!hashSet2.Add(item))
						{
							links.RemoveAt(num5);
							num4++;
						}
						else
						{
							value10.FromRegionId = text5;
							value10.ToRegionId = text6;
							links[num5] = value10;
						}
					}
				}
			}
			if (pass3EdgePairs != null)
			{
				HashSet<string> hashSet3 = new HashSet<string>();
				for (int num6 = pass3EdgePairs.Count - 1; num6 >= 0; num6--)
				{
					(string, string, Vector3, Vector3) tuple = pass3EdgePairs[num6];
					string text7;
					if (!dictionary2.TryGetValue(tuple.Item1, out var value13))
					{
						(text7, _, _, _) = tuple;
					}
					else
					{
						text7 = value13;
					}
					string text8 = text7;
					string value14;
					string text9 = (dictionary2.TryGetValue(tuple.Item2, out value14) ? value14 : tuple.Item2);
					if (text8 == text9)
					{
						pass3EdgePairs.RemoveAt(num6);
					}
					else
					{
						string item2 = ((string.CompareOrdinal(text8, text9) < 0) ? (text8 + "|" + text9) : (text9 + "|" + text8));
						if (!hashSet3.Add(item2))
						{
							pass3EdgePairs.RemoveAt(num6);
						}
						else
						{
							pass3EdgePairs[num6] = (text8, text9, tuple.Item3, tuple.Item4);
						}
					}
				}
			}
			if (boundaryCells != null)
			{
				for (int l = 0; l < boundaryCells.Count; l++)
				{
					(string, Vector3, Vector3) tuple3 = boundaryCells[l];
					if (dictionary2.TryGetValue(tuple3.Item1, out var value15))
					{
						boundaryCells[l] = (value15, tuple3.Item2, tuple3.Item3);
					}
				}
			}
			stats.Pass5ChainsConsolidated = num;
			stats.Pass5RegionsConsumed = num2;
			stats.Pass5LinksRemoved = num4;
			DebugLog.Event("RubberBandPrune", "pass5_chain_consolidation", ("chains_consolidated", num), ("regions_consumed", num2), ("links_removed", num4));
		}

		private static void SnapBordersToAgentNavMesh(HashSet<string> regionIds, List<RegionLink> links, List<RegionBuilder.CachedTriangle> triangles, ref Stats stats)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: 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_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			if (!VillagerAgentType.IsRegistered || triangles == null || triangles.Count == 0)
			{
				return;
			}
			int unityAgentTypeID = VillagerAgentType.UnityAgentTypeID;
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = unityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			Dictionary<string, List<int>> dictionary = new Dictionary<string, List<int>>();
			for (int i = 0; i < triangles.Count; i++)
			{
				string regionId = triangles[i].RegionId;
				if (!string.IsNullOrEmpty(regionId) && regionIds.Contains(regionId))
				{
					if (!dictionary.TryGetValue(regionId, out var value))
					{
						value = (dictionary[regionId] = new List<int>());
					}
					value.Add(i);
				}
			}
			Dictionary<Vector3, Vector3> dictionary2 = new Dictionary<Vector3, Vector3>();
			int snapped = 0;
			int misses = 0;
			foreach (KeyValuePair<string, List<int>> item in dictionary)
			{
				List<int> value2 = item.Value;
				Dictionary<long, int> dictionary3 = new Dictionary<long, int>();
				Dictionary<long, (Vector3, Vector3)> dictionary4 = new Dictionary<long, (Vector3, Vector3)>();
				foreach (int item2 in value2)
				{
					RegionBuilder.CachedTriangle cachedTriangle = triangles[item2];
					AddEdgeForSnap(dictionary3, dictionary4, cachedTriangle.V0, cachedTriangle.V1);
					AddEdgeForSnap(dictionary3, dictionary4, cachedTriangle.V1, cachedTriangle.V2);
					AddEdgeForSnap(dictionary3, dictionary4, cachedTriangle.V2, cachedTriangle.V0);
				}
				foreach (KeyValuePair<long, int> item3 in dictionary3)
				{
					if (item3.Value == 1)
					{
						var (v, v2) = dictionary4[item3.Key];
						TrySnapAndCache(v, val2, 0.5f, dictionary2, ref snapped, ref misses);
						TrySnapAndCache(v2, val2, 0.5f, dictionary2, ref snapped, ref misses);
					}
				}
			}
			for (int j = 0; j < triangles.Count; j++)
			{
				RegionBuilder.CachedTriangle value3 = triangles[j];
				bool flag = false;
				if (dictionary2.TryGetValue(value3.V0, out var value4) && value4 != value3.V0)
				{
					value3.V0 = value4;
					flag = true;
				}
				if (dictionary2.TryGetValue(value3.V1, out var value5) && value5 != value3.V1)
				{
					value3.V1 = value5;
					flag = true;
				}
				if (dictionary2.TryGetValue(value3.V2, out var value6) && value6 != value3.V2)
				{
					value3.V2 = value6;
					flag = true;
				}
				if (flag)
				{
					triangles[j] = value3;
				}
			}
			int num = 0;
			if (links != null)
			{
				NavMeshHit val3 = default(NavMeshHit);
				NavMeshHit val4 = default(NavMeshHit);
				for (int k = 0; k < links.Count; k++)
				{
					RegionLink value7 = links[k];
					bool flag2 = false;
					if (NavMesh.SamplePosition(value7.PositionStart, ref val3, 0.5f, val2) && value7.PositionStart != ((NavMeshHit)(ref val3)).position)
					{
						value7.PositionStart = ((NavMeshHit)(ref val3)).position;
						flag2 = true;
					}
					if (NavMesh.SamplePosition(value7.PositionEnd, ref val4, 0.5f, val2) && value7.PositionEnd != ((NavMeshHit)(ref val4)).position)
					{
						value7.PositionEnd = ((NavMeshHit)(ref val4)).position;
						flag2 = true;
					}
					if (flag2)
					{
						links[k] = value7;
						num++;
					}
				}
			}
			stats.Pass4BoundaryVertsSnapped = snapped;
			stats.Pass4SnapMisses = misses;
			stats.Pass4LinksSnapped = num;
			DebugLog.Event("RubberBandPrune", "pass4_border_snap", ("boundary_verts_snapped", snapped), ("snap_misses", misses), ("links_snapped", num));
		}

		private unsafe static void AddEdgeForSnap(Dictionary<long, int> edgeCount, Dictionary<long, (Vector3 a, Vector3 b)> edgeVerts, Vector3 a, Vector3 b)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			int hashCode = ((object)(*(Vector3*)(&a))/*cast due to .constrained prefix*/).GetHashCode();
			int hashCode2 = ((object)(*(Vector3*)(&b))/*cast due to .constrained prefix*/).GetHashCode();
			long key = ((hashCode <= hashCode2) ? (((long)hashCode << 32) | (uint)hashCode2) : (((long)hashCode2 << 32) | (uint)hashCode));
			if (edgeCount.TryGetValue(key, out var value))
			{
				edgeCount[key] = value + 1;
				return;
			}
			edgeCount[key] = 1;
			edgeVerts[key] = (a, b);
		}

		private static void TrySnapAndCache(Vector3 v, NavMeshQueryFilter filter, float radius, Dictionary<Vector3, Vector3> cache, ref int snapped, ref int misses)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (cache.ContainsKey(v))
			{
				return;
			}
			NavMeshHit val = default(NavMeshHit);
			if (NavMesh.SamplePosition(v, ref val, radius, filter))
			{
				cache[v] = ((NavMeshHit)(ref val)).position;
				if (((NavMeshHit)(ref val)).position != v)
				{
					snapped++;
				}
			}
			else
			{
				cache[v] = v;
				misses++;
			}
		}

		internal static bool Diagnose(int gxA, int gzA, int gxB, int gzB, float yA, float yB, float cell, int mask, out string hitNames)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			ComputeWaistProbeBox(gxA, gzA, gxB, gzB, yA, cell, out var center, out var halfExtents);
			Collider[] array = Physics.OverlapBox(center, halfExtents, Quaternion.identity, mask, (QueryTriggerInteraction)1);
			Collider[] array2 = null;
			if (yA != yB)
			{
				ComputeWaistProbeBox(gxA, gzA, gxB, gzB, yB, cell, out var center2, out var halfExtents2);
				array2 = Physics.OverlapBox(center2, halfExtents2, Quaternion.identity, mask, (QueryTriggerInteraction)1);
			}
			int num = ((array != null) ? array.Length : 0) + ((array2 != null) ? array2.Length : 0);
			if (num == 0)
			{
				hitNames = "";
				return false;
			}
			List<string> names = new List<string>(Mathf.Min(num, 8));
			bool blocked = false;
			AddNames(array, 4);
			AddNames(array2, 4);
			hitNames = string.Join(";", names);
			if (num > names.Count)
			{
				hitNames += $";+{num - names.Count}";
			}
			return blocked;
			void AddNames(Collider[] arr, int max)
			{
				if (arr != null)
				{
					for (int i = 0; i < arr.Length; i++)
					{
						Collider val = arr[i];
						bool flag = (Object)(object)val != (Object)null && IsBedCollider(val);
						if (!flag && (Object)(object)val != (Object)null)
						{
							blocked = true;
						}
						if (i < max)
						{
							if ((Object)(object)val == (Object)null)
							{
								names.Add("<null>");
							}
							else
							{
								names.Add(flag ? (((Object)val).name + "(bed,ignored)") : ((Object)val).name);
							}
						}
					}
				}
			}
		}

		private static void ComputeWaistProbeBox(int gxA, int gzA, int gxB, int gzB, float floorY, float cell, out Vector3 center, out Vector3 halfExtents)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			float num = cell * 0.5f;
			float num2 = floorY + 0.7f;
			float num3 = floorY + 1.3f;
			float num4 = (num2 + num3) * 0.5f;
			float num5 = (num3 - num2) * 0.5f;
			float num6 = (float)(gxA + gxB) * 0.5f * cell + num;
			float num7 = (float)(gzA + gzB) * 0.5f * cell + num;
			center = new Vector3(num6, num4, num7);
			int num8 = gxB - gxA;
			int num9 = gzB - gzA;
			if ((num8 != 0 && num9 == 0) || (num9 != 0 && num8 == 0))
			{
				halfExtents = new Vector3(num, num5, num);
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogError((object)("[RubberBand] ComputeWaistProbeBox called with non-cardinal step " + $"({gxA},{gzA})->({gxB},{gzB}); 4-neighbour BFS contract violated."));
			}
			halfExtents = new Vector3(num, num5, num);
		}

		private static long XzKey(int gx, int gz)
		{
			return RegionGraph.PackXz(gx, gz);
		}

		private static void UnpackXz(long key, out int gx, out int gz)
		{
			RegionGraph.UnpackXz(key, out gx, out gz);
		}

		internal static void UnpackLookup(long key, out int gx, out int gz, out int hb)
		{
			long num = key % 1000003;
			if (num > 500001)
			{
				num -= 1000003;
			}
			else if (num < -500001)
			{
				num += 1000003;
			}
			long num2 = (key - num) / 1000003;
			long num3 = num2 % 1000003;
			if (num3 > 500001)
			{
				num3 -= 1000003;
			}
			else if (num3 < -500001)
			{
				num3 += 1000003;
			}
			long num4 = (num2 - num3) / 1000003;
			hb = (int)num;
			gz = (int)num3;
			gx = (int)num4;
		}
	}
	public static class SpatialDump
	{
		private const float CellSize = 4f;

		private const float ScanRadius = 50f;

		private const float RaycastHeight = 3f;

		private const float RaycastMaxDown = 8f;

		private const float HeightStep = 3f;

		private const float HeightMarginBelow = 5f;

		private const float HeightMarginAbove = 10f;

		private static readonly int GroundMask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "terrain", "piece" });

		[DevCommand("Dump spatial data (anchors, height grid, doors, pieces) to JSON for offline testing", Name = "vv_hna_dump")]
		public static void Dump()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_0665: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_066c: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0694: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0703: Unknown result type (might be due to invalid IL or missing references)
			//IL_073e: Unknown result type (might be due to invalid IL or missing references)
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_075c: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> allAnchorPositions = VillagerAIManager.GetAllAnchorPositions();
			if (allAnchorPositions == null || allAnchorPositions.Count == 0)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("No villager anchors found.");
				}
				return;
			}
			float minX;
			float minZ;
			float maxX;
			float maxZ;
			bool flag = VillageAreaManager.TryGetCombinedBounds(out minX, out minZ, out maxX, out maxZ);
			float num;
			float num2;
			float num3;
			float num4;
			if (flag)
			{
				num = minX;
				num2 = minZ;
				num3 = maxX;
				num4 = maxZ;
			}
			else
			{
				num = (num3 = allAnchorPositions[0].x);
				num2 = (num4 = allAnchorPositions[0].z);
			}
			foreach (Vector3 item2 in allAnchorPositions)
			{
				if (item2.x - 50f < num)
				{
					num = item2.x - 50f;
				}
				if (item2.z - 50f < num2)
				{
					num2 = item2.z - 50f;
				}
				if (item2.x + 50f > num3)
				{
					num3 = item2.x + 50f;
				}
				if (item2.z + 50f > num4)
				{
					num4 = item2.z + 50f;
				}
			}
			float num5 = num;
			float num6 = num2;
			int num7 = Mathf.Max(1, Mathf.CeilToInt((num3 - num) / 4f));
			int num8 = Mathf.Max(1, Mathf.CeilToInt((num4 - num2) / 4f));
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{\n");
			stringBuilder.Append("  \"anchors\": [\n");
			for (int i = 0; i < allAnchorPositions.Count; i++)
			{
				Vector3 val = allAnchorPositions[i];
				stringBuilder.Append($"    [{val.x:F2}, {val.y:F2}, {val.z:F2}]");
				stringBuilder.Append((i < allAnchorPositions.Count - 1) ? ",\n" : "\n");
			}
			stringBuilder.Append("  ],\n");
			if (flag)
			{
				stringBuilder.Append($"  \"patrolBounds\": [{minX:F2}, {minZ:F2}, {maxX:F2}, {maxZ:F2}],\n");
			}
			else
			{
				stringBuilder.Append("  \"patrolBounds\": null,\n");
			}
			stringBuilder.Append($"  \"cellSize\": {4f:F1},\n");
			stringBuilder.Append($"  \"origin\": [{num5:F2}, {num6:F2}],\n");
			stringBuilder.Append($"  \"gridSize\": [{num7}, {num8}],\n");
			stringBuilder.Append("  \"heightGrid\": [\n");
			int num9 = ((GroundMask != 0) ? GroundMask : (-1));
			float[] array = GatherReferenceHeights(allAnchorPositions);
			RaycastHit val2 = default(RaycastHit);
			for (int j = 0; j < num8; j++)
			{
				for (int k = 0; k < num7; k++)
				{
					float num10 = num5 + ((float)k + 0.5f) * 4f;
					float num11 = num6 + ((float)j + 0.5f) * 4f;
					stringBuilder.Append("    { ");
					stringBuilder.Append($"\"ix\": {k}, \"iz\": {j}, ");
					stringBuilder.Append($"\"wx\": {num10:F2}, \"wz\": {num11:F2}, ");
					stringBuilder.Append("\"hits\": [");
					HashSet<int> hashSet = new HashSet<int>();
					bool flag2 = true;
					float[] array2 = array;
					foreach (float num12 in array2)
					{
						if (!Physics.Raycast(new Vector3(num10, num12 + 3f, num11), Vector3.down, ref val2, 8f, num9, (QueryTriggerInteraction)1))
						{
							continue;
						}
						int item = Mathf.RoundToInt(((RaycastHit)(ref val2)).point.y * 4f);
						if (hashSet.Add(item))
						{
							if (!flag2)
							{
								stringBuilder.Append(", ");
							}
							string text = LayerMask.LayerToName(((Component)((RaycastHit)(ref val2)).collider).gameObject.layer);
							stringBuilder.Append($"{{\"refY\": {num12:F2}, \"hitY\": {((RaycastHit)(ref val2)).point.y:F2}, \"layer\": \"{text}\", \"layerIdx\": {((Component)((RaycastHit)(ref val2)).collider).gameObject.layer}}}");
							flag2 = false;
						}
					}
					stringBuilder.Append("] }");
					bool flag3 = j == num8 - 1 && k == num7 - 1;
					stringBuilder.Append(flag3 ? "\n" : ",\n");
				}
			}
			stringBuilder.Append("  ],\n");
			stringBuilder.Append("  \"doors\": [\n");
			Door[] array3 = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			int num13 = 0;
			Door[] array4 = array3;
			foreach (Door val3 in array4)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				Vector3 position = ((Component)val3).transform.position;
				if (!(position.x < num - 10f) && !(position.x > num3 + 10f) && !(position.z < num2 - 10f) && !(position.z > num4 + 10f))
				{
					Vector3 forward = ((Component)val3).transform.forward;
					bool flag4 = (Object)(object)((Component)val3).GetComponentInParent<Piece>() != (Object)null;
					if (num13 > 0)
					{
						stringBuilder.Append(",\n");
					}
					stringBuilder.Append(string.Format("    {{\"pos\": [{0:F2}, {1:F2}, {2:F2}], \"forward\": [{3:F3}, {4:F3}, {5:F3}], \"hasPiece\": {6}}}", position.x, position.y, position.z, forward.x, forward.y, forward.z, flag4 ? "true" : "false"));
					num13++;
				}
			}
			stringBuilder.Append("\n  ],\n");
			stringBuilder.Append("  \"buildingPieces\": [\n");
			Piece[] array5 = Object.FindObjectsByType<Piece>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			int num14 = 0;
			Piece[] array6 = array5;
			foreach (Piece val4 in array6)
			{
				if ((Object)(object)val4 == (Object)null)
				{
					continue;
				}
				Vector3 position2 = ((Component)val4).transform.position;
				if (!(position2.x < num - 5f) && !(position2.x > num3 + 5f) && !(position2.z < num2 - 5f) && !(position2.z > num4 + 5f))
				{
					string s = val4.m_name ?? ((Object)((Component)val4).gameObject).name;
					Collider component = ((Component)val4).GetComponent<Collider>();
					Vector3 val5;
					if (component == null)
					{
						val5 = Vector3.zero;
					}
					else
					{
						Bounds bounds = component.bounds;
						val5 = ((Bounds)(ref bounds)).extents;
					}
					Vector3 val6 = val5;
					Vector3 forward2 = ((Component)val4).transform.forward;
					int layer = ((Component)val4).gameObject.layer;
					if (num14 > 0)
					{
						stringBuilder.Append(",\n");
					}
					stringBuilder.Append($"    {{\"name\": \"{EscapeJson(s)}\", \"pos\": [{position2.x:F2}, {position2.y:F2}, {position2.z:F2}], " + $"\"fwd\": [{forward2.x:F3}, {forward2.y:F3}, {forward2.z:F3}], \"layer\": {layer}, " + $"\"extents\": [{val6.x:F2}, {val6.y:F2}, {val6.z:F2}]}}");
					num14++;
				}
			}
			stringBuilder.Append("\n  ]\n");
			stringBuilder.Append("}\n");
			string text2 = Path.Combine(Paths.ConfigPath, "vv_dumps", "hna_spatial_dump.json");
			Directory.CreateDirectory(Path.GetDirectoryName(text2));
			File.WriteAllText(text2, stringBuilder.ToString());
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print($"HNA spatial dump written to {text2} ({allAnchorPositions.Count} anchors, {num7}x{num8} grid, {num13} doors, {num14} pieces)");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[Region] Spatial dump: " + text2));
			}
		}

		private static float[] GatherReferenceHeights(List<Vector3> anchors)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			HashSet<int> hashSet = new HashSet<int>();
			foreach (Vector3 anchor in anchors)
			{
				int num = Mathf.FloorToInt((anchor.y - 5f) / 3f) * 3;
				int num2 = Mathf.CeilToInt((anchor.y + 10f) / 3f) * 3;
				for (int i = num; i <= num2; i += 3)
				{
					hashSet.Add(i);
				}
			}
			List<int> list = new List<int>(hashSet);
			list.Sort();
			return list.ConvertAll((Converter<int, float>)((int h) => h)).ToArray();
		}

		private static string EscapeJson(string s)
		{
			if (s == null)
			{
				return "";
			}
			return s.Replace("\\", "\\\\").Replace("\"", "\\\"");
		}
	}
	public class HnaPathRecorder : MonoBehaviour
	{
		private const float SampleInterval = 0.3f;

		private const float MinMoveDist = 0.5f;

		private static HnaPathRecorder s_instance;

		private static readonly List<Vector3> s_positions = new List<Vector3>();

		private Vector3 _lastPos;

		private float _timer;

		private void Update()
		{
			//IL_004f: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			_timer -= Time.deltaTime;
			if (_timer > 0f)
			{
				return;
			}
			_timer = 0.3f;
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)((Component)localPlayer).transform == (Object)null))
			{
				Vector3 position = ((Component)localPlayer).transform.position;
				if (s_positions.Count <= 0 || !(Vector3.Distance(position, _lastPos) < 0.5f))
				{
					s_positions.Add(position);
					_lastPos = position;
				}
			}
		}

		[DevCommand("Start recording player path for walkable ground truth", Name = "vv_hna_record_start")]
		public static void StartRecording()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if ((Object)(object)s_instance != (Object)null)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("Already recording. Use vv_hna_record_stop to stop.");
				}
				return;
			}
			s_positions.Clear();
			GameObject val = new GameObject("HnaPathRecorder");
			Object.DontDestroyOnLoad((Object)val);
			s_instance = val.AddComponent<HnaPathRecorder>();
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print("Recording player path. Walk around all walkable areas, then run: vv_hna_record_stop");
			}
		}

		[DevCommand("Stop recording and save path to vv_dumps/hna_walkable_path.json", Name = "vv_hna_record_stop")]
		public static void StopRecording()
		{
			if ((Object)(object)s_instance == (Object)null)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("Not recording. Use vv_hna_record_start first.");
				}
			}
			else
			{
				Object.Destroy((Object)(object)((Component)s_instance).gameObject);
				s_instance = null;
				SavePath();
			}
		}

		private static void SavePath()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (s_positions.Count == 0)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("No positions recorded.");
				}
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{\n");
			stringBuilder.Append($"  \"count\": {s_positions.Count},\n");
			stringBuilder.Append("  \"positions\": [\n");
			for (int i = 0; i < s_positions.Count; i++)
			{
				Vector3 val = s_positions[i];
				stringBuilder.Append($"    [{val.x:F2}, {val.y:F2}, {val.z:F2}]");
				stringBuilder.Append((i < s_positions.Count - 1) ? ",\n" : "\n");
			}
			stringBuilder.Append("  ]\n");
			stringBuilder.Append("}\n");
			string text = Path.Combine(Paths.ConfigPath, "vv_dumps", "hna_walkable_path.json");
			Directory.CreateDirectory(Path.GetDirectoryName(text));
			File.WriteAllText(text, stringBuilder.ToString());
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print($"Saved {s_positions.Count} positions to {text}");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Region] Walkable path recording: {s_positions.Count} positions → {text}");
			}
		}
	}
	public static class VillageNavLock
	{
		private static float s_holdUntil;

		public static bool IsHeld => Time.time < s_holdUntil;

		public static float SecondsRemaining => Mathf.Max(0f, s_holdUntil - Time.time);

		public static void RequestHold(float seconds)
		{
			float num = Time.time + seconds;
			if (num > s_holdUntil)
			{
				s_holdUntil = num;
			}
		}
	}
	public static class VillagerMovement
	{
		private const float ApproachProbeRadius = 1.5f;

		private static readonly Vector3[] s_probeOffsets = BuildProbeOffsets();

		public static bool IsAtPosition(Vector3 villagerPos, Vector3 target, float threshold)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.Distance(villagerPos, target) < threshold;
		}

		public static bool TryFindCompletePath(Vector3 start, Vector3 end, List<Vector3> outPath)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			outPath?.Clear();
			if (!VillagerAgentType.IsRegistered)
			{
				return false;
			}
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter filter = val;
			return TryFindUnconstrainedPath(start, end, filter, outPath);
		}

		private static bool TryFindUnconstrainedPath(Vector3 start, Vector3 end, NavMeshQueryFilter filter, List<Vector3> outPath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(start, ref val, 3f, filter))
			{
				return false;
			}
			NavMeshHit val2 = default(NavMeshHit);
			if (!NavMesh.SamplePosition(end, ref val2, 3f, filter))
			{
				return false;
			}
			NavMeshPath val3 = new NavMeshPath();
			if (!NavMesh.CalculatePath(((NavMeshHit)(ref val)).position, ((NavMeshHit)(ref val2)).position, filter, val3))
			{
				return false;
			}
			if ((int)val3.status != 0)
			{
				return false;
			}
			if (outPath != null)
			{
				Vector3[] corners = val3.corners;
				for (int i = 0; i < corners.Length; i++)
				{
					outPath.Add(corners[i]);
				}
			}
			return true;
		}

		public static bool TryFindReachableApproach(Vector3 target, float maxRadius, out Vector3 approachPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			approachPoint = target;
			if (!VillagerAgentType.IsRegistered)
			{
				return false;
			}
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter val2 = val;
			NavMeshHit val3 = default(NavMeshHit);
			if (!NavMesh.SamplePosition(target, ref val3, maxRadius, val2))
			{
				return false;
			}
			approachPoint = ((NavMeshHit)(ref val3)).position;
			return true;
		}

		public static bool TryResolveApproach(Vector3 target, Vector3 pathSource, Func<Vector3, bool> hullPredicate, out Vector3 approach)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			approach = target;
			Vector3[] array = s_probeOffsets;
			List<Vector3> outPath = new List<Vector3>();
			for (int i = 0; i < array.Length; i++)
			{
				if (TryFindReachableApproach(target + array[i], 1.5f, out var approachPoint) && (hullPredicate == null || hullPredicate(approachPoint)) && TryFindCompletePath(pathSource, approachPoint, outPath))
				{
					approach = approachPoint;
					return true;
				}
			}
			return false;
		}

		private static Vector3[] BuildProbeOffsets()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3> { Vector3.zero };
			float[] array = new float[2] { 2f, 4f };
			foreach (float num in array)
			{
				list.Add(new Vector3(0f, 0f, num));
				list.Add(new Vector3(num, 0f, 0f));
				list.Add(new Vector3(0f, 0f, 0f - num));
				list.Add(new Vector3(0f - num, 0f, 0f));
				list.Add(new Vector3(num, 0f, num));
				list.Add(new Vector3(num, 0f, 0f - num));
				list.Add(new Vector3(0f - num, 0f, 0f - num));
				list.Add(new Vector3(0f - num, 0f, num));
			}
			return list.ToArray();
		}
	}
}
namespace ValheimVillages.Villager.AI.Memory
{
	public class VillagerMemory : IVillagerMemory
	{
		private const string ZdoKeyBestComfort = "vv_memory_best_comfort";

		private const string ZdoKeyBestComfortPos = "vv_memory_best_comfort_pos";

		public float BestComfortLevel { get; set; }

		public Vector3? BestComfortPosition { get; set; }

		public Vector3 HomeAnchor { get; set; }

		public VillagerMemory(Vector3 anchorPosition)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			HomeAnchor = anchorPosition;
		}

		public void UpdateBestComfort(float comfort, Vector3 position)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (comfort > BestComfortLevel)
			{
				BestComfortLevel = comfort;
				BestComfortPosition = position;
			}
		}

		public void SaveToZDO(ZDO zdo)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null)
			{
				return;
			}
			try
			{
				zdo.Set("vv_memory_best_comfort", BestComfortLevel);
				if (BestComfortPosition.HasValue)
				{
					zdo.Set("vv_memory_best_comfort_pos", BestComfortPosition.Value);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Failed to save villager memory: " + ex.Message));
				}
			}
		}

		public void LoadFromZDO(ZDO zdo)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null)
			{
				return;
			}
			try
			{
				BestComfortLevel = zdo.GetFloat("vv_memory_best_comfort", 0f);
				Vector3 vec = zdo.GetVec3("vv_memory_best_comfort_pos", Vector3.zero);
				if (vec != Vector3.zero)
				{
					BestComfortPosition = vec;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Failed to load villager memory: " + ex.Message));
				}
			}
		}
	}
}
namespace ValheimVillages.Testing
{
	public static class ModAssert
	{
		public class CollectScope : IDisposable
		{
			private readonly List<AssertionEntry> _previous;

			public CollectScope()
			{
				_previous = s_collected;
				s_collected = new List<AssertionEntry>();
			}

			public void Dispose()
			{
				List<AssertionEntry> s_collected = ModAssert.s_collected;
				ModAssert.s_collected = _previous;
				if (s_collected != null && s_collected.Count > 0)
				{
					throw new ModAssertException(s_collected);
				}
			}
		}

		[ThreadStatic]
		private static List<AssertionEntry> s_collected;

		public static void True(bool condition, string message)
		{
			if (!condition)
			{
				AssertionEntry item = new AssertionEntry
				{
					Message = message,
					Expected = "true",
					Actual = "false"
				};
				if (s_collected == null)
				{
					throw new ModAssertException(message, "true", "false");
				}
				s_collected.Add(item);
			}
		}

		public static void Equal<T>(T expected, T actual, string message)
		{
			if (EqualityComparer<T>.Default.Equals(expected, actual))
			{
				return;
			}
			ref T reference = ref expected;
			T val = default(T);
			object obj;
			if (val == null)
			{
				val = reference;
				reference = ref val;
				if (val == null)
				{
					obj = null;
					goto IL_0040;
				}
			}
			obj = reference.ToString();
			goto IL_0040;
			IL_007b:
			object obj2;
			if (obj2 == null)
			{
				obj2 = "null";
			}
			string actual2 = (string)obj2;
			string expected2;
			AssertionEntry item = new AssertionEntry
			{
				Message = message,
				Expected = expected2,
				Actual = actual2
			};
			if (s_collected != null)
			{
				s_collected.Add(item);
				return;
			}
			throw new ModAssertException(message, expected2, actual2);
			IL_0040:
			if (obj == null)
			{
				obj = "null";
			}
			expected2 = (string)obj;
			ref T reference2 = ref actual;
			val = default(T);
			if (val == null)
			{
				val = reference2;
				reference2 = ref val;
				if (val == null)
				{
					obj2 = null;
					goto IL_007b;
				}
			}
			obj2 = reference2.ToString();
			goto IL_007b;
		}

		public static void NotNull(object obj, string message)
		{
			if (obj == null)
			{
				AssertionEntry item = new AssertionEntry
				{
					Message = message,
					Expected = "not null",
					Actual = "null"
				};
				if (s_collected == null)
				{
					throw new ModAssertException(message, "not null", "null");
				}
				s_collected.Add(item);
			}
		}

		public static CollectScope Collect()
		{
			return new CollectScope();
		}
	}
	public class AssertionEntry
	{
		public string Actual;

		public string Expected;

		public string Message;
	}
	public class ModAssertException : Exception
	{
		public List<AssertionEntry> Assertions { get; }

		public ModAssertException(string message)
			: base(message)
		{
			Assertions = new List<AssertionEntry>
			{
				new AssertionEntry
				{
					Message = message
				}
			};
		}

		public ModAssertException(string message, string expected, string actual)
			: base(message)
		{
			Assertions = new List<AssertionEntry>
			{
				new AssertionEntry
				{
					Message = message,
					Expected = expected,
					Actual = actual
				}
			};
		}

		public ModAssertException(List<AssertionEntry> assertions)
			: base((assertions.Count > 0) ? assertions[0].Message : "Assertion failed")
		{
			Assertions = assertions;
		}
	}
	public static class ModTestRunner
	{
		private class TestResultEntry
		{
			public readonly List<AssertionOutput> Assertions = new List<AssertionOutput>();

			public string ClassName = "";

			public string File;

			public int Line;

			public string Message = "";

			public string StackTrace = "";

			public string State = "";

			public string Test = "";
		}

		private class AssertionOutput
		{
			public string Actual = "";

			public string Expected = "";

			public string Message = "";
		}

		public static bool AutoRunEnabled { get; set; } = true;

		private static string ResultsPath => Path.Combine(Paths.ConfigPath, "vv_test_results.json");

		public static void RunAll()
		{
			List<MethodInfo> list = DiscoverTests(typeof(Plugin).Assembly);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[ModTestRunner] Running {list.Count} integration tests...");
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			List<TestResultEntry> list2 = new List<TestResultEntry>();
			List<TestResultEntry> list3 = new List<TestResultEntry>();
			ModAssertException ex2 = default(ModAssertException);
			foreach (MethodInfo item3 in list)
			{
				string text = item3.GetCustomAttribute<ModTestAttribute>()?.Name ?? (item3.DeclaringType?.Name + "." + item3.Name);
				try
				{
					item3.Invoke(null, null);
					num++;
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogDebug((object)("[ModTestRunner] PASS: " + text));
					}
				}
				catch (TargetInvocationException ex) when (((Func<bool>)delegate
				{
					// Could not convert BlockContainer to single expression
					ex2 = ex.InnerException as ModAssertException;
					return ex2 != null;
				}).Invoke())
				{
					num2++;
					TestResultEntry item = BuildResult(item3, ex2, text, "FAIL");
					list2.Add(item);
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogWarning((object)("[ModTestRunner] FAIL: " + text + " — " + ex2.Message));
					}
				}
				catch (Exception ex3)
				{
					Exception ex4 = ((ex3 is TargetInvocationException ex5) ? (ex5.InnerException ?? ex3) : ex3);
					num3++;
					TestResultEntry item2 = BuildResult(item3, ex4, text, "ERROR");
					list3.Add(item2);
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogError((object)("[ModTestRunner] ERROR: " + text + " — " + ex4.Message));
					}
				}
			}
			string text2 = ((num2 == 0 && num3 == 0) ? "PASS" : "FAIL");
			ManualLogSource log5 = Plugin.Log;
			if (log5 != null)
			{
				log5.LogInfo((object)($"[ModTestRunner] Results: {num} passed, {num2} failed, " + $"{num3} errors, {num4} skipped — {text2}"));
			}
			WriteJsonResults(text2, num, num2, num3, num4, list2, list3, list.Count);
		}

		private static List<MethodInfo> DiscoverTests(Assembly assembly)
		{
			List<(MethodInfo, int, string)> list = new List<(MethodInfo, int, string)>();
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					ModTestAttribute customAttribute = methodInfo.GetCustomAttribute<ModTestAttribute>();
					if (customAttribute == null)
					{
						continue;
					}
					if (methodInfo.GetParameters().Length != 0)
					{
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogWarning((object)("[ModTestRunner] Skipping " + type.Name + "." + methodInfo.Name + ": must be parameterless static"));
						}
					}
					else
					{
						string item = customAttribute.Name ?? (type.Name + "." + methodInfo.Name);
						list.Add((methodInfo, customAttribute.Order, item));
					}
				}
			}
			return (from m in list
				orderby m.order, m.name
				select m.method).ToList();
		}

		private static TestResultEntry BuildResult(MethodInfo method, Exception ex, string testName, string state)
		{
			TestResultEntry testResultEntry = new TestResultEntry
			{
				Test = testName,
				State = state,
				Message = ex.Message,
				StackTrace = (ex.StackTrace ?? "")
			};
			if (ex.StackTrace != null)
			{
				Match match = Regex.Match(ex.StackTrace, "in (.+):line (\\d+)");
				if (match.Success)
				{
					testResultEntry.File = match.Groups[1].Value;
					int.TryParse(match.Groups[2].Value, out testResultEntry.Line);
				}
			}
			testResultEntry.ClassName = method.DeclaringType?.FullName ?? "";
			if (ex is ModAssertException ex2)
			{
				foreach (AssertionEntry assertion in ex2.Assertions)
				{
					testResultEntry.Assertions.Add(new AssertionOutput
					{
						Message = assertion.Message,
						Expected = (assertion.Expected ?? ""),
						Actual = (assertion.Actual ?? "")
					});
				}
			}
			return testResultEntry;
		}

		private static void WriteJsonResults(string result, int passed, int failed, int errored, int skipped, List<TestResultEntry> failures, List<TestResultEntry> errors, int totalTests)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("{");
			stringBuilder.AppendLine("  \"v\": 1,");
			stringBuilder.AppendLine($"  \"ts\": \"{DateTime.UtcNow:O}\",");
			stringBuilder.AppendLine("  \"result\": \"" + result + "\",");
			stringBuilder.AppendLine("  \"summary\": {");
			stringBuilder.AppendLine($"    \"total\": {totalTests},");
			stringBuilder.AppendLine($"    \"passed\": {passed},");
			stringBuilder.AppendLine($"    \"failed\": {failed},");
			stringBuilder.AppendLine($"    \"errors\": {errored},");
			stringBuilder.AppendLine($"    \"skipped\": {skipped}");
			stringBuilder.AppendLine("  },");
			stringBuilder.AppendLine("  \"failures\": [");
			WriteEntries(stringBuilder, failures);
			stringBuilder.AppendLine("  ],");
			stringBuilder.AppendLine("  \"errors\": [");
			WriteEntries(stringBuilder, errors);
			stringBuilder.AppendLine("  ],");
			stringBuilder.AppendLine("  \"skipped\": []");
			stringBuilder.AppendLine("}");
			try
			{
				File.WriteAllText(ResultsPath, stringBuilder.ToString());
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[ModTestRunner] Results written to " + ResultsPath));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("[ModTestRunner] Failed to write results: " + ex.Message));
				}
			}
		}

		private static void WriteEntries(StringBuilder sb, List<TestResultEntry> entries)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				TestResultEntry testResultEntry = entries[i];
				sb.AppendLine("    {");
				sb.AppendLine("      \"test\": " + JsonEscape(testResultEntry.Test) + ",");
				sb.AppendLine("      \"state\": " + JsonEscape(testResultEntry.State) + ",");
				sb.AppendLine("      \"location\": {");
				sb.AppendLine("        \"file\": " + JsonEscape(testResultEntry.File ?? "") + ",");
				sb.AppendLine($"        \"line\": {testResultEntry.Line},");
				sb.AppendLine("        \"class\": " + JsonEscape(testResultEntry.ClassName ?? ""));
				sb.AppendLine("      },");
				sb.AppendLine("      \"message\": " + JsonEscape(testResultEntry.Message ?? "") + ",");
				sb.AppendLine("      \"assertions\": [");
				for (int j = 0; j < testResultEntry.Assertions.Count; j++)
				{
					AssertionOutput assertionOutput = testResultEntry.Assertions[j];
					sb.Append("        { ");
					sb.Append("\"message\": " + JsonEscape(assertionOutput.Message) + ", ");
					sb.Append("\"expected\": " + JsonEscape(assertionOutput.Expected) + ", ");
					sb.Append("\"actual\": " + JsonEscape(assertionOutput.Actual));
					sb.Append(" }");
					if (j < testResultEntry.Assertions.Count - 1)
					{
						sb.Append(",");
					}
					sb.AppendLine();
				}
				sb.AppendLine("      ],");
				sb.AppendLine("      \"stackTrace\": " + JsonEscape(testResultEntry.StackTrace ?? ""));
				sb.Append("    }");
				if (i < entries.Count - 1)
				{
					sb.Append(",");
				}
				sb.AppendLine();
			}
		}

		private static string JsonEscape(string s)
		{
			if (s == null)
			{
				return "\"\"";
			}
			return "\"" + s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r")
				.Replace("\t", "\\t") + "\"";
		}

		[DevCommand("Run all [ModTest] integration tests", Name = "vv_test_run")]
		public static void RunTestsCommand()
		{
			RunAll();
		}
	}
	public class SceneSnapshot
	{
		public string Timestamp;

		public List<VillageAreaSnapshot> VillageAreas = new List<VillageAreaSnapshot>();

		public List<VillagerSnapshot> Villagers = new List<VillagerSnapshot>();

		public static SceneSnapshot Capture()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			SceneSnapshot sceneSnapshot = new SceneSnapshot
			{
				Timestamp = DateTime.UtcNow.ToString("O")
			};
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				VillagerAI value = activeVillager.Value;
				Vector3 position = value.Position;
				sceneSnapshot.Villagers.Add(new VillagerSnapshot
				{
					UniqueId = (value.UniqueId ?? "unknown"),
					NpcType = (value.VillagerType ?? "unknown"),
					BehaviorState = value.CurrentState.ToString(),
					Position = new float[3] { position.x, position.y, position.z },
					KnownLocationCount = 0
				});
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)($"[SceneSnapshot] Captured {sceneSnapshot.Villagers.Count} villagers, " + $"{VillageAreaManager.AreaCount} village areas"));
			}
			return sceneSnapshot;
		}

		public void SaveToFile(string path)
		{
			string contents = ToJson();
			File.WriteAllText(path, contents);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[SceneSnapshot] Saved to " + path));
			}
		}

		public static SceneSnapshot LoadFromFile(string path)
		{
			if (!File.Exists(path))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[SceneSnapshot] File not found: " + path));
				}
				return null;
			}
			return FromJson(File.ReadAllText(path));
		}

		public static string CompareWithCurrent(SceneSnapshot saved)
		{
			SceneSnapshot sceneSnapshot = Capture();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Snapshot comparison (saved: " + saved.Timestamp + ", current: " + sceneSnapshot.Timestamp + ")");
			stringBuilder.AppendLine($"  Villagers: saved={saved.Villagers.Count}, current={sceneSnapshot.Villagers.Count}");
			Dictionary<string, int> dictionary = (from v in saved.Villagers
				group v by v.NpcType ?? "unknown").ToDictionary((IGrouping<string, VillagerSnapshot> g) => g.Key, (IGrouping<string, VillagerSnapshot> g) => g.Count());
			Dictionary<string, int> dictionary2 = (from v in sceneSnapshot.Villagers
				group v by v.NpcType ?? "unknown").ToDictionary((IGrouping<string, VillagerSnapshot> g) => g.Key, (IGrouping<string, VillagerSnapshot> g) => g.Count());
			foreach (string item in from t in dictionary.Keys.Union(dictionary2.Keys)
				orderby t
				select t)
			{
				int value;
				int num = (dictionary.TryGetValue(item, out value) ? value : 0);
				int value2;
				int num2 = (dictionary2.TryGetValue(item, out value2) ? value2 : 0);
				if (num != num2)
				{
					stringBuilder.AppendLine($"  DIFF {item}: saved={num}, current={num2}");
				}
			}
			return stringBuilder.ToString();
		}

		private string ToJson()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("{");
			stringBuilder.AppendLine("  \"timestamp\": \"" + Timestamp + "\",");
			stringBuilder.AppendLine("  \"villagers\": [");
			for (int i = 0; i < Villagers.Count; i++)
			{
				VillagerSnapshot villagerSnapshot = Villagers[i];
				stringBuilder.AppendLine("    {");
				stringBuilder.AppendLine("      \"uniqueId\": \"" + Esc(villagerSnapshot.UniqueId) + "\",");
				stringBuilder.AppendLine("      \"npcType\": \"" + Esc(villagerSnapshot.NpcType) + "\",");
				stringBuilder.AppendLine("      \"behaviorState\": \"" + Esc(villagerSnapshot.BehaviorState) + "\",");
				stringBuilder.AppendLine($"      \"position\": [{villagerSnapshot.Position[0]:F2}, {villagerSnapshot.Position[1]:F2}, {villagerSnapshot.Position[2]:F2}],");
				stringBuilder.AppendLine($"      \"knownLocationCount\": {villagerSnapshot.KnownLocationCount}");
				stringBuilder.Append("    }");
				if (i < Villagers.Count - 1)
				{
					stringBuilder.Append(",");
				}
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine("  ],");
			stringBuilder.AppendLine("  \"villageAreas\": [");
			for (int j = 0; j < VillageAreas.Count; j++)
			{
				VillageAreaSnapshot villageAreaSnapshot = VillageAreas[j];
				stringBuilder.AppendLine("    {");
				stringBuilder.AppendLine($"      \"center\": [{villageAreaSnapshot.Center[0]:F2}, {villageAreaSnapshot.Center[1]:F2}, {villageAreaSnapshot.Center[2]:F2}],");
				stringBuilder.AppendLine($"      \"radius\": {villageAreaSnapshot.Radius:F2},");
				stringBuilder.AppendLine($"      \"villagerCount\": {villageAreaSnapshot.VillagerCount}");
				stringBuilder.Append("    }");
				if (j < VillageAreas.Count - 1)
				{
					stringBuilder.Append(",");
				}
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine("  ]");
			stringBuilder.AppendLine("}");
			return stringBuilder.ToString();
		}

		private static SceneSnapshot FromJson(string json)
		{
			SceneSnapshot sceneSnapshot = new SceneSnapshot();
			Match match = Regex.Match(json, "\"timestamp\":\\s*\"([^\"]+)\"");
			if (match.Success)
			{
				sceneSnapshot.Timestamp = match.Groups[1].Value;
			}
			return sceneSnapshot;
		}

		private static string Esc(string s)
		{
			return s?.Replace("\"", "\\\"") ?? "";
		}

		[DevCommand("Capture scene snapshot to vv_snapshot.json", Name = "vv_snapshot_capture")]
		public static void CaptureCommand()
		{
			string path = Path.Combine(Paths.ConfigPath, "vv_snapshot.json");
			Capture().SaveToFile(path);
		}

		[DevCommand("Verify current state against saved snapshot", Name = "vv_snapshot_verify")]
		public static void VerifyCommand()
		{
			SceneSnapshot sceneSnapshot = LoadFromFile(Path.Combine(Paths.ConfigPath, "vv_snapshot.json"));
			if (sceneSnapshot == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[SceneSnapshot] No saved snapshot found. Run vv_snapshot first.");
				}
				return;
			}
			string text = CompareWithCurrent(sceneSnapshot);
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)("[SceneSnapshot] Comparison:\n" + text));
			}
		}
	}
	public class VillagerSnapshot
	{
		public string BehaviorState;

		public int KnownLocationCount;

		public string NpcType;

		public float[] Position = new float[3];

		public string UniqueId;
	}
	public class VillageAreaSnapshot
	{
		public float[] Center = new float[3];

		public float Radius;

		public int VillagerCount;
	}
}
namespace ValheimVillages.TaskQueue
{
	public static class GlobalTaskQueue
	{
		private static readonly Dictionary<TaskPriority, Queue<VillagerTask>> s_queues = new Dictionary<TaskPriority, Queue<VillagerTask>>
		{
			{
				TaskPriority.High,
				new Queue<VillagerTask>()
			},
			{
				TaskPriority.Medium,
				new Queue<VillagerTask>()
			},
			{
				TaskPriority.Low,
				new Queue<VillagerTask>()
			}
		};

		private static readonly TaskPriority[] s_tiersDescending = new TaskPriority[3]
		{
			TaskPriority.High,
			TaskPriority.Medium,
			TaskPriority.Low
		};

		private static readonly HashSet<(string, string)> s_pendingKeys = new HashSet<(string, string)>();

		private const float ReadinessRecheckSeconds = 1.5f;

		private static readonly List<VillagerTask> s_deadLetters = new List<VillagerTask>();

		public static IReadOnlyList<VillagerTask> DeadLetters => s_deadLetters;

		public static int PendingCount => s_queues.Values.Sum((Queue<VillagerTask> q) => q.Count);

		public static bool Enqueue(VillagerTask task)
		{
			if (task == null)
			{
				return false;
			}
			(string, string) item = (task.Name, task.SourceId);
			if (s_pendingKeys.Contains(item))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[TaskQueue] Dedup: skipping duplicate " + task.Name + " for " + task.SourceId));
				}
				return false;
			}
			if (!s_queues.ContainsKey(task.Priority))
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"[TaskQueue] Unknown priority {task.Priority}, dropping task {task.Name}");
				}
				return false;
			}
			task.CreatedAt = Time.time;
			s_queues[task.Priority].Enqueue(task);
			s_pendingKeys.Add(item);
			return true;
		}

		public static void ProcessBatch()
		{
			int num = 0;
			int num2 = (int)s_tiersDescending[0];
			TaskPriority[] array = s_tiersDescending;
			for (int i = 0; i < array.Length; i++)
			{
				int maxCount;
				int num3 = DrainQueue((TaskPriority)(maxCount = (int)array[i]), maxCount);
				num += num3;
			}
			if (num >= num2)
			{
				return;
			}
			int num4 = num2 - num;
			array = s_tiersDescending;
			foreach (TaskPriority tier in array)
			{
				if (num4 > 0)
				{
					int num5 = DrainQueue(tier, num4);
					num += num5;
					num4 -= num5;
					continue;
				}
				break;
			}
		}

		private static int DrainQueue(TaskPriority tier, int maxCount)
		{
			Queue<VillagerTask> queue = s_queues[tier];
			int num = 0;
			int num2 = 0;
			int count = queue.Count;
			while (num < maxCount && queue.Count > 0 && num2 < count)
			{
				num2++;
				VillagerTask villagerTask = queue.Dequeue();
				if (villagerTask.NotBefore > 0f && Time.time < villagerTask.NotBefore)
				{
					queue.Enqueue(villagerTask);
					continue;
				}
				if (TaskHandlerRegistry.Get(villagerTask.Name) is ITaskPrecondition taskPrecondition && !taskPrecondition.IsReady(villagerTask))
				{
					if (Time.time - villagerTask.CreatedAt > villagerTask.TimeoutSeconds)
					{
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogWarning((object)("[TaskQueue] Task '" + villagerTask.Name + "' for " + villagerTask.SourceId + " timed out waiting " + $"for preconditions after {Time.time - villagerTask.CreatedAt:F1}s; dropping."));
						}
						RemovePendingKey(villagerTask);
					}
					else
					{
						villagerTask.NotBefore = Time.time + 1.5f;
						queue.Enqueue(villagerTask);
					}
					continue;
				}
				RemovePendingKey(villagerTask);
				if (Time.time - villagerTask.CreatedAt > villagerTask.TimeoutSeconds)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("[TaskQueue] Task '" + villagerTask.Name + "' for " + villagerTask.SourceId + " timed out " + $"after {Time.time - villagerTask.CreatedAt:F1}s (limit {villagerTask.TimeoutSeconds}s)"));
					}
					continue;
				}
				ITaskHandler taskHandler = TaskHandlerRegistry.Get(villagerTask.Name);
				if (taskHandler == null)
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogWarning((object)("[TaskQueue] No handler registered for '" + villagerTask.Name + "', dead-lettering"));
					}
					AddToDeadLetters(villagerTask);
					continue;
				}
				try
				{
					TaskResult taskResult = ((ITaskHandlerWithLog)taskHandler).Handle(villagerTask, VillagerActivityLog.Instance);
					if (taskResult.Success)
					{
						villagerTask.Callback?.Invoke(taskResult);
						num++;
					}
					else
					{
						HandleFailure(villagerTask, taskResult.Error);
						num++;
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogError((object)("[TaskQueue] Handler '" + villagerTask.Name + "' threw exception: " + ex.Message));
					}
					HandleFailure(villagerTask, ex.Message);
					num++;
				}
			}
			return num;
		}

		private static void HandleFailure(VillagerTask task, string error)
		{
			task.RetryCount++;
			if (task.RetryCount < 3)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[TaskQueue] Retrying '" + task.Name + "' for " + task.SourceId + " " + $"(attempt {task.RetryCount + 1}/{3}): {error}"));
				}
				s_queues[task.Priority].Enqueue(task);
				s_pendingKeys.Add((task.Name, task.SourceId));
			}
			else
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[TaskQueue] Dead-lettering '" + task.Name + "' for " + task.SourceId + " " + $"after {task.RetryCount} retries: {error}"));
				}
				AddToDeadLetters(task);
			}
		}

		private static void AddToDeadLetters(VillagerTask task)
		{
			if (s_deadLetters.Count >= 50)
			{
				s_deadLetters.RemoveAt(0);
			}
			s_deadLetters.Add(task);
		}

		private static void RemovePendingKey(VillagerTask task)
		{
			s_pendingKeys.Remove((task.Name, task.SourceId));
		}

		public static int PendingCount_ForTier(TaskPriority tier)
		{
			if (!s_queues.TryGetValue(tier, out var value))
			{
				return 0;
			}
			return value.Count;
		}

		[RegisterCleanup]
		public static void Clear()
		{
			foreach (Queue<VillagerTask> value in s_queues.Values)
			{
				value.Clear();
			}
			s_pendingKeys.Clear();
			s_deadLetters.Clear();
		}
	}
	public interface ITaskHandlerWithLog : ITaskHandler
	{
		TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog);
	}
	public interface ITaskPrecondition
	{
		bool IsReady(VillagerTask task);
	}
	internal static class RepartitionCommand
	{
		[DevCommand("Force enqueue an immediate hna_partition rebuild", Name = "vv_repartition")]
		public static void Repartition()
		{
			GlobalTaskQueue.Enqueue(new VillagerTask
			{
				Name = "hna_partition",
				SourceId = "user",
				Priority = TaskPriority.High,
				TimeoutSeconds = 60f,
				Attributes = new Dictionary<string, string>()
			});
			string text = "[vv_repartition] Enqueued hna_partition (high priority, no anchor)";
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}
	}
	public static class TaskAttributeParser
	{
		public static bool TryParsePosition(Dictionary<string, string> attrs, string prefix, out Vector3 result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			result = Vector3.zero;
			if (attrs == null)
			{
				return false;
			}
			if (!attrs.TryGetValue(prefix + "_x", out var value) || !attrs.TryGetValue(prefix + "_y", out var value2) || !attrs.TryGetValue(prefix + "_z", out var value3))
			{
				return false;
			}
			if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || !float.TryParse(value2, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) || !float.TryParse(value3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
			{
				return false;
			}
			result = new Vector3(result2, result3, result4);
			return true;
		}
	}
	public static class TaskHandlerRegistry
	{
		private static readonly Dictionary<string, ITaskHandler> s_handlers = new Dictionary<string, ITaskHandler>();

		public static void Register(ITaskHandler handler)
		{
			if (handler == null)
			{
				return;
			}
			if (s_handlers.ContainsKey(handler.TaskName))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[TaskRegistry] Replacing existing handler for '" + handler.TaskName + "'"));
				}
			}
			s_handlers[handler.TaskName] = handler;
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogDebug((object)("[TaskRegistry] Registered handler: " + handler.TaskName));
			}
		}

		public static ITaskHandler Get(string taskName)
		{
			s_handlers.TryGetValue(taskName, out var value);
			return value;
		}

		[RegisterCleanup]
		public static void Clear()
		{
			s_handlers.Clear();
		}
	}
}
namespace ValheimVillages.TaskQueue.Handlers
{
	internal static class CellValidator
	{
		internal const float MaxLedgeDrop = 1.5f;

		internal const float MaxSlopeDeg = 30f;

		internal const float GroundCheckDist = 2f;

		internal const float MinEdgeDistance = 0.2f;

		internal const float WidthProbeOffset = 0.35f;

		internal const int MinProbeHits = 3;

		private static readonly int GroundMask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "terrain", "piece" });

		internal static bool IsLedgeDrop(float fromY, float toY)
		{
			return fromY - toY > 1.5f;
		}

		internal static bool IsTooSteep(float fromX, float fromY, float fromZ, float toX, float toY, float toZ)
		{
			if (TryIsTooSteep(fromX, fromY, fromZ, toX, toY, toZ, out var tooSteep))
			{
				return tooSteep;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogError((object)"[CellValidator] IsTooSteep: villager agent climb unavailable (Pathfinding.instance not alive or agent slot 31 not registered); rejecting cell transition fail-closed. Caller should defer cell validation.");
			}
			return true;
		}

		internal static bool TryIsTooSteep(float fromX, float fromY, float fromZ, float toX, float toY, float toZ, out bool tooSteep)
		{
			tooSteep = false;
			float num = Mathf.Abs(toY - fromY);
			float num2 = toX - fromX;
			float num3 = toZ - fromZ;
			float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
			if (num4 < 0.01f)
			{
				if (!VillagerAgentType.TryGetClimb(out var climb))
				{
					return false;
				}
				tooSteep = num > climb;
				return true;
			}
			tooSteep = Mathf.Atan2(num, num4) * 57.29578f > 30f;
			return true;
		}

		internal static bool HasGroundBelow(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			return Physics.Raycast(new Vector3(pos.x, pos.y + 0.2f, pos.z), Vector3.down, 2.2f, GroundMask, (QueryTriggerInteraction)1);
		}

		internal static bool IsSurfaceWideEnough(Vector3 pos, NavMeshQueryFilter filter)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.FindClosestEdge(pos, ref val, filter))
			{
				return false;
			}
			return ((NavMeshHit)(ref val)).distance >= 0.2f;
		}

		internal static bool IsWideEnough(Vector3 pos, NavMeshQueryFilter filter)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			NavMeshHit val = default(NavMeshHit);
			if (NavMesh.SamplePosition(pos + new Vector3(0.35f, 0f, 0f), ref val, 0.5f, filter))
			{
				num++;
			}
			if (NavMesh.SamplePosition(pos + new Vector3(-0.35f, 0f, 0f), ref val, 0.5f, filter))
			{
				num++;
			}
			if (NavMesh.SamplePosition(pos + new Vector3(0f, 0f, 0.35f), ref val, 0.5f, filter))
			{
				num++;
			}
			if (NavMesh.SamplePosition(pos + new Vector3(0f, 0f, -0.35f), ref val, 0.5f, filter))
			{
				num++;
			}
			return num >= 3;
		}
	}
	[RegisterTaskHandler]
	public class ContainerScanHandler : ITaskHandlerWithLog, ITaskHandler
	{
		public string TaskName => "container_scan";

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			if (!TaskAttributeParser.TryParsePosition(task.Attributes, "center", out var result))
			{
				return TaskResult.Fail("Missing or invalid center position attributes");
			}
			if (!task.Attributes.TryGetValue("radius", out var value) || !float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				result2 = 20f;
			}
			List<Container> list = ContainerScanner.FindNearbyContainers(result, result2);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)($"[ContainerScanHandler] Found {list.Count} containers " + $"near ({result.x:F0},{result.y:F0},{result.z:F0}), radius={result2:F0}m"));
			}
			activityLog.Record(task.SourceId, TaskName, "scan_containers", $"found {list.Count} containers near ({result.x:F0},{result.y:F0},{result.z:F0})");
			return TaskResult.Ok(new Dictionary<string, string> { 
			{
				"container_count",
				list.Count.ToString()
			} });
		}
	}
	public static class FarmWorkOrderHelper
	{
		public static FarmingContext BuildFarmingContext(IVillagerWorkContext ai, WorkOrderMatch match, Recipe recipe, List<IngredientSource> ingredients, int existingCount)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			string itemPrefabName = match.ItemPrefabName;
			Vector3 anchorPos = ai.HomeAnchor;
			Pickable val = HarvestHelper.FindNearestHarvestableCrop(anchorPos, itemPrefabName, 20f);
			if ((Object)(object)val != (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[FarmScan:" + ai.NpcName + "] Found harvestable " + itemPrefabName + " at " + $"{((Component)val).transform.position}"));
				}
				return new FarmingContext
				{
					WorkOrder = match,
					Recipe = recipe,
					SourceContainer = match.SourceContainer,
					IngredientSources = null,
					FarmPosition = ((Component)val).transform.position,
					HarvestedCount = existingCount,
					IsHarvestingPass = true,
					CurrentHarvestTarget = val
				};
			}
			KnownLocation knownLocation = (from l in VillagePoiRegistry.GetPois(anchorPos, LocationType.Farm)
				orderby Vector3.Distance(anchorPos, l.Position)
				select l).FirstOrDefault();
			Vector3 val2;
			if (knownLocation != null)
			{
				val2 = knownLocation.Position;
			}
			else
			{
				Vector3? val3 = FindCultivatedGroundNearAnchor(anchorPos);
				if (!val3.HasValue)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogDebug((object)("[FarmScan:" + ai.NpcName + "] No ready crop, farm location, or cultivated ground found"));
					}
					return null;
				}
				val2 = val3.Value;
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)$"[FarmScan:{ai.NpcName}] Using cultivated ground at {val2}");
				}
			}
			GameObject piecePrefab = PlantPieceRegistry.GetPiecePrefab(itemPrefabName);
			if ((Object)(object)piecePrefab == (Object)null)
			{
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogDebug((object)("[FarmScan:" + ai.NpcName + "] No plant piece for " + itemPrefabName));
				}
				return null;
			}
			if (ingredients == null || ingredients.Count == 0)
			{
				ManualLogSource log5 = Plugin.Log;
				if (log5 != null)
				{
					log5.LogDebug((object)("[FarmScan:" + ai.NpcName + "] No seeds for " + itemPrefabName));
				}
				return null;
			}
			Plant component = piecePrefab.GetComponent<Plant>();
			float num = (((Object)(object)component != (Object)null) ? component.m_growRadius : 0.5f);
			if (!PlantingHelper.FindPlantingPosition(val2, 20f, num).HasValue)
			{
				ManualLogSource log6 = Plugin.Log;
				if (log6 != null)
				{
					log6.LogDebug((object)("[FarmScan:" + ai.NpcName + "] No planting positions near farm"));
				}
				return null;
			}
			ManualLogSource log7 = Plugin.Log;
			if (log7 != null)
			{
				log7.LogInfo((object)("[FarmScan:" + ai.NpcName + "] Planting pass for " + itemPrefabName));
			}
			return new FarmingContext
			{
				WorkOrder = match,
				Recipe = recipe,
				SourceContainer = match.SourceContainer,
				IngredientSources = ingredients,
				FarmPosition = val2,
				PlantPiecePrefab = piecePrefab,
				PlantGrowRadius = num,
				HarvestedCount = existingCount,
				IsHarvestingPass = false
			};
		}

		private static Vector3? FindCultivatedGroundNearAnchor(Vector3 anchorPos)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0068: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			for (float num = 5f; num <= 30f; num += 3f)
			{
				int num2 = Mathf.Max(8, Mathf.RoundToInt((float)Math.PI * 2f * num / 3f));
				for (int i = 0; i < num2; i++)
				{
					float num3 = (float)Math.PI * 2f * (float)i / (float)num2;
					Vector3 val = anchorPos + new Vector3(Mathf.Cos(num3) * num, 0f, Mathf.Sin(num3) * num);
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						continue;
					}
					float groundHeight = ZoneSystem.instance.GetGroundHeight(val);
					if (!(groundHeight <= -1000f))
					{
						val.y = groundHeight;
						if (PlantingHelper.IsCultivated(val))
						{
							return val;
						}
					}
				}
			}
			return null;
		}
	}
	[RegisterTaskHandler]
	public class IntegrationTestHandler : ITaskHandlerWithLog, ITaskHandler
	{
		public const string TaskNameConst = "integration_tests";

		private const float DeferralSeconds = 2f;

		private const float DeadlineSeconds = 30f;

		private const string AttrScheduledAt = "scheduled_at";

		public string TaskName => "integration_tests";

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			float scheduledAt = GetScheduledAt(task);
			float num = Time.time - scheduledAt;
			if (num < 2f)
			{
				GlobalTaskQueue.Enqueue(new VillagerTask
				{
					Name = "integration_tests",
					SourceId = "system",
					Priority = TaskPriority.Low,
					TimeoutSeconds = 35f,
					NotBefore = Time.time + 2f,
					Attributes = new Dictionary<string, string> { 
					{
						"scheduled_at",
						scheduledAt.ToString("R")
					} }
				});
				return TaskResult.Ok();
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[IntegrationTests] Running tests ({num:F1}s after schedule)");
			}
			ModTestRunner.RunAll();
			return TaskResult.Ok();
		}

		private static float GetScheduledAt(VillagerTask task)
		{
			if (task.Attributes != null && task.Attributes.TryGetValue("scheduled_at", out var value) && float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return task.CreatedAt;
		}
	}
	[RegisterTaskHandler]
	public class RecipeDiscoveryRefreshHandler : ITaskHandlerWithLog, ITaskHandler
	{
		public string TaskName => "recipe_discovery_refresh";

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return TaskResult.Fail("ObjectDB not ready");
			}
			int num = VirtualRecipeLoader.RecheckDiscoveredRecipes(ObjectDB.instance);
			activityLog.Record(task.SourceId, TaskName, "recheck", $"added {num} discovered recipes");
			return TaskResult.Ok(new Dictionary<string, string> { 
			{
				"recipes_added",
				num.ToString()
			} });
		}
	}
	[RegisterTaskHandler]
	public class RegionPartitionHandler : ITaskHandlerWithLog, ITaskHandler, ITaskPrecondition
	{
		public const string RegionPartitionTaskName = "hna_partition";

		private static readonly int s_pieceLayerMask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });

		private static readonly List<ZDO> s_readinessScratch = new List<ZDO>();

		public const float AnchorVillageRadius = 15f;

		internal const float FloodFillRadius = 30f;

		private const float RegionBuildRadius = 30f;

		private const float VillageClusterRadius = 50f;

		private const float NavRebuildSettleSeconds = 3f;

		public string TaskName => "hna_partition";

		public bool IsReady(VillagerTask task)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || (Object)(object)ZoneSystem.instance == (Object)null || ZDOMan.instance == null)
			{
				return false;
			}
			if (!VillagerAgentType.IsRegistered)
			{
				return false;
			}
			List<Vector3> list = FilterAnchorsByTask(VillagerAIManager.GetAllAnchorPositions(), task);
			if (list == null || list.Count == 0)
			{
				return true;
			}
			int activeArea = ZoneSystem.instance.m_activeArea;
			foreach (Vector3 item in list)
			{
				Vector2i zone = ZoneSystem.GetZone(item);
				if (!ZoneSystem.instance.IsZoneLoaded(zone))
				{
					return false;
				}
				if (!SectorBakeGeometryInstantiated(zone, activeArea))
				{
					return false;
				}
			}
			return true;
		}

		private static bool SectorBakeGeometryInstantiated(Vector2i zone, int area)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			s_readinessScratch.Clear();
			ZDOMan.instance.FindSectorObjects(zone, area, 0, s_readinessScratch, (List<ZDO>)null);
			foreach (ZDO item in s_readinessScratch)
			{
				if (item != null)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(item.GetPrefab());
					if (!((Object)(object)prefab == (Object)null) && ((1 << prefab.layer) & s_pieceLayerMask) != 0 && (Object)(object)ZNetScene.instance.FindInstance(item) == (Object)null)
					{
						return false;
					}
				}
			}
			return true;
		}

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: 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_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: 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_023e: Unknown result type (might be due to invalid IL or missing references)
			VillageNavLock.RequestHold(3f);
			List<Vector3> anchors = FilterAnchorsByTask(VillagerAIManager.GetAllAnchorPositions(), task);
			anchors = ResolveWalkableSeeds(anchors);
			float minX;
			float minZ;
			float maxX;
			float maxZ;
			bool flag = VillageAreaManager.TryGetCombinedBounds(out minX, out minZ, out maxX, out maxZ);
			Village village = ResolveVillage(task, anchors);
			if (village == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[Region] Partition skipped: no existing village resolved for this task (villages are created at registry placement; nothing to partition).");
				}
				return TaskResult.Ok(new Dictionary<string, string>
				{
					{ "regions", "0" },
					{ "links", "0" },
					{ "reason", "no_village" }
				});
			}
			string villageId = village.VillageId;
			float num;
			float num2;
			float num3;
			float num4;
			if (flag && anchors != null && anchors.Count > 0)
			{
				num = minX;
				num2 = minZ;
				num3 = maxX;
				num4 = maxZ;
				foreach (Vector3 item4 in anchors)
				{
					if (item4.x - 30f < num)
					{
						num = item4.x - 30f;
					}
					if (item4.z - 30f < num2)
					{
						num2 = item4.z - 30f;
					}
					if (item4.x + 30f > num3)
					{
						num3 = item4.x + 30f;
					}
					if (item4.z + 30f > num4)
					{
						num4 = item4.z + 30f;
					}
				}
			}
			else if (flag)
			{
				num = minX;
				num2 = minZ;
				num3 = maxX;
				num4 = maxZ;
			}
			else
			{
				if (anchors == null || anchors.Count <= 0)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)"[Region] Partition skipped: no village areas and no villager anchors.");
					}
					return TaskResult.Ok(new Dictionary<string, string>
					{
						{ "regions", "0" },
						{ "links", "0" },
						{ "reason", "no_anchors_or_areas" }
					});
				}
				num = (num3 = anchors[0].x);
				num2 = (num4 = anchors[0].z);
				foreach (Vector3 item5 in anchors)
				{
					if (item5.x - 30f < num)
					{
						num = item5.x - 30f;
					}
					if (item5.z - 30f < num2)
					{
						num2 = item5.z - 30f;
					}
					if (item5.x + 30f > num3)
					{
						num3 = item5.x + 30f;
					}
					if (item5.z + 30f > num4)
					{
						num4 = item5.z + 30f;
					}
				}
			}
			if (anchors == null || anchors.Count == 0)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)("[Region] Partition aborted: no villager anchors for village '" + villageId + "'. Cannot determine bake elevation without anchors — refusing to bake at sea-level fallback."));
				}
				return TaskResult.Ok(new Dictionary<string, string>
				{
					{ "regions", "0" },
					{ "links", "0" },
					{ "reason", "no_anchors_for_bake_y" }
				});
			}
			float num5 = float.MaxValue;
			float num6 = float.MinValue;
			foreach (Vector3 item6 in anchors)
			{
				if (item6.y < num5)
				{
					num5 = item6.y;
				}
				if (item6.y > num6)
				{
					num6 = item6.y;
				}
			}
			Bounds bounds = default(Bounds);
			((Bounds)(ref bounds)).SetMinMax(new Vector3(num, num5 - 30f, num2), new Vector3(num3, num6 + 30f, num4));
			NavMeshBakeManager.BakeResult bakeResult = NavMeshBakeManager.BakeVillage(bounds);
			DebugLog.Event("NavMeshBake", "village_bake", ("success", bakeResult.Success), ("sources", bakeResult.SourceCount), ("terrain_sources", bakeResult.TerrainSourceCount), ("piece_sources", bakeResult.PieceSourceCount), ("doors_blocked", bakeResult.DoorsBlocked), ("door_pieces_dropped", bakeResult.DoorPiecesDropped), ("beds_blocked", bakeResult.BedsBlocked), ("outside_cells_blocked", bakeResult.OutsideCellsBlocked), ("duration_ms", bakeResult.DurationMs), ("terrain_ms", bakeResult.TerrainDurationMs), ("piece_ms", bakeResult.PieceDurationMs), ("agent_slot", VillagerAgentType.UnityAgentTypeID), ("bounds_x", $"{num:F0}..{num3:F0}"), ("bounds_z", $"{num2:F0}..{num4:F0}"), ("bounds_y", $"{num5 - 30f:F0}..{num6 + 30f:F0}"), ("reason", bakeResult.FailureReason ?? ""));
			RegionBuilder.BuildResult terrainResult = RegionBuilder.BuildFromTriangulation(SurfaceKind.Terrain, num, num2, num3, num4, anchors);
			RegionBuilder.BuildResult pieceResult = RegionBuilder.BuildFromTriangulation(SurfaceKind.Piece, num, num2, num3, num4, anchors);
			(Dictionary<string, HashSet<string>>, HashSet<string>, Dictionary<string, BfsEdgeMeta>)? tuple = BuildCrossKindAdjacency(terrainResult, pieceResult, anchors);
			RegionBuilder.CombineTerrainAndPiece(terrainResult, pieceResult, out var combinedRegionIds, out var combinedCentroids, out var combinedLinks, out var combinedLookup, out var combinedBoundary, out var combinedTriangles, out var kindMap);
			HashSet<string> droppedRegionIds;
			List<(string, string, Vector3, Vector3)> pass3DiscoveredEdgeList;
			HashSet<long> anchorReachableCellsOut;
			HashSet<long> outsideCellsOut;
			HashSet<long> prunedPieceKeysOut;
			List<Vector3> gateMarkersOut;
			RubberBandPrune.Stats stats = RubberBandPrune.Apply(combinedRegionIds, combinedCentroids, combinedLookup, combinedBoundary, combinedLinks, kindMap, combinedTriangles, anchors, num, num2, num3, num4, out droppedRegionIds, out pass3DiscoveredEdgeList, out anchorReachableCellsOut, out outsideCellsOut, out prunedPieceKeysOut, out gateMarkersOut);
			if (tuple.HasValue)
			{
				(Dictionary<string, HashSet<string>>, HashSet<string>, Dictionary<string, BfsEdgeMeta>) value = tuple.Value;
				Dictionary<string, HashSet<string>> item = value.Item1;
				HashSet<string> item2 = value.Item2;
				Dictionary<string, BfsEdgeMeta> item3 = value.Item3;
				int num7 = 0;
				foreach (var (text, text2, _, _) in pass3DiscoveredEdgeList)
				{
					if (!droppedRegionIds.Contains(text) && !droppedRegionIds.Contains(text2))
					{
						if (!item.TryGetValue(text, out var value2))
						{
							value2 = (item[text] = new HashSet<string>());
						}
						if (!item.TryGetValue(text2, out var value3))
						{
							value3 = (item[text2] = new HashSet<string>());
						}
						value2.Add(text2);
						value3.Add(text);
						string key = BfsAdjacencyStore.EdgeKey(text, text2);
						if (item3.TryGetValue(key, out var value4))
						{
							value4.Kinds |= BfsEdgeKind.Pass3Step;
							item3[key] = value4;
						}
						else
						{
							item3[key] = new BfsEdgeMeta
							{
								Kinds = BfsEdgeKind.Pass3Step
							};
							num7++;
						}
					}
				}
				BfsAdjacencyStore.Set(item, item2, item3);
				if (num7 > 0)
				{
					DebugLog.Event("Region", "bfs_store_merged_pass3", ("new_edges", num7), ("total_pass3_pairs", pass3DiscoveredEdgeList.Count));
				}
			}
			DebugLog.Event("RubberBandPrune", "applied", ("outside_terrain_cells", stats.OutsideTerrainCells), ("pass2_seeds", stats.Pass2Seeds), ("anchor_reachable_terrain_cells", stats.AnchorReachableTerrainCells), ("pass3_seeds", stats.Pass3Seeds), ("anchor_reachable_piece_keys", stats.AnchorReachablePieceKeys), ("pass3_piece_keys_dropped", stats.Pass3PieceKeysDropped), ("pass3_links_added", stats.Pass3LinksAdded), ("pass4_verts_snapped", stats.Pass4BoundaryVertsSnapped), ("pass4_snap_misses", stats.Pass4SnapMisses), ("pass4_links_snapped", stats.Pass4LinksSnapped), ("pass5_chains", stats.Pass5ChainsConsolidated), ("pass5_consumed", stats.Pass5RegionsConsumed), ("pass5_links_removed", stats.Pass5LinksRemoved), ("lookup_cells_dropped", stats.LookupCellsDropped), ("triangles_dropped", stats.TrianglesDropped), ("static_solid_dropped", stats.StaticSolidTrianglesDropped), ("regions_dropped", stats.RegionsDropped), ("seed_perimeter_cells", stats.PerimeterSeeds), ("regions_kept", combinedRegionIds.Count));
			if (droppedRegionIds.Count > 0)
			{
				DebugLog.List("RubberBandPrune", "dropped_region_ids", ((IEnumerable<string>)droppedRegionIds).Select((Func<string, object>)((string r) => r)));
			}
			if (combinedRegionIds.Count == 0)
			{
				RegionGraph regionGraph = FindContainingNonEmptyGraph(anchors);
				if (regionGraph != null)
				{
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogWarning((object)("[Region] Partition for key=" + villageId + " produced 0 regions, but its seed is inside " + $"existing graph '{regionGraph.RegisteredVillageKey}' ({regionGraph.RegionCount} regions, " + $"{regionGraph.LinkCount} links) — treating as a failed mutation of the same village; " + "keeping the existing graph rather than clobbering it."));
					}
					return TaskResult.Ok(new Dictionary<string, string>
					{
						{
							"regions",
							regionGraph.RegionCount.ToString()
						},
						{
							"links",
							regionGraph.LinkCount.ToString()
						},
						{
							"village_key",
							regionGraph.RegisteredVillageKey ?? villageId
						},
						{ "reason", "degenerate_kept_existing" }
					});
				}
			}
			RegionGraph orCreateGraph = village.GetOrCreateGraph();
			orCreateGraph.SetGraph(combinedRegionIds, combinedLinks, combinedCentroids, combinedLookup, combinedBoundary, kindMap);
			orCreateGraph.SetGates(gateMarkersOut);
			orCreateGraph.SetClassification(outsideCellsOut, anchorReachableCellsOut, prunedPieceKeysOut);
			if (gateMarkersOut.Count > 0)
			{
				ManualLogSource log5 = Plugin.Log;
				if (log5 != null)
				{
					log5.LogInfo((object)$"[Region] Sealed {gateMarkersOut.Count} gate(s) into the village boundary");
				}
			}
			int num8 = VillagerAIManager.InvalidatePathsAfterRebake();
			if (num8 > 0)
			{
				ManualLogSource log6 = Plugin.Log;
				if (log6 != null)
				{
					log6.LogInfo((object)$"[Region] Invalidated cached paths for {num8} villager(s) after rebake");
				}
			}
			string regionCenters = BuildRegionCentersString(orCreateGraph);
			string linksSummary = BuildLinksSummaryString(combinedLinks);
			PathTelemetry.LogRegionGraph(combinedRegionIds.Count, combinedLinks.Count, num, num2, num3, num4, regionCenters, linksSummary);
			ManualLogSource log7 = Plugin.Log;
			if (log7 != null)
			{
				log7.LogInfo((object)($"[Region] Partition complete: {combinedRegionIds.Count} regions " + $"(terrain={terrainResult.RegionIds.Count}, piece={pieceResult.RegionIds.Count}), " + $"{combinedLinks.Count} links " + $"(bounds {num:F0},{num2:F0} to {num3:F0},{num4:F0}, key={villageId})"));
			}
			village.SaveGraph();
			VillageAreaManager.RefreshFromVillage(village);
			int num9 = VillagerAIManager.ResetPatrolRoutesAfterRepartition();
			if (num9 > 0)
			{
				ManualLogSource log8 = Plugin.Log;
				if (log8 != null)
				{
					log8.LogInfo((object)$"[Region] Rebuilt patrol routes for {num9} patroller(s) after repartition");
				}
			}
			return TaskResult.Ok(new Dictionary<string, string>
			{
				{
					"regions",
					combinedRegionIds.Count.ToString()
				},
				{
					"regions_terrain",
					terrainResult.RegionIds.Count.ToString()
				},
				{
					"regions_piece",
					pieceResult.RegionIds.Count.ToString()
				},
				{
					"links",
					combinedLinks.Count.ToString()
				},
				{ "village_key", villageId }
			});
		}

		private static string BuildRegionCentersString(RegionGraph graph)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string regionId in graph.GetRegionIds())
			{
				if (!string.IsNullOrEmpty(regionId) && graph.GetCellWorldXZ(regionId, out var wx, out var wz))
				{
					float num = 0f;
					float height2;
					if (graph.TryGetCellHeight(regionId, out var height))
					{
						num = height;
					}
					else if (RegionGraph.GetSolidHeightAt(wx, wz, out height2))
					{
						num = height2;
					}
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(';');
					}
					stringBuilder.Append(regionId).Append(',').Append(wx.ToString("F1", CultureInfo.InvariantCulture))
						.Append(',')
						.Append(num.ToString("F1", CultureInfo.InvariantCulture))
						.Append(',')
						.Append(wz.ToString("F1", CultureInfo.InvariantCulture));
				}
			}
			return stringBuilder.ToString();
		}

		private static string BuildLinksSummaryString(List<RegionLink> links)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (RegionLink link in links)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(';');
				}
				string value = ((link.LinkType == RegionLinkType.Door) ? "door" : ((link.LinkType == RegionLinkType.Slope) ? "slope" : "stair"));
				stringBuilder.Append(link.FromRegionId).Append(',').Append(link.ToRegionId)
					.Append(',')
					.Append(value);
			}
			return stringBuilder.ToString();
		}

		private static Village ResolveVillage(VillagerTask task, List<Vector3> anchors)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (task?.Attributes != null && task.Attributes.TryGetValue("village_id", out var value) && !string.IsNullOrEmpty(value))
			{
				Village village = VillageRegistry.FindById(value);
				if (village != null)
				{
					return village;
				}
			}
			if (task?.Attributes != null && task.Attributes.TryGetValue("anchor_x", out var value2) && task.Attributes.TryGetValue("anchor_z", out var value3) && float.TryParse(value2, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(value3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				float num = ((anchors != null && anchors.Count > 0) ? anchors[0].y : 0f);
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(result, num, result2);
				return VillageRegistry.GetVillageCovering(val) ?? VillageRegistry.FindNearAnchor(val);
			}
			if (anchors != null && anchors.Count > 0)
			{
				return VillageRegistry.GetVillageCovering(anchors[0]) ?? VillageRegistry.FindNearAnchor(anchors[0]);
			}
			return null;
		}

		private static RegionGraph FindContainingNonEmptyGraph(List<Vector3> seeds)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (seeds == null)
			{
				return null;
			}
			foreach (Vector3 seed in seeds)
			{
				RegionGraph regionGraph = VillageRegistry.GetVillageAt(seed)?.Graph;
				if (regionGraph != null && regionGraph.RegionCount != 0)
				{
					if (!string.IsNullOrEmpty(regionGraph.PointToRegionId(seed)))
					{
						return regionGraph;
					}
					if (regionGraph.TryFindNearestLookupCell(seed, null, out var _, out var _, 6f))
					{
						return regionGraph;
					}
				}
			}
			return null;
		}

		private static List<Vector3> ResolveWalkableSeeds(List<Vector3> anchors)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (anchors == null || anchors.Count == 0)
			{
				return anchors;
			}
			List<Vector3> list = new List<Vector3>(anchors.Count);
			int num = 0;
			foreach (Vector3 anchor in anchors)
			{
				if (RegistrySeedResolver.TryResolveWalkableSeed(anchor, out var seed))
				{
					Vector3 val = seed - anchor;
					if (((Vector3)(ref val)).sqrMagnitude > 0.25f)
					{
						num++;
					}
					list.Add(seed);
				}
				else
				{
					list.Add(anchor);
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)($"[Region] No walkable seed near home ({anchor.x:F1},{anchor.y:F1},{anchor.z:F1}); " + "using it as-is (flood may degenerate)."));
					}
				}
			}
			if (num > 0)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"[Region] Snapped {num}/{anchors.Count} village seed(s) onto walkable cells near their anchor.");
				}
			}
			return list;
		}

		private static List<Vector3> FilterAnchorsByTask(List<Vector3> allAnchors, VillagerTask task)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (allAnchors == null || allAnchors.Count == 0)
			{
				return allAnchors;
			}
			if (task?.Attributes == null || !task.Attributes.TryGetValue("anchor_x", out var value) || !task.Attributes.TryGetValue("anchor_z", out var value2))
			{
				return allAnchors;
			}
			if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !float.TryParse(value2, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return allAnchors;
			}
			float num = 2500f;
			List<Vector3> list = new List<Vector3>();
			foreach (Vector3 allAnchor in allAnchors)
			{
				float num2 = allAnchor.x - result;
				float num3 = allAnchor.z - result2;
				if (num2 * num2 + num3 * num3 <= num)
				{
					list.Add(allAnchor);
				}
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Region] Filtered anchors by anchor ({result:F0},{result2:F0}): " + $"{list.Count}/{allAnchors.Count} within {50f}m"));
			}
			if (list.Count == 0)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"[Region] No anchors within {50f}m of anchor ({result:F0},{result2:F0})");
				}
			}
			return list;
		}

		private static (Dictionary<string, HashSet<string>> adjacency, HashSet<string> seeds, Dictionary<string, BfsEdgeMeta> edgeMeta)? BuildCrossKindAdjacency(RegionBuilder.BuildResult terrainResult, RegionBuilder.BuildResult pieceResult, List<Vector3> anchors)
		{
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0744: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_077e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0785: Unknown result type (might be due to invalid IL or missing references)
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0614: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_0629: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0643: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_067f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_068b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Unknown result type (might be due to invalid IL or missing references)
			if (terrainResult.RegionIds == null || terrainResult.RegionIds.Count == 0)
			{
				return null;
			}
			Dictionary<string, HashSet<string>> combinedAdj = new Dictionary<string, HashSet<string>>();
			Dictionary<string, BfsEdgeMeta> edgeMeta = new Dictionary<string, BfsEdgeMeta>();
			if (terrainResult.Adjacency != null)
			{
				foreach (KeyValuePair<string, HashSet<string>> item in terrainResult.Adjacency)
				{
					EnsureNode(item.Key);
					foreach (string item2 in item.Value)
					{
						RecordEdge(item.Key, item2, BfsEdgeKind.InPassEdge, null, 0f);
					}
				}
			}
			if (pieceResult.Adjacency != null)
			{
				foreach (KeyValuePair<string, HashSet<string>> item3 in pieceResult.Adjacency)
				{
					EnsureNode(item3.Key);
					foreach (string item4 in item3.Value)
					{
						RecordEdge(item3.Key, item4, BfsEdgeKind.InPassEdge, null, 0f);
					}
				}
			}
			Dictionary<long, Vector3> dictionary = new Dictionary<long, Vector3>();
			if (terrainResult.RegionVertexList != null)
			{
				foreach (KeyValuePair<string, List<Vector3>> regionVertex in terrainResult.RegionVertexList)
				{
					foreach (Vector3 item5 in regionVertex.Value)
					{
						long key = RegionBuilder.PackQuantizedPos(item5);
						if (!dictionary.ContainsKey(key))
						{
							dictionary[key] = item5;
						}
					}
				}
			}
			if (pieceResult.RegionVertexList != null)
			{
				foreach (KeyValuePair<string, List<Vector3>> regionVertex2 in pieceResult.RegionVertexList)
				{
					foreach (Vector3 item6 in regionVertex2.Value)
					{
						long key2 = RegionBuilder.PackQuantizedPos(item6);
						if (!dictionary.ContainsKey(key2))
						{
							dictionary[key2] = item6;
						}
					}
				}
			}
			int num = 0;
			int num2 = 0;
			if (terrainResult.RegionVertexPositions != null && pieceResult.RegionVertexPositions != null)
			{
				Dictionary<long, List<string>> dictionary2 = new Dictionary<long, List<string>>();
				foreach (KeyValuePair<string, HashSet<long>> regionVertexPosition in pieceResult.RegionVertexPositions)
				{
					foreach (long item7 in regionVertexPosition.Value)
					{
						if (!dictionary2.TryGetValue(item7, out var value))
						{
							value = (dictionary2[item7] = new List<string>());
						}
						value.Add(regionVertexPosition.Key);
					}
				}
				foreach (KeyValuePair<string, HashSet<long>> regionVertexPosition2 in terrainResult.RegionVertexPositions)
				{
					Dictionary<string, long> dictionary3 = new Dictionary<string, long>();
					foreach (long item8 in regionVertexPosition2.Value)
					{
						if (!dictionary2.TryGetValue(item8, out var value2))
						{
							continue;
						}
						foreach (string item9 in value2)
						{
							if (!dictionary3.ContainsKey(item9))
							{
								dictionary3[item9] = item8;
							}
						}
					}
					foreach (KeyValuePair<string, long> item10 in dictionary3)
					{
						Vector3 value3;
						Vector3? repPos = (dictionary.TryGetValue(item10.Value, out value3) ? new Vector3?(value3) : ((Vector3?)null));
						RecordEdge(regionVertexPosition2.Key, item10.Key, BfsEdgeKind.CrossVert, repPos, 0f);
						num++;
					}
				}
			}
			if (terrainResult.RegionVertexList != null && pieceResult.RegionVertexList != null && terrainResult.RegionBounds != null && pieceResult.RegionBounds != null)
			{
				foreach (KeyValuePair<string, List<Vector3>> regionVertex3 in terrainResult.RegionVertexList)
				{
					if (!terrainResult.RegionBounds.TryGetValue(regionVertex3.Key, out var value4))
					{
						continue;
					}
					List<Vector3> value5 = regionVertex3.Value;
					foreach (KeyValuePair<string, List<Vector3>> regionVertex4 in pieceResult.RegionVertexList)
					{
						if (!pieceResult.RegionBounds.TryGetValue(regionVertex4.Key, out var value6))
						{
							continue;
						}
						float num3 = Mathf.Max(0f, Mathf.Max(((Bounds)(ref value4)).min.x - ((Bounds)(ref value6)).max.x, ((Bounds)(ref value6)).min.x - ((Bounds)(ref value4)).max.x));
						float num4 = Mathf.Max(0f, Mathf.Max(((Bounds)(ref value4)).min.y - ((Bounds)(ref value6)).max.y, ((Bounds)(ref value6)).min.y - ((Bounds)(ref value4)).max.y));
						float num5 = Mathf.Max(0f, Mathf.Max(((Bounds)(ref value4)).min.z - ((Bounds)(ref value6)).max.z, ((Bounds)(ref value6)).min.z - ((Bounds)(ref value4)).max.z));
						if (num3 * num3 + num4 * num4 + num5 * num5 > 0.25f)
						{
							continue;
						}
						List<Vector3> value7 = regionVertex4.Value;
						bool flag = false;
						Vector3 value8 = default(Vector3);
						float num6 = 0f;
						for (int i = 0; i < value5.Count; i++)
						{
							if (flag)
							{
								break;
							}
							Vector3 val = value5[i];
							for (int j = 0; j < value7.Count; j++)
							{
								Vector3 val2 = value7[j];
								float num7 = val.x - val2.x;
								float num8 = val.y - val2.y;
								float num9 = val.z - val2.z;
								float num10 = num7 * num7 + num8 * num8 + num9 * num9;
								if (num10 <= 0.25f)
								{
									flag = true;
									value8 = (val + val2) * 0.5f;
									num6 = num10;
									break;
								}
							}
						}
						if (flag)
						{
							RecordEdge(regionVertex3.Key, regionVertex4.Key, BfsEdgeKind.CrossProx, value8, Mathf.Sqrt(num6));
							num2++;
						}
					}
				}
			}
			HashSet<string> hashSet = new HashSet<string>();
			if (anchors != null)
			{
				foreach (Vector3 anchor in anchors)
				{
					string text = null;
					float num11 = float.MaxValue;
					foreach (string regionId in terrainResult.RegionIds)
					{
						if (terrainResult.Centroids.TryGetValue(regionId, out var value9) && !(Mathf.Abs(value9.y - anchor.y) > 3f))
						{
							float num12 = value9.x - anchor.x;
							float num13 = value9.z - anchor.z;
							float num14 = num12 * num12 + num13 * num13;
							if (!(num14 > 900f) && num14 < num11)
							{
								num11 = num14;
								text = regionId;
							}
						}
					}
					if (text != null)
					{
						hashSet.Add(text);
					}
				}
			}
			if (hashSet.Count == 0)
			{
				int num15 = anchors?.Count ?? 0;
				int num16 = terrainResult.RegionIds?.Count ?? 0;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("[Region] CrossKind adjacency aborted: no anchor mapped to any terrain region " + $"(anchors={num15}, terrain_regions={num16}). " + "Refusing to seed BFS from a synthetic largest-region fallback; vv_bfs_trace will report no data."));
				}
				return null;
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)($"[Region] CrossKind adjacency built: {combinedAdj.Count} nodes, " + $"seeds={hashSet.Count}, edges={edgeMeta.Count}, " + $"cross_vert={num}, cross_prox={num2} " + "(piece-step edges added downstream by RubberBandPrune)"));
			}
			return (combinedAdj, hashSet, edgeMeta);
			void AddEdgeBoth(string a, string b)
			{
				EnsureNode(a);
				EnsureNode(b);
				combinedAdj[a].Add(b);
				combinedAdj[b].Add(a);
			}
			void EnsureNode(string id)
			{
				if (!combinedAdj.ContainsKey(id))
				{
					combinedAdj[id] = new HashSet<string>();
				}
			}
			void RecordEdge(string a, string b, BfsEdgeKind kind, Vector3? representativePos, float proxDist)
			{
				AddEdgeBoth(a, b);
				string key3 = BfsAdjacencyStore.EdgeKey(a, b);
				if (edgeMeta.TryGetValue(key3, out var value10))
				{
					value10.Kinds |= kind;
					if (!value10.RepresentativePos.HasValue && representativePos.HasValue)
					{
						value10.RepresentativePos = representativePos;
					}
					if (kind == BfsEdgeKind.CrossProx && (value10.ProxMinDist == 0f || proxDist < value10.ProxMinDist))
					{
						value10.ProxMinDist = proxDist;
					}
					edgeMeta[key3] = value10;
				}
				else
				{
					edgeMeta[key3] = new BfsEdgeMeta
					{
						Kinds = kind,
						RepresentativePos = representativePos,
						ProxMinDist = ((kind == BfsEdgeKind.CrossProx) ? proxDist : 0f)
					};
				}
			}
		}
	}
	[RegisterTaskHandler]
	public class VillageIndexHandler : ITaskHandlerWithLog, ITaskHandler
	{
		public string TaskName => "village_index";

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			(int villages, int withGraph) tuple = VillageRegistry.HydrateAll();
			int item = tuple.villages;
			int item2 = tuple.withGraph;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[village_index] villages={item} with_graph={item2}");
			}
			activityLog.Record(task.SourceId, TaskName, "index", $"villages={item} with_graph={item2}");
			return TaskResult.Ok(new Dictionary<string, string>
			{
				{
					"villages",
					item.ToString()
				},
				{
					"with_graph",
					item2.ToString()
				}
			});
		}
	}
	[RegisterTaskHandler]
	public class VillagerRecordIndexHandler : ITaskHandlerWithLog, ITaskHandler
	{
		public string TaskName => "villager_record_index";

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				return TaskResult.Fail("ZDOMan not ready");
			}
			Dictionary<ZDOID, ZDO> value = Traverse.Create((object)instance).Field<Dictionary<ZDOID, ZDO>>("m_objectsByID").Value;
			if (value == null)
			{
				return TaskResult.Fail("m_objectsByID unavailable");
			}
			List<ZDO> list = new List<ZDO>();
			foreach (ZDO value2 in value.Values)
			{
				if (value2 != null && string.IsNullOrEmpty(value2.GetString("vv_record_id", "")) && !string.IsNullOrEmpty(value2.GetString("vv_villager_type", "")))
				{
					list.Add(value2);
				}
			}
			int num = 0;
			foreach (ZDO item in list)
			{
				string text = item.GetString("vv_villager_type", "");
				string text2 = item.GetString("vv_villager_name", "");
				Vector3 vec = item.GetVec3("vv_home_position", Vector3.zero);
				string text3 = item.GetString("vv_village_id", "");
				string text4 = ((!string.IsNullOrEmpty(text3)) ? text3 : (VillageRegistry.GetVillageCovering(vec) ?? VillageRegistry.FindNearAnchor(vec))?.VillageId);
				if (string.IsNullOrEmpty(text4))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)($"[villager_record_index] legacy villager '{text2}' ({text}) at {vec} resolves to " + "no village; not migrating."));
					}
					continue;
				}
				VillagerRecord villagerRecord = VillagerRecordTable.Create(text, string.IsNullOrEmpty(text2) ? text : text2, text4, vec, RecordStatus.Alive, item.m_uid);
				if (villagerRecord != null)
				{
					item.Set("vv_record_id", villagerRecord.RecordId);
					item.Set("vv_village_id", text4);
					num++;
				}
			}
			int num2 = VillagerRecordTable.AuditOrphans();
			int num3 = VillagerRecordTable.EnumerateAll().Count();
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"[villager_record_index] records={num3} migrated={num} orphans={num2}");
			}
			activityLog.Record(task.SourceId, TaskName, "index", $"records={num3} migrated={num} orphans={num2}");
			return TaskResult.Ok(new Dictionary<string, string>
			{
				{
					"records_total",
					num3.ToString()
				},
				{
					"migrated",
					num.ToString()
				},
				{
					"orphans",
					num2.ToString()
				}
			});
		}
	}
	[RegisterTaskHandler]
	public class WorkOrderScanHandler : ITaskHandlerWithLog, ITaskHandler
	{
		private struct RejectionRecord
		{
			public string ItemPrefab;

			public string Station;

			public string PhysicalStation;

			public string Reason;

			public bool IsUnimplemented;

			public Vector3 WorkOrderPosition;
		}

		public string TaskName => "work_order_scan";

		public TaskResult Handle(VillagerTask task, VillagerActivityLog activityLog)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0779: Unknown result type (might be due to invalid IL or missing references)
			//IL_0794: Unknown result type (might be due to invalid IL or missing references)
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0914: Unknown result type (might be due to invalid IL or missing references)
			//IL_0919: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0877: Unknown result type (might be due to invalid IL or missing references)
			//IL_087c: Unknown result type (might be due to invalid IL or missing references)
			if (!task.Attributes.TryGetValue("villager_id", out var value))
			{
				return TaskResult.Fail("Missing villager_id");
			}
			if (!task.Attributes.TryGetValue("villager_type", out var value2) || string.IsNullOrEmpty(value2))
			{
				return TaskResult.Fail("Missing villager_type");
			}
			if (!TaskAttributeParser.TryParsePosition(task.Attributes, "home", out var result))
			{
				return TaskResult.Fail("Missing or invalid anchor position");
			}
			if (!VillagerAIManager.ActiveVillagers.TryGetValue(value, out var value3))
			{
				return TaskResult.Fail("Villager " + value + " not found in active villagers");
			}
			List<Container> list = ContainerScanner.FindNearbyContainers(result, 20f);
			if (list.Count == 0)
			{
				return TaskResult.Fail("No containers found near anchor");
			}
			List<WorkOrderMatch> list2 = ContainerScanner.FindAllWorkOrders(list, value2);
			if (list2 == null || list2.Count == 0)
			{
				return TaskResult.Ok();
			}
			if (!VillageStationRegistry.HasVillageFor(result))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[WorkOrderScan] {value3.NpcName} deferring scan — no village registered yet at anchor {result}");
				}
				return TaskResult.Ok();
			}
			List<RejectionRecord> list3 = new List<RejectionRecord>();
			foreach (WorkOrderMatch match in list2)
			{
				int num = ContainerScanner.CountAcrossContainers(list, match.ItemPrefabName);
				if (num >= match.MaxQuantity)
				{
					list3.Add(new RejectionRecord
					{
						ItemPrefab = match.ItemPrefabName,
						Station = match.StationName,
						PhysicalStation = null,
						Reason = $"Already have {num}/{match.MaxQuantity}",
						IsUnimplemented = false,
						WorkOrderPosition = ((Component)match.SourceContainer).transform.position
					});
					continue;
				}
				Recipe val = StationMatcher.FindRecipeForNpc(match.ItemPrefabName, value2);
				if ((Object)(object)val == (Object)null)
				{
					list3.Add(new RejectionRecord
					{
						ItemPrefab = match.ItemPrefabName,
						Station = match.StationName,
						PhysicalStation = null,
						Reason = "No recipe for '" + match.ItemPrefabName + "'",
						IsUnimplemented = false,
						WorkOrderPosition = ((Component)match.SourceContainer).transform.position
					});
					continue;
				}
				int amount = ((val.m_amount <= 0) ? 1 : val.m_amount);
				if (!ContainerScanner.CanAcceptItem(match.SourceContainer, match.ItemPrefabName, amount))
				{
					list3.Add(new RejectionRecord
					{
						ItemPrefab = match.ItemPrefabName,
						Station = match.StationName,
						PhysicalStation = null,
						Reason = "Output chest full",
						IsUnimplemented = false,
						WorkOrderPosition = ((Component)match.SourceContainer).transform.position
					});
					continue;
				}
				string physicalStation = VirtualRecipeLoader.GetPhysicalStation(((Object)val).name);
				List<IngredientSource> list4 = ContainerScanner.FindIngredients(list, val);
				if (list4 == null && physicalStation != "farm")
				{
					list3.Add(new RejectionRecord
					{
						ItemPrefab = match.ItemPrefabName,
						Station = match.StationName,
						PhysicalStation = null,
						Reason = "Missing ingredients for " + match.ItemPrefabName,
						IsUnimplemented = false,
						WorkOrderPosition = ((Component)match.SourceContainer).transform.position
					});
					continue;
				}
				if (physicalStation == "farm")
				{
					FarmingContext farmingContext = FarmWorkOrderHelper.BuildFarmingContext(value3, match, val, list4, num);
					if (farmingContext == null)
					{
						list3.Add(new RejectionRecord
						{
							ItemPrefab = match.ItemPrefabName,
							Station = match.StationName,
							PhysicalStation = physicalStation,
							Reason = "No farm location in memory",
							IsUnimplemented = false,
							WorkOrderPosition = ((Component)match.SourceContainer).transform.position
						});
						continue;
					}
					activityLog.Record(value, TaskName, "farm_work_matched", "matched farming work order for " + match.ItemPrefabName);
					return TaskResult.Ok(new Dictionary<string, string>
					{
						{ "item_prefab", match.ItemPrefabName },
						{ "station_name", match.StationName },
						{
							"existing_count",
							num.ToString()
						},
						{ "is_farming", "true" }
					}, farmingContext);
				}
				CookingStation val2 = null;
				Smelter val3 = null;
				string smelterInputItemName = null;
				FuelNeed? fuelRequirement = null;
				Container fuelContainer = null;
				Vector3? val4;
				string text;
				if (physicalStation == "cookingstation")
				{
					if (VillageStationRegistry.TryFindStation<CookingStation>(result, (Func<CookingStation, bool>)((CookingStation s) => StationFinder.IsCookingStationReady(s)), out Vector3 stationPos, out CookingStation component))
					{
						val4 = stationPos;
						val2 = component;
					}
					else if (VillageStationRegistry.TryFindStation<CookingStation>(result, (Func<CookingStation, bool>)null, out stationPos, out component))
					{
						if (StationFuelHelper.DiagnoseFuelNeed(component, out var need) && StationFuelHelper.FindFuelInContainers(list, need.FuelItemPrefab, out var fuelContainer2))
						{
							val4 = stationPos;
							val2 = component;
							fuelRequirement = need;
							fuelContainer = fuelContainer2;
							ManualLogSource log2 = Plugin.Log;
							if (log2 != null)
							{
								log2.LogInfo((object)("[WorkOrderScan] Station needs fuel (" + need.FuelItemPrefab + "), found in container. Will fuel before cooking."));
							}
						}
						else
						{
							val4 = null;
						}
					}
					else
					{
						val4 = null;
					}
					text = "CookingStation";
				}
				else if (!string.IsNullOrEmpty(physicalStation) && (Object)(object)StationFinder.GetSmelterPrefab(physicalStation) != (Object)null)
				{
					if (VillageStationRegistry.TryFindStation<Smelter>(result, (Func<Smelter, bool>)((Smelter s) => (Object)(object)s != (Object)null && PrefabNameMatches(((Object)((Component)s).gameObject).name, physicalStation)), out Vector3 stationPos2, out Smelter component2))
					{
						FuelNeed need2;
						Container fuelContainer3;
						if (StationFinder.IsSmelterReady(component2))
						{
							val4 = stationPos2;
							val3 = component2;
						}
						else if (StationFuelHelper.DiagnoseFuelNeed(component2, out need2) && StationFuelHelper.FindFuelInContainers(list, need2.FuelItemPrefab, out fuelContainer3))
						{
							val4 = stationPos2;
							val3 = component2;
							need2.FuelTargetPosition = stationPos2;
							fuelRequirement = need2;
							fuelContainer = fuelContainer3;
							ManualLogSource log3 = Plugin.Log;
							if (log3 != null)
							{
								log3.LogInfo((object)("[WorkOrderScan] Smelter (" + physicalStation + ") needs fuel (" + need2.FuelItemPrefab + "), found in container. Will fuel before smelting."));
							}
						}
						else
						{
							val4 = null;
						}
						if ((Object)(object)val3 != (Object)null && val.m_resources != null && val.m_resources.Length != 0 && (Object)(object)val.m_resources[0].m_resItem != (Object)null)
						{
							smelterInputItemName = ((Object)((Component)val.m_resources[0].m_resItem).gameObject).name;
						}
					}
					else
					{
						val4 = null;
					}
					text = physicalStation;
				}
				else
				{
					val4 = ((!VillageStationRegistry.TryFindStation<CraftingStation>(result, (Func<CraftingStation, bool>)((CraftingStation cs) => cs.m_name == match.StationName), out Vector3 stationPos3, out CraftingStation _)) ? ((Vector3?)null) : new Vector3?(stationPos3));
					text = match.StationName;
				}
				if (!val4.HasValue)
				{
					bool isUnimplemented = physicalStation != null && physicalStation != "farm" && physicalStation != "cookingstation" && (Object)(object)StationFinder.GetSmelterPrefab(physicalStation) == (Object)null;
					list3.Add(new RejectionRecord
					{
						ItemPrefab = match.ItemPrefabName,
						Station = match.StationName,
						PhysicalStation = physicalStation,
						Reason = "No station '" + text + "' in village",
						IsUnimplemented = isUnimplemented,
						WorkOrderPosition = ((Component)match.SourceContainer).transform.position
					});
					continue;
				}
				string cookingInputItemName = null;
				if ((Object)(object)val2 != (Object)null && val.m_resources != null && val.m_resources.Length != 0 && (Object)(object)val.m_resources[0].m_resItem != (Object)null)
				{
					cookingInputItemName = ((Object)((Component)val.m_resources[0].m_resItem).gameObject).name;
				}
				WorkOrderContext payload = new WorkOrderContext
				{
					SourceContainer = match.SourceContainer,
					WorkOrder = match,
					Recipe = val,
					IngredientSources = list4,
					CraftStationPosition = val4.Value,
					CookingStationRef = val2,
					CookingInputItemName = cookingInputItemName,
					CraftedCount = num,
					CurrentIngredientIndex = 0,
					FuelRequirement = fuelRequirement,
					FuelContainer = fuelContainer,
					SmelterRef = val3,
					SmelterInputItemName = smelterInputItemName,
					SmelterProcessedAtStart = 0,
					SmelterRemovalRequested = false,
					SmelterItemAlreadyInChest = false
				};
				string text2 = string.Join(", ", list4.Select((IngredientSource i) => $"{i.Amount}x {i.PrefabName}"));
				activityLog.Record(value, TaskName, "work_order_matched", "matched work order for " + match.ItemPrefabName + " (need: " + text2 + ", station: " + match.StationName + ")");
				return TaskResult.Ok(new Dictionary<string, string>
				{
					{ "item_prefab", match.ItemPrefabName },
					{ "station_name", match.StationName },
					{
						"existing_count",
						num.ToString()
					}
				}, payload);
			}
			EmitRejections(list3, value3, activityLog, value);
			return TaskResult.Ok();
		}

		private void EmitRejections(List<RejectionRecord> rejections, VillagerAI ai, VillagerActivityLog activityLog, string villagerId)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			if (rejections.Count == 0)
			{
				return;
			}
			bool num = rejections.Any((RejectionRecord r) => r.IsUnimplemented);
			string text = string.Concat(str1: string.Join("\n", rejections.Select(delegate(RejectionRecord r)
			{
				string text2 = r.PhysicalStation ?? r.Station;
				return "  " + r.ItemPrefab + " [" + text2 + "] — " + r.Reason;
			})), str0: $"[WorkOrderScan] {ai.NpcName} blocked on {rejections.Count} orders:\n");
			if (num)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)text);
				}
			}
			else
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)text);
				}
			}
			foreach (RejectionRecord rejection in rejections)
			{
				string stationName = rejection.PhysicalStation ?? rejection.Station;
				activityLog.RecordBlocked(villagerId, TaskName, rejection.ItemPrefab, stationName, rejection.Reason, rejection.WorkOrderPosition);
			}
		}

		private static bool PrefabNameMatches(string instanceName, string prefabName)
		{
			if (string.IsNullOrEmpty(instanceName) || string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			if (instanceName == prefabName)
			{
				return true;
			}
			int num = instanceName.IndexOf("(Clone)", StringComparison.Ordinal);
			if (num > 0)
			{
				instanceName = instanceName.Substring(0, num);
			}
			return instanceName == prefabName;
		}
	}
}
namespace ValheimVillages.TaskQueue.ActivityLog
{
	public class ActivityLogEntry
	{
		public string Action;

		public bool Committed;

		public string Description;

		public string TaskName;

		public float Timestamp;

		public string VillagerId;

		public string ItemPrefab;

		public string StationName;

		public string Reason;

		public float? WorkOrderPosX;

		public float? WorkOrderPosY;

		public float? WorkOrderPosZ;
	}
	public class VillagerActivityLog
	{
		private const string ZdoKey = "vv_wal";

		private const char FieldSeparator = '\u001f';

		private const char EntrySeparator = '\u001e';

		private static VillagerActivityLog s_instance;

		private readonly Dictionary<string, List<ActivityLogEntry>> m_logs = new Dictionary<string, List<ActivityLogEntry>>();

		public static VillagerActivityLog Instance => s_instance ?? (s_instance = new VillagerActivityLog());

		public void Record(string villagerId, string taskName, string action, string description)
		{
			if (!string.IsNullOrEmpty(villagerId))
			{
				if (!m_logs.TryGetValue(villagerId, out var value))
				{
					value = new List<ActivityLogEntry>();
					m_logs[villagerId] = value;
				}
				if (value.Count >= 100)
				{
					TrimOldest(value);
				}
				value.Add(new ActivityLogEntry
				{
					Timestamp = Time.time,
					VillagerId = villagerId,
					TaskName = taskName,
					Action = action,
					Description = description,
					Committed = false
				});
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[ActivityLog:" + villagerId + "] " + taskName + "/" + action + ": " + description));
				}
			}
		}

		public void RecordBlocked(string villagerId, string taskName, string itemPrefab, string stationName, string reason, Vector3? workOrderPosition)
		{
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(villagerId))
			{
				if (!m_logs.TryGetValue(villagerId, out var value))
				{
					value = new List<ActivityLogEntry>();
					m_logs[villagerId] = value;
				}
				value.RemoveAll((ActivityLogEntry e) => e.VillagerId == villagerId && e.TaskName == taskName && e.Action == "blocked" && e.ItemPrefab == itemPrefab && e.StationName == stationName && e.Reason == reason);
				if (value.Count >= 100)
				{
					TrimOldest(value);
				}
				string text = string.Empty;
				if (!string.IsNullOrEmpty(itemPrefab))
				{
					text = itemPrefab;
				}
				if (!string.IsNullOrEmpty(stationName))
				{
					text = text + " [" + stationName + "]";
				}
				text = text.Trim();
				string text2 = (string.IsNullOrEmpty(text) ? reason : (text + " — " + reason));
				value.Add(new ActivityLogEntry
				{
					Timestamp = Time.time,
					VillagerId = villagerId,
					TaskName = taskName,
					Action = "blocked",
					Description = text2,
					ItemPrefab = itemPrefab,
					StationName = stationName,
					Reason = reason,
					WorkOrderPosX = workOrderPosition?.x,
					WorkOrderPosY = workOrderPosition?.y,
					WorkOrderPosZ = workOrderPosition?.z,
					Committed = false
				});
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[ActivityLog:" + villagerId + "] " + taskName + "/blocked: " + text2));
				}
			}
		}

		public IReadOnlyList<ActivityLogEntry> GetEntries(string villagerId)
		{
			if (!m_logs.TryGetValue(villagerId, out var value))
			{
				return new List<ActivityLogEntry>();
			}
			return value;
		}

		public List<ActivityLogEntry> GetUncommitted(string villagerId)
		{
			if (!m_logs.TryGetValue(villagerId, out var value))
			{
				return new List<ActivityLogEntry>();
			}
			return value.Where((ActivityLogEntry e) => !e.Committed).ToList();
		}

		public void MarkCommitted(string villagerId)
		{
			if (!m_logs.TryGetValue(villagerId, out var value))
			{
				return;
			}
			foreach (ActivityLogEntry item in value)
			{
				item.Committed = true;
			}
		}

		public void TrimCommitted(string villagerId)
		{
			if (!m_logs.TryGetValue(villagerId, out var value))
			{
				return;
			}
			List<ActivityLogEntry> list = value.Where((ActivityLogEntry e) => e.Committed).ToList();
			if (list.Count > 10)
			{
				int count = list.Count - 10;
				HashSet<ActivityLogEntry> toRemove = new HashSet<ActivityLogEntry>(list.Take(count));
				value.RemoveAll((ActivityLogEntry e) => toRemove.Contains(e));
			}
		}

		public void SaveToZDO(string villagerId, ZDO zdo)
		{
			if (zdo == null)
			{
				return;
			}
			List<ActivityLogEntry> uncommitted = GetUncommitted(villagerId);
			if (uncommitted.Count == 0)
			{
				zdo.Set("vv_wal", "");
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < uncommitted.Count; i++)
			{
				ActivityLogEntry activityLogEntry = uncommitted[i];
				if (i > 0)
				{
					stringBuilder.Append('\u001e');
				}
				stringBuilder.Append(activityLogEntry.Timestamp.ToString("F2"));
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.TaskName ?? "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.Action ?? "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.Description ?? "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.ItemPrefab ?? "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.StationName ?? "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.Reason ?? "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.WorkOrderPosX.HasValue ? activityLogEntry.WorkOrderPosX.Value.ToString(CultureInfo.InvariantCulture) : "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.WorkOrderPosY.HasValue ? activityLogEntry.WorkOrderPosY.Value.ToString(CultureInfo.InvariantCulture) : "");
				stringBuilder.Append('\u001f');
				stringBuilder.Append(activityLogEntry.WorkOrderPosZ.HasValue ? activityLogEntry.WorkOrderPosZ.Value.ToString(CultureInfo.InvariantCulture) : "");
			}
			zdo.Set("vv_wal", stringBuilder.ToString());
		}

		public void LoadFromZDO(string villagerId, ZDO zdo)
		{
			if (zdo == null)
			{
				return;
			}
			string text = zdo.GetString("vv_wal", "");
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			if (!m_logs.TryGetValue(villagerId, out var value))
			{
				value = new List<ActivityLogEntry>();
				m_logs[villagerId] = value;
			}
			string[] array = text.Split(new char[1] { '\u001e' });
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string[] array3 = array2[i].Split(new char[1] { '\u001f' });
				if (array3.Length < 4 || !float.TryParse(array3[0], out var result))
				{
					continue;
				}
				float? workOrderPosX = null;
				float? workOrderPosY = null;
				float? workOrderPosZ = null;
				if (array3.Length >= 10)
				{
					if (float.TryParse(array3[7], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
					{
						workOrderPosX = result2;
					}
					if (float.TryParse(array3[8], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
					{
						workOrderPosY = result3;
					}
					if (float.TryParse(array3[9], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
					{
						workOrderPosZ = result4;
					}
				}
				value.Add(new ActivityLogEntry
				{
					Timestamp = result,
					VillagerId = villagerId,
					TaskName = array3[1],
					Action = array3[2],
					Description = array3[3],
					ItemPrefab = ((array3.Length >= 7) ? array3[4] : null),
					StationName = ((array3.Length >= 7) ? array3[5] : null),
					Reason = ((array3.Length >= 7) ? array3[6] : null),
					WorkOrderPosX = workOrderPosX,
					WorkOrderPosY = workOrderPosY,
					WorkOrderPosZ = workOrderPosZ,
					Committed = false
				});
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)$"[ActivityLog:{villagerId}] Loaded {array.Length} entries from ZDO");
			}
		}

		public void ClearVillager(string villagerId)
		{
			m_logs.Remove(villagerId);
		}

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

		[RegisterCleanup]
		public static void ResetInstance()
		{
			s_instance?.Clear();
			s_instance = null;
		}

		private static void TrimOldest(List<ActivityLogEntry> entries)
		{
			int num = entries.Count - 100 + 1;
			if (num > 0)
			{
				entries.RemoveRange(0, num);
			}
		}
	}
}
namespace ValheimVillages.Tags
{
	public static class TagParser
	{
		public static bool TryParse(string tag, out string ns, out string value)
		{
			ns = null;
			value = null;
			if (string.IsNullOrEmpty(tag))
			{
				return false;
			}
			int num = tag.IndexOf(':');
			if (num <= 0 || num >= tag.Length - 1)
			{
				return false;
			}
			ns = tag.Substring(0, num).Trim();
			value = tag.Substring(num + 1).Trim();
			if (ns.Length > 0)
			{
				return value.Length > 0;
			}
			return false;
		}

		public static string GetNamespace(string tag)
		{
			if (!TryParse(tag, out var ns, out var _))
			{
				return null;
			}
			return ns;
		}

		public static string GetValue(string tag)
		{
			if (!TryParse(tag, out var _, out var value))
			{
				return null;
			}
			return value;
		}

		public static List<string> FilterByNamespace(IEnumerable<string> tags, string ns)
		{
			List<string> list = new List<string>();
			foreach (string tag in tags)
			{
				if (TryParse(tag, out var ns2, out var _) && string.Equals(ns2, ns, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(tag);
				}
			}
			return list;
		}

		public static List<string> GetValues(IEnumerable<string> tags, string ns)
		{
			List<string> list = new List<string>();
			foreach (string tag in tags)
			{
				if (TryParse(tag, out var ns2, out var value) && string.Equals(ns2, ns, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(value);
				}
			}
			return list;
		}

		public static bool HasTag(IEnumerable<string> tags, string ns, string value)
		{
			foreach (string tag in tags)
			{
				if (TryParse(tag, out var ns2, out var value2) && string.Equals(ns2, ns, StringComparison.OrdinalIgnoreCase) && string.Equals(value2, value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasNamespace(IEnumerable<string> tags, string ns)
		{
			foreach (string tag in tags)
			{
				if (TryParse(tag, out var ns2, out var _) && string.Equals(ns2, ns, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace ValheimVillages.Settings
{
	public static class VillagerSettings
	{
		public const float MaxWanderRange = 200f;

		public const float DiscoveryRadius = 20f;

		public const float UpdateInterval = 15f;

		public const float PatrolWaypointLookahead = 2f;

		public const float BehaviorReselectIntervalSec = 2f;

		public const float PostWorkLingerSec = 15f;

		public const float BehaviorTickJitter = 11f;

		public const float ArrivalThreshold = 1f;

		public const float PathNodePopThreshold = 0.5f;

		public const float NavMeshBakeRadiusBuffer = 0.025f;

		public const float PatrolHardStuckTimeoutSeconds = 60f;

		public const float PathStallEscapeSeconds = 10f;

		public const int MaxRecoveryAttempts = 3;

		public const float RecoveryBackoffBaseSeconds = 5f;

		public const float RecoveryBackoffMaxSeconds = 30f;

		public const float StepJumpForceFraction = 0.6f;

		public const bool StepJumpEnabled = false;

		public const bool AutoPathRecoveryEnabled = false;

		public const bool AutoDiagnosticCaptureEnabled = false;

		public const float NightStart = 0.875f;

		public const float MorningStart = 0.25f;

		public const float DayStart = 0.417f;

		public const float EveningStart = 0.708f;
	}
	public static class DoorSettings
	{
		public const float DoorCloseDelay = 1.5f;

		public const float DoorDetectionRadius = 3f;

		public const float MovementStallThreshold = 1f;

		public const float MovementProgressThreshold = 0.5f;
	}
	public static class ExplorationSettings
	{
		public const int MinDesiredVariety = 4;

		public const float ExplorationChance = 0.4f;

		public const float MinDistanceFromKnown = 25f;

		public const float MaxExplorationRange = 250f;

		public const float ExplorationDuration = 5f;

		public const float ExplorationWanderRadius = 25f;
	}
	public static class WorkSettings
	{
		public const float ChestScanRadius = 20f;

		public const float HaulScanRadius = 32f;

		public const float CraftDuration = 5f;

		public const float WorkScanInterval = 6f;

		public const float WorkArrivalThreshold = 2.5f;

		public const float WaitingPollInterval = 3f;

		public const float CookingDoneGraceSeconds = 1.5f;

		public const float WorkStuckTimeoutSeconds = 30f;

		public const float RepairScanRadius = 40f;
	}
	public static class CombatSettings
	{
		public const float DetectionRadius = 25f;

		public const float LeashRadius = 40f;

		public const float MeleeAttackRange = 2.2f;

		public const float RangedEngageRange = 22f;

		public const float RangedMinStandoff = 8f;

		public const float TargetRescanInterval = 1f;

		public const float ChaseRepathInterval = 0.35f;

		public const int AmmoTopUpStack = 20;

		public const float VillageThreatRadius = 18f;

		public const float FleeDangerRadius = 16f;

		public const float FleeClearRadius = 24f;

		public const float FleeDistance = 14f;

		public const float LosEyeHeight = 1.5f;

		public const float LosSearchInterval = 0.4f;

		public const int LosMaxSearchFails = 3;

		public const float LosIgnoreSeconds = 8f;

		public const int LosSampleCount = 12;
	}
	public static class DevSettings
	{
		public const bool ShowDebugTools = false;
	}
	internal static class HelpCommand
	{
		[DevCommand("List all Valheim Villages dev commands (try also: vv help, vv --help)", Name = "vv")]
		public static void PrintHelp(ConsoleEventArgs args)
		{
			List<(string, string)> list = (from c in AttributeScanner.GetRegisteredDevCommands()
				orderby c.Name
				select c).ToList();
			if (list.Count == 0)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("[vv] No dev commands registered.");
				}
				return;
			}
			int totalWidth = list.Max<(string, string)>(((string Name, string Description) c) => c.Name.Length);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[vv] ").Append(list.Count).Append(" dev command(s):");
			Console instance2 = Console.instance;
			if (instance2 != null)
			{
				instance2.Print(stringBuilder.ToString());
			}
			foreach (var (text, text2) in list)
			{
				stringBuilder.Clear();
				stringBuilder.Append("  ").Append(text.PadRight(totalWidth)).Append("  ")
					.Append(text2 ?? "");
				Console instance3 = Console.instance;
				if (instance3 != null)
				{
					instance3.Print(stringBuilder.ToString());
				}
			}
		}
	}
	internal static class LogCommands
	{
		[DevCommand("Toggle high-volume NavMesh probe-area logging on/off", Name = "vv_log_navmesh")]
		public static void ToggleVerboseNavMesh(ConsoleEventArgs args)
		{
			LogSettings.VerboseNavMesh = !LogSettings.VerboseNavMesh;
			string text = (LogSettings.VerboseNavMesh ? "ON" : "OFF");
			string text2 = "[LogSettings] VerboseNavMesh = " + text;
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text2);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text2);
			}
		}
	}
	public static class LogSettings
	{
		public static bool VerboseNavMesh;
	}
}
namespace ValheimVillages.Schemas
{
	public struct BehaviorContext
	{
		public bool IsRaining;

		public TimeOfDay TimeOfDay;

		public bool InShelter;

		public float CurrentComfort;

		public Vector3 CurrentPosition;
	}
	public class KnownLocation
	{
		public const float SameLocationThreshold = 2f;

		public Vector3 Position { get; set; }

		public LocationType Type { get; set; }

		public bool HasShelter { get; set; }

		public float ComfortValue { get; set; }

		public float LastVisitedAt { get; set; }

		public bool IsSameLocation(Vector3 other)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.Distance(Position, other) < 2f;
		}

		public bool IsTooCloseForSameType(Vector3 other)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			float minDistanceForType = GetMinDistanceForType(Type);
			return Vector3.Distance(Position, other) < minDistanceForType;
		}

		public static float GetMinDistanceForType(LocationType type)
		{
			return type switch
			{
				LocationType.Home => 3f, 
				LocationType.Shelter => 20f, 
				LocationType.Fire => 15f, 
				LocationType.Table => 10f, 
				LocationType.Farm => 25f, 
				LocationType.Animals => 20f, 
				LocationType.CraftStation => 5f, 
				LocationType.CookingStation => 5f, 
				_ => 10f, 
			};
		}

		public static int GetMaxLocationsForType(LocationType type)
		{
			return type switch
			{
				LocationType.Home => 1, 
				LocationType.Shelter => 3, 
				LocationType.Fire => 2, 
				LocationType.Table => 2, 
				LocationType.Farm => 2, 
				LocationType.Animals => 2, 
				LocationType.CraftStation => 3, 
				LocationType.CookingStation => 5, 
				_ => 3, 
			};
		}

		public float GetQualityScore()
		{
			float num = ComfortValue * 10f;
			if (HasShelter)
			{
				num += 5f;
			}
			return num;
		}
	}
	public class TabDetailData
	{
		public string Title { get; set; }

		public string Description { get; set; }

		public string ActionText { get; set; }

		public Action OnAction { get; set; }
	}
	public class TabListItem
	{
		public string TabName { get; set; }
	}
	public class TaskResult
	{
		public Dictionary<string, string> Data;

		public string Error;

		public object Payload;

		public bool Success;

		public static TaskResult Ok(Dictionary<string, string> data = null, object payload = null)
		{
			return new TaskResult
			{
				Success = true,
				Data = data,
				Payload = payload
			};
		}

		public static TaskResult Fail(string error)
		{
			return new TaskResult
			{
				Success = false,
				Error = error
			};
		}
	}
	public class VillagerTask
	{
		public Dictionary<string, string> Attributes;

		public Action<TaskResult> Callback;

		public float CreatedAt;

		public string Name;

		public float NotBefore;

		public TaskPriority Priority;

		public int RetryCount;

		public string SourceId;

		public float TimeoutSeconds;
	}
	public static class TaskSettings
	{
		public const int MaxRetries = 3;

		public const float DefaultTimeoutSeconds = 30f;

		public const int MaxDeadLetterSize = 50;

		public const int MaxActivityLogEntriesPerVillager = 100;
	}
	[Serializable]
	public class VillagerDef
	{
		public string type = "";

		public string category = "";

		public string displayName = "";

		public string description = "";

		public bool disabled;

		public List<WorkbenchRequirement> workbenches = new List<WorkbenchRequirement>();

		public List<string> requiredBiomes = new List<string>();

		public List<string> preferredBiomes = new List<string>();

		public bool requiresCoastal;

		public int minComfortLevel = 2;

		public string materialRequirements = "";

		public string scalingType = "Comfort";

		public string dependentOnNpcType = "";

		public List<TieredBenefit> tieredBenefits = new List<TieredBenefit>();

		public List<ProductionOutput> productions = new List<ProductionOutput>();

		public List<string> providesLevelTo = new List<string>();

		public List<string> receivesLevelFrom = new List<string>();

		public string interdependenceDescription = "";

		public string preferredPrefab = "";

		public List<string> equipment = new List<string>();

		public string skinColor = "";

		public string stationName = "";

		public string stationIcon = "";

		public List<string> workStations = new List<string>();

		public List<StationRecipe> stationRecipes = new List<StationRecipe>();

		public List<string> cultivatorExclusions = new List<string>();

		public List<string> behaviors = new List<string>();

		public List<string> tags = new List<string>();

		public List<string> randomTalk = new List<string>();

		public List<string> randomGreets = new List<string>();

		public List<string> randomGoodbye = new List<string>();
	}
	[Serializable]
	public class WorkbenchRequirement
	{
		public string name = "";

		public int minLevel = 1;
	}
	[Serializable]
	public class TieredBenefit
	{
		public int minLevel = 1;

		public int maxLevel = 99;

		public string description = "";

		public float effectMultiplier = 1f;
	}
	[Serializable]
	public class ProductionOutput
	{
		public int requiredLevel = 1;

		public string outputItem = "";

		public string description = "";
	}
	[Serializable]
	public class StationRecipe
	{
		public string output = "";

		public int outputAmount = 1;

		public string input = "";

		public int inputAmount = 1;

		public int minStationLevel = 1;
	}
	public enum WorkSubState
	{
		Idle,
		GatheringFuel,
		FuelingStation,
		GatheringIngredients,
		TravelingToStation,
		Crafting,
		ReturningToChest,
		Depositing
	}
	public class WorkOrderContext
	{
		public string CookingInputItemName;

		public bool CookingItemAlreadyInChest;

		public bool CookingRemovalRequested;

		public CookingStation CookingStationRef;

		public float CraftCookTimeSeconds;

		public float CraftStartTime;

		public Vector3 CraftStationPosition;

		public int CraftedCount;

		public int CurrentIngredientIndex;

		public Container FuelContainer;

		public FuelNeed? FuelRequirement;

		public List<IngredientSource> IngredientSources;

		public bool IsRescue;

		public Recipe Recipe;

		public string SmelterInputItemName;

		public bool SmelterItemAlreadyInChest;

		public int SmelterProcessedAtStart;

		public Smelter SmelterRef;

		public bool SmelterRemovalRequested;

		public Container SourceContainer;

		public WorkOrderMatch WorkOrder;

		public List<HeldItem> HeldItems = new List<HeldItem>();
	}
	public class HeldItem
	{
		public Container SourceContainer;

		public string PrefabName;

		public int Amount;
	}
	public class WorkOrderMatch
	{
		public ItemData ItemData;

		public string ItemPrefabName;

		public int MaxQuantity;

		public int MinQuantity;

		public Container SourceContainer;

		public string StationName;
	}
	public class IngredientSource
	{
		public int Amount;

		public Container Container;

		public string PrefabName;
	}
}
namespace ValheimVillages.Patches
{
	[HarmonyPatch(typeof(ItemDrop), "Awake")]
	public static class ItemDropAwakePatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemDrop __instance)
		{
			GameObject gameObject = ((Component)__instance).gameObject;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[ItemDrop.Awake] " + ((gameObject != null) ? ((Object)gameObject).name : null)));
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	[HarmonyPriority(700)]
	public static class ObjectDBAwakePatch
	{
		[HarmonyPostfix]
		public static void Postfix(ObjectDB __instance)
		{
			ItemFactory.RegisterAll(__instance);
			VirtualRecipeLoader.RegisterAll(__instance);
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	[HarmonyPriority(700)]
	public static class ObjectDBCopyPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ObjectDB __instance)
		{
			ItemFactory.RegisterAll(__instance);
			VirtualRecipeLoader.RegisterAll(__instance);
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	[HarmonyPriority(700)]
	public static class ZNetSceneAwakePatch
	{
		[HarmonyPostfix]
		public static void Postfix(ZNetScene __instance)
		{
			ItemFactory.RegisterAllInZNetScene(__instance);
			PieceFactory.RegisterAllInZNetScene(__instance);
			RecordPrefabFactory.RegisterInZNetScene(__instance);
			VillagePrefabFactory.RegisterInZNetScene(__instance);
			VirtualRecipeLoader.RegisterCookingRecipesIfNeeded(ObjectDB.instance);
			VillagerSpawner.LogAvailableDvergrPrefabs();
		}
	}
	[HarmonyPatch(typeof(Localization), "SetupLanguage")]
	public static class LocalizationPatch
	{
		private static Dictionary<string, string> s_tokens;

		private static MethodInfo s_addWord;

		private static Dictionary<string, string> Tokens
		{
			get
			{
				if (s_tokens != null)
				{
					return s_tokens;
				}
				s_tokens = new Dictionary<string, string> { { "vv_villager", "Villager" } };
				foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
				{
					if (!string.IsNullOrEmpty(definition.Value.stationName))
					{
						string key = definition.Value.stationName.TrimStart(new char[1] { '$' });
						s_tokens[key] = definition.Value.displayName;
					}
				}
				return s_tokens;
			}
		}

		public static void RegisterTokens()
		{
			Localization instance = Localization.instance;
			if (instance != null)
			{
				AddTokens(instance);
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Localization __instance)
		{
			AddTokens(__instance);
		}

		private static void AddTokens(Localization instance)
		{
			if ((object)s_addWord == null)
			{
				s_addWord = AccessTools.Method(typeof(Localization), "AddWord", new Type[2]
				{
					typeof(string),
					typeof(string)
				}, (Type[])null);
			}
			if (s_addWord == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"LocalizationPatch: AddWord method not found");
				}
				return;
			}
			foreach (KeyValuePair<string, string> token in Tokens)
			{
				s_addWord.Invoke(instance, new object[2] { token.Key, token.Value });
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"LocalizationPatch: Registered {Tokens.Count} custom tokens");
			}
		}
	}
	[HarmonyPatch]
	public static class PieceChangePatch
	{
		internal static float LastStructureChangeTime { get; private set; }

		internal static bool IsDirty { get; set; }

		[RegisterCleanup]
		public static void Reset()
		{
			IsDirty = false;
			LastStructureChangeTime = 0f;
		}

		private static void MarkDirty()
		{
			IsDirty = true;
			LastStructureChangeTime = Time.realtimeSinceStartup;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Piece), "SetCreator")]
		private static void OnPiecePlaced()
		{
			MarkDirty();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(WearNTear), "Remove")]
		private static void OnPieceRemoved()
		{
			MarkDirty();
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "Awake")]
	public static class ItemDropAwakeProtectionPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(ItemDrop __instance)
		{
			string name = ((Object)((Component)__instance).gameObject).name;
			if (name.StartsWith("vv_") && !name.Contains("(Clone)"))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[ItemDrop.Awake] Skipping for template: " + name));
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "OnDestroy")]
	public static class ItemDropOnDestroyProtectionPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(ItemDrop __instance)
		{
			string name = ((Object)((Component)__instance).gameObject).name;
			if (name.StartsWith("vv_") && !name.Contains("(Clone)"))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	public static class ZNetViewAwakeProtectionPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(ZNetView __instance)
		{
			string name = ((Object)((Component)__instance).gameObject).name;
			if (name.StartsWith("vv_") && !name.Contains("(Clone)"))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[ZNetView.Awake] Skipping for template: " + name));
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ZDOMan), "ReleaseNearbyZDOS")]
	public static class VillagerZDOOwnershipPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Vector3 refPosition)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			Vector2i zone = ZoneSystem.GetZone(refPosition);
			List<ZDO> list = new List<ZDO>();
			ZDOMan.instance.FindSectorObjects(zone, ZoneSystem.instance.m_activeArea, 0, list, (List<ZDO>)null);
			long uID = ZNet.GetUID();
			foreach (ZDO item in list)
			{
				if (!string.IsNullOrEmpty(item.GetString("vv_record_id", "")) && item.GetOwner() != uID)
				{
					item.SetOwner(uID);
				}
			}
		}
	}
	public static class VillageZoneLoadingPatch
	{
		[HarmonyPatch(typeof(ZoneSystem), "CreateLocalZones")]
		[HarmonyPatch(new Type[] { typeof(Vector3) })]
		private static class ZoneSystemCreateZonesPatch
		{
		}

		[HarmonyPatch(typeof(ZoneSystem), "Update")]
		private static class ZoneSystemUpdatePatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZoneSystem __instance)
			{
				//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_004f: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
				{
					return;
				}
				List<Vector3> phantomPositions = GetPhantomPositions();
				if (phantomPositions.Count == 0)
				{
					return;
				}
				Traverse val = Traverse.Create((object)__instance);
				foreach (Vector3 item in phantomPositions)
				{
					val.Method("CreateLocalZones", new object[1] { item }).GetValue<bool>();
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "CreateDestroyObjects")]
		private static class ZNetSceneCreateDestroyPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(ZNetScene __instance)
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
				{
					return true;
				}
				List<Vector3> phantomPositions = GetPhantomPositions();
				if (phantomPositions.Count == 0)
				{
					return true;
				}
				Traverse val = Traverse.Create((object)__instance);
				List<ZDO> value = val.Field<List<ZDO>>("m_tempCurrentObjects").Value;
				List<ZDO> value2 = val.Field<List<ZDO>>("m_tempCurrentDistantObjects").Value;
				value.Clear();
				value2.Clear();
				Vector2i zone = ZoneSystem.GetZone(ZNet.instance.GetReferencePosition());
				int activeArea = ZoneSystem.instance.m_activeArea;
				int activeDistantArea = ZoneSystem.instance.m_activeDistantArea;
				ZDOMan.instance.FindSectorObjects(zone, activeArea, activeDistantArea, value, value2);
				foreach (Vector3 item in phantomPositions)
				{
					Vector2i zone2 = ZoneSystem.GetZone(item);
					if (zone2.x != zone.x || zone2.y != zone.y)
					{
						ZDOMan.instance.FindSectorObjects(zone2, activeArea, 0, value, (List<ZDO>)null);
					}
				}
				val.Method("CreateObjects", new object[2] { value, value2 }).GetValue();
				val.Method("RemoveObjects", new object[2] { value, value2 }).GetValue();
				return false;
			}
		}

		private const int MaxPhantomZones = 10;

		private const float ZoneSize = 64f;

		private static List<Vector3> GetPhantomPositions()
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> allAnchorPositions = VillagerAIManager.GetAllAnchorPositions();
			if (allAnchorPositions.Count == 0)
			{
				return allAnchorPositions;
			}
			HashSet<Vector2Int> hashSet = new HashSet<Vector2Int>();
			List<Vector3> list = new List<Vector3>();
			Vector2Int item = default(Vector2Int);
			foreach (Vector3 item2 in allAnchorPositions)
			{
				((Vector2Int)(ref item))..ctor(Mathf.FloorToInt(item2.x / 64f), Mathf.FloorToInt(item2.z / 64f));
				if (hashSet.Add(item))
				{
					list.Add(item2);
					if (list.Count >= 10)
					{
						break;
					}
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	public static class ZoneLoadRestorationPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ZNetView __instance)
		{
			ZDO zDO = __instance.GetZDO();
			if (zDO != null && zDO.GetPrefab() != RecordPrefabFactory.RecordPrefabHash && !NativeNpcStripper.IsPlayerOwned(((Component)__instance).gameObject) && (!string.IsNullOrEmpty(zDO.GetString("vv_record_id", "")) || !string.IsNullOrEmpty(zDO.GetString("vv_villager_id", ""))) && !((Object)(object)((Component)__instance).GetComponent<ValheimVillages.Villager.Villager>() != (Object)null))
			{
				VillagerRestoration.Restore(((Component)__instance).gameObject, zDO);
			}
		}
	}
}
namespace ValheimVillages.Items
{
	[Serializable]
	public class ItemDefinition
	{
		public string name = "";

		public string source = "";

		public string basePrefab = "";

		public string displayName = "";

		public string description = "";

		public int maxStackSize = 1;

		public float weight = 1f;

		public int variants;

		public string itemType = "";

		public string biome = "";

		public string stationType = "";
	}
	public static class ItemFactory
	{
		private static readonly List<GameObject> _prefabs = new List<GameObject>();

		private static List<ItemDefinition> _definitions;

		private static readonly (string station, string key, string displayName, string stationType)[] PhysicalStations = new(string, string, string, string)[5]
		{
			("$piece_workbench", "workbench", "Workbench", "Workbench"),
			("$piece_forge", "forge", "Forge", "Forge"),
			("$piece_cauldron", "cauldron", "Cauldron", "Cauldron"),
			("$piece_artisanstation", "artisan", "Artisan Table", "ArtisanTable"),
			("$piece_stonecutter", "stonecutter", "Stonecutter", "Stonecutter")
		};

		public static readonly (int biomeEnum, string key, string biomeId, string displayName, string inkColor)[] FragmentBiomes = new(int, string, string, string, string)[7]
		{
			(1, "meadows", "Meadows", "Meadows", "green"),
			(8, "blackforest", "BlackForest", "Black Forest", "dark blue"),
			(2, "swamp", "Swamp", "Swamp", "sickly brown"),
			(4, "mountains", "Mountain", "Mountains", "blue"),
			(16, "plains", "Plains", "Plains", "golden"),
			(512, "mistlands", "Mistlands", "Mistlands", "purple"),
			(32, "ashlands", "Ashlands", "Ashlands", "crimson")
		};

		public static void RegisterAll(ObjectDB objectDB)
		{
			if (objectDB?.m_items == null || objectDB.m_items.Count == 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"ObjectDB not ready");
				}
				return;
			}
			foreach (ItemDefinition definition in GetDefinitions())
			{
				CreatePrefabIfNeeded(objectDB, definition);
			}
			int num = _prefabs.RemoveAll((GameObject p) => (Object)(object)p == (Object)null) + objectDB.m_items.RemoveAll((GameObject go) => (Object)(object)go == (Object)null);
			Dictionary<int, GameObject> privateDictionary = GetPrivateDictionary<ObjectDB>(objectDB, "m_itemByHash");
			if (privateDictionary != null)
			{
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, GameObject> item in privateDictionary)
				{
					if ((Object)(object)item.Value == (Object)null)
					{
						list.Add(item.Key);
					}
				}
				foreach (int item2 in list)
				{
					privateDictionary.Remove(item2);
				}
				num += list.Count;
			}
			foreach (GameObject prefab in _prefabs)
			{
				AddToCollection(objectDB.m_items, prefab);
				AddToHashMap(privateDictionary, prefab);
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"Registered {_prefabs.Count} custom items in ObjectDB (purged {num} dead entries)");
			}
		}

		public static void RegisterAllInZNetScene(ZNetScene instance)
		{
			_prefabs.RemoveAll((GameObject p) => (Object)(object)p == (Object)null);
			instance.m_prefabs.RemoveAll((GameObject go) => (Object)(object)go == (Object)null);
			Dictionary<int, GameObject> privateDictionary = GetPrivateDictionary<ZNetScene>(instance, "m_namedPrefabs");
			if (privateDictionary != null)
			{
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, GameObject> item in privateDictionary)
				{
					if ((Object)(object)item.Value == (Object)null)
					{
						list.Add(item.Key);
					}
				}
				foreach (int item2 in list)
				{
					privateDictionary.Remove(item2);
				}
			}
			foreach (GameObject prefab in _prefabs)
			{
				AddToCollection(instance.m_prefabs, prefab);
				AddToHashMap(privateDictionary, prefab);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"Registered {_prefabs.Count} prefabs in ZNetScene");
			}
		}

		public static List<ItemDefinition> GetDefinitions()
		{
			if (_definitions != null)
			{
				return _definitions;
			}
			_definitions = new List<ItemDefinition>();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			typeof(ItemDefinition).Namespace?.Replace('.', '_');
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.EndsWith(".json") || !text.Contains(".Items."))
				{
					continue;
				}
				try
				{
					using Stream stream = executingAssembly.GetManifestResourceStream(text);
					using StreamReader streamReader = new StreamReader(stream);
					ItemDefinition itemDefinition = JsonUtility.FromJson<ItemDefinition>(streamReader.ReadToEnd());
					if (!string.IsNullOrEmpty(itemDefinition?.name) && itemDefinition.source == "clone")
					{
						_definitions.Add(itemDefinition);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogError((object)("Failed to load " + text + ": " + ex.Message));
					}
				}
			}
			GenerateRegistryItems(_definitions);
			return _definitions;
		}

		public static Dictionary<string, string> BuildStationWorkOrderMap()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			(string, string, string, string)[] physicalStations = PhysicalStations;
			for (int i = 0; i < physicalStations.Length; i++)
			{
				(string, string, string, string) tuple = physicalStations[i];
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				dictionary[item] = "vv_workorder_" + item2;
			}
			foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
			{
				if (!string.IsNullOrEmpty(definition.Value.stationName))
				{
					dictionary[definition.Value.stationName] = "vv_workorder_" + definition.Key.ToLower();
				}
			}
			return dictionary;
		}

		private static void GenerateRegistryItems(List<ItemDefinition> definitions)
		{
			AddIfMissing(definitions, new ItemDefinition
			{
				name = "vv_pawn",
				source = "clone",
				basePrefab = "DragonEgg",
				displayName = "Villager",
				description = "A villager packaged for transport.",
				maxStackSize = 1,
				weight = 10f,
				itemType = "pawn"
			});
			foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
			{
				VillagerDef value = definition.Value;
				string text = value.type.ToLower();
				AddIfMissing(definitions, new ItemDefinition
				{
					name = "vv_" + text + "_pawn",
					source = "clone",
					basePrefab = "DragonEgg",
					displayName = value.displayName,
					description = "A " + value.displayName.ToLower() + " villager packaged for transport. " + value.description,
					maxStackSize = 1,
					weight = 10f,
					itemType = "pawn"
				});
				if (!string.IsNullOrEmpty(value.stationName))
				{
					AddIfMissing(definitions, new ItemDefinition
					{
						name = "vv_workorder_" + text,
						source = "clone",
						basePrefab = "Wood",
						displayName = value.displayName + " Work Order",
						description = "A work order scroll for " + value.displayName.ToLower() + " tasks. Right-click to set production quotas.",
						maxStackSize = 1,
						weight = 0.3f,
						itemType = "workorder",
						stationType = value.type
					});
				}
			}
			(string, string, string, string)[] physicalStations = PhysicalStations;
			for (int i = 0; i < physicalStations.Length; i++)
			{
				(string, string, string, string) tuple = physicalStations[i];
				string item = tuple.Item2;
				string item2 = tuple.Item3;
				string item3 = tuple.Item4;
				AddIfMissing(definitions, new ItemDefinition
				{
					name = "vv_workorder_" + item,
					source = "clone",
					basePrefab = "Wood",
					displayName = item2 + " Work Order",
					description = "A work order scroll for " + item2.ToLower() + " tasks. Right-click to set production quotas.",
					maxStackSize = 1,
					weight = 0.3f,
					itemType = "workorder",
					stationType = item3
				});
			}
			(int, string, string, string, string)[] fragmentBiomes = FragmentBiomes;
			for (int i = 0; i < fragmentBiomes.Length; i++)
			{
				(int, string, string, string, string) tuple2 = fragmentBiomes[i];
				string item4 = tuple2.Item2;
				string item5 = tuple2.Item3;
				string item6 = tuple2.Item4;
				string item7 = tuple2.Item5;
				AddIfMissing(definitions, new ItemDefinition
				{
					name = "vv_fragment_" + item4,
					source = "clone",
					basePrefab = "DragonEgg",
					displayName = item6 + " Ransom Fragment",
					description = "A torn piece of parchment stained with " + item7 + " ink. The scrawled text hints at a captive held somewhere in the " + item6.ToLower() + ". Combine three to reveal their location.",
					maxStackSize = 3,
					weight = 0.1f,
					itemType = "fragment",
					biome = item5
				});
			}
		}

		private static void AddIfMissing(List<ItemDefinition> defs, ItemDefinition def)
		{
			if (!defs.Exists((ItemDefinition d) => d.name == def.name))
			{
				defs.Add(def);
			}
		}

		public static List<ItemDefinition> GetDefinitionsByType(string itemType)
		{
			List<ItemDefinition> list = new List<ItemDefinition>();
			foreach (ItemDefinition definition in GetDefinitions())
			{
				if (definition.itemType == itemType)
				{
					list.Add(definition);
				}
			}
			return list;
		}

		public static ItemDefinition GetDefinition(string name)
		{
			foreach (ItemDefinition definition in GetDefinitions())
			{
				if (definition.name == name)
				{
					return definition;
				}
			}
			return null;
		}

		private static void CreatePrefabIfNeeded(ObjectDB objectDB, ItemDefinition def)
		{
			if (_prefabs.Exists((GameObject p) => (Object)(object)p != (Object)null && ((Object)p).name == def.name))
			{
				return;
			}
			GameObject itemPrefab = objectDB.GetItemPrefab(def.name);
			if ((Object)(object)itemPrefab != (Object)null)
			{
				ApplyItemDefinition(itemPrefab, def);
				if (!_prefabs.Contains(itemPrefab))
				{
					_prefabs.Add(itemPrefab);
				}
				return;
			}
			GameObject itemPrefab2 = objectDB.GetItemPrefab(def.basePrefab);
			if ((Object)(object)itemPrefab2 == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Base prefab '" + def.basePrefab + "' not found for item '" + def.name + "'"));
				}
			}
			else
			{
				GameObject val = ClonePrefab(itemPrefab2, def.name);
				ApplyItemDefinition(val, def);
				_prefabs.Add(val);
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("Created custom item: " + def.name));
				}
			}
		}

		private static GameObject ClonePrefab(GameObject basePrefab, string newName)
		{
			bool activeSelf = basePrefab.activeSelf;
			basePrefab.SetActive(false);
			GameObject obj = Object.Instantiate<GameObject>(basePrefab);
			basePrefab.SetActive(activeSelf);
			((Object)obj).name = newName;
			obj.transform.SetParent(PrefabTemplates.Root, false);
			obj.SetActive(true);
			return obj;
		}

		private static void ApplyItemDefinition(GameObject prefab, ItemDefinition def)
		{
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			SharedData val = JsonUtility.FromJson<SharedData>(JsonUtility.ToJson((object)component.m_itemData.m_shared));
			val.m_name = def.displayName;
			val.m_description = def.description;
			val.m_maxStackSize = def.maxStackSize;
			val.m_weight = def.weight;
			val.m_variants = def.variants;
			if (def.itemType == "workorder" && !string.IsNullOrEmpty(def.stationType))
			{
				Sprite val2 = WorkOrderIconLoader.Load(def.stationType);
				if ((Object)(object)val2 != (Object)null)
				{
					val.m_icons = (Sprite[])(object)new Sprite[1] { val2 };
				}
				Texture2D val3 = WorkOrderIconLoader.LoadTexture(def.stationType);
				if ((Object)(object)val3 != (Object)null)
				{
					ParchmentModel.Apply(prefab, val3);
				}
			}
			component.m_itemData.m_shared = val;
			component.m_itemData.m_dropPrefab = prefab;
		}

		private static Dictionary<int, GameObject> GetPrivateDictionary<T>(T instance, string fieldName)
		{
			return typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance) as Dictionary<int, GameObject>;
		}

		private static void AddToCollection(List<GameObject> list, GameObject prefab)
		{
			if (!((Object)(object)prefab == (Object)null) && !list.Contains(prefab))
			{
				list.Add(prefab);
			}
		}

		private static void AddToHashMap(Dictionary<int, GameObject> hashMap, GameObject prefab)
		{
			if (hashMap != null && !((Object)(object)prefab == (Object)null))
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)prefab).name);
				hashMap[stableHashCode] = prefab;
			}
		}
	}
	internal static class ParchmentModel
	{
		public static void Apply(GameObject prefab, Texture2D tex)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null || (Object)(object)tex == (Object)null)
			{
				return;
			}
			MeshRenderer[] componentsInChildren = prefab.GetComponentsInChildren<MeshRenderer>(true);
			if (componentsInChildren.Length == 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("ParchmentModel: no MeshRenderer on '" + ((Object)prefab).name + "'"));
				}
				return;
			}
			Mesh sharedMesh = BuildSheet();
			MeshRenderer[] array = componentsInChildren;
			foreach (MeshRenderer obj in array)
			{
				MeshFilter component = ((Component)obj).GetComponent<MeshFilter>();
				if ((Object)(object)component != (Object)null)
				{
					component.sharedMesh = sharedMesh;
				}
				Material val = new Material(((Renderer)obj).sharedMaterial)
				{
					name = "vv_parchment_mat"
				};
				val.mainTexture = (Texture)(object)tex;
				if (val.HasProperty("_Color"))
				{
					val.color = Color.white;
				}
				if (val.HasProperty("_BumpMap"))
				{
					val.SetTexture("_BumpMap", (Texture)null);
				}
				val.DisableKeyword("_NORMALMAP");
				val.EnableKeyword("_ALPHATEST_ON");
				if (val.HasProperty("_Cutoff"))
				{
					val.SetFloat("_Cutoff", 0.5f);
				}
				val.SetOverrideTag("RenderType", "TransparentCutout");
				val.renderQueue = 2450;
				((Renderer)obj).sharedMaterials = (Material[])(object)new Material[1] { val };
			}
			Light[] componentsInChildren2 = prefab.GetComponentsInChildren<Light>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				((Behaviour)componentsInChildren2[i]).enabled = false;
			}
		}

		private static Mesh BuildSheet(float width = 0.3f, float height = 0.4f)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			float num = width / 2f;
			float num2 = height / 2f;
			Vector3 up = Vector3.up;
			Vector3 down = Vector3.down;
			Mesh val = new Mesh();
			((Object)val).name = "vv_parchment";
			val.vertices = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(0f - num, 0f, 0f - num2),
				new Vector3(num, 0f, 0f - num2),
				new Vector3(num, 0f, num2),
				new Vector3(0f - num, 0f, num2),
				new Vector3(0f - num, 0f, 0f - num2),
				new Vector3(num, 0f, 0f - num2),
				new Vector3(num, 0f, num2),
				new Vector3(0f - num, 0f, num2)
			};
			val.uv = (Vector2[])(object)new Vector2[8]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f),
				new Vector2(0f, 1f),
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f),
				new Vector2(0f, 1f)
			};
			val.normals = (Vector3[])(object)new Vector3[8] { up, up, up, up, down, down, down, down };
			val.triangles = new int[12]
			{
				0, 1, 2, 0, 2, 3, 4, 6, 5, 4,
				7, 6
			};
			val.RecalculateBounds();
			return val;
		}
	}
	public static class PieceFactory
	{
		public const string RegistryPrefabName = "vv_village_registry";

		private const string BaseTable = "piece_table";

		private const string CandleSource = "Candle_resin";

		private const string FeatherSource = "CelestialFeather";

		private const string CurtainSource = "piece_cloth_hanging_door_blue2";

		private const string ShelfSource = "dvergrprops_shelf";

		private const string StoolSource = "dvergrprops_stool";

		private const float TopY = 0.83f;

		private static GameObject _registryPrefab;

		public static void RegisterAllInZNetScene(ZNetScene zNetScene)
		{
			if ((Object)(object)zNetScene == (Object)null)
			{
				return;
			}
			EnsureRegistryPrefab(zNetScene);
			if (!((Object)(object)_registryPrefab == (Object)null))
			{
				if (!zNetScene.m_prefabs.Contains(_registryPrefab))
				{
					zNetScene.m_prefabs.Add(_registryPrefab);
				}
				Dictionary<int, GameObject> privateDictionary = GetPrivateDictionary<ZNetScene>(zNetScene, "m_namedPrefabs");
				if (privateDictionary != null)
				{
					privateDictionary[StringExtensionMethods.GetStableHashCode("vv_village_registry")] = _registryPrefab;
				}
				AddToHammerTable(_registryPrefab);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[PieceFactory] Registered 'vv_village_registry' in ZNetScene + Hammer table");
				}
			}
		}

		private static void EnsureRegistryPrefab(ZNetScene zNetScene)
		{
			if ((Object)(object)_registryPrefab != (Object)null)
			{
				return;
			}
			GameObject prefab = zNetScene.GetPrefab("vv_village_registry");
			if ((Object)(object)prefab != (Object)null)
			{
				StripGraftedChildren(prefab);
				ConfigurePiece(prefab);
				ConfigureInteraction(prefab);
				GraftProps(prefab, zNetScene);
				_registryPrefab = prefab;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[PieceFactory] Re-grafted registry prefab after hot reload");
				}
				return;
			}
			GameObject prefab2 = zNetScene.GetPrefab("piece_table");
			if ((Object)(object)prefab2 == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)"[PieceFactory] Base prefab 'piece_table' not found; cannot build registry");
				}
				return;
			}
			GameObject obj = ClonePrefab(prefab2, "vv_village_registry");
			ConfigurePiece(obj);
			ConfigureInteraction(obj);
			GraftProps(obj, zNetScene);
			_registryPrefab = obj;
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)"[PieceFactory] Built registry prefab from 'piece_table'");
			}
		}

		private static void ConfigurePiece(GameObject prefab)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			Piece component = prefab.GetComponent<Piece>();
			if (!((Object)(object)component == (Object)null))
			{
				component.m_name = "Village Registry";
				component.m_description = "A scribe's desk where villagers are enrolled, revived, and recorded.";
				component.m_category = (PieceCategory)1;
				ObjectDB instance = ObjectDB.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject itemPrefab = instance.GetItemPrefab("Wood");
					obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				}
				ItemDrop val = (ItemDrop)obj;
				ObjectDB instance2 = ObjectDB.instance;
				object obj2;
				if (instance2 == null)
				{
					obj2 = null;
				}
				else
				{
					GameObject itemPrefab2 = instance2.GetItemPrefab("Resin");
					obj2 = ((itemPrefab2 != null) ? itemPrefab2.GetComponent<ItemDrop>() : null);
				}
				ItemDrop val2 = (ItemDrop)obj2;
				List<Requirement> list = new List<Requirement>();
				if ((Object)(object)val != (Object)null)
				{
					list.Add(new Requirement
					{
						m_resItem = val,
						m_amount = 10,
						m_recover = true
					});
				}
				if ((Object)(object)val2 != (Object)null)
				{
					list.Add(new Requirement
					{
						m_resItem = val2,
						m_amount = 4,
						m_recover = true
					});
				}
				if (list.Count > 0)
				{
					component.m_resources = list.ToArray();
				}
			}
		}

		private static void ConfigureInteraction(GameObject prefab)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			RegistryInteract target = prefab.GetComponent<RegistryInteract>() ?? prefab.AddComponent<RegistryInteract>();
			CraftingStation val = prefab.GetComponent<CraftingStation>();
			if ((Object)(object)val != (Object)null && ComponentIndex(prefab, (Component)(object)val) < ComponentIndex(prefab, (Component)(object)target))
			{
				Object.DestroyImmediate((Object)(object)val);
				val = null;
			}
			if ((Object)(object)val == (Object)null)
			{
				val = prefab.AddComponent<CraftingStation>();
				val.m_name = "$vv_village_registry";
				val.m_discoverRange = 0f;
				val.m_rangeBuild = 0f;
				val.m_craftRequireRoof = false;
				val.m_craftRequireFire = false;
				val.m_showBasicRecipies = false;
				val.m_useDistance = 10f;
				val.m_useAnimation = 0;
				val.m_areaMarker = null;
				val.m_inUseObject = null;
				val.m_haveFireObject = null;
				val.m_craftItemEffects = new EffectList();
				val.m_craftItemDoneEffects = new EffectList();
				val.m_repairItemDoneEffects = new EffectList();
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[PieceFactory] Registry interaction ready: RegistryInteract@{ComponentIndex(prefab, (Component)(object)target)}, " + $"CraftingStation@{ComponentIndex(prefab, (Component)(object)val)} (interact must precede station)"));
			}
		}

		public static void ReapplyInteractionToInstance(GameObject instance)
		{
			if (!((Object)(object)instance == (Object)null))
			{
				RegistryInteract[] components = instance.GetComponents<RegistryInteract>();
				for (int i = 0; i < components.Length; i++)
				{
					Object.DestroyImmediate((Object)(object)components[i]);
				}
				CraftingStation[] components2 = instance.GetComponents<CraftingStation>();
				for (int i = 0; i < components2.Length; i++)
				{
					Object.DestroyImmediate((Object)(object)components2[i]);
				}
				ConfigureInteraction(instance);
			}
		}

		private static int ComponentIndex(GameObject prefab, Component target)
		{
			Component[] components = prefab.GetComponents<Component>();
			for (int i = 0; i < components.Length; i++)
			{
				if (components[i] == target)
				{
					return i;
				}
			}
			return -1;
		}

		private static void GraftProps(GameObject prefab, ZNetScene zNetScene)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab2 = zNetScene.GetPrefab("piece_cloth_hanging_door_blue2");
			Material mat = BuildPaperMaterial(GetItemChildMaterial("vv_workorder_workbench", "log (1)"));
			Mesh sheet = BuildSheetMesh(0.28f, 0.38f);
			(Vector3, float, float)[] array = new(Vector3, float, float)[5]
			{
				(new Vector3(-0.3f, 0.835f, 0f), 18f, 1f),
				(new Vector3(-0.14f, 0.84f, -0.18f), -28f, 0.92f),
				(new Vector3(-0.4f, 0.844f, 0.16f), 42f, 0.85f),
				(new Vector3(0.06f, 0.838f, 0.16f), -8f, 1f),
				(new Vector3(0.2f, 0.84599996f, -0.04f), 62f, 0.8f)
			};
			for (int i = 0; i < array.Length; i++)
			{
				AddPaper(prefab, sheet, mat, $"vv_paper_{i}", array[i].Item1, array[i].Item2, array[i].Item3);
			}
			GameObject prefab3 = zNetScene.GetPrefab("Candle_resin");
			GraftMesh(prefab, prefab3, "full/stack", "vv_candle", new Vector3(0.84f, 0.83f, 0.34f), Vector3.zero, Vector3.one);
			AddCandleLight(prefab, new Vector3(0.84f, 1.11f, 0.34f));
			GraftMesh(prefab, prefab3, "full/stack", "vv_candle2", new Vector3(0.99f, 0.83f, 0.2f), new Vector3(0f, 0f, 14f), new Vector3(1f, 1.6f, 1f));
			AddCandleLight(prefab, new Vector3(0.99f, 1.48f, 0.2f));
			GameObject prefab4 = zNetScene.GetPrefab("CelestialFeather");
			GraftMesh(prefab, prefab4, "attach/default", "vv_feather", new Vector3(0.4f, 0.85999995f, -0.02f), new Vector3(0f, -40f, 0f), Vector3.one * 0.62f);
			object obj;
			if (!((Object)(object)prefab2 != (Object)null))
			{
				obj = null;
			}
			else
			{
				Transform obj2 = prefab2.transform.Find("new");
				obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			}
			GameObject source = (GameObject)obj;
			GraftMeshGroup(prefab, source, "vv_curtain", new Vector3(-1.18f, 2.05f, 0.61f), new Vector3(0f, -90f, 0f), 0.28f);
			GameObject prefab5 = zNetScene.GetPrefab("dvergrprops_shelf");
			GraftMesh(prefab, prefab5, "new/shelf_high", "vv_shelf", new Vector3(-0.9f, 0.83f, 0.34f), Vector3.zero, new Vector3(0.34f, 0.32f, 0.8f));
			GameObject prefab6 = zNetScene.GetPrefab("dvergrprops_stool");
			GraftMesh(prefab, prefab6, "new/high", "vv_stool", new Vector3(0f, 0f, -0.73f), Vector3.zero, Vector3.one);
		}

		private static Material GetChildMaterial(GameObject source, string childPath)
		{
			Transform val = (((Object)(object)source != (Object)null) ? source.transform.Find(childPath) : null);
			MeshRenderer val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<MeshRenderer>() : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return null;
			}
			return ((Renderer)val2).sharedMaterial;
		}

		private static Material GetItemChildMaterial(string itemName, string childPath)
		{
			ObjectDB instance = ObjectDB.instance;
			return GetChildMaterial((instance != null) ? instance.GetItemPrefab(itemName) : null, childPath);
		}

		private static Material BuildPaperMaterial(Material baseMat)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(0.88f, 0.82f, 0.67f);
			Shader val2 = Shader.Find("Unlit/Texture") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Sprites/Default");
			Material val3 = (((Object)(object)val2 != (Object)null) ? new Material(val2) : (((Object)(object)baseMat != (Object)null) ? new Material(baseMat) : new Material(Shader.Find("Standard"))));
			((Object)val3).name = "vv_paper_mat";
			val3.mainTexture = (Texture)(object)BuildSolidTexture(val);
			if (val3.HasProperty("_Color"))
			{
				val3.color = val;
			}
			return val3;
		}

		private static void AddPaper(GameObject parent, Mesh sheet, Material mat, string name, Vector3 localPos, float yaw, float scale)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent.transform, false);
			val.transform.localPosition = localPos;
			val.transform.localRotation = Quaternion.Euler(0f, yaw, 0f);
			val.transform.localScale = Vector3.one * scale;
			val.AddComponent<MeshFilter>().sharedMesh = sheet;
			((Renderer)val.AddComponent<MeshRenderer>()).sharedMaterial = mat;
		}

		private static Texture2D BuildSolidTexture(Color c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(2, 2)
			{
				name = "vv_solid_tex"
			};
			val.SetPixels((Color[])(object)new Color[4] { c, c, c, c });
			val.Apply();
			return val;
		}

		private static Mesh BuildSheetMesh(float width, float height)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: 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_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: 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)
			float num = width / 2f;
			float num2 = height / 2f;
			Mesh val = new Mesh();
			((Object)val).name = "vv_paper_sheet";
			val.vertices = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(0f - num, 0f, 0f - num2),
				new Vector3(num, 0f, 0f - num2),
				new Vector3(num, 0f, num2),
				new Vector3(0f - num, 0f, num2),
				new Vector3(0f - num, 0f, 0f - num2),
				new Vector3(num, 0f, 0f - num2),
				new Vector3(num, 0f, num2),
				new Vector3(0f - num, 0f, num2)
			};
			val.uv = (Vector2[])(object)new Vector2[8]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f),
				new Vector2(0f, 1f),
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f),
				new Vector2(0f, 1f)
			};
			val.normals = (Vector3[])(object)new Vector3[8]
			{
				Vector3.up,
				Vector3.up,
				Vector3.up,
				Vector3.up,
				Vector3.down,
				Vector3.down,
				Vector3.down,
				Vector3.down
			};
			val.triangles = new int[12]
			{
				0, 1, 2, 0, 2, 3, 4, 6, 5, 4,
				7, 6
			};
			return val;
		}

		private static void GraftMesh(GameObject parent, GameObject source, string childPath, string name, Vector3 localPos, Vector3 localEuler, Vector3 scale)
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[PieceFactory] Graft '" + name + "' skipped: source prefab missing"));
				}
				return;
			}
			Transform val = source.transform.Find(childPath);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[PieceFactory] Graft '" + name + "' skipped: child '" + childPath + "' not found on '" + ((Object)source).name + "'"));
				}
				return;
			}
			MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
			MeshRenderer component2 = ((Component)val).GetComponent<MeshRenderer>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[PieceFactory] Graft '" + name + "' skipped: no MeshFilter/MeshRenderer at '" + childPath + "'"));
				}
			}
			else
			{
				GameObject val2 = new GameObject(name);
				val2.transform.SetParent(parent.transform, false);
				val2.transform.localPosition = localPos;
				val2.transform.localRotation = Quaternion.Euler(localEuler);
				val2.transform.localScale = scale;
				val2.AddComponent<MeshFilter>().sharedMesh = component.sharedMesh;
				((Renderer)val2.AddComponent<MeshRenderer>()).sharedMaterials = ((Renderer)component2).sharedMaterials;
			}
		}

		private static void GraftMeshGroup(GameObject parent, GameObject source, string name, Vector3 localPos, Vector3 localEuler, float scale)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0048: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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)
			if ((Object)(object)source == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[PieceFactory] Graft group '" + name + "' skipped: source prefab missing"));
				}
				return;
			}
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent.transform, false);
			val.transform.localPosition = localPos;
			val.transform.localRotation = Quaternion.Euler(localEuler);
			val.transform.localScale = Vector3.one * scale;
			int num = 0;
			MeshFilter[] componentsInChildren = source.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val2 in componentsInChildren)
			{
				MeshRenderer component = ((Component)val2).GetComponent<MeshRenderer>();
				if (!((Object)(object)component == (Object)null))
				{
					GameObject val3 = new GameObject(((Object)val2).name);
					val3.transform.SetParent(val.transform, false);
					val3.transform.localPosition = ((Component)val2).transform.localPosition;
					val3.transform.localRotation = ((Component)val2).transform.localRotation;
					val3.transform.localScale = ((Component)val2).transform.localScale;
					val3.AddComponent<MeshFilter>().sharedMesh = val2.sharedMesh;
					((Renderer)val3.AddComponent<MeshRenderer>()).sharedMaterials = ((Renderer)component).sharedMaterials;
					num++;
				}
			}
			if (num == 0)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[PieceFactory] Graft group '" + name + "': no meshes copied from '" + ((Object)source).name + "'"));
				}
			}
		}

		private static void AddCandleLight(GameObject parent, Vector3 localPos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("vv_candle_light");
			val.transform.SetParent(parent.transform, false);
			val.transform.localPosition = localPos;
			Light obj = val.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.color = new Color(1f, 0.72f, 0.36f);
			obj.range = 3.5f;
			obj.intensity = 1.3f;
			obj.shadows = (LightShadows)0;
		}

		private static void AddToHammerTable(GameObject piece)
		{
			ObjectDB instance = ObjectDB.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject itemPrefab = instance.GetItemPrefab("Hammer");
				obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			}
			PieceTable val = ((ItemDrop)(obj?)).m_itemData?.m_shared?.m_buildPieces;
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[PieceFactory] Hammer build PieceTable not available; piece not added to build menu");
				}
			}
			else if (!val.m_pieces.Contains(piece))
			{
				val.m_pieces.Add(piece);
			}
		}

		private static void StripGraftedChildren(GameObject prefab)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			List<Transform> list = new List<Transform>();
			foreach (Transform item in prefab.transform)
			{
				Transform val = item;
				if (((Object)val).name.StartsWith("vv_"))
				{
					list.Add(val);
				}
			}
			foreach (Transform item2 in list)
			{
				Object.DestroyImmediate((Object)(object)((Component)item2).gameObject);
			}
		}

		private static GameObject ClonePrefab(GameObject basePrefab, string newName)
		{
			bool activeSelf = basePrefab.activeSelf;
			basePrefab.SetActive(false);
			GameObject obj = Object.Instantiate<GameObject>(basePrefab);
			basePrefab.SetActive(activeSelf);
			((Object)obj).name = newName;
			obj.transform.SetParent(PrefabTemplates.Root, false);
			obj.SetActive(true);
			return obj;
		}

		private static Dictionary<int, GameObject> GetPrivateDictionary<T>(T instance, string fieldName)
		{
			return typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance) as Dictionary<int, GameObject>;
		}
	}
	internal static class PrefabTemplates
	{
		private static GameObject s_root;

		public static Transform Root
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)s_root == (Object)null)
				{
					s_root = new GameObject("vv_prefab_templates");
					s_root.SetActive(false);
					Object.DontDestroyOnLoad((Object)(object)s_root);
				}
				return s_root.transform;
			}
		}
	}
}
namespace ValheimVillages.Items.WorkOrders
{
	[HarmonyPatch]
	public static class CraftingStationPatch
	{
		private enum CraftFocus
		{
			List,
			Craft,
			Order
		}

		private const string WorkOrderTooltipText = "Orders placed in a chest will be fulfilled by nearby villagers.";

		private static GameObject _workOrderButton;

		private static bool _buttonCreated;

		private static CraftFocus s_focus = CraftFocus.List;

		private static GameObject s_craftFrame;

		private static GameObject s_orderFrame;

		private static GameObject s_listFrame;

		private static bool s_framesCreated;

		private static Vector2 _cleanCraftSizeDelta;

		private static bool _cleanSizeDeltaSaved;

		private static Dictionary<string, string> s_stationWorkOrderMap;

		private static readonly Color FocusFrameColor = new Color(1f, 0.78f, 0.28f, 0.95f);

		private const float FocusFrameThickness = 3f;

		private static bool _orderReplacesCraft;

		private static Dictionary<string, string> StationWorkOrderMap => s_stationWorkOrderMap ?? (s_stationWorkOrderMap = ItemFactory.BuildStationWorkOrderMap());

		[RegisterCleanup]
		public static void Clear()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			_workOrderButton = null;
			_buttonCreated = false;
			_cleanSizeDeltaSaved = false;
			_cleanCraftSizeDelta = Vector2.zero;
			s_focus = CraftFocus.List;
			s_craftFrame = null;
			s_orderFrame = null;
			s_listFrame = null;
			s_framesCreated = false;
		}

		public static void HideWorkOrderButton()
		{
			if ((Object)(object)_workOrderButton != (Object)null)
			{
				_workOrderButton.SetActive(false);
			}
		}

		private static bool IsVirtualStation(string stationName)
		{
			return stationName?.StartsWith("$vv_") ?? false;
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		[HarmonyPostfix]
		public static void UpdateCraftingPanelPostfix(InventoryGui __instance)
		{
			RepairCraftButtonIfCorrupted(__instance);
			EnsureButtonCreated(__instance);
			EnsureFocusFrames(__instance);
			UpdateButtonVisibility(__instance);
			ForceRecipeListFullColorAtVillagerStation(__instance);
		}

		private static void EnsureFocusFrames(InventoryGui gui)
		{
			if (!s_framesCreated && !((Object)(object)gui.m_craftButton == (Object)null) && !((Object)(object)_workOrderButton == (Object)null))
			{
				s_framesCreated = true;
				s_craftFrame = CreateFocusFrame(((Component)gui.m_craftButton).transform);
				s_orderFrame = CreateFocusFrame(_workOrderButton.transform);
				BringGlyphToFront(((Component)gui.m_craftButton).gameObject);
				BringGlyphToFront(_workOrderButton);
				Transform val = (((Object)(object)gui.m_recipeListRoot != (Object)null) ? ((Transform)gui.m_recipeListRoot).parent : null);
				if ((Object)(object)val != (Object)null)
				{
					s_listFrame = CreateFocusFrame(val);
				}
			}
		}

		private static void BringGlyphToFront(GameObject buttonGO)
		{
			GameObject val = buttonGO.GetComponent<UIGamePad>()?.m_hint;
			if ((Object)(object)val != (Object)null)
			{
				val.transform.SetAsLastSibling();
			}
		}

		private static GameObject CreateFocusFrame(Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0088: 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_00ac: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			GameObject val = new GameObject("VV_FocusFrame", new Type[1] { typeof(RectTransform) });
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Transform)component).SetAsLastSibling();
			float num = 3f;
			AddFrameEdge((Transform)(object)component, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, num));
			AddFrameEdge((Transform)(object)component, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, num));
			AddFrameEdge((Transform)(object)component, new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(num, 0f));
			AddFrameEdge((Transform)(object)component, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(num, 0f));
			val.SetActive(false);
			return val;
		}

		private static void AddFrameEdge(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeDelta)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Edge", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = sizeDelta;
			component.anchoredPosition = Vector2.zero;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = FocusFrameColor;
			((Graphic)component2).raycastTarget = false;
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		[HarmonyPostfix]
		public static void UpdateFocusNavPostfix(InventoryGui __instance)
		{
			if (!FocusNavActive(__instance))
			{
				if (!((Object)(object)_workOrderButton != (Object)null) || !_workOrderButton.activeSelf)
				{
					s_focus = CraftFocus.List;
				}
				RestoreButtons(__instance);
				SetFrameActive(s_craftFrame, active: false);
				SetFrameActive(s_orderFrame, active: false);
				SetFrameActive(s_listFrame, active: false);
			}
			else
			{
				HandleFocusInput(((Selectable)__instance.m_craftButton).interactable);
				ApplyFocusGating(__instance);
				SetFrameActive(s_craftFrame, s_focus == CraftFocus.Craft);
				SetFrameActive(s_orderFrame, s_focus == CraftFocus.Order);
				SetFrameActive(s_listFrame, s_focus == CraftFocus.List);
			}
		}

		private static void RestoreButtons(InventoryGui gui)
		{
			Button val = (((Object)(object)_workOrderButton != (Object)null) ? _workOrderButton.GetComponent<Button>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Selectable)val).interactable = true;
			}
			CraftingStation val2 = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetCurrentCraftingStation() : null);
			bool enabled = (Object)(object)val2 != (Object)null && IsVirtualStation(val2.m_name);
			SetGamepadEnabled(_workOrderButton, enabled);
			if ((Object)(object)gui.m_craftButton != (Object)null)
			{
				SetGamepadEnabled(((Component)gui.m_craftButton).gameObject, enabled: true);
			}
		}

		private static void SetFrameActive(GameObject frame, bool active)
		{
			if ((Object)(object)frame != (Object)null && frame.activeSelf != active)
			{
				frame.SetActive(active);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeGamepadInput")]
		[HarmonyPrefix]
		public static bool SuppressRecipeNavWhenPanelFocused()
		{
			return s_focus == CraftFocus.List;
		}

		private static bool FocusNavActive(InventoryGui gui)
		{
			if (ZInput.IsGamepadActive() && (Object)(object)_workOrderButton != (Object)null && _workOrderButton.activeSelf && (Object)(object)gui.m_craftButton != (Object)null)
			{
				return ((Component)gui.m_craftButton).gameObject.activeSelf;
			}
			return false;
		}

		private static void HandleFocusInput(bool craftAvailable)
		{
			bool flag = ZInput.GetButtonDown("JoyDPadLeft") || ZInput.GetButtonDown("JoyLStickLeft");
			bool flag2 = ZInput.GetButtonDown("JoyDPadRight") || ZInput.GetButtonDown("JoyLStickRight");
			bool flag3 = ZInput.GetButtonDown("JoyDPadUp") || ZInput.GetButtonDown("JoyLStickUp");
			bool flag4 = ZInput.GetButtonDown("JoyDPadDown") || ZInput.GetButtonDown("JoyLStickDown");
			switch (s_focus)
			{
			case CraftFocus.List:
				if (flag2)
				{
					s_focus = (craftAvailable ? CraftFocus.Craft : CraftFocus.Order);
				}
				break;
			case CraftFocus.Craft:
				if (flag)
				{
					s_focus = CraftFocus.List;
				}
				else if (flag3)
				{
					s_focus = CraftFocus.Order;
				}
				break;
			case CraftFocus.Order:
				if (flag)
				{
					s_focus = CraftFocus.List;
				}
				else if (flag4 && craftAvailable)
				{
					s_focus = CraftFocus.Craft;
				}
				break;
			}
		}

		private static void ApplyFocusGating(InventoryGui gui)
		{
			Button component = _workOrderButton.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((Selectable)component).interactable = true;
			}
			bool flag = s_focus == CraftFocus.Order;
			SetGamepadEnabled(_workOrderButton, flag);
			SetGamepadEnabled(((Component)gui.m_craftButton).gameObject, !flag);
		}

		private static void SetGamepadEnabled(GameObject go, bool enabled)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			UIGamePad component = go.GetComponent<UIGamePad>();
			if (!((Object)(object)component == (Object)null))
			{
				if (((Behaviour)component).enabled != enabled)
				{
					((Behaviour)component).enabled = enabled;
				}
				if (!enabled && (Object)(object)component.m_hint != (Object)null)
				{
					component.m_hint.SetActive(false);
				}
			}
		}

		private static void ForceRecipeListFullColorAtVillagerStation(InventoryGui gui)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui?.m_recipeListRoot == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			CraftingStation val = ((localPlayer != null) ? localPlayer.GetCurrentCraftingStation() : null);
			if (val == null || val.m_name == null || !val.m_name.StartsWith("$vv_"))
			{
				return;
			}
			Color white = Color.white;
			for (int i = 0; i < ((Transform)gui.m_recipeListRoot).childCount; i++)
			{
				Transform child = ((Transform)gui.m_recipeListRoot).GetChild(i);
				if (!((Component)child).gameObject.activeSelf)
				{
					continue;
				}
				Transform obj = child.Find("icon");
				Image val2 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					((Graphic)val2).color = white;
				}
				Transform val3 = child.Find("name");
				if (!((Object)(object)val3 != (Object)null))
				{
					continue;
				}
				Component[] components = ((Component)val3).GetComponents<Component>();
				foreach (Component val4 in components)
				{
					PropertyInfo propertyInfo = ((object)val4)?.GetType().GetProperty("color", BindingFlags.Instance | BindingFlags.Public);
					if (propertyInfo != null && propertyInfo.PropertyType == typeof(Color))
					{
						propertyInfo.SetValue(val4, white);
						break;
					}
				}
			}
		}

		private static void RepairCraftButtonIfCorrupted(InventoryGui gui)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_009c: 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)
			Button craftButton = gui.m_craftButton;
			RectTransform val = ((craftButton != null) ? ((Component)craftButton).GetComponent<RectTransform>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			bool flag = val.anchorMin.x < val.anchorMax.x;
			if (!_cleanSizeDeltaSaved)
			{
				_cleanSizeDeltaSaved = true;
				if (flag && val.sizeDelta.x > 10f)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)($"Craft button sizeDelta.x={val.sizeDelta.x}" + " looks corrupted (stretch-anchored), resetting to 0"));
					}
					_cleanCraftSizeDelta = new Vector2(0f, val.sizeDelta.y);
				}
				else
				{
					_cleanCraftSizeDelta = val.sizeDelta;
				}
			}
			if (flag)
			{
				val.sizeDelta = _cleanCraftSizeDelta;
			}
		}

		private static void EnsureButtonCreated(InventoryGui gui)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (_buttonCreated && (Object)(object)_workOrderButton != (Object)null)
			{
				return;
			}
			Button craftButton = gui.m_craftButton;
			if ((Object)(object)craftButton == (Object)null)
			{
				return;
			}
			_workOrderButton = Object.Instantiate<GameObject>(((Component)craftButton).gameObject, ((Component)craftButton).transform.parent);
			((Object)_workOrderButton).name = "VV_WorkOrderButton";
			SetButtonText(_workOrderButton, "Order");
			SetButtonFontSize(_workOrderButton, 11f);
			Button component = _workOrderButton.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener(new UnityAction(OnWorkOrderClicked));
				((Selectable)component).interactable = true;
				Button component2 = ((Component)craftButton).GetComponent<Button>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Selectable)component).transition = ((Selectable)component2).transition;
					((Selectable)component).colors = ((Selectable)component2).colors;
				}
			}
			SetOrderButtonTooltip(_workOrderButton);
			PinOrderTextColor(craftButton, _workOrderButton);
			_buttonCreated = true;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"Work Order button created in crafting UI");
			}
		}

		private static void PinOrderTextColor(Button craftButton, GameObject orderGO)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			Color val = Color.white;
			ButtonTextColor component = ((Component)craftButton).GetComponent<ButtonTextColor>();
			if ((Object)(object)component != (Object)null)
			{
				FieldInfo field = typeof(ButtonTextColor).GetField("m_defaultColor", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					val = (Color)field.GetValue(component);
				}
			}
			ButtonTextColor component2 = orderGO.GetComponent<ButtonTextColor>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			Component[] componentsInChildren = orderGO.GetComponentsInChildren<Component>(true);
			foreach (Component val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Type type = ((object)val2).GetType();
					PropertyInfo property = type.GetProperty("text", BindingFlags.Instance | BindingFlags.Public);
					PropertyInfo property2 = type.GetProperty("color", BindingFlags.Instance | BindingFlags.Public);
					if (property != null && property.PropertyType == typeof(string) && property2 != null && property2.PropertyType == typeof(Color))
					{
						property2.SetValue(val2, val);
					}
				}
			}
		}

		private static void SetOrderButtonTooltip(GameObject buttonGO)
		{
			if ((Object)(object)buttonGO == (Object)null)
			{
				return;
			}
			Component[] components = buttonGO.GetComponents<Component>();
			foreach (Component val in components)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				FieldInfo field = type.GetField("m_text", BindingFlags.Instance | BindingFlags.Public);
				if (field != null && field.FieldType == typeof(string))
				{
					field.SetValue(val, "Orders placed in a chest will be fulfilled by nearby villagers.");
					FieldInfo field2 = type.GetField("m_topic", BindingFlags.Instance | BindingFlags.Public);
					if (field2 != null && field2.FieldType == typeof(string))
					{
						field2.SetValue(val, "");
					}
					return;
				}
			}
			Type type2 = typeof(Localization).Assembly.GetType("UITooltip");
			if (type2 != null)
			{
				Component obj = buttonGO.AddComponent(type2);
				type2.GetField("m_text", BindingFlags.Instance | BindingFlags.Public)?.SetValue(obj, "Orders placed in a chest will be fulfilled by nearby villagers.");
				type2.GetField("m_topic", BindingFlags.Instance | BindingFlags.Public)?.SetValue(obj, "");
			}
		}

		private static void UpdateButtonVisibility(InventoryGui gui)
		{
			_orderReplacesCraft = false;
			if ((Object)(object)_workOrderButton == (Object)null || (Object)(object)gui.m_craftButton == (Object)null)
			{
				return;
			}
			if (RegistryTabManager.IsActive)
			{
				_workOrderButton.SetActive(false);
				return;
			}
			if (VillagerTabManager.IsCustomTabActive)
			{
				_workOrderButton.SetActive(false);
				return;
			}
			if (VillagerTabManager.IsActive ? VillagerTabManager.IsUpgradeTabActive : gui.InUpradeTab())
			{
				_workOrderButton.SetActive(false);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				_workOrderButton.SetActive(false);
				((Component)gui.m_craftButton).gameObject.SetActive(true);
				return;
			}
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			bool flag = (Object)(object)currentCraftingStation != (Object)null && StationWorkOrderMap.ContainsKey(currentCraftingStation.m_name);
			if ((Object)(object)currentCraftingStation != (Object)null && IsVirtualStation(currentCraftingStation.m_name))
			{
				_orderReplacesCraft = true;
				((Component)gui.m_craftButton).gameObject.SetActive(false);
				_workOrderButton.SetActive(true);
				PositionWorkOrderButtonAsCraftReplacement(gui);
				return;
			}
			((Component)gui.m_craftButton).gameObject.SetActive(true);
			_workOrderButton.SetActive(flag);
			if (flag)
			{
				PositionWorkOrderButton(gui);
			}
		}

		private static void PositionWorkOrderButtonAsCraftReplacement(InventoryGui gui)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui?.m_craftButton == (Object)null || (Object)(object)_workOrderButton == (Object)null)
			{
				return;
			}
			RectTransform component = ((Component)gui.m_craftButton).GetComponent<RectTransform>();
			RectTransform component2 = _workOrderButton.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component2 == (Object)null))
			{
				component2.anchorMin = component.anchorMin;
				component2.anchorMax = component.anchorMax;
				component2.pivot = component.pivot;
				component2.anchoredPosition = component.anchoredPosition;
				component2.sizeDelta = component.sizeDelta;
				((Transform)component2).localScale = ((Transform)component).localScale;
				Button component3 = _workOrderButton.GetComponent<Button>();
				if ((Object)(object)component3 != (Object)null)
				{
					((Selectable)component3).interactable = true;
				}
			}
		}

		private static void PositionWorkOrderButton(InventoryGui gui)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui?.m_craftButton == (Object)null || (Object)(object)_workOrderButton == (Object)null)
			{
				return;
			}
			RectTransform component = ((Component)gui.m_craftButton).GetComponent<RectTransform>();
			RectTransform component2 = _workOrderButton.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component2 == (Object)null))
			{
				component2.anchorMin = component.anchorMin;
				component2.anchorMax = component.anchorMax;
				component2.pivot = component.pivot;
				component2.sizeDelta = component.sizeDelta;
				((Transform)component2).localScale = ((Transform)component).localScale;
				Rect rect = component.rect;
				float height = ((Rect)(ref rect)).height;
				rect = component2.rect;
				float height2 = ((Rect)(ref rect)).height;
				component2.anchoredPosition = new Vector2(component.anchoredPosition.x, component.anchoredPosition.y + height * 0.5f + 6f + height2 * 0.5f);
				Button component3 = _workOrderButton.GetComponent<Button>();
				if ((Object)(object)component3 != (Object)null)
				{
					((Selectable)component3).interactable = true;
				}
			}
		}

		private static void SetButtonText(GameObject buttonGO, string text)
		{
			Component[] componentsInChildren = buttonGO.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				PropertyInfo property = ((object)val).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public);
				if (property != null && property.PropertyType == typeof(string) && !string.IsNullOrEmpty(property.GetValue(val) as string))
				{
					property.SetValue(val, text);
					break;
				}
			}
		}

		private static void SetButtonFontSize(GameObject buttonGO, float size)
		{
			Component[] componentsInChildren = buttonGO.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				PropertyInfo property = ((object)val).GetType().GetProperty("fontSize", BindingFlags.Instance | BindingFlags.Public);
				if (property != null && property.PropertyType == typeof(float))
				{
					property.SetValue(val, size);
					break;
				}
			}
		}

		private static void OnWorkOrderClicked()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			if ((Object)(object)currentCraftingStation == (Object)null)
			{
				return;
			}
			if (!StationWorkOrderMap.TryGetValue(currentCraftingStation.m_name, out var value))
			{
				((Character)localPlayer).Message((MessageType)2, "No work order available for this station", 0, (Sprite)null);
				return;
			}
			Recipe selectedRecipe = RecipeHelper.GetSelectedRecipe();
			if ((Object)(object)selectedRecipe == (Object)null)
			{
				((Character)localPlayer).Message((MessageType)2, "Select a recipe first", 0, (Sprite)null);
				return;
			}
			ItemDrop item = selectedRecipe.m_item;
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject gameObject = ((Component)item).gameObject;
				obj = ((gameObject != null) ? ((Object)gameObject).name : null);
			}
			string text = (string)obj;
			string text2 = selectedRecipe.m_item?.m_itemData?.m_shared?.m_name ?? text;
			if (string.IsNullOrEmpty(text))
			{
				((Character)localPlayer).Message((MessageType)2, "Invalid recipe selected", 0, (Sprite)null);
				return;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(value) : null);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Work order prefab not found: " + value));
				}
				((Character)localPlayer).Message((MessageType)2, "Failed to create work order", 0, (Sprite)null);
				return;
			}
			ItemDrop component = val.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("Work order prefab missing ItemDrop: " + value));
				}
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null)
			{
				return;
			}
			if (!inventory.CanAddItem(val, 1))
			{
				((Character)localPlayer).Message((MessageType)2, "Inventory full", 0, (Sprite)null);
				return;
			}
			ItemData val2 = component.m_itemData.Clone();
			val2.m_stack = 1;
			val2.m_dropPrefab = val;
			if (val2.m_customData == null)
			{
				val2.m_customData = new Dictionary<string, string>();
			}
			val2.m_customData["wo_min"] = "1";
			val2.m_customData["wo_max"] = "10";
			val2.m_customData["wo_range"] = "1-10";
			val2.m_customData["wo_station"] = currentCraftingStation.m_name;
			val2.m_customData["wo_item"] = text;
			val2.m_customData["wo_item_name"] = text2;
			string text3 = Localization.instance.Localize(text2);
			if (val2.m_shared != null)
			{
				val2.m_shared = JsonUtility.FromJson<SharedData>(JsonUtility.ToJson((object)val2.m_shared));
				val2.m_shared.m_description = text3 + " (1-10)\nRight-click to change settings.";
			}
			WorkOrderIconCompositor.ApplyOverlay(val2);
			if (inventory.AddItem(val2))
			{
				((Character)localPlayer).Message((MessageType)2, "Created work order: " + text3, 0, (Sprite)null);
				WorkOrderTutorial.MaybeShowWorkOrderTutorial(localPlayer);
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)("Created work order: " + value + " for " + text));
				}
			}
			else
			{
				((Character)localPlayer).Message((MessageType)2, "Failed to add work order to inventory", 0, (Sprite)null);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		[HarmonyPostfix]
		public static void HidePostfix()
		{
			if ((Object)(object)_workOrderButton != (Object)null)
			{
				_workOrderButton.SetActive(false);
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.m_craftButton != (Object)null)
			{
				SetGamepadEnabled(((Component)instance.m_craftButton).gameObject, enabled: true);
			}
			s_focus = CraftFocus.List;
		}
	}
	public static class RecipeHelper
	{
		private static readonly FieldInfo s_selectedRecipeField = typeof(InventoryGui).GetField("m_selectedRecipe", BindingFlags.Instance | BindingFlags.NonPublic);

		public static Recipe GetSelectedRecipe()
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || s_selectedRecipeField == null)
			{
				return null;
			}
			try
			{
				object value = s_selectedRecipeField.GetValue(instance);
				if (value == null)
				{
					return null;
				}
				object? obj = value.GetType().GetProperty("Recipe", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value);
				return (Recipe)((obj is Recipe) ? obj : null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Failed to get selected recipe: " + ex.Message));
				}
				return null;
			}
		}
	}
	public static class StationDisplay
	{
		public static string Pretty(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return "?";
			}
			string str = raw.Replace("$piece_", "").Replace("$vv_", "").Replace("_", " ");
			return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str);
		}
	}
	public static class WorkOrderDiagnostics
	{
		public enum Severity
		{
			Info,
			Good,
			Warning
		}

		public readonly struct Status
		{
			public readonly string Message;

			public readonly Severity Severity;

			public readonly int CurrentCount;

			public Status(string message, Severity severity, int currentCount)
			{
				Message = message;
				Severity = severity;
				CurrentCount = currentCount;
			}
		}

		public static Status Describe(ItemData item, Vector3 scanPos)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (item?.m_customData == null)
			{
				return Empty();
			}
			if (!item.m_customData.TryGetValue("wo_item", out var value) || string.IsNullOrEmpty(value))
			{
				return Empty();
			}
			item.m_customData.TryGetValue("wo_station", out var value2);
			int result = 10;
			if (item.m_customData.TryGetValue("wo_max", out var value3))
			{
				int.TryParse(value3, out result);
			}
			List<Container> list = ContainerScanner.FindNearbyContainers(scanPos, 20f);
			int num = ((list.Count > 0) ? ContainerScanner.CountAcrossContainers(list, value) : 0);
			var (message, severity) = Evaluate(value, value2, result, list, num);
			return new Status(message, severity, num);
		}

		private static (string message, Severity severity) Evaluate(string itemPrefab, string station, int max, List<Container> containers, int current)
		{
			if (IsBeingWorked(itemPrefab))
			{
				return (message: "A villager is crafting this now.", severity: Severity.Info);
			}
			Recipe val = ResolveRecipe(itemPrefab, station);
			if ((Object)(object)val == (Object)null)
			{
				return (message: "No known recipe — this can't be produced here.", severity: Severity.Warning);
			}
			if (containers.Count == 0)
			{
				return (message: "No storage chests nearby.", severity: Severity.Warning);
			}
			if (current >= max)
			{
				return (message: $"Quota met — {current} in storage.", severity: Severity.Good);
			}
			int outputAmount = ((val.m_amount <= 0) ? 1 : val.m_amount);
			if (!containers.Any((Container c) => ContainerScanner.CanAcceptItem(c, itemPrefab, outputAmount)))
			{
				return (message: "Storage full — no room for the output.", severity: Severity.Warning);
			}
			string text = MissingIngredients(containers, val);
			if (text != null)
			{
				return (message: "Out of materials — needs " + text + ".", severity: Severity.Warning);
			}
			return (message: "Ready — a villager will craft it when free.", severity: Severity.Info);
		}

		private static Status Empty()
		{
			return new Status("", Severity.Info, 0);
		}

		private static bool IsBeingWorked(string itemPrefab)
		{
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				CraftingBehavior craftingBehavior = activeVillager.Value?.CraftingBehavior?.Crafting;
				if (craftingBehavior != null && craftingBehavior.IsWorking && craftingBehavior.CurrentItemPrefab == itemPrefab)
				{
					return true;
				}
			}
			return false;
		}

		private static Recipe ResolveRecipe(string itemPrefab, string station)
		{
			if (string.IsNullOrEmpty(station))
			{
				return null;
			}
			Recipe val = StationMatcher.FindRecipe(itemPrefab, station);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			string text = VillagerTypeForStation(station);
			if (text == null)
			{
				return null;
			}
			return StationMatcher.FindRecipeForNpc(itemPrefab, text);
		}

		private static string VillagerTypeForStation(string station)
		{
			foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
			{
				if (definition.Value?.stationName == station)
				{
					return definition.Value.type;
				}
			}
			return null;
		}

		private static string MissingIngredients(List<Container> containers, Recipe recipe)
		{
			if (recipe.m_resources == null)
			{
				return null;
			}
			List<string> list = new List<string>();
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (!((Object)(object)val.m_resItem == (Object)null) && val.m_amount > 0)
				{
					string name = ((Object)((Component)val.m_resItem).gameObject).name;
					int num = ContainerScanner.CountAcrossContainers(containers, name);
					if (num < val.m_amount)
					{
						string text = val.m_resItem.m_itemData?.m_shared?.m_name;
						string arg = (string.IsNullOrEmpty(text) ? name : Localization.instance.Localize(text));
						list.Add($"{val.m_amount - num} {arg}");
					}
				}
			}
			if (list.Count <= 0)
			{
				return null;
			}
			return string.Join(", ", list);
		}
	}
	[HarmonyPatch]
	public static class WorkOrderEditHintPatch
	{
		private static GameObject s_hint;

		[RegisterCleanup]
		public static void Clear()
		{
			s_hint = null;
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		[HarmonyPostfix]
		public static void Postfix(InventoryGui __instance)
		{
			if (!ZInput.IsGamepadActive() || WorkOrderMenu.IsVisible)
			{
				HideHint();
				return;
			}
			RectTransform focusedWorkOrderSlot = GetFocusedWorkOrderSlot(__instance);
			if ((Object)(object)focusedWorkOrderSlot == (Object)null)
			{
				HideHint();
				return;
			}
			EnsureHint(__instance);
			if (!((Object)(object)s_hint == (Object)null))
			{
				PositionAt(focusedWorkOrderSlot);
				if (!s_hint.activeSelf)
				{
					s_hint.SetActive(true);
				}
			}
		}

		private static RectTransform GetFocusedWorkOrderSlot(InventoryGui gui)
		{
			return CheckGrid(gui.m_playerGrid) ?? CheckGrid(gui.ContainerGrid);
		}

		private static RectTransform CheckGrid(InventoryGrid grid)
		{
			if ((Object)(object)grid == (Object)null)
			{
				return null;
			}
			RectTransform gamepadSelectedElement = grid.GetGamepadSelectedElement();
			if ((Object)(object)gamepadSelectedElement == (Object)null)
			{
				return null;
			}
			if (!IsWorkOrder(grid.GetGamepadSelectedItem()))
			{
				return null;
			}
			return gamepadSelectedElement;
		}

		private static bool IsWorkOrder(ItemData item)
		{
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			ItemDefinition definition = ItemFactory.GetDefinition(text);
			if (definition != null)
			{
				return definition.itemType == "workorder";
			}
			return false;
		}

		private static void EnsureHint(InventoryGui gui)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_hint != (Object)null)
			{
				return;
			}
			GameObject val = ((!((Object)(object)gui.m_craftButton != (Object)null)) ? null : ((Component)gui.m_craftButton).GetComponent<UIGamePad>()?.m_hint);
			if (!((Object)(object)val == (Object)null))
			{
				s_hint = Object.Instantiate<GameObject>(val, ((Component)gui).transform);
				((Object)s_hint).name = "VV_WorkOrderEditHint";
				UIGamePad[] componentsInChildren = s_hint.GetComponentsInChildren<UIGamePad>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Object.Destroy((Object)(object)componentsInChildren[i]);
				}
				RectTransform component = s_hint.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					Vector2 val2 = default(Vector2);
					((Vector2)(ref val2))..ctor(0.5f, 0.5f);
					component.pivot = val2;
					Vector2 anchorMin = (component.anchorMax = val2);
					component.anchorMin = anchorMin;
				}
				s_hint.SetActive(false);
			}
		}

		private static void PositionAt(RectTransform slot)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = s_hint.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				slot.GetWorldCorners(array);
				((Transform)component).position = array[2];
				((Transform)component).SetAsLastSibling();
			}
		}

		private static void HideHint()
		{
			if ((Object)(object)s_hint != (Object)null && s_hint.activeSelf)
			{
				s_hint.SetActive(false);
			}
		}
	}
	public static class WorkOrderTutorial
	{
		public const string TutorialName = "vv_workorder";

		private const string Topic = "Work orders";

		private const string Text = "Place work orders in a chest. Villagers who use that station will find them and craft the requested items.";

		private static bool s_registered;

		[HarmonyPatch(typeof(Tutorial), "Awake")]
		[HarmonyPostfix]
		public static void Tutorial_Awake_Postfix(Tutorial __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !s_registered)
			{
				RegisterTutorial(__instance);
				s_registered = true;
			}
		}

		private static void RegisterTutorial(Tutorial tutorial)
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			if (tutorial.m_texts == null)
			{
				return;
			}
			List<TutorialText> texts = tutorial.m_texts;
			foreach (TutorialText item in texts)
			{
				FieldInfo field = ((object)item).GetType().GetField("m_name", BindingFlags.Instance | BindingFlags.Public);
				if (field != null && field.GetValue(item) as string == "vv_workorder")
				{
					return;
				}
			}
			Type type = typeof(Tutorial).Assembly.GetType("Tutorial+TutorialText");
			if (type == null)
			{
				return;
			}
			object obj = Activator.CreateInstance(type);
			if (obj != null)
			{
				SetField(obj, type, "m_name", "vv_workorder");
				SetField(obj, type, "m_topic", "Work orders");
				SetField(obj, type, "m_text", "Place work orders in a chest. Villagers who use that station will find them and craft the requested items.");
				SetField(obj, type, "m_label", "");
				SetField(obj, type, "m_isMunin", false);
				SetField(obj, type, "m_globalKeyTrigger", "");
				SetField(obj, type, "m_tutorialTrigger", "");
				texts.Add((TutorialText)obj);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[Valheim Villages] Registered work order tutorial: vv_workorder");
				}
			}
		}

		private static void SetField(object obj, Type type, string name, object value)
		{
			FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public);
			if (field != null)
			{
				field.SetValue(obj, value);
			}
		}

		public static void MaybeShowWorkOrderTutorial(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				player.ShowTutorial("vv_workorder", false);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UseItem")]
	public static class WorkOrderUsePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(600)]
		public static bool Prefix(Humanoid __instance, Inventory inventory, ItemData item)
		{
			if (!(__instance is Player))
			{
				return true;
			}
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			ItemDefinition definition = ItemFactory.GetDefinition(text);
			if (definition == null || definition.itemType != "workorder")
			{
				return true;
			}
			WorkOrderMenu.Show(item);
			return false;
		}
	}
	[HarmonyPatch(typeof(TextInput), "IsVisible")]
	public static class WorkOrderTextInputPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ref bool __result)
		{
			if (WorkOrderMenu.IsEditingText)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGamepad")]
	public static class WorkOrderGridInputBlockPatch
	{
		[HarmonyPrefix]
		public static bool Prefix()
		{
			return !WorkOrderMenu.IsVisible;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	public static class WorkOrderInventoryHidePatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			if (WorkOrderMenu.IsVisible)
			{
				WorkOrderMenu.Hide();
			}
		}
	}
}
namespace ValheimVillages.Items.VirtualRecipes
{
	public static class CookingRecipeDiscovery
	{
		public static List<VirtualRecipeEntry> GetCookingRecipes(HashSet<string> existingOutputs)
		{
			List<VirtualRecipeEntry> list = new List<VirtualRecipeEntry>();
			ZNetScene instance = ZNetScene.instance;
			if (instance?.m_prefabs == null)
			{
				return list;
			}
			CookingStation val = null;
			for (int i = 0; i < instance.m_prefabs.Count; i++)
			{
				GameObject val2 = instance.m_prefabs[i];
				if (!((Object)(object)val2 == (Object)null))
				{
					CookingStation component = val2.GetComponent<CookingStation>();
					if (!((Object)(object)component == (Object)null))
					{
						val = component;
						break;
					}
				}
			}
			if (val?.m_conversion == null || val.m_conversion.Count == 0)
			{
				return list;
			}
			foreach (ItemConversion item in val.m_conversion)
			{
				if (!((Object)(object)item?.m_from == (Object)null) && !((Object)(object)item.m_to == (Object)null))
				{
					string name = ((Object)((Component)item.m_from).gameObject).name;
					string name2 = ((Object)((Component)item.m_to).gameObject).name;
					if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(name2) && (existingOutputs == null || !existingOutputs.Contains(name2)))
					{
						list.Add(new VirtualRecipeEntry
						{
							output = name2,
							outputAmount = 1,
							inputs = new VirtualRecipeInput[1]
							{
								new VirtualRecipeInput
								{
									item = name,
									amount = 1
								}
							},
							minStationLevel = 1,
							physicalStation = "cookingstation"
						});
					}
				}
			}
			return list;
		}
	}
	internal static class CultivatorDiscoveryDebug
	{
		public const bool Enabled = true;
	}
	public static class CultivatorRecipeDiscovery
	{
		private static readonly FieldInfo s_buildPieces = typeof(SharedData).GetField("m_buildPieces", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo s_mPieces = typeof(PieceTable).GetField("m_pieces", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo s_mAvailablePieces = typeof(PieceTable).GetField("m_availablePieces", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static bool MatchesExclusion(string text, IReadOnlyList<string> exclusionSubstringsLower)
		{
			if (string.IsNullOrEmpty(text) || exclusionSubstringsLower == null)
			{
				return false;
			}
			string text2 = text.ToLowerInvariant();
			for (int i = 0; i < exclusionSubstringsLower.Count; i++)
			{
				string value = exclusionSubstringsLower[i];
				if (!string.IsNullOrEmpty(value) && text2.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		public static List<VirtualRecipeEntry> GetPlantingRecipes(HashSet<string> existingOutputs, IReadOnlyList<string> exclusionSubstringsLower)
		{
			List<VirtualRecipeEntry> list = new List<VirtualRecipeEntry>();
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return list;
			}
			GameObject itemPrefab = instance.GetItemPrefab("Cultivator");
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return list;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if (component?.m_itemData?.m_shared == null)
			{
				return list;
			}
			object? obj = s_buildPieces?.GetValue(component.m_itemData.m_shared);
			PieceTable val = (PieceTable)((obj is PieceTable) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return list;
			}
			int fromMPiecesCount;
			int fromAvailablePiecesCount;
			List<GameObject> pieceGameObjects = GetPieceGameObjects(val, out fromMPiecesCount, out fromAvailablePiecesCount);
			if (Plugin.Log != null)
			{
				Plugin.Log.LogInfo((object)$"[Valheim Villages] Cultivator discovery: m_pieces count={fromMPiecesCount}, m_availablePieces total pieces={fromAvailablePiecesCount}, merged unique={pieceGameObjects?.Count ?? 0}");
			}
			if (pieceGameObjects == null || pieceGameObjects.Count == 0)
			{
				return list;
			}
			foreach (GameObject item in pieceGameObjects)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				Piece component2 = item.GetComponent<Piece>();
				if ((Object)(object)component2 == (Object)null)
				{
					if (Plugin.Log != null)
					{
						Plugin.Log.LogDebug((object)("[Valheim Villages] Piece skip (no Piece component): " + ((Object)item).name));
					}
					continue;
				}
				string text = component2.m_name ?? ((Object)item).name;
				if (MatchesExclusion(text, exclusionSubstringsLower))
				{
					if (Plugin.Log != null)
					{
						Plugin.Log.LogDebug((object)("[Valheim Villages] Piece filtered out (piece name): name='" + text + "' (gameObject='" + ((Object)item).name + "')"));
					}
					continue;
				}
				string text2 = ResolveOutputItemName(item, component2);
				if (string.IsNullOrEmpty(text2))
				{
					if (Plugin.Log != null)
					{
						Plugin.Log.LogDebug((object)("[Valheim Villages] Piece no output: name='" + text + "' gameObject='" + ((Object)item).name + "'"));
					}
					continue;
				}
				if (MatchesExclusion(text2, exclusionSubstringsLower))
				{
					if (Plugin.Log != null)
					{
						Plugin.Log.LogDebug((object)("[Valheim Villages] Piece filtered out (output): output=" + text2 + " name='" + text + "'"));
					}
					continue;
				}
				if (existingOutputs != null && existingOutputs.Contains(text2))
				{
					if (Plugin.Log != null)
					{
						Plugin.Log.LogDebug((object)("[Valheim Villages] Piece skipped (already in JSON): output=" + text2 + " name='" + text + "'"));
					}
					continue;
				}
				VirtualRecipeInput[] inputsFromPiece = GetInputsFromPiece(component2);
				if (inputsFromPiece == null || inputsFromPiece.Length == 0)
				{
					if (Plugin.Log != null)
					{
						Plugin.Log.LogDebug((object)("[Valheim Villages] Piece no inputs: name='" + text + "' output=" + text2));
					}
					continue;
				}
				bool flag = false;
				for (int i = 0; i < inputsFromPiece.Length; i++)
				{
					if (MatchesExclusion(inputsFromPiece[i].item, exclusionSubstringsLower))
					{
						flag = true;
						if (Plugin.Log != null)
						{
							Plugin.Log.LogDebug((object)("[Valheim Villages] Piece filtered out (ingredient): input=" + inputsFromPiece[i].item + " name='" + text + "'"));
						}
						break;
					}
				}
				if (flag)
				{
					continue;
				}
				if (Plugin.Log != null)
				{
					Plugin.Log.LogInfo((object)("[Valheim Villages] Cultivator recipe added: '" + text + "' -> " + text2 + " (inputs: " + string.Join(", ", Array.ConvertAll(inputsFromPiece, (VirtualRecipeInput virtualRecipeInput) => $"{virtualRecipeInput.item}x{virtualRecipeInput.amount}")) + ")"));
				}
				PlantPieceRegistry.Register(text2, item);
				list.Add(new VirtualRecipeEntry
				{
					output = text2,
					outputAmount = 1,
					inputs = inputsFromPiece,
					minStationLevel = 1,
					physicalStation = "farm"
				});
			}
			if (Plugin.Log != null)
			{
				Plugin.Log.LogInfo((object)$"[Valheim Villages] Cultivator discovery total recipes added: {list.Count}");
			}
			return list;
		}

		private static List<GameObject> GetPieceGameObjects(PieceTable table, out int fromMPiecesCount, out int fromAvailablePiecesCount)
		{
			fromMPiecesCount = 0;
			fromAvailablePiecesCount = 0;
			HashSet<GameObject> hashSet = new HashSet<GameObject>();
			List<GameObject> list = new List<GameObject>();
			if (s_mPieces?.GetValue(table) is List<GameObject> list2)
			{
				fromMPiecesCount = list2.Count;
				foreach (GameObject item2 in list2)
				{
					if ((Object)(object)item2 != (Object)null && hashSet.Add(item2))
					{
						list.Add(item2);
					}
				}
			}
			if (s_mAvailablePieces?.GetValue(table) is List<List<Piece>> list3)
			{
				foreach (List<Piece> item3 in list3)
				{
					if (item3 == null)
					{
						continue;
					}
					foreach (Piece item4 in item3)
					{
						if (!((Object)(object)item4 == (Object)null) && !((Object)(object)((Component)item4).gameObject == (Object)null))
						{
							fromAvailablePiecesCount++;
							if (hashSet.Add(((Component)item4).gameObject))
							{
								list.Add(((Component)item4).gameObject);
							}
						}
					}
				}
			}
			if (Plugin.Log != null)
			{
				List<string> list4 = new List<string>();
				foreach (GameObject item5 in list)
				{
					if (!((Object)(object)item5 == (Object)null))
					{
						Piece component = item5.GetComponent<Piece>();
						string item = (((Object)(object)component != (Object)null) ? (component.m_name ?? ((Object)item5).name) : ((Object)item5).name);
						list4.Add(item);
					}
				}
				DebugLog.List("Cultivator", "piece_list", list4);
			}
			return list;
		}

		private static string ResolveOutputItemName(GameObject pieceGo, Piece piece)
		{
			Plant component = pieceGo.GetComponent<Plant>();
			if ((Object)(object)component != (Object)null)
			{
				GameObject[] grownPrefabs = component.m_grownPrefabs;
				if (grownPrefabs != null && grownPrefabs.Length != 0)
				{
					foreach (GameObject val in grownPrefabs)
					{
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						Pickable component2 = val.GetComponent<Pickable>();
						if (!((Object)(object)component2 == (Object)null))
						{
							GameObject itemPrefab = component2.m_itemPrefab;
							if ((Object)(object)itemPrefab != (Object)null && (Object)(object)itemPrefab.GetComponent<ItemDrop>() != (Object)null)
							{
								return ((Object)itemPrefab).name;
							}
						}
					}
				}
			}
			Pickable component3 = pieceGo.GetComponent<Pickable>();
			if ((Object)(object)component3 != (Object)null && (Object)(object)component3.m_itemPrefab != (Object)null)
			{
				return ((Object)component3.m_itemPrefab).name;
			}
			if (piece.m_resources != null && piece.m_resources.Length != 0 && (Object)(object)piece.m_resources[0].m_resItem != (Object)null)
			{
				return ((Object)((Component)piece.m_resources[0].m_resItem).gameObject).name;
			}
			return null;
		}

		private static VirtualRecipeInput[] GetInputsFromPiece(Piece piece)
		{
			if (piece.m_resources == null || piece.m_resources.Length == 0)
			{
				return null;
			}
			List<VirtualRecipeInput> list = new List<VirtualRecipeInput>();
			Requirement[] resources = piece.m_resources;
			foreach (Requirement val in resources)
			{
				if (!((Object)(object)val.m_resItem == (Object)null))
				{
					string name = ((Object)((Component)val.m_resItem).gameObject).name;
					if (!string.IsNullOrEmpty(name))
					{
						list.Add(new VirtualRecipeInput
						{
							item = name,
							amount = val.m_amount
						});
					}
				}
			}
			if (list.Count <= 0)
			{
				return null;
			}
			return list.ToArray();
		}
	}
	public static class PlantPieceRegistry
	{
		private static readonly Dictionary<string, GameObject> _outputToPiece = new Dictionary<string, GameObject>();

		public static void Register(string outputItemName, GameObject piecePrefab)
		{
			if (!string.IsNullOrEmpty(outputItemName) && !((Object)(object)piecePrefab == (Object)null))
			{
				_outputToPiece[outputItemName] = piecePrefab;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("PlantPieceRegistry: " + outputItemName + " -> " + ((Object)piecePrefab).name));
				}
			}
		}

		public static GameObject GetPiecePrefab(string outputItemName)
		{
			if (string.IsNullOrEmpty(outputItemName))
			{
				return null;
			}
			if (!_outputToPiece.TryGetValue(outputItemName, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool IsFarmingOutput(string outputItemName)
		{
			if (!string.IsNullOrEmpty(outputItemName))
			{
				return _outputToPiece.ContainsKey(outputItemName);
			}
			return false;
		}

		[RegisterCleanup]
		public static void Clear()
		{
			_outputToPiece.Clear();
		}
	}
	public static class SmelterRecipeDiscovery
	{
		public static List<VirtualRecipeEntry> GetSmelterRecipes(HashSet<string> existingOutputs)
		{
			List<VirtualRecipeEntry> list = new List<VirtualRecipeEntry>();
			ZNetScene instance = ZNetScene.instance;
			if (instance?.m_prefabs == null)
			{
				return list;
			}
			HashSet<string> hashSet = new HashSet<string>();
			for (int i = 0; i < instance.m_prefabs.Count; i++)
			{
				GameObject val = instance.m_prefabs[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Smelter component = val.GetComponent<Smelter>();
				if ((Object)(object)component == (Object)null || component.m_conversion == null || component.m_conversion.Count == 0)
				{
					continue;
				}
				string name = ((Object)val).name;
				foreach (ItemConversion item in component.m_conversion)
				{
					if (!((Object)(object)item?.m_from == (Object)null) && !((Object)(object)item.m_to == (Object)null))
					{
						string name2 = ((Object)((Component)item.m_from).gameObject).name;
						string name3 = ((Object)((Component)item.m_to).gameObject).name;
						if (!string.IsNullOrEmpty(name2) && !string.IsNullOrEmpty(name3) && (existingOutputs == null || !existingOutputs.Contains(name3)) && hashSet.Add(name3))
						{
							list.Add(new VirtualRecipeEntry
							{
								output = name3,
								outputAmount = 1,
								inputs = new VirtualRecipeInput[1]
								{
									new VirtualRecipeInput
									{
										item = name2,
										amount = 1
									}
								},
								minStationLevel = 1,
								physicalStation = name
							});
						}
					}
				}
			}
			return list;
		}
	}
	[Serializable]
	public class VirtualRecipeEntry
	{
		public string output = "";

		public int outputAmount = 1;

		public VirtualRecipeInput[] inputs;

		public int minStationLevel = 1;

		public string physicalStation = "";
	}
	[Serializable]
	public class VirtualRecipeInput
	{
		public string item = "";

		public int amount = 1;
	}
	public static class VirtualRecipeLoader
	{
		private static readonly List<Recipe> _registeredRecipes = new List<Recipe>();

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

		[RegisterCleanup]
		public static void Clear()
		{
			_registeredRecipes.Clear();
			_physicalStationMap.Clear();
		}

		private static bool IsExcludedFromCraftMenu(string output)
		{
			return string.Equals(output, "AncientSeed", StringComparison.OrdinalIgnoreCase);
		}

		public static void RegisterAll(ObjectDB objectDB)
		{
			if (objectDB?.m_recipes == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"VirtualRecipeLoader: ObjectDB not ready");
				}
				return;
			}
			if (_registeredRecipes.Count > 0)
			{
				ReAddExisting(objectDB);
				return;
			}
			RemoveOurRecipesFrom(objectDB);
			int num = 0;
			foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
			{
				VillagerDef value = definition.Value;
				if (!string.IsNullOrEmpty(value?.stationName))
				{
					CraftingStation orCreateStationTemplate = VirtualRecipeParser.GetOrCreateStationTemplate(value.stationName);
					HashSet<string> existingOutputs = new HashSet<string>();
					num += RegisterStationRecipes(objectDB, orCreateStationTemplate, value.stationRecipes, existingOutputs);
					if (value.tags != null && TagParser.HasTag(value.tags, "recipe", "cultivator"))
					{
						IReadOnlyList<string> cultivatorExclusionsLower = GetCultivatorExclusionsLower(value);
						List<VirtualRecipeEntry> plantingRecipes = CultivatorRecipeDiscovery.GetPlantingRecipes(existingOutputs, cultivatorExclusionsLower);
						num += RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, plantingRecipes, existingOutputs);
					}
					if (value.tags != null && TagParser.HasTag(value.tags, "recipe", "cooking"))
					{
						List<VirtualRecipeEntry> cookingRecipes = CookingRecipeDiscovery.GetCookingRecipes(existingOutputs);
						num += RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, cookingRecipes, existingOutputs);
					}
					if (value.tags != null && TagParser.HasTag(value.tags, "recipe", "smelter"))
					{
						List<VirtualRecipeEntry> smelterRecipes = SmelterRecipeDiscovery.GetSmelterRecipes(existingOutputs);
						num += RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, smelterRecipes, existingOutputs);
					}
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"VirtualRecipeLoader: Registered {num} virtual recipes");
			}
		}

		public static void RegisterCookingRecipesIfNeeded(ObjectDB objectDB)
		{
			if (objectDB?.m_recipes == null || _registeredRecipes.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
			{
				VillagerDef value = definition.Value;
				if (string.IsNullOrEmpty(value?.stationName) || value.tags == null)
				{
					continue;
				}
				CraftingStation orCreateStationTemplate = VirtualRecipeParser.GetOrCreateStationTemplate(value.stationName);
				if ((Object)(object)orCreateStationTemplate == (Object)null)
				{
					continue;
				}
				if (TagParser.HasTag(value.tags, "recipe", "cooking"))
				{
					HashSet<string> existingOutputs = CollectExistingOutputs(value.stationName);
					List<VirtualRecipeEntry> cookingRecipes = CookingRecipeDiscovery.GetCookingRecipes(existingOutputs);
					if (cookingRecipes.Count > 0)
					{
						int num = RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, cookingRecipes, existingOutputs);
						if (num > 0)
						{
							ManualLogSource log = Plugin.Log;
							if (log != null)
							{
								log.LogInfo((object)$"VirtualRecipeLoader: Registered {num} cooking-discovered recipes for {value.stationName} (ZNetScene ready)");
							}
						}
					}
				}
				if (!TagParser.HasTag(value.tags, "recipe", "smelter"))
				{
					continue;
				}
				HashSet<string> existingOutputs2 = CollectExistingOutputs(value.stationName);
				List<VirtualRecipeEntry> smelterRecipes = SmelterRecipeDiscovery.GetSmelterRecipes(existingOutputs2);
				if (smelterRecipes.Count <= 0)
				{
					continue;
				}
				int num2 = RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, smelterRecipes, existingOutputs2);
				if (num2 > 0)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"VirtualRecipeLoader: Registered {num2} smelter-discovered recipes for {value.stationName} (ZNetScene ready)");
					}
				}
			}
		}

		public static int RecheckDiscoveredRecipes(ObjectDB objectDB)
		{
			if (objectDB?.m_recipes == null)
			{
				return 0;
			}
			int num = 0;
			foreach (KeyValuePair<string, VillagerDef> definition in VillagerRegistry.Definitions)
			{
				VillagerDef value = definition.Value;
				if (string.IsNullOrEmpty(value?.stationName))
				{
					continue;
				}
				bool flag = value.tags != null && TagParser.HasTag(value.tags, "recipe", "cultivator");
				bool flag2 = value.tags != null && TagParser.HasTag(value.tags, "recipe", "cooking");
				bool flag3 = value.tags != null && TagParser.HasTag(value.tags, "recipe", "smelter");
				if (!flag && !flag2 && !flag3)
				{
					continue;
				}
				CraftingStation orCreateStationTemplate = VirtualRecipeParser.GetOrCreateStationTemplate(value.stationName);
				if (!((Object)(object)orCreateStationTemplate == (Object)null))
				{
					HashSet<string> existingOutputs = CollectExistingOutputs(value.stationName);
					if (flag)
					{
						IReadOnlyList<string> cultivatorExclusionsLower = GetCultivatorExclusionsLower(value);
						List<VirtualRecipeEntry> plantingRecipes = CultivatorRecipeDiscovery.GetPlantingRecipes(existingOutputs, cultivatorExclusionsLower);
						num += RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, plantingRecipes, existingOutputs);
					}
					if (flag2)
					{
						List<VirtualRecipeEntry> cookingRecipes = CookingRecipeDiscovery.GetCookingRecipes(existingOutputs);
						num += RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, cookingRecipes, existingOutputs);
					}
					if (flag3)
					{
						List<VirtualRecipeEntry> smelterRecipes = SmelterRecipeDiscovery.GetSmelterRecipes(existingOutputs);
						num += RegisterDiscoveredEntries(objectDB, orCreateStationTemplate, smelterRecipes, existingOutputs);
					}
				}
			}
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"VirtualRecipeLoader: Recheck added {num} discovered recipes (post-world load)");
				}
			}
			return num;
		}

		public static CraftingStation GetStationTemplate(string stationName)
		{
			return VirtualRecipeParser.GetStationTemplate(stationName);
		}

		public static string GetPhysicalStation(string recipeName)
		{
			if (string.IsNullOrEmpty(recipeName))
			{
				return null;
			}
			if (!_physicalStationMap.TryGetValue(recipeName, out var value))
			{
				return null;
			}
			return value;
		}

		private static int RegisterStationRecipes(ObjectDB objectDB, CraftingStation station, List<StationRecipe> recipes, HashSet<string> existingOutputs)
		{
			if (recipes == null || recipes.Count == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (StationRecipe recipe in recipes)
			{
				if (!IsExcludedFromCraftMenu(recipe.output))
				{
					if (!string.IsNullOrEmpty(recipe.output))
					{
						existingOutputs.Add(recipe.output);
					}
					VirtualRecipeEntry virtualRecipeEntry = new VirtualRecipeEntry();
					virtualRecipeEntry.output = recipe.output;
					virtualRecipeEntry.outputAmount = recipe.outputAmount;
					virtualRecipeEntry.inputs = (string.IsNullOrEmpty(recipe.input) ? null : new VirtualRecipeInput[1]
					{
						new VirtualRecipeInput
						{
							item = recipe.input,
							amount = recipe.inputAmount
						}
					});
					virtualRecipeEntry.minStationLevel = recipe.minStationLevel;
					VirtualRecipeEntry entry = virtualRecipeEntry;
					Recipe val = CreateRecipe(objectDB, station, entry);
					if ((Object)(object)val != (Object)null)
					{
						objectDB.m_recipes.Add(val);
						_registeredRecipes.Add(val);
						num++;
					}
				}
			}
			return num;
		}

		private static int RegisterDiscoveredEntries(ObjectDB objectDB, CraftingStation station, List<VirtualRecipeEntry> entries, HashSet<string> existingOutputs)
		{
			int num = 0;
			foreach (VirtualRecipeEntry entry in entries)
			{
				if (!IsExcludedFromCraftMenu(entry.output))
				{
					if (!string.IsNullOrEmpty(entry.output))
					{
						existingOutputs.Add(entry.output);
					}
					Recipe val = CreateRecipe(objectDB, station, entry);
					if ((Object)(object)val != (Object)null)
					{
						objectDB.m_recipes.Add(val);
						_registeredRecipes.Add(val);
						num++;
					}
				}
			}
			return num;
		}

		private static HashSet<string> CollectExistingOutputs(string stationName)
		{
			HashSet<string> hashSet = new HashSet<string>();
			string value = "VV_Recipe_" + stationName + "_";
			foreach (Recipe registeredRecipe in _registeredRecipes)
			{
				object obj;
				if (registeredRecipe == null)
				{
					obj = null;
				}
				else
				{
					ItemDrop item = registeredRecipe.m_item;
					obj = ((item != null) ? ((Component)item).gameObject : null);
				}
				if (!((Object)obj == (Object)null) && ((Object)registeredRecipe).name != null && ((Object)registeredRecipe).name.StartsWith(value))
				{
					hashSet.Add(((Object)((Component)registeredRecipe.m_item).gameObject).name);
				}
			}
			return hashSet;
		}

		private static IReadOnlyList<string> GetCultivatorExclusionsLower(VillagerDef def)
		{
			if (def?.cultivatorExclusions == null || def.cultivatorExclusions.Count == 0)
			{
				return Array.Empty<string>();
			}
			string[] array = new string[def.cultivatorExclusions.Count];
			for (int i = 0; i < def.cultivatorExclusions.Count; i++)
			{
				string text = def.cultivatorExclusions[i];
				array[i] = (string.IsNullOrEmpty(text) ? "" : text.Trim().ToLowerInvariant());
			}
			return array;
		}

		private static void ReAddExisting(ObjectDB objectDB)
		{
			int num = 0;
			foreach (Recipe registeredRecipe in _registeredRecipes)
			{
				if (!objectDB.m_recipes.Contains(registeredRecipe))
				{
					objectDB.m_recipes.Add(registeredRecipe);
					num++;
				}
			}
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"VirtualRecipeLoader: Re-added {num} virtual recipes");
				}
			}
		}

		private static void RemoveOurRecipesFrom(ObjectDB objectDB)
		{
			int num = objectDB.m_recipes.RemoveAll((Recipe r) => (Object)(object)r != (Object)null && !string.IsNullOrEmpty(((Object)r).name) && ((Object)r).name.StartsWith("VV_Recipe_"));
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"VirtualRecipeLoader: Removed {num} existing virtual recipes before re-register");
				}
			}
		}

		private static Recipe CreateRecipe(ObjectDB objectDB, CraftingStation station, VirtualRecipeEntry entry)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_015e: Expected O, but got Unknown
			if (string.IsNullOrEmpty(entry.output))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"VirtualRecipeLoader: Recipe has no output");
				}
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(entry.output);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("VirtualRecipeLoader: Output prefab not found: " + entry.output));
				}
				return null;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("VirtualRecipeLoader: Output prefab has no ItemDrop: " + entry.output));
				}
				return null;
			}
			List<Requirement> list = new List<Requirement>();
			if (entry.inputs != null)
			{
				VirtualRecipeInput[] inputs = entry.inputs;
				foreach (VirtualRecipeInput virtualRecipeInput in inputs)
				{
					GameObject itemPrefab2 = ObjectDB.instance.GetItemPrefab(virtualRecipeInput.item);
					if ((Object)(object)itemPrefab2 == (Object)null)
					{
						ManualLogSource log4 = Plugin.Log;
						if (log4 != null)
						{
							log4.LogWarning((object)("VirtualRecipeLoader: Input prefab not found: " + virtualRecipeInput.item));
						}
						return null;
					}
					ItemDrop component2 = itemPrefab2.GetComponent<ItemDrop>();
					if ((Object)(object)component2 == (Object)null)
					{
						ManualLogSource log5 = Plugin.Log;
						if (log5 != null)
						{
							log5.LogWarning((object)("VirtualRecipeLoader: Input prefab has no ItemDrop: " + virtualRecipeInput.item));
						}
						return null;
					}
					list.Add(new Requirement
					{
						m_resItem = component2,
						m_amount = virtualRecipeInput.amount,
						m_amountPerLevel = 0,
						m_recover = false
					});
				}
			}
			string text = "VV_Recipe_" + station.m_name + "_" + entry.output;
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			((Object)val).name = text;
			val.m_item = component;
			val.m_amount = entry.outputAmount;
			val.m_craftingStation = station;
			val.m_minStationLevel = entry.minStationLevel;
			val.m_resources = list.ToArray();
			val.m_enabled = true;
			if (!string.IsNullOrEmpty(entry.physicalStation))
			{
				_physicalStationMap[text] = entry.physicalStation;
			}
			ManualLogSource log6 = Plugin.Log;
			if (log6 != null)
			{
				string[] obj = new string[5] { "VirtualRecipeLoader: Created recipe '", text, "' ", null, null };
				VirtualRecipeInput[] inputs2 = entry.inputs;
				obj[3] = $"({((inputs2 != null) ? inputs2.Length : 0)} inputs -> {entry.outputAmount}x {entry.output})";
				obj[4] = (string.IsNullOrEmpty(entry.physicalStation) ? "" : (" [physicalStation=" + entry.physicalStation + "]"));
				log6.LogInfo((object)string.Concat(obj));
			}
			return val;
		}
	}
	internal static class VirtualRecipeParser
	{
		private static readonly Dictionary<string, CraftingStation> _stationTemplates = new Dictionary<string, CraftingStation>();

		internal static CraftingStation GetOrCreateStationTemplate(string stationName)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			if (_stationTemplates.TryGetValue(stationName, out var value))
			{
				return value;
			}
			GameObject val = new GameObject("VV_StationTemplate_" + stationName);
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)val);
			CraftingStation val2 = val.AddComponent<CraftingStation>();
			val2.m_name = stationName;
			val2.m_icon = null;
			val2.m_discoverRange = 0f;
			val2.m_rangeBuild = 0f;
			val2.m_craftRequireRoof = false;
			val2.m_craftRequireFire = false;
			val2.m_showBasicRecipies = false;
			val2.m_useDistance = 10f;
			val2.m_useAnimation = 0;
			val2.m_areaMarker = null;
			val2.m_inUseObject = null;
			val2.m_haveFireObject = null;
			val2.m_craftItemEffects = new EffectList();
			val2.m_craftItemDoneEffects = new EffectList();
			val2.m_repairItemDoneEffects = new EffectList();
			_stationTemplates[stationName] = val2;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("VirtualRecipeParser: Created station template for '" + stationName + "'"));
			}
			return val2;
		}

		internal static CraftingStation GetStationTemplate(string stationName)
		{
			if (!_stationTemplates.TryGetValue(stationName, out var value))
			{
				return null;
			}
			return value;
		}
	}
}
namespace ValheimVillages.Items.Icons
{
	public static class WorkOrderIconCompositor
	{
		private class CachedBase
		{
			public int Height;

			public Color32[] Pixels;

			public int Width;
		}

		private const int IconSize = 64;

		private const int OverlaySize = 42;

		private const int OverlayX = 11;

		private const int OverlayY = 11;

		private static readonly Dictionary<string, CachedBase> _baseCache = new Dictionary<string, CachedBase>();

		private static readonly Dictionary<string, Sprite> _spriteCache = new Dictionary<string, Sprite>();

		private static readonly Dictionary<int, Color32[]> _parchmentCache = new Dictionary<int, Color32[]>();

		public static void ApplyOverlay(ItemData itemData, WorkOrderStatus status = WorkOrderStatus.Pending)
		{
			if (itemData?.m_shared == null || itemData.m_customData == null || !itemData.m_customData.TryGetValue("wo_item", out var value) || string.IsNullOrEmpty(value))
			{
				return;
			}
			Sprite val = ResolveParchment(itemData);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject dropPrefab = itemData.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? "wo";
			string key = $"{text}_{value}_{status}";
			if (_spriteCache.TryGetValue(key, out var value2))
			{
				EnsureOwnSharedData(itemData);
				itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { value2 };
				return;
			}
			string key2 = text + "_" + value;
			if (!_baseCache.TryGetValue(key2, out var value3))
			{
				value3 = BuildBaseComposite(val, value);
				if (value3 == null)
				{
					return;
				}
				_baseCache[key2] = value3;
			}
			Sprite val2 = StampStatus(value3, status);
			if (!((Object)(object)val2 == (Object)null))
			{
				_spriteCache[key] = val2;
				EnsureOwnSharedData(itemData);
				itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { val2 };
			}
		}

		public static void EnsureOverlays(Inventory inventory, Vector3? containerPos = null, List<Container> containers = null)
		{
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem.m_customData != null && allItem.m_customData.ContainsKey("wo_item"))
				{
					WorkOrderStatus status = WorkOrderStatusResolver.Resolve(allItem, containerPos, containers);
					ApplyOverlay(allItem, status);
				}
			}
		}

		private static CachedBase BuildBaseComposite(Sprite parchment, string itemPrefab)
		{
			Sprite itemSprite = GetItemSprite(itemPrefab);
			if ((Object)(object)itemSprite == (Object)null)
			{
				return null;
			}
			try
			{
				Color32[] parchmentPixels = GetParchmentPixels(parchment);
				if (parchmentPixels == null)
				{
					return null;
				}
				Color32[] array = ScaleSpriteToBuffer(itemSprite, 42);
				if (array == null)
				{
					return null;
				}
				Color32[] array2 = (Color32[])parchmentPixels.Clone();
				CompositeOver(array2, 64, 64, array, 42, 42, 11, 11, clipToDstAlpha: true);
				return new CachedBase
				{
					Pixels = array2,
					Width = 64,
					Height = 64
				};
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Failed to build base composite for " + itemPrefab + ": " + ex.Message));
				}
				return null;
			}
		}

		private static Sprite StampStatus(CachedBase baseCached, WorkOrderStatus status)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Color32[] array = (Color32[])baseCached.Pixels.Clone();
				WorkOrderStatusOverlay.Draw(array, baseCached.Width, baseCached.Height, status);
				Texture2D val = new Texture2D(baseCached.Width, baseCached.Height, (TextureFormat)4, false);
				val.SetPixels32(array);
				val.Apply();
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Failed to stamp status {status}: {ex.Message}");
				}
				return null;
			}
		}

		private static void EnsureOwnSharedData(ItemData item)
		{
			GameObject dropPrefab = item.m_dropPrefab;
			if (!((Object)(object)dropPrefab == (Object)null))
			{
				ItemDrop component = dropPrefab.GetComponent<ItemDrop>();
				if ((Object)(object)component != (Object)null && item.m_shared == component.m_itemData.m_shared)
				{
					item.m_shared = JsonUtility.FromJson<SharedData>(JsonUtility.ToJson((object)item.m_shared));
				}
			}
		}

		private static Sprite ResolveParchment(ItemData itemData)
		{
			Sprite[] array = (((Object)(object)itemData.m_dropPrefab != (Object)null) ? itemData.m_dropPrefab.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_icons;
			if (array != null && array.Length != 0 && (Object)(object)array[0] != (Object)null)
			{
				return array[0];
			}
			Sprite[] array2 = itemData.m_shared?.m_icons;
			if (array2 == null || array2.Length == 0)
			{
				return null;
			}
			return array2[0];
		}

		private static Sprite GetItemSprite(string prefabName)
		{
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Sprite[] array = val.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0)
			{
				return null;
			}
			return array[0];
		}

		private static Color32[] GetParchmentPixels(Sprite parchment)
		{
			Texture2D val = ((parchment != null) ? parchment.texture : null);
			if (val == null)
			{
				return null;
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (_parchmentCache.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			Color32[] pixels = val.GetPixels32();
			_parchmentCache[instanceID] = pixels;
			return pixels;
		}

		private static Color32[] ScaleSpriteToBuffer(Sprite sprite, int size)
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			Texture2D texture = sprite.texture;
			if ((Object)(object)texture == (Object)null)
			{
				return null;
			}
			Rect val = sprite.textureRect;
			if (((Rect)(ref val)).width < 1f || ((Rect)(ref val)).height < 1f)
			{
				val = sprite.rect;
			}
			float num = ((Texture)texture).width;
			float num2 = ((Texture)texture).height;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(((Rect)(ref val)).width / num, ((Rect)(ref val)).height / num2);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(((Rect)(ref val)).x / num, ((Rect)(ref val)).y / num2);
			FilterMode filterMode = ((Texture)texture).filterMode;
			((Texture)texture).filterMode = (FilterMode)1;
			RenderTexture temporary = RenderTexture.GetTemporary(size, size, 0, (RenderTextureFormat)0);
			((Texture)temporary).filterMode = (FilterMode)1;
			RenderTexture active = RenderTexture.active;
			try
			{
				Graphics.Blit((Texture)(object)texture, temporary, val2, val3);
				RenderTexture.active = temporary;
				Texture2D val4 = new Texture2D(size, size, (TextureFormat)4, false);
				val4.ReadPixels(new Rect(0f, 0f, (float)size, (float)size), 0, 0);
				val4.Apply();
				Color32[] pixels = val4.GetPixels32();
				Object.Destroy((Object)val4);
				return pixels;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				((Texture)texture).filterMode = filterMode;
			}
		}

		private static void CompositeOver(Color32[] dst, int dstW, int dstH, Color32[] src, int srcW, int srcH, int dstX, int dstY, bool clipToDstAlpha)
		{
			//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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < srcH; i++)
			{
				int num = dstY + i;
				if (num < 0 || num >= dstH)
				{
					continue;
				}
				for (int j = 0; j < srcW; j++)
				{
					int num2 = dstX + j;
					if (num2 < 0 || num2 >= dstW)
					{
						continue;
					}
					Color32 val = src[i * srcW + j];
					if (val.a != 0)
					{
						int num3 = num * dstW + num2;
						Color32 val2 = dst[num3];
						if (!clipToDstAlpha || val2.a >= 26)
						{
							int a = val.a;
							int num4 = 255 - a;
							dst[num3] = new Color32((byte)((val2.r * num4 + val.r * a) / 255), (byte)((val2.g * num4 + val.g * a) / 255), (byte)((val2.b * num4 + val.b * a) / 255), Math.Max(val2.a, val.a));
						}
					}
				}
			}
		}
	}
	public static class WorkOrderIconLoader
	{
		private const string DefaultStation = "workbench";

		private static readonly Dictionary<string, Sprite> _cache = new Dictionary<string, Sprite>();

		private static readonly Dictionary<string, Texture2D> _texCache = new Dictionary<string, Texture2D>();

		private static MethodInfo _loadImageMethod;

		public static Sprite Load(string stationType)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			string text = stationType ?? "";
			if (_cache.TryGetValue(text, out var value))
			{
				return value;
			}
			Texture2D val = LoadTexture(text);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			_cache[text] = val2;
			return val2;
		}

		public static Texture2D LoadTexture(string stationType)
		{
			//IL_00d4: 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_00e2: Expected O, but got Unknown
			string text = stationType ?? "";
			if (_texCache.TryGetValue(text, out var value))
			{
				return value;
			}
			string text2 = "ValheimVillages.Items.Icons.WorkOrders.workorder_" + text.ToLowerInvariant() + ".png";
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(text2);
			if (stream == null)
			{
				if (!text.Equals("workbench", StringComparison.OrdinalIgnoreCase))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Work order icon resource not found: " + text2 + " — using 'workbench' scroll."));
					}
					Texture2D val = LoadTexture("workbench");
					_texCache[text] = val;
					return val;
				}
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Work order icon resource not found: " + text2));
				}
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val2 = new Texture2D(2, 2, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1
			};
			if (!InvokeLoadImage(val2, array))
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)("Failed to decode work order icon PNG: " + text2));
				}
				return null;
			}
			_texCache[text] = val2;
			ManualLogSource log4 = Plugin.Log;
			if (log4 != null)
			{
				log4.LogInfo((object)$"Loaded work order icon: {stationType} ({((Texture)val2).width}x{((Texture)val2).height})");
			}
			return val2;
		}

		private static bool InvokeLoadImage(Texture2D tex, byte[] data)
		{
			if (_loadImageMethod == null)
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					Type type = assemblies[i].GetType("UnityEngine.ImageConversion");
					if (!(type == null))
					{
						_loadImageMethod = type.GetMethod("LoadImage", new Type[2]
						{
							typeof(Texture2D),
							typeof(byte[])
						});
						break;
					}
				}
			}
			if (_loadImageMethod == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)"ImageConversion.LoadImage not found via reflection");
				}
				return false;
			}
			return (bool)_loadImageMethod.Invoke(null, new object[2] { tex, data });
		}
	}
	[HarmonyPatch]
	public static class WorkOrderIconPatch
	{
		private static FieldInfo _containerField;

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		[HarmonyPostfix]
		private static void OnInventoryShow(InventoryGui __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				Vector3 position = ((Component)localPlayer).transform.position;
				List<Container> list = ContainerScanner.FindNearbyContainers(position, 20f);
				WorkOrderIconCompositor.EnsureOverlays(((Humanoid)localPlayer).GetInventory(), position, list);
				RefreshContainerIcons(__instance, list);
			}
		}

		private static void RefreshContainerIcons(InventoryGui gui, List<Container> sharedContainers)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui == (Object)null)
			{
				return;
			}
			Container currentContainer = GetCurrentContainer(gui);
			if (!((Object)(object)currentContainer == (Object)null))
			{
				Inventory inventory = currentContainer.GetInventory();
				if (inventory != null)
				{
					Vector3 position = ((Component)currentContainer).transform.position;
					WorkOrderIconCompositor.EnsureOverlays(inventory, position, sharedContainers);
				}
			}
		}

		private static Container GetCurrentContainer(InventoryGui gui)
		{
			if (_containerField == null)
			{
				_containerField = typeof(InventoryGui).GetField("m_currentContainer", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj = _containerField?.GetValue(gui);
			return (Container)((obj is Container) ? obj : null);
		}
	}
	public enum WorkOrderStatus
	{
		Pending,
		InProgress,
		Completed,
		Unworkable
	}
	public static class WorkOrderStatusOverlay
	{
		private const int BadgeSize = 20;

		private const int BadgePadding = 2;

		private const int BorderWidth = 2;

		private static readonly Color32 OutlineColor = new Color32((byte)26, (byte)26, (byte)26, (byte)230);

		private static readonly Color32 White = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);

		public static void Draw(Color32[] px, int w, int h, WorkOrderStatus status)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			switch (status)
			{
			case WorkOrderStatus.Completed:
				DrawBadge(px, w, h, new Color32((byte)38, (byte)166, (byte)38, (byte)242), DrawCheckmark);
				break;
			case WorkOrderStatus.InProgress:
				DrawBadge(px, w, h, new Color32((byte)217, (byte)166, (byte)26, (byte)242), DrawHourglass);
				break;
			case WorkOrderStatus.Unworkable:
				DrawBadge(px, w, h, new Color32((byte)191, (byte)31, (byte)31, (byte)242), DrawRedX);
				break;
			}
		}

		private static void DrawBadge(Color32[] px, int w, int h, Color32 fill, Action<Color32[], int, int, int, int> glyph)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			int num = w - 2 - 10;
			int num2 = h - 2 - 10;
			int num3 = 10;
			DrawFilledCircle(px, w, h, num, num2, num3, OutlineColor);
			DrawFilledCircle(px, w, h, num, num2, num3 - 2, fill);
			glyph(px, w, h, num, num2);
		}

		private static void DrawCheckmark(Color32[] px, int w, int h, int cx, int cy)
		{
			//IL_0012: 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)
			int num = cx - 4;
			DrawThickLine(px, w, h, num, cy, num + 3, cy - 3, White, 2);
			DrawThickLine(px, w, h, num + 3, cy - 3, num + 8, cy + 4, White, 2);
		}

		private static void DrawHourglass(Color32[] px, int w, int h, int cx, int cy)
		{
			//IL_001d: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			int num = cx - 3;
			int num2 = cx + 3;
			int num3 = cy + 4;
			int num4 = cy - 4;
			DrawThickLine(px, w, h, num, num3, num2, num3, White, 1);
			DrawThickLine(px, w, h, num, num4, num2, num4, White, 1);
			DrawThickLine(px, w, h, num, num3 - 1, cx, cy, White, 1);
			DrawThickLine(px, w, h, num2, num3 - 1, cx, cy, White, 1);
			DrawThickLine(px, w, h, cx, cy, num, num4 + 1, White, 1);
			DrawThickLine(px, w, h, cx, cy, num2, num4 + 1, White, 1);
		}

		private static void DrawRedX(Color32[] px, int w, int h, int cx, int cy)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			DrawThickLine(px, w, h, cx - 4, cy - 4, cx + 4, cy + 4, White, 2);
			DrawThickLine(px, w, h, cx - 4, cy + 4, cx + 4, cy - 4, White, 2);
		}

		private static void Blend(Color32[] px, int w, int h, int x, int y, Color32 c)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (x >= 0 && x < w && y >= 0 && y < h)
			{
				int num = y * w + x;
				Color32 val = px[num];
				int a = c.a;
				int num2 = 255 - a;
				px[num] = new Color32((byte)((val.r * num2 + c.r * a) / 255), (byte)((val.g * num2 + c.g * a) / 255), (byte)((val.b * num2 + c.b * a) / 255), (byte)Mathf.Max((int)val.a, (int)c.a));
			}
		}

		private static void DrawFilledCircle(Color32[] px, int w, int h, int cx, int cy, int radius, Color32 color)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			int num = radius * radius;
			for (int i = -radius; i <= radius; i++)
			{
				for (int j = -radius; j <= radius; j++)
				{
					if (j * j + i * i <= num)
					{
						Blend(px, w, h, cx + j, cy + i, color);
					}
				}
			}
		}

		private static void DrawThickLine(Color32[] px, int w, int h, int x0, int y0, int x1, int y1, Color32 color, int thickness)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			int num = thickness / 2;
			for (int i = -num; i <= num; i++)
			{
				for (int j = -num; j <= num; j++)
				{
					DrawLine(px, w, h, x0 + j, y0 + i, x1 + j, y1 + i, color);
				}
			}
		}

		private static void DrawLine(Color32[] px, int w, int h, int x0, int y0, int x1, int y1, Color32 color)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Abs(x1 - x0);
			int num2 = -Mathf.Abs(y1 - y0);
			int num3 = ((x0 < x1) ? 1 : (-1));
			int num4 = ((y0 < y1) ? 1 : (-1));
			int num5 = num + num2;
			for (int i = 0; i < 200; i++)
			{
				Blend(px, w, h, x0, y0, color);
				if (x0 != x1 || y0 != y1)
				{
					int num6 = 2 * num5;
					if (num6 >= num2)
					{
						num5 += num2;
						x0 += num3;
					}
					if (num6 <= num)
					{
						num5 += num;
						y0 += num4;
					}
					continue;
				}
				break;
			}
		}
	}
	public static class WorkOrderStatusResolver
	{
		public static WorkOrderStatus Resolve(ItemData item, Vector3? containerPos, List<Container> containers = null)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (item?.m_customData == null)
			{
				return WorkOrderStatus.Pending;
			}
			if (!item.m_customData.TryGetValue("wo_item", out var value) || string.IsNullOrEmpty(value))
			{
				return WorkOrderStatus.Pending;
			}
			if (!item.m_customData.TryGetValue("wo_station", out var value2) || string.IsNullOrEmpty(value2))
			{
				return WorkOrderStatus.Pending;
			}
			int result = 10;
			if (item.m_customData.TryGetValue("wo_max", out var value3))
			{
				int.TryParse(value3, out result);
			}
			if (IsBeingWorked(value))
			{
				return WorkOrderStatus.InProgress;
			}
			if (containers == null && containerPos.HasValue)
			{
				containers = ContainerScanner.FindNearbyContainers(containerPos.Value, 20f);
			}
			if (containers != null && containers.Count > 0)
			{
				if (ContainerScanner.CountAcrossContainers(containers, value) >= result)
				{
					return WorkOrderStatus.Completed;
				}
				if (!HasRecipe(value, value2))
				{
					return WorkOrderStatus.Unworkable;
				}
			}
			else if (!HasRecipe(value, value2))
			{
				return WorkOrderStatus.Unworkable;
			}
			return WorkOrderStatus.Pending;
		}

		private static bool IsBeingWorked(string itemPrefab)
		{
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				CraftingBehavior craftingBehavior = (activeVillager.Value?.CraftingBehavior)?.Crafting;
				if (craftingBehavior != null && craftingBehavior.IsWorking && craftingBehavior.CurrentItemPrefab == itemPrefab)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasRecipe(string itemPrefab, string station)
		{
			return (Object)(object)StationMatcher.FindRecipe(itemPrefab, station) != (Object)null;
		}
	}
}
namespace ValheimVillages.Items.Fragments
{
	public static class FragmentCombiner
	{
		private const int RequiredFragments = 3;

		private static readonly Dictionary<string, string> BiomeNpcMap = new Dictionary<string, string>
		{
			{ "Meadows", "Farmer" },
			{ "BlackForest", "Carpenter" },
			{ "Swamp", "Blacksmith" },
			{ "Mountain", "Mountaineer" },
			{ "Plains", "Farmer" },
			{ "Mistlands", "Guard" },
			{ "Ashlands", "Guard" }
		};

		private static readonly Dictionary<string, string[]> BiomeLocationMap = new Dictionary<string, string[]>
		{
			{
				"Meadows",
				new string[4] { "Dolmen01", "Dolmen02", "Dolmen03", "WoodVillage1" }
			},
			{
				"BlackForest",
				new string[6] { "TrollCave", "TrollCave02", "Crypt2", "Crypt3", "Crypt4", "Hildir_crypt" }
			},
			{
				"Swamp",
				new string[6] { "SunkenCrypt1", "SunkenCrypt2", "SunkenCrypt3", "SunkenCrypt4", "SwampRuin1", "SwampRuin2" }
			},
			{
				"Mountain",
				new string[6] { "MountainCave01", "MountainCave02", "Hildir_cave", "AbandonedLogCabin02", "AbandonedLogCabin03", "AbandonedLogCabin04" }
			},
			{
				"Plains",
				new string[7] { "GoblinCamp1", "GoblinCamp2", "StoneTower1", "StoneTower2", "StoneTower3", "StoneTower4", "Hildir_plainsfortress" }
			},
			{
				"Mistlands",
				new string[6] { "Mistlands_GuardTower1_new", "Mistlands_GuardTower2_new", "Mistlands_GuardTower3_new", "Mistlands_Excavation1", "Mistlands_Excavation2", "Mistlands_Excavation3" }
			},
			{
				"Ashlands",
				new string[6] { "CharredFortress", "FortressRuins", "CharredRuins1", "CharredTowerRuins1", "CharredTowerRuins2", "CharredTowerRuins3" }
			}
		};

		public static bool TryCombine(Player player, string biome)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || string.IsNullOrEmpty(biome))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			List<ItemData> list = FindFragmentsByBiome(inventory, biome);
			int num = 0;
			foreach (ItemData item in list)
			{
				num += item.m_stack;
			}
			if (num < 3)
			{
				int num2 = 3 - num;
				((Character)player).Message((MessageType)2, $"Need {num2} more {biome} fragments ({num}/{3})", 0, (Sprite)null);
				return false;
			}
			if (!BiomeNpcMap.TryGetValue(biome, out var value))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("No NPC type mapped for biome: " + biome));
				}
				value = "Farmer";
			}
			Vector3? val = FindPositionInBiome(biome, ((Component)player).transform.position);
			if (!val.HasValue)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("Cannot combine " + biome + " fragments: no valid " + biome + " location found " + $"in loaded world (player at {((Component)player).transform.position}, " + $"villagerType={value}, fragmentsHeld={num}). " + "Fragments NOT consumed."));
				}
				((Character)player).Message((MessageType)2, "Cannot locate " + biome + " in the surrounding world. Try again from a different area.", 0, (Sprite)null);
				return false;
			}
			int num3 = 3;
			foreach (ItemData item2 in list)
			{
				if (num3 <= 0)
				{
					break;
				}
				int num4 = Mathf.Min(num3, item2.m_stack);
				for (int i = 0; i < num4; i++)
				{
					inventory.RemoveOneItem(item2);
				}
				num3 -= num4;
			}
			AddQuestMarker(val.Value, value, biome);
			RescueQuestTracker.AddQuest(val.Value, value, biome);
			((Character)player).Message((MessageType)2, "Rescue quest revealed! A captive " + value + " awaits in the " + biome + ".", 0, (Sprite)null);
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)$"Combined {3} {biome} fragments -> rescue quest for {value}");
			}
			return true;
		}

		public static string GetBiomeFromItem(string itemName)
		{
			ItemDefinition definition = ItemFactory.GetDefinition(itemName);
			if (definition != null && definition.itemType == "fragment" && !string.IsNullOrEmpty(definition.biome))
			{
				return definition.biome;
			}
			return null;
		}

		private static List<ItemData> FindFragmentsByBiome(Inventory inventory, string biome)
		{
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				object obj;
				if (allItem == null)
				{
					obj = null;
				}
				else
				{
					GameObject dropPrefab = allItem.m_dropPrefab;
					obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
				}
				string text = (string)obj;
				if (!string.IsNullOrEmpty(text))
				{
					ItemDefinition definition = ItemFactory.GetDefinition(text);
					if (definition != null && definition.itemType == "fragment" && definition.biome == biome)
					{
						list.Add(allItem);
					}
				}
			}
			return list;
		}

		private static Vector3? FindPositionInBiome(string biomeName, Vector3 playerPos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			if (!BiomeLocationMap.TryGetValue(biomeName, out var value))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("No location names mapped for biome: " + biomeName));
				}
				return null;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return null;
			}
			HashSet<string> hashSet = new HashSet<string>(value);
			List<Vector3> list = new List<Vector3>();
			foreach (KeyValuePair<Vector2i, LocationInstance> locationInstance in ZoneSystem.instance.m_locationInstances)
			{
				LocationInstance value2 = locationInstance.Value;
				if (value2.m_location != null)
				{
					string prefabName = value2.m_location.m_prefabName;
					if (!string.IsNullOrEmpty(prefabName) && hashSet.Contains(prefabName))
					{
						list.Add(value2.m_position);
					}
				}
			}
			if (list.Count == 0)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("No placed locations found for biome " + biomeName + " (searched for: " + string.Join(", ", value) + ")"));
				}
				return null;
			}
			list.Sort((Vector3 a, Vector3 b) => Vector3.Distance(playerPos, a).CompareTo(Vector3.Distance(playerPos, b)));
			int num = Mathf.Max(1, list.Count / 4);
			int index = Random.Range(0, num);
			Vector3 val = list[index];
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)($"Selected location for {biomeName} rescue quest: {val} " + $"(distance: {Vector3.Distance(playerPos, val):F0}m, " + $"{list.Count} candidates found, picked from top {num})"));
			}
			return val;
		}

		private static void AddQuestMarker(Vector3 position, string villagerType, string biome)
		{
			//IL_0115: 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)
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Cannot add quest marker: Minimap not available");
				}
				return;
			}
			string text = "Rescue: Captive " + villagerType + " (" + biome + ")";
			try
			{
				MethodInfo[] array = (from m in typeof(Minimap).GetMethods(BindingFlags.Instance | BindingFlags.Public)
					where m.Name == "AddPin"
					select m).ToArray();
				MethodInfo methodInfo = null;
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo2 in array2)
				{
					ParameterInfo[] parameters = methodInfo2.GetParameters();
					if (parameters.Length >= 5 && parameters[0].ParameterType == typeof(Vector3) && parameters[2].ParameterType == typeof(string))
					{
						methodInfo = methodInfo2;
						break;
					}
				}
				if (methodInfo != null)
				{
					ParameterInfo[] parameters2 = methodInfo.GetParameters();
					object[] array3 = new object[parameters2.Length];
					array3[0] = position;
					array3[1] = (object)(PinType)3;
					array3[2] = text;
					array3[3] = true;
					array3[4] = false;
					for (int num2 = 5; num2 < parameters2.Length; num2++)
					{
						if (parameters2[num2].HasDefaultValue)
						{
							array3[num2] = parameters2[num2].DefaultValue;
						}
						else if (parameters2[num2].ParameterType.IsValueType)
						{
							array3[num2] = Activator.CreateInstance(parameters2[num2].ParameterType);
						}
						else
						{
							array3[num2] = null;
						}
					}
					methodInfo.Invoke(instance, array3);
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"Added quest marker at {position}: {text}");
					}
				}
				else
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogWarning((object)$"Could not find Minimap.AddPin method (found {array.Length} overloads)");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogError((object)("Failed to add quest marker: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	public static class FragmentLootPatch
	{
		private const float FragmentDropWeight = 0.15f;

		private static Dictionary<Biome, string> s_biomeFragmentMap;

		private static Dictionary<Biome, string> BiomeFragmentMap
		{
			get
			{
				if (s_biomeFragmentMap != null)
				{
					return s_biomeFragmentMap;
				}
				s_biomeFragmentMap = new Dictionary<Biome, string>();
				(int, string, string, string, string)[] fragmentBiomes = ItemFactory.FragmentBiomes;
				for (int i = 0; i < fragmentBiomes.Length; i++)
				{
					var (num, text, _, _, _) = fragmentBiomes[i];
					s_biomeFragmentMap[(Biome)num] = "vv_fragment_" + text;
				}
				return s_biomeFragmentMap;
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Container __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.m_defaultItems == null || __instance.m_defaultItems.m_drops == null || __instance.m_defaultItems.m_drops.Count == 0)
			{
				return;
			}
			Biome biomeAtPosition = GetBiomeAtPosition(((Component)__instance).transform.position);
			if (!BiomeFragmentMap.TryGetValue(biomeAtPosition, out var value))
			{
				return;
			}
			GameObject fragmentPrefab = GetFragmentPrefab(value);
			if ((Object)(object)fragmentPrefab == (Object)null)
			{
				return;
			}
			foreach (DropData drop in __instance.m_defaultItems.m_drops)
			{
				if ((Object)(object)drop.m_item != (Object)null && ((Object)drop.m_item).name == value)
				{
					return;
				}
			}
			__instance.m_defaultItems.m_drops.Add(new DropData
			{
				m_item = fragmentPrefab,
				m_stackMin = 1,
				m_stackMax = 1,
				m_weight = 0.15f,
				m_dontScale = true
			});
		}

		private static Biome GetBiomeAtPosition(Vector3 position)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			WorldGenerator instance = WorldGenerator.instance;
			if (instance != null)
			{
				return instance.GetBiome(position);
			}
			return (Biome)1;
		}

		private static GameObject GetFragmentPrefab(string fragmentName)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			return ZNetScene.instance.GetPrefab(fragmentName);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UseItem")]
	public static class FragmentUsePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(600)]
		public static bool Prefix(Humanoid __instance, Inventory inventory, ItemData item)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val == null)
			{
				return true;
			}
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			ItemDefinition definition = ItemFactory.GetDefinition(text);
			if (definition == null || definition.itemType != "fragment")
			{
				return true;
			}
			string biome = definition.biome;
			if (string.IsNullOrEmpty(biome))
			{
				return true;
			}
			FragmentCombiner.TryCombine(val, biome);
			return false;
		}
	}
	[HarmonyPatch(typeof(EnvMan), "SetForceEnvironment")]
	public static class DungeonEntryPatch
	{
		[HarmonyPostfix]
		public static void Postfix(string env)
		{
			if (!string.IsNullOrEmpty(env))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					RescueQuestTracker.OnDungeonEntered(localPlayer, env);
				}
			}
		}
	}
	public static class RescueQuestTracker
	{
		public class PendingQuest
		{
			public string Biome;

			public Vector3 Position;

			public string VillagerType;
		}

		private const float QuestDungeonRadius = 150f;

		private static readonly List<PendingQuest> _pendingQuests = new List<PendingQuest>();

		public static int PendingCount => _pendingQuests.Count;

		public static void AddQuest(Vector3 position, string villagerType, string biome)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			_pendingQuests.Add(new PendingQuest
			{
				Position = position,
				VillagerType = villagerType,
				Biome = biome
			});
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"Registered pending rescue quest: {villagerType} at {position} ({biome}). " + $"Pawn will spawn when player enters dungeon within {150f}m."));
			}
		}

		public static void OnDungeonEntered(Player player, string environmentName)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || _pendingQuests.Count == 0)
			{
				return;
			}
			Vector3 position = ((Component)player).transform.position;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Dungeon entry detected (env: " + environmentName + "), " + $"player at {position}, checking {_pendingQuests.Count} pending quest(s)."));
			}
			for (int num = _pendingQuests.Count - 1; num >= 0; num--)
			{
				PendingQuest pendingQuest = _pendingQuests[num];
				float num2 = position.x - pendingQuest.Position.x;
				float num3 = position.z - pendingQuest.Position.z;
				float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)($"  Quest {num}: {pendingQuest.VillagerType} at {pendingQuest.Position}, " + $"horizontal distance: {num4:F0}m"));
				}
				if (num4 <= 150f)
				{
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogInfo((object)("Player entered dungeon (env: " + environmentName + ") within " + $"{num4:F0}m (horizontal) of rescue quest for " + pendingQuest.VillagerType + " — spawning captive pawn in dungeon room."));
					}
					SpawnCaptivePawn(FindDungeonRoomPosition(position), pendingQuest.VillagerType);
					_pendingQuests.RemoveAt(num);
					break;
				}
			}
		}

		[RegisterCleanup]
		public static void Clear()
		{
			_pendingQuests.Clear();
		}

		private static Vector3 FindDungeonRoomPosition(Vector3 playerPos)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			DungeonGenerator[] array = Object.FindObjectsByType<DungeonGenerator>((FindObjectsSortMode)0);
			DungeonGenerator val = null;
			float num = float.MaxValue;
			DungeonGenerator[] array2 = array;
			foreach (DungeonGenerator val2 in array2)
			{
				float num2 = Vector3.Distance(playerPos, ((Component)val2).transform.position);
				if (num2 < num)
				{
					num = num2;
					val = val2;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"No DungeonGenerator found, spawning near player.");
				}
				return playerPos;
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)($"Found DungeonGenerator at {((Component)val).transform.position} " + $"(distance: {num:F1}m from player)"));
			}
			Room[] componentsInChildren = ((Component)val).GetComponentsInChildren<Room>();
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)"DungeonGenerator has no rooms, spawning near player.");
				}
				return playerPos;
			}
			List<Room> list = new List<Room>();
			Room[] array3 = componentsInChildren;
			foreach (Room val3 in array3)
			{
				if (!val3.m_entrance)
				{
					list.Add(val3);
				}
			}
			if (list.Count == 0)
			{
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogInfo((object)($"Dungeon has {componentsInChildren.Length} room(s), all marked as entrance — " + "spawning in available room."));
				}
				list.AddRange(componentsInChildren);
			}
			Room val4 = list[Random.Range(0, list.Count)];
			Vector3 position = ((Component)val4).transform.position;
			ManualLogSource log5 = Plugin.Log;
			if (log5 != null)
			{
				log5.LogInfo((object)("Picked dungeon room: " + ((Object)val4).name + " " + $"(entrance: {val4.m_entrance}, " + $"total rooms: {componentsInChildren.Length}, interior: {list.Count}) " + $"at {position}"));
			}
			return position;
		}

		private static string GetPawnName(string villagerType)
		{
			return "vv_" + villagerType.ToLower() + "_pawn";
		}

		private static void SpawnCaptivePawn(Vector3 position, string villagerType)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			string pawnName = GetPawnName(villagerType);
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)"ZNetScene not available, cannot spawn captive pawn");
				}
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(pawnName);
			if ((Object)(object)prefab == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("Pawn prefab not found: " + pawnName));
				}
				return;
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)("Pawn prefab " + pawnName + " has no ItemDrop component"));
				}
				return;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(position.x, position.y + 0.5f, position.z);
			if ((Object)(object)ItemDrop.DropItem(component.m_itemData, 1, val, Quaternion.identity) != (Object)null)
			{
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogInfo((object)$"Spawned captive pawn {pawnName} at {val}");
				}
			}
			else
			{
				ManualLogSource log5 = Plugin.Log;
				if (log5 != null)
				{
					log5.LogError((object)$"Failed to spawn captive pawn {pawnName} at {val}");
				}
			}
		}
	}
}
namespace ValheimVillages.UI.Tabs
{
	[RegisterTab("debug", Order = 1)]
	public class DebugTab : IVillagerTabUI, IVillagerTab, ITabContent<VillagerBehaviorBridge>
	{
		private class DebugCommand
		{
			public string ActionText;

			public string CommandName;

			public string Description;

			public Action OnAction;
		}

		private readonly List<DebugCommand> m_commands = new List<DebugCommand>();

		private static readonly List<IListPanel> s_panels = new List<IListPanel>();

		private readonly List<(IListPanel panel, int startIdx, int count)> m_panelRanges = new List<(IListPanel, int, int)>();

		public string TabName => "Debug";

		public void OnSelected(VillagerBehaviorBridge villager)
		{
			BuildCommands(villager);
		}

		public void OnDeselected()
		{
			m_commands.Clear();
			m_panelRanges.Clear();
		}

		public void OnUpdate(VillagerBehaviorBridge villager)
		{
			BuildCommands(villager);
		}

		public List<TabListItemUI> GetListItems(VillagerBehaviorBridge villager)
		{
			List<TabListItemUI> list = new List<TabListItemUI>();
			foreach (DebugCommand command in m_commands)
			{
				list.Add(new TabListItemUI
				{
					TabName = command.CommandName
				});
			}
			AddPanelItems(list, villager);
			return list;
		}

		public TabDetailDataUI GetDetail(int index, VillagerBehaviorBridge villager)
		{
			if (index >= 0 && index < m_commands.Count)
			{
				DebugCommand debugCommand = m_commands[index];
				return new TabDetailDataUI
				{
					Title = debugCommand.CommandName,
					Description = debugCommand.Description,
					ActionText = debugCommand.ActionText,
					OnAction = debugCommand.OnAction
				};
			}
			return GetPanelDetail(index, villager);
		}

		public static void RegisterPanel(IListPanel panel)
		{
			if (panel.ParentTab == "debug" && !s_panels.Contains(panel))
			{
				s_panels.Add(panel);
			}
		}

		private void AddPanelItems(List<TabListItemUI> items, VillagerBehaviorBridge villager)
		{
			m_panelRanges.Clear();
			foreach (IListPanel s_panel in s_panels)
			{
				if (!(s_panel is IListPanelUI listPanelUI))
				{
					continue;
				}
				List<TabListItemUI> listItems = listPanelUI.GetListItems(villager);
				if (listItems.Count <= 0)
				{
					continue;
				}
				m_panelRanges.Add((s_panel, items.Count, listItems.Count));
				foreach (TabListItemUI item in listItems)
				{
					items.Add(item);
				}
			}
		}

		private TabDetailDataUI GetPanelDetail(int index, VillagerBehaviorBridge villager)
		{
			foreach (var (listPanel, num, num2) in m_panelRanges)
			{
				if (index >= num && index < num + num2)
				{
					return (listPanel is IListPanelUI listPanelUI) ? listPanelUI.GetDetail(index - num, villager) : null;
				}
			}
			return null;
		}

		private void BuildCommands(VillagerBehaviorBridge villager)
		{
			m_commands.Clear();
			if (!((Object)(object)villager == (Object)null))
			{
				AddStateInfo(villager);
				AddRecentTasks(villager);
				AddNavigationCommands(villager);
			}
		}

		private void AddStateInfo(VillagerBehaviorBridge villager)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			string text = $"State: {villager.CurrentState}";
			VillagerWaypoint villagerWaypoint = villager.villagerInstance?.villagerAI?.GetCurrentWaypoint();
			if (villagerWaypoint != null)
			{
				float num = Vector3.Distance(((Component)villager).transform.position, villagerWaypoint.Position);
				text += $"\nTarget: {num:F0}m away";
			}
			text += $"\nBest comfort: {villager.Memory?.BestComfortLevel ?? 0f:F1}";
			m_commands.Add(new DebugCommand
			{
				CommandName = "Current State",
				Description = text,
				ActionText = null,
				OnAction = null
			});
		}

		private void AddRecentTasks(VillagerBehaviorBridge villager)
		{
			IReadOnlyList<ActivityLogEntry> entries = VillagerActivityLog.Instance.GetEntries(villager.UniqueId);
			int num = Math.Min(10, entries.Count);
			List<ActivityLogEntry> list = ((num == 0) ? new List<ActivityLogEntry>() : entries.Skip(entries.Count - num).ToList());
			List<string> list2 = new List<string>();
			for (int num2 = list.Count - 1; num2 >= 0; num2--)
			{
				ActivityLogEntry activityLogEntry = list[num2];
				list2.Add(activityLogEntry.TaskName + " / " + activityLogEntry.Action + ": " + activityLogEntry.Description);
			}
			string description = ((list2.Count == 0) ? "No recent tasks recorded." : string.Join("\n", list2));
			m_commands.Add(new DebugCommand
			{
				CommandName = "Recent tasks",
				Description = description,
				ActionText = null,
				OnAction = null
			});
		}

		private void AddNavigationCommands(VillagerBehaviorBridge villager)
		{
			AddNavCommand(villager, "Go Home", LocationType.Home);
			AddNavCommand(villager, "Find Fire", LocationType.Fire);
		}

		private void AddNavCommand(VillagerBehaviorBridge v, string name, LocationType type)
		{
			m_commands.Add(new DebugCommand
			{
				CommandName = name,
				Description = $"Send villager to the nearest known {type}.",
				ActionText = "Go",
				OnAction = delegate
				{
					//IL_0045: 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_004a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_0058: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
					VillagerAI villagerAI = v.villagerInstance?.villagerAI;
					if ((Object)(object)villagerAI == (Object)null)
					{
						Msg("No villager available.");
					}
					else
					{
						Vector3 anchorPos = villagerAI.GetMemory()?.HomeAnchor ?? villagerAI.Position;
						Vector3 target;
						if (type == LocationType.Home)
						{
							target = anchorPos;
						}
						else
						{
							KnownLocation knownLocation = (from l in VillagePoiRegistry.GetPois(anchorPos, type)
								orderby Vector3.Distance(anchorPos, l.Position)
								select l).FirstOrDefault();
							if (knownLocation == null)
							{
								Msg($"No {type} location known.");
								return;
							}
							target = knownLocation.Position;
						}
						if (villagerAI.NavTo(target, BehaviorState.Traveling, name + " destination", snapToApproach: true, null, directOrder: true))
						{
							Msg($"Going to {type}");
						}
						else
						{
							Msg($"Can't reach {type} from here");
						}
						InventoryGui instance = InventoryGui.instance;
						if (instance != null)
						{
							instance.Hide();
						}
					}
				}
			});
		}

		private static void Msg(string text)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, text, 0, (Sprite)null);
			}
		}
	}
	[RegisterTab("info", Order = 0)]
	public class InfoTab : IVillagerTabUI, IVillagerTab, ITabContent<VillagerBehaviorBridge>
	{
		private const string AttentionPrefix = "⚠ ";

		private List<ActivityLogEntry> m_issues = new List<ActivityLogEntry>();

		private int m_issueCount;

		private const int CurrentTaskCount = 1;

		private static readonly List<IListPanel> s_panels = new List<IListPanel>();

		private readonly List<(IListPanel panel, int startIdx, int count)> m_panelRanges = new List<(IListPanel, int, int)>();

		private static readonly Color ChestPinColor = new Color(1f, 0.55f, 0.15f);

		private static readonly Color TargetPinColor = new Color(0.3f, 0.9f, 0.3f);

		private static readonly Color PlayerPinColor = new Color(0.35f, 0.8f, 1f);

		private static readonly Color ProblemPinColor = new Color(0.95f, 0.25f, 0.2f);

		public string TabName => "Tasks";

		public void OnSelected(VillagerBehaviorBridge villager)
		{
			RefreshIssues(villager);
		}

		public void OnDeselected()
		{
			m_issues.Clear();
			m_issueCount = 0;
		}

		public void OnUpdate(VillagerBehaviorBridge villager)
		{
			RefreshIssues(villager);
		}

		public List<TabListItemUI> GetListItems(VillagerBehaviorBridge villager)
		{
			List<TabListItemUI> list = new List<TabListItemUI>
			{
				new TabListItemUI
				{
					TabName = "▶ " + CurrentActivityLabel(villager),
					Icon = null
				}
			};
			m_issueCount = m_issues.Count;
			foreach (ActivityLogEntry issue in m_issues)
			{
				list.Add(new TabListItemUI
				{
					TabName = "⚠ " + (issue.ItemPrefab ?? issue.TaskName ?? "(blocked)"),
					Icon = ResolveItemIcon(issue.ItemPrefab)
				});
			}
			AddAbilityItems(list, villager);
			return list;
		}

		private static string CurrentActivityLabel(VillagerBehaviorBridge villager)
		{
			string text = villager?.AI?.ActiveBehavior?.GetStatusText();
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			if (!((Object)(object)villager != (Object)null))
			{
				return "Idle";
			}
			return villager.CurrentState.ToString();
		}

		public TabDetailDataUI GetDetail(int index, VillagerBehaviorBridge villager)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (index < 1)
			{
				return CurrentTaskDetail(villager);
			}
			int num = index - 1;
			if (num >= 0 && num < m_issueCount)
			{
				ActivityLogEntry activityLogEntry = m_issues[num];
				List<(Vector3, Color)> pins = new List<(Vector3, Color)>();
				Vector3? focus = null;
				if (activityLogEntry.WorkOrderPosX.HasValue && activityLogEntry.WorkOrderPosY.HasValue && activityLogEntry.WorkOrderPosZ.HasValue)
				{
					focus = new Vector3(activityLogEntry.WorkOrderPosX.Value, activityLogEntry.WorkOrderPosY.Value, activityLogEntry.WorkOrderPosZ.Value);
				}
				bool num2 = !string.IsNullOrEmpty(activityLogEntry.StationName);
				string focusLabel = (num2 ? "Chest" : "Problem");
				Color focusColor = (num2 ? ChestPinColor : ProblemPinColor);
				string text = BuildPins(pins, focus, focusLabel, focusColor);
				string text2 = activityLogEntry.Reason ?? activityLogEntry.Description ?? "";
				string text3 = (string.IsNullOrEmpty(activityLogEntry.StationName) ? text2 : ("Station: " + StationDisplay.Pretty(activityLogEntry.StationName) + "\n" + text2));
				if (text.Length > 0)
				{
					text3 = text3 + "\n\n" + text;
				}
				return new TabDetailDataUI
				{
					Title = (activityLogEntry.ItemPrefab ?? activityLogEntry.TaskName ?? "Blocked"),
					Icon = ResolveItemIcon(activityLogEntry.ItemPrefab),
					Description = text3,
					MapTexture = VillageMapPanel.RenderForTask(villager, pins)
				};
			}
			return GetAbilityDetail(index, villager);
		}

		private TabDetailDataUI CurrentTaskDetail(VillagerBehaviorBridge villager)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			string text = (((Object)(object)villager != (Object)null) ? villager.CurrentState.ToString() : "Idle");
			string text2 = CurrentActivityLabel(villager);
			List<(Vector3, Color)> pins = new List<(Vector3, Color)>();
			Vector3? focus = (villager?.CurrentWaypoint)?.Position;
			string text3 = BuildPins(pins, focus, "Target", TargetPinColor);
			string text4 = ((text2 == text) ? ("State: " + text) : (text2 + "\nState: " + text));
			if (text3.Length > 0)
			{
				text4 = text4 + "\n\n" + text3;
			}
			Sprite icon = ResolveItemIcon(((villager?.AI?.ActiveBehavior as CraftingBehaviorAdapter)?.Crafting)?.CurrentItemPrefab) ?? ResolveItemIcon("Hammer");
			return new TabDetailDataUI
			{
				Title = "Current Activity",
				Icon = icon,
				Description = text4,
				MapTexture = VillageMapPanel.RenderForTask(villager, pins)
			};
		}

		public static void RegisterPanel(IListPanel panel)
		{
			if (panel.ParentTab == "info" && !s_panels.Contains(panel))
			{
				s_panels.Add(panel);
			}
		}

		private void AddAbilityItems(List<TabListItemUI> items, VillagerBehaviorBridge villager)
		{
			m_panelRanges.Clear();
			foreach (IListPanel s_panel in s_panels)
			{
				if (!(s_panel is IListPanelUI listPanelUI))
				{
					continue;
				}
				List<TabListItemUI> listItems = listPanelUI.GetListItems(villager);
				if (listItems.Count <= 0)
				{
					continue;
				}
				m_panelRanges.Add((s_panel, items.Count, listItems.Count));
				foreach (TabListItemUI item in listItems)
				{
					items.Add(item);
				}
			}
		}

		private TabDetailDataUI GetAbilityDetail(int absoluteIndex, VillagerBehaviorBridge villager)
		{
			foreach (var (listPanel, num, num2) in m_panelRanges)
			{
				if (absoluteIndex >= num && absoluteIndex < num + num2)
				{
					return (listPanel is IListPanelUI listPanelUI) ? listPanelUI.GetDetail(absoluteIndex - num, villager) : null;
				}
			}
			return null;
		}

		private void RefreshIssues(VillagerBehaviorBridge villager)
		{
			m_issues.Clear();
			if (!((Object)(object)villager == (Object)null) && !string.IsNullOrEmpty(villager.UniqueId))
			{
				m_issues = (from e in VillagerActivityLog.Instance.GetEntries(villager.UniqueId)
					where e.Action == "blocked"
					select e).ToList();
			}
		}

		private static string BuildPins(List<(Vector3 position, Color color)> pins, Vector3? focus, string focusLabel, Color focusColor)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			string text = "";
			if (focus.HasValue)
			{
				pins.Add((focus.Value, focusColor));
				text = Bullet(focusColor) + " " + focusLabel;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				pins.Add((((Component)localPlayer).transform.position, PlayerPinColor));
				text = text + ((text.Length > 0) ? "    " : "") + Bullet(PlayerPinColor) + " You";
			}
			return text;
		}

		private static string Bullet(Color c)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return "<color=#" + ColorUtility.ToHtmlStringRGB(c) + ">●</color>";
		}

		private static Sprite ResolveItemIcon(string itemPrefab)
		{
			if (string.IsNullOrEmpty(itemPrefab) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab2 = ObjectDB.instance.GetItemPrefab(itemPrefab);
			if ((Object)(object)itemPrefab2 == (Object)null)
			{
				return null;
			}
			Sprite[] array = itemPrefab2.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0)
			{
				return null;
			}
			return array[0];
		}
	}
}
namespace ValheimVillages.UI.Tabs.Registry
{
	[RegisterRegistryTab("add", Order = 1)]
	public class AddTab : IRegistryTabUI, ITabContent<RegistryContext>
	{
		private List<VillagerDef> m_types = new List<VillagerDef>();

		public string TabName => "Add";

		public void OnSelected(RegistryContext context)
		{
			RefreshTypes();
		}

		public void OnDeselected()
		{
			m_types.Clear();
		}

		public void OnUpdate(RegistryContext context)
		{
			RefreshTypes();
		}

		private void RefreshTypes()
		{
			m_types = VillagerRegistry.EnabledDefinitions.OrderBy((VillagerDef d) => d.displayName).ToList();
		}

		public List<TabListItemUI> GetListItems(RegistryContext context)
		{
			if (m_types.Count == 0)
			{
				RefreshTypes();
			}
			List<TabListItemUI> list = new List<TabListItemUI>();
			foreach (VillagerDef type in m_types)
			{
				list.Add(new TabListItemUI
				{
					TabName = (string.IsNullOrEmpty(type.displayName) ? type.type : type.displayName),
					Icon = ResolveItemIcon(type.stationIcon)
				});
			}
			return list;
		}

		public TabDetailDataUI GetDetail(int selectedIndex, RegistryContext context)
		{
			if (selectedIndex < 0 || selectedIndex >= m_types.Count)
			{
				return null;
			}
			VillagerDef def = m_types[selectedIndex];
			string name = (string.IsNullOrEmpty(def.displayName) ? def.type : def.displayName);
			return new TabDetailDataUI
			{
				Title = name,
				Icon = ResolveItemIcon(def.stationIcon),
				Description = (string.IsNullOrEmpty(def.description) ? ("Recruit a " + name + " to this village. They will spawn at the registry.") : def.description),
				ActionText = "Recruit",
				OnAction = delegate
				{
					Recruit(def, name, context);
				}
			};
		}

		private static void Recruit(VillagerDef def, string name, RegistryContext context)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			if (context == null)
			{
				return;
			}
			Vector3 anchorPos = context.RegistryPosition;
			if (RegistrySeedResolver.TryResolveWalkableSeed(context.RegistryPosition, out var seed))
			{
				anchorPos = seed;
			}
			else
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)($"[AddTab] No walkable seed near registry {context.RegistryPosition}; " + "spawning at the anchor (region graph may degenerate)."));
				}
			}
			VillagerRecord record = null;
			string villagerPrefab = ((!string.IsNullOrEmpty(def.preferredPrefab)) ? def.preferredPrefab : "DvergerMage");
			GameObject val = VillagerSpawner.SpawnVillagerNpc(def, def.type, villagerPrefab, anchorPos, ref record, context.VillageId);
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, ((Object)(object)val != (Object)null) ? ("Recruited " + name) : ("Failed to recruit " + name), 0, (Sprite)null);
			}
		}

		private static Sprite ResolveItemIcon(string itemPrefab)
		{
			if (string.IsNullOrEmpty(itemPrefab) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab2 = ObjectDB.instance.GetItemPrefab(itemPrefab);
			Sprite[] array = (((Object)(object)itemPrefab2 != (Object)null) ? itemPrefab2.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0)
			{
				return null;
			}
			return array[0];
		}
	}
	[RegisterRegistryTab("revive", Order = 2)]
	public class ReviveTab : IRegistryTabUI, ITabContent<RegistryContext>
	{
		private List<VillagerRecord> m_dead = new List<VillagerRecord>();

		public string TabName => "Revive";

		public void OnSelected(RegistryContext context)
		{
			Refresh(context);
		}

		public void OnDeselected()
		{
			m_dead.Clear();
		}

		public void OnUpdate(RegistryContext context)
		{
			Refresh(context);
		}

		private void Refresh(RegistryContext context)
		{
			m_dead = ((context == null) ? new List<VillagerRecord>() : VillagerRecordTable.QueryByStatus(context.VillageId, RecordStatus.Dead).ToList());
		}

		public List<TabListItemUI> GetListItems(RegistryContext context)
		{
			if (m_dead.Count == 0)
			{
				Refresh(context);
			}
			if (m_dead.Count == 0)
			{
				return new List<TabListItemUI>
				{
					new TabListItemUI
					{
						TabName = "(no fallen villagers)"
					}
				};
			}
			return m_dead.Select((VillagerRecord r) => new TabListItemUI
			{
				TabName = r.Name + " — " + r.Type
			}).ToList();
		}

		public TabDetailDataUI GetDetail(int selectedIndex, RegistryContext context)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (selectedIndex < 0 || selectedIndex >= m_dead.Count)
			{
				return new TabDetailDataUI
				{
					Title = "Revive",
					Description = "Fallen villagers will appear here.\nRevive them to return them to the village."
				};
			}
			VillagerRecord villagerRecord = m_dead[selectedIndex];
			TabDetailDataUI tabDetailDataUI = new TabDetailDataUI
			{
				Title = villagerRecord.Name,
				Description = "Type: <color=#FFA13C>" + villagerRecord.Type + "</color>\nStatus: <color=#E8643C>Fallen</color>"
			};
			if (VillagerReviveService.IsOnCooldown)
			{
				tabDetailDataUI.Description += $"\n\n<color=#FFE300>Revive cooldown: {VillagerReviveService.CooldownRemaining:F0}s</color>";
			}
			else
			{
				tabDetailDataUI.ActionText = "Revive";
				string recordId = villagerRecord.RecordId;
				string name = villagerRecord.Name;
				Vector3 registryPos = context.RegistryPosition;
				tabDetailDataUI.OnAction = delegate
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					if (VillagerReviveService.Revive(VillagerRecordTable.FindById(recordId), registryPos, out var error))
					{
						Player localPlayer = Player.m_localPlayer;
						if (localPlayer != null)
						{
							((Character)localPlayer).Message((MessageType)2, name + " revived", 0, (Sprite)null);
						}
					}
					else
					{
						Player localPlayer2 = Player.m_localPlayer;
						if (localPlayer2 != null)
						{
							((Character)localPlayer2).Message((MessageType)2, "Cannot revive: " + error, 0, (Sprite)null);
						}
					}
				};
			}
			return tabDetailDataUI;
		}
	}
	[RegisterRegistryTab("roster", Order = 0)]
	public class RosterTab : IRegistryTabUI, ITabContent<RegistryContext>
	{
		private List<VillagerRecord> m_alive = new List<VillagerRecord>();

		public string TabName => "Roster";

		public void OnSelected(RegistryContext context)
		{
			Refresh(context);
		}

		public void OnDeselected()
		{
			m_alive.Clear();
		}

		public void OnUpdate(RegistryContext context)
		{
			Refresh(context);
		}

		private void Refresh(RegistryContext context)
		{
			m_alive = ((context == null) ? new List<VillagerRecord>() : VillagerRecordTable.QueryByStatus(context.VillageId, RecordStatus.Alive).ToList());
		}

		public List<TabListItemUI> GetListItems(RegistryContext context)
		{
			if (m_alive.Count == 0)
			{
				Refresh(context);
			}
			if (m_alive.Count == 0)
			{
				return new List<TabListItemUI>
				{
					new TabListItemUI
					{
						TabName = "(no villagers yet)"
					}
				};
			}
			return m_alive.Select((VillagerRecord r) => new TabListItemUI
			{
				TabName = r.Name + " — " + r.Type
			}).ToList();
		}

		public TabDetailDataUI GetDetail(int selectedIndex, RegistryContext context)
		{
			if (selectedIndex < 0 || selectedIndex >= m_alive.Count)
			{
				return new TabDetailDataUI
				{
					Title = "Roster",
					Description = "No villagers are enrolled in this village yet.\nUse the Add tab to enroll one."
				};
			}
			VillagerRecord villagerRecord = m_alive[selectedIndex];
			return new TabDetailDataUI
			{
				Title = villagerRecord.Name,
				Description = "Type: <color=#FFA13C>" + villagerRecord.Type + "</color>\nStatus: <color=#6FCF6F>Alive</color>"
			};
		}
	}
}
namespace ValheimVillages.UI.Patches
{
	public static class DialogPatches
	{
		[HarmonyPatch(typeof(Character), "GetHoverText")]
		public static class Character_GetHoverText_Patch
		{
			[HarmonyPrefix]
			public static bool Prefix(Character __instance, ref string __result)
			{
				VillagerInteract component = ((Component)__instance).GetComponent<VillagerInteract>();
				if ((Object)(object)component != (Object)null)
				{
					__result = component.GetHoverText();
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		public static class InventoryGui_Hide_Patch
		{
			[HarmonyPostfix]
			public static void Postfix()
			{
				VillagerInteract.OnCraftingUIClosed();
				RegistryInteract.OnCraftingUIClosed();
			}
		}
	}
	[HarmonyPatch]
	public static class VillagerCraftingPatch
	{
		private static CanvasGroup s_craftingCanvasGroup;

		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		[HarmonyPostfix]
		public static void UpdateCraftingPanelPostfix(InventoryGui __instance)
		{
			if (!((Object)(object)__instance.m_crafting == (Object)null) && VillagerTabManager.IsNonCrafterActive)
			{
				if ((Object)(object)s_craftingCanvasGroup == (Object)null)
				{
					s_craftingCanvasGroup = ((Component)__instance.m_crafting).GetComponent<CanvasGroup>() ?? ((Component)__instance.m_crafting).gameObject.AddComponent<CanvasGroup>();
				}
				s_craftingCanvasGroup.interactable = false;
				s_craftingCanvasGroup.blocksRaycasts = false;
				s_craftingCanvasGroup.alpha = 0f;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		[HarmonyPrefix]
		public static void HidePrefix()
		{
			if ((Object)(object)s_craftingCanvasGroup != (Object)null)
			{
				s_craftingCanvasGroup.interactable = true;
				s_craftingCanvasGroup.blocksRaycasts = true;
				s_craftingCanvasGroup.alpha = 1f;
			}
		}
	}
}
namespace ValheimVillages.UI.Panels
{
	[RegisterListPanel("ability", "info")]
	public class AbilityTeachPanel : IListPanelUI, IListPanel
	{
		public string Tag => "ability";

		public string ParentTab => "info";

		public List<TabListItemUI> GetListItems(VillagerBehaviorBridge villager)
		{
			List<TabListItemUI> list = new List<TabListItemUI>();
			Player localPlayer = Player.m_localPlayer;
			foreach (IPlayerAbility item in TaughtAbilities(villager))
			{
				bool flag = (Object)(object)localPlayer != (Object)null && item.HasLearned(localPlayer);
				list.Add(new TabListItemUI
				{
					TabName = (flag ? ("✦ " + item.DisplayName) : ("✦ Learn " + item.DisplayName))
				});
			}
			return list;
		}

		public TabDetailDataUI GetDetail(int index, VillagerBehaviorBridge villager)
		{
			List<IPlayerAbility> list = TaughtAbilities(villager);
			if (index < 0 || index >= list.Count)
			{
				return null;
			}
			IPlayerAbility ability = list[index];
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && ability.HasLearned(localPlayer))
			{
				return new TabDetailDataUI
				{
					Title = ability.DisplayName,
					Description = ability.Description + "\n\nYou have learned this technique."
				};
			}
			return new TabDetailDataUI
			{
				Title = ability.DisplayName,
				Description = ability.Description + "\n\nThe " + villager.VillagerType + " can teach you this.",
				ActionText = "Learn",
				OnAction = delegate
				{
					ability.Learn(Player.m_localPlayer);
				}
			};
		}

		private static List<IPlayerAbility> TaughtAbilities(VillagerBehaviorBridge villager)
		{
			List<IPlayerAbility> list = new List<IPlayerAbility>();
			VillagerDef villagerDef = VillagerRegistry.Get(villager?.VillagerType);
			if (villagerDef?.tags == null)
			{
				return list;
			}
			foreach (string value in TagParser.GetValues(villagerDef.tags, "ability"))
			{
				IAbility ability = AttributeScanner.GetAbility(value);
				if (ability == null)
				{
					throw new InvalidOperationException("Villager '" + villager.VillagerType + "' has tag 'ability:" + value + "' but no ability with id '" + value + "' is registered.");
				}
				if (!(ability is IPlayerAbility item))
				{
					throw new InvalidOperationException("Villager '" + villager.VillagerType + "' tag 'ability:" + value + "' resolves to '" + ability.GetType().Name + "', which is not player-teachable (IPlayerAbility).");
				}
				list.Add(item);
			}
			return list;
		}
	}
	public static class PatrolMapRenderer
	{
		private const int MapSize = 256;

		private const float Padding = 10f;

		private const int WaypointDotRadius = 4;

		private const int AnchorDotRadius = 5;

		private const int PathLineWidth = 2;

		private static readonly Color WildColor = new Color(0.6f, 0.15f, 0.15f, 0.7f);

		private static readonly Color VillageColor = new Color(0.45f, 0.45f, 0.45f, 1f);

		private static readonly Color PathColor = new Color(0.2f, 0.85f, 0.2f, 1f);

		private static readonly Color WaypointColor = new Color(0.1f, 1f, 0.1f, 1f);

		private static readonly Color InactiveWaypointColor = new Color(0.7f, 0.5f, 0.2f, 0.7f);

		private static readonly Color InactivePathColor = new Color(0.5f, 0.35f, 0.15f, 0.4f);

		private static readonly Color AnchorColor = new Color(1f, 0.9f, 0.3f, 1f);

		private static readonly Color PatrollerColor = new Color(0.3f, 0.6f, 1f, 1f);

		private static readonly Color FloodFillColor = new Color(0.45f, 0.45f, 0.45f, 0.95f);

		private static readonly Color GroundTruthColor = new Color(1f, 0.4f, 0.9f, 1f);

		private static readonly Color GroundTruthDotColor = new Color(1f, 0.5f, 0.95f, 0.8f);

		private static readonly Color MinimalPerimeter = new Color(0.92f, 0.85f, 0.6f, 1f);

		private static readonly Color PinOutline = new Color(0.05f, 0.05f, 0.05f, 1f);

		public static Texture2D Render(IReadOnlyList<VillagerWaypoint> waypoints, Vector3 anchorPosition, Vector3? patrollerPosition, List<Vector3> floodFillCells = null, List<Vector3> groundTruthPath = null, float cellSize = 3f, IReadOnlyList<(Vector3 position, Color color)> extraPins = null)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			if (waypoints != null)
			{
				foreach (VillagerWaypoint waypoint in waypoints)
				{
					if (waypoint.Active)
					{
						num++;
					}
				}
			}
			if ((waypoints == null || num < 3) && (floodFillCells == null || floodFillCells.Count == 0) && (groundTruthPath == null || groundTruthPath.Count == 0) && (extraPins == null || extraPins.Count == 0))
			{
				return RenderEmpty();
			}
			ComputeBounds(waypoints, anchorPosition, floodFillCells, groundTruthPath, extraPins, out var min, out var max);
			float num2 = max.x - min.x;
			float num3 = max.y - min.y;
			if (num2 < 1f)
			{
				num2 = 1f;
			}
			if (num3 < 1f)
			{
				num3 = 1f;
			}
			Texture2D val = new Texture2D(256, 256, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)0;
			List<Vector2> polygon = (((floodFillCells == null || floodFillCells.Count <= 0) && waypoints != null) ? BuildActivePolygon2D(waypoints) : new List<Vector2>());
			FillPixels(val, polygon, min, num2, num3);
			if (floodFillCells != null && floodFillCells.Count > 0)
			{
				DrawFloodFillCells(val, floodFillCells, cellSize, min, num2, num3);
			}
			if (waypoints != null)
			{
				DrawPatrolPath(val, waypoints, min, num2, num3);
				DrawDots(val, waypoints, anchorPosition, patrollerPosition, min, num2, num3);
			}
			if (groundTruthPath != null && groundTruthPath.Count >= 2)
			{
				DrawGroundTruthPath(val, groundTruthPath, min, num2, num3);
			}
			else
			{
				Vector2Int center = WorldToPixel(anchorPosition, min, num2, num3);
				DrawCircle(val, center, 5, AnchorColor);
			}
			if (extraPins != null)
			{
				foreach (var extraPin in extraPins)
				{
					Vector2Int center2 = WorldToPixel(extraPin.position, min, num2, num3);
					DrawCircle(val, center2, 5, extraPin.color);
				}
			}
			val.Apply();
			return val;
		}

		public static Texture2D RenderMinimal(IReadOnlyList<Vector3> perimeter, IReadOnlyList<(Vector3 position, Color color)> pins)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: 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_031a: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2> list = new List<Vector2>();
			if (perimeter != null)
			{
				foreach (Vector3 item in perimeter)
				{
					list.Add(new Vector2(item.x, item.z));
				}
			}
			if (pins != null)
			{
				foreach (var pin in pins)
				{
					list.Add(new Vector2(pin.position.x, pin.position.z));
				}
			}
			Texture2D val = new Texture2D(256, 256, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0
			};
			Color[] array = (Color[])(object)new Color[65536];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = Color.clear;
			}
			val.SetPixels(array);
			if (list.Count == 0)
			{
				val.Apply();
				return val;
			}
			float num = list[0].x;
			float num2 = list[0].x;
			float num3 = list[0].y;
			float num4 = list[0].y;
			foreach (Vector2 item2 in list)
			{
				num = Mathf.Min(num, item2.x);
				num2 = Mathf.Max(num2, item2.x);
				num3 = Mathf.Min(num3, item2.y);
				num4 = Mathf.Max(num4, item2.y);
			}
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(num - 10f, num3 - 10f);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(num2 + 10f, num4 + 10f);
			float num5 = val3.x - val2.x;
			float num6 = val3.y - val2.y;
			if (num5 > num6)
			{
				float num7 = (num5 - num6) * 0.5f;
				val2.y -= num7;
				val3.y += num7;
			}
			else if (num6 > num5)
			{
				float num8 = (num6 - num5) * 0.5f;
				val2.x -= num8;
				val3.x += num8;
			}
			float worldW = Mathf.Max(val3.x - val2.x, 1f);
			float worldH = Mathf.Max(val3.y - val2.y, 1f);
			if (perimeter != null && perimeter.Count >= 2)
			{
				for (int j = 0; j < perimeter.Count; j++)
				{
					Vector2Int a = WorldToPixel(perimeter[j], val2, worldW, worldH);
					Vector2Int b = WorldToPixel(perimeter[(j + 1) % perimeter.Count], val2, worldW, worldH);
					DrawLine(val, a, b, MinimalPerimeter, 3);
				}
			}
			if (pins != null)
			{
				foreach (var pin2 in pins)
				{
					Vector2Int center = WorldToPixel(pin2.position, val2, worldW, worldH);
					DrawCircle(val, center, 7, PinOutline);
					DrawCircle(val, center, 5, pin2.color);
				}
			}
			val.Apply();
			return val;
		}

		private static Texture2D RenderEmpty()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(256, 256, (TextureFormat)4, false);
			Color[] array = (Color[])(object)new Color[65536];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = WildColor;
			}
			val.SetPixels(array);
			val.Apply();
			return val;
		}

		private static void ComputeBounds(IReadOnlyList<VillagerWaypoint> waypoints, Vector3 anchor, List<Vector3> floodFillCells, List<Vector3> groundTruthPath, IReadOnlyList<(Vector3 position, Color color)> extraPins, out Vector2 min, out Vector2 max)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			float x = anchor.x;
			float x2 = anchor.x;
			float z = anchor.z;
			float z2 = anchor.z;
			if (waypoints != null)
			{
				for (int i = 0; i < waypoints.Count; i++)
				{
					Vector3 position = waypoints[i].Position;
					if (position.x < x)
					{
						x = position.x;
					}
					if (position.x > x2)
					{
						x2 = position.x;
					}
					if (position.z < z)
					{
						z = position.z;
					}
					if (position.z > z2)
					{
						z2 = position.z;
					}
				}
			}
			if (floodFillCells != null)
			{
				for (int j = 0; j < floodFillCells.Count; j++)
				{
					Vector3 val = floodFillCells[j];
					if (val.x < x)
					{
						x = val.x;
					}
					if (val.x > x2)
					{
						x2 = val.x;
					}
					if (val.z < z)
					{
						z = val.z;
					}
					if (val.z > z2)
					{
						z2 = val.z;
					}
				}
			}
			if (groundTruthPath != null)
			{
				for (int k = 0; k < groundTruthPath.Count; k++)
				{
					Vector3 val2 = groundTruthPath[k];
					if (val2.x < x)
					{
						x = val2.x;
					}
					if (val2.x > x2)
					{
						x2 = val2.x;
					}
					if (val2.z < z)
					{
						z = val2.z;
					}
					if (val2.z > z2)
					{
						z2 = val2.z;
					}
				}
			}
			if (extraPins != null)
			{
				for (int l = 0; l < extraPins.Count; l++)
				{
					Vector3 item = extraPins[l].position;
					if (item.x < x)
					{
						x = item.x;
					}
					if (item.x > x2)
					{
						x2 = item.x;
					}
					if (item.z < z)
					{
						z = item.z;
					}
					if (item.z > z2)
					{
						z2 = item.z;
					}
				}
			}
			min = new Vector2(x - 10f, z - 10f);
			max = new Vector2(x2 + 10f, z2 + 10f);
			float num = max.x - min.x;
			float num2 = max.y - min.y;
			if (num > num2)
			{
				float num3 = (num - num2) * 0.5f;
				min.y -= num3;
				max.y += num3;
			}
			else if (num2 > num)
			{
				float num4 = (num2 - num) * 0.5f;
				min.x -= num4;
				max.x += num4;
			}
		}

		private static List<Vector2> BuildActivePolygon2D(IReadOnlyList<VillagerWaypoint> waypoints)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2> list = new List<Vector2>();
			for (int i = 0; i < waypoints.Count; i++)
			{
				if (waypoints[i].Active)
				{
					list.Add(new Vector2(waypoints[i].Position.x, waypoints[i].Position.z));
				}
			}
			return list;
		}

		private static void FillPixels(Texture2D tex, List<Vector2> polygon, Vector2 min, float worldW, float worldH)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Color[] array = (Color[])(object)new Color[65536];
			for (int i = 0; i < 256; i++)
			{
				for (int j = 0; j < 256; j++)
				{
					float num = min.x + (float)j / 256f * worldW;
					float num2 = min.y + (float)i / 256f * worldH;
					bool flag = polygon.Count >= 3 && PointInPolygon(new Vector2(num, num2), polygon);
					array[i * 256 + j] = (flag ? VillageColor : WildColor);
				}
			}
			tex.SetPixels(array);
		}

		private static void DrawFloodFillCells(Texture2D tex, List<Vector3> cells, float cellSize, Vector2 min, float worldW, float worldH)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			float num = cellSize * 0.85f;
			foreach (Vector3 cell in cells)
			{
				Vector2Int val = WorldToPixel(new Vector3(cell.x - num, 0f, cell.z - num), min, worldW, worldH);
				Vector2Int val2 = WorldToPixel(new Vector3(cell.x + num, 0f, cell.z + num), min, worldW, worldH);
				int num2 = Mathf.Min(((Vector2Int)(ref val)).x, ((Vector2Int)(ref val2)).x);
				int num3 = Mathf.Max(((Vector2Int)(ref val)).x, ((Vector2Int)(ref val2)).x);
				int num4 = Mathf.Min(((Vector2Int)(ref val)).y, ((Vector2Int)(ref val2)).y);
				int num5 = Mathf.Max(((Vector2Int)(ref val)).y, ((Vector2Int)(ref val2)).y);
				for (int i = num4; i <= num5; i++)
				{
					for (int j = num2; j <= num3; j++)
					{
						if (j >= 0 && j < 256 && i >= 0 && i < 256)
						{
							Color pixel = tex.GetPixel(j, i);
							tex.SetPixel(j, i, BlendOver(pixel, FloodFillColor));
						}
					}
				}
			}
		}

		private static void DrawGroundTruthPath(Texture2D tex, List<Vector3> path, Vector2 min, float worldW, float worldH)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < path.Count; i++)
			{
				int index = (i + 1) % path.Count;
				Vector2Int a = WorldToPixel(path[i], min, worldW, worldH);
				Vector2Int b = WorldToPixel(path[index], min, worldW, worldH);
				DrawLine(tex, a, b, GroundTruthColor, 2);
			}
			for (int j = 0; j < path.Count; j++)
			{
				Vector2Int center = WorldToPixel(path[j], min, worldW, worldH);
				DrawCircle(tex, center, 2, GroundTruthDotColor);
			}
		}

		private static void DrawPatrolPath(Texture2D tex, IReadOnlyList<VillagerWaypoint> waypoints, Vector2 min, float worldW, float worldH)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			VillagerWaypoint villagerWaypoint = null;
			int num = -1;
			for (int i = 0; i < waypoints.Count; i++)
			{
				if (waypoints[i].Active)
				{
					if (num < 0)
					{
						num = i;
					}
					if (villagerWaypoint != null)
					{
						Vector2Int a = WorldToPixel(villagerWaypoint.Position, min, worldW, worldH);
						Vector2Int b = WorldToPixel(waypoints[i].Position, min, worldW, worldH);
						DrawLine(tex, a, b, PathColor, 2);
					}
					villagerWaypoint = waypoints[i];
				}
			}
			if (villagerWaypoint != null && num >= 0 && villagerWaypoint != waypoints[num])
			{
				Vector2Int a2 = WorldToPixel(villagerWaypoint.Position, min, worldW, worldH);
				Vector2Int b2 = WorldToPixel(waypoints[num].Position, min, worldW, worldH);
				DrawLine(tex, a2, b2, PathColor, 2);
			}
			for (int j = 0; j < waypoints.Count; j++)
			{
				if (waypoints[j].Active)
				{
					continue;
				}
				int num2 = -1;
				for (int k = 1; k < waypoints.Count; k++)
				{
					int num3 = (j + k) % waypoints.Count;
					if (waypoints[num3].Active)
					{
						num2 = num3;
						break;
					}
				}
				if (num2 >= 0)
				{
					Vector2Int a3 = WorldToPixel(waypoints[j].Position, min, worldW, worldH);
					Vector2Int b3 = WorldToPixel(waypoints[num2].Position, min, worldW, worldH);
					DrawLine(tex, a3, b3, InactivePathColor, 1);
				}
			}
		}

		private static void DrawDots(Texture2D tex, IReadOnlyList<VillagerWaypoint> waypoints, Vector3 anchor, Vector3? patroller, Vector2 min, float worldW, float worldH)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < waypoints.Count; i++)
			{
				if (!waypoints[i].Active)
				{
					Vector2Int center = WorldToPixel(waypoints[i].Position, min, worldW, worldH);
					DrawCircle(tex, center, 3, InactiveWaypointColor);
				}
			}
			for (int j = 0; j < waypoints.Count; j++)
			{
				if (waypoints[j].Active)
				{
					Vector2Int center2 = WorldToPixel(waypoints[j].Position, min, worldW, worldH);
					DrawCircle(tex, center2, 4, WaypointColor);
				}
			}
			Vector2Int center3 = WorldToPixel(anchor, min, worldW, worldH);
			DrawCircle(tex, center3, 5, AnchorColor);
			if (patroller.HasValue)
			{
				Vector2Int center4 = WorldToPixel(patroller.Value, min, worldW, worldH);
				DrawCircle(tex, center4, 5, PatrollerColor);
			}
		}

		private static Vector2Int WorldToPixel(Vector3 world, Vector2 min, float worldW, float worldH)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(Mathf.RoundToInt((world.x - min.x) / worldW * 256f), 0, 255);
			int num2 = Mathf.Clamp(Mathf.RoundToInt((world.z - min.y) / worldH * 256f), 0, 255);
			return new Vector2Int(num, num2);
		}

		private static void DrawCircle(Texture2D tex, Vector2Int center, int radius, Color color)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			int num = radius * radius;
			for (int i = -radius; i <= radius; i++)
			{
				for (int j = -radius; j <= radius; j++)
				{
					if (j * j + i * i <= num)
					{
						int num2 = ((Vector2Int)(ref center)).x + j;
						int num3 = ((Vector2Int)(ref center)).y + i;
						if (num2 >= 0 && num2 < 256 && num3 >= 0 && num3 < 256)
						{
							tex.SetPixel(num2, num3, color);
						}
					}
				}
			}
		}

		private static void DrawLine(Texture2D tex, Vector2Int a, Vector2Int b, Color color, int width)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Abs(((Vector2Int)(ref b)).x - ((Vector2Int)(ref a)).x);
			int num2 = Mathf.Abs(((Vector2Int)(ref b)).y - ((Vector2Int)(ref a)).y);
			int num3 = ((((Vector2Int)(ref a)).x < ((Vector2Int)(ref b)).x) ? 1 : (-1));
			int num4 = ((((Vector2Int)(ref a)).y < ((Vector2Int)(ref b)).y) ? 1 : (-1));
			int num5 = num - num2;
			int num6 = ((Vector2Int)(ref a)).x;
			int num7 = ((Vector2Int)(ref a)).y;
			int num8 = width / 2;
			while (true)
			{
				for (int i = -num8; i <= num8; i++)
				{
					int num9 = num6 + i;
					int num10 = num7 + i;
					if (num9 >= 0 && num9 < 256 && num7 >= 0 && num7 < 256)
					{
						tex.SetPixel(num9, num7, color);
					}
					if (num6 >= 0 && num6 < 256 && num10 >= 0 && num10 < 256)
					{
						tex.SetPixel(num6, num10, color);
					}
				}
				if (num6 != ((Vector2Int)(ref b)).x || num7 != ((Vector2Int)(ref b)).y)
				{
					int num11 = 2 * num5;
					if (num11 > -num2)
					{
						num5 -= num2;
						num6 += num3;
					}
					if (num11 < num)
					{
						num5 += num;
						num7 += num4;
					}
					continue;
				}
				break;
			}
		}

		private static Color BlendOver(Color dst, Color src)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			float num = src.a + dst.a * (1f - src.a);
			if (num < 0.001f)
			{
				return Color.clear;
			}
			return new Color((src.r * src.a + dst.r * dst.a * (1f - src.a)) / num, (src.g * src.a + dst.g * dst.a * (1f - src.a)) / num, (src.b * src.a + dst.b * dst.a * (1f - src.a)) / num, num);
		}

		private static bool PointInPolygon(Vector2 point, List<Vector2> polygon)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			int count = polygon.Count;
			int num = 0;
			int index = count - 1;
			while (num < count)
			{
				Vector2 val = polygon[num];
				Vector2 val2 = polygon[index];
				if (val.y > point.y != val2.y > point.y && point.x < (val2.x - val.x) * (point.y - val.y) / (val2.y - val.y) + val.x)
				{
					flag = !flag;
				}
				index = num++;
			}
			return flag;
		}
	}
	public static class VillageMapPanel
	{
		private static readonly Color GatePinColor = new Color(0.25f, 0.85f, 0.95f, 1f);

		public static Texture2D RenderForTask(VillagerBehaviorBridge villager, IReadOnlyList<(Vector3 position, Color color)> pins)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)villager == (Object)null)
			{
				return null;
			}
			VillagerAI aI = villager.AI;
			if ((Object)(object)aI == (Object)null)
			{
				return null;
			}
			Vector3 homeAnchor = aI.HomeAnchor;
			RegionGraph regionGraph = VillageRegistry.GraphAt(homeAnchor);
			if (regionGraph == null)
			{
				return null;
			}
			List<Vector3> lookupCellCenters = regionGraph.Diagnostics.GetLookupCellCenters();
			IReadOnlyList<VillagerWaypoint> waypoints = aI.GetBehavior<PerimeterPatrolBehavior>()?.PatrolWaypoints;
			Vector3 position = aI.Position;
			return PatrolMapRenderer.Render(waypoints, homeAnchor, position, lookupCellCenters, null, 1f, WithGatePins(villager, pins));
		}

		private static IReadOnlyList<(Vector3 position, Color color)> WithGatePins(VillagerBehaviorBridge villager, IReadOnlyList<(Vector3 position, Color color)> pins)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = VillageRegistry.GraphAt(villager.AI?.HomeAnchor ?? Vector3.zero)?.GetGates();
			if (list == null || list.Count == 0)
			{
				return pins;
			}
			List<(Vector3, Color)> list2 = new List<(Vector3, Color)>();
			if (pins != null)
			{
				list2.AddRange(pins);
			}
			foreach (Vector3 item in list)
			{
				list2.Add((item, GatePinColor));
			}
			return list2;
		}
	}
}
namespace ValheimVillages.UI.Interaction
{
	public class RegistryInteract : MonoBehaviour, Hoverable, Interactable
	{
		private Piece m_piece;

		public static RegistryInteract ActiveRegistry { get; private set; }

		private void Awake()
		{
			m_piece = ((Component)this).GetComponent<Piece>();
		}

		public string GetHoverName()
		{
			if (!((Object)(object)m_piece != (Object)null) || string.IsNullOrEmpty(m_piece.m_name))
			{
				return "Village Registry";
			}
			return m_piece.m_name;
		}

		public string GetHoverText()
		{
			return Localization.instance.Localize(GetHoverName() + "\n[<color=yellow><b>$KEY_Use</b></color>] Manage");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (hold)
			{
				return false;
			}
			Player val = (Player)(object)((user is Player) ? user : null);
			if (val == null)
			{
				return false;
			}
			CraftingStation component = ((Component)this).GetComponent<CraftingStation>();
			if ((Object)(object)component == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"RegistryInteract: no CraftingStation on registry piece");
				}
				return false;
			}
			if ((Object)(object)InventoryGui.instance == (Object)null)
			{
				return false;
			}
			val.SetCraftingStation(component);
			InventoryGui.instance.Show((Container)null, 3);
			RegistryTabManager.Activate(new RegistryContext(((Component)this).transform.position, ResolveVillageId()));
			ActiveRegistry = this;
			return true;
		}

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

		private string ResolveVillageId()
		{
			ZNetView component = ((Component)this).GetComponent<ZNetView>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = component.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("vv_village_id", "") : null);
			}
			string text = (string)obj;
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogError((object)"[RegistryInteract] registry piece has no vv_village_id (it should be stamped at placement); opening with no village. Village state is inconsistent — investigate.");
			}
			return null;
		}

		public static void OnCraftingUIClosed()
		{
			if (!((Object)(object)ActiveRegistry == (Object)null))
			{
				RegistryTabManager.Deactivate();
				ActiveRegistry = null;
			}
		}
	}
	public class VillagerBehaviorBridge : MonoBehaviour
	{
		public ValheimVillages.Villager.Villager villagerInstance;

		private VillagerAI m_cachedAI;

		private float m_lastLookupTime;

		public VillagerMemory Memory => villagerInstance.villagerAI.GetMemory();

		public BehaviorState CurrentState => villagerInstance.villagerAI?.CurrentState ?? BehaviorState.Idle;

		public VillagerWaypoint CurrentWaypoint => villagerInstance.villagerAI.GetCurrentWaypoint();

		public string UniqueId => villagerInstance.uid;

		public VillagerAI AI => villagerInstance?.villagerAI;

		public string VillagerType => villagerInstance?.villagerType ?? "";

		public void Initialize(string uniqueId)
		{
		}

		public void SetPaused(bool paused)
		{
			villagerInstance.villagerAI?.SetPaused(paused);
		}
	}
	public class VillagerInteract : MonoBehaviour, Hoverable, Interactable
	{
		private VillagerBehaviorBridge m_bridge;

		private Character m_character;

		private Humanoid m_humanoid;

		private bool m_resolved;

		public static VillagerInteract ActiveCraftingVillager { get; private set; }

		private VillagerBehaviorBridge Bridge
		{
			get
			{
				if ((Object)(object)m_bridge == (Object)null && !m_resolved)
				{
					m_bridge = ((Component)this).GetComponent<VillagerBehaviorBridge>();
					m_resolved = true;
				}
				return m_bridge;
			}
		}

		private void Awake()
		{
			m_character = ((Component)this).GetComponent<Character>();
			m_humanoid = ((Component)this).GetComponent<Humanoid>();
		}

		public string GetHoverName()
		{
			if ((Object)(object)m_humanoid != (Object)null)
			{
				return ((Character)m_humanoid).m_name;
			}
			if ((Object)(object)m_character != (Object)null)
			{
				return m_character.GetHoverName();
			}
			return "Villager";
		}

		public string GetHoverText()
		{
			string hoverName = GetHoverName();
			string stateInfo = GetStateInfo();
			return Localization.instance.Localize(hoverName + "\n" + stateInfo + "\n[<color=yellow><b>$KEY_Use</b></color>] Talk");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold)
			{
				return false;
			}
			Player val = (Player)(object)((user is Player) ? user : null);
			if (val == null)
			{
				return false;
			}
			if ((Object)(object)Bridge == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"VillagerInteract: No VillagerBehaviorBridge component found");
				}
				((Character)val).Message((MessageType)2, "This villager cannot be inspected", 0, (Sprite)null);
				return false;
			}
			VillagerStation component = ((Component)this).GetComponent<VillagerStation>();
			if ((Object)(object)component?.Station != (Object)null)
			{
				return OpenCraftingUI(val, component);
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogWarning((object)("VillagerInteract: " + GetHoverName() + " has no VillagerStation"));
			}
			return false;
		}

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

		private string GetStateInfo()
		{
			if ((Object)(object)Bridge == (Object)null)
			{
				return "";
			}
			VillagerAI villagerAI = Bridge.villagerInstance.villagerAI;
			if ((Object)(object)villagerAI == (Object)null)
			{
				return "";
			}
			CraftingBehaviorAdapter craftingBehavior = villagerAI.CraftingBehavior;
			bool flag = craftingBehavior != null && craftingBehavior.Crafting?.IsWorking == true;
			BehaviorState currentState = villagerAI.CurrentState;
			string text;
			if (currentState != BehaviorState.Wandering)
			{
				if (currentState != BehaviorState.Traveling || flag)
				{
					goto IL_0092;
				}
				text = "Idle";
			}
			else
			{
				if (flag)
				{
					goto IL_0092;
				}
				text = "Idle";
			}
			goto IL_00a9;
			IL_00a9:
			string text2 = text;
			return "<color=grey>" + text2 + "</color>";
			IL_0092:
			text = villagerAI.CurrentState.ToString();
			goto IL_00a9;
		}

		private bool OpenCraftingUI(Player player, VillagerStation villagerStation)
		{
			CraftingStation station = villagerStation.Station;
			Bridge?.SetPaused(paused: true);
			ActiveCraftingVillager = this;
			player.SetCraftingStation(station);
			InventoryGui.instance.Show((Container)null, 3);
			VillagerBehaviorBridge bridge = Bridge;
			bool flag = bridge != null && bridge.villagerInstance.villagerType != null && VillagerStation.HasCraftingRecipes(bridge.villagerInstance.villagerType);
			VillagerTabManager.Activate(Bridge, flag);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("VillagerInteract: Opened UI for " + GetHoverName() + " " + $"(station: {station.m_name}, crafting: {flag})"));
			}
			return true;
		}

		public static void OnCraftingUIClosed()
		{
			if (!((Object)(object)ActiveCraftingVillager == (Object)null))
			{
				VillagerTabManager.Deactivate();
				ActiveCraftingVillager.Bridge?.SetPaused(paused: false);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"VillagerInteract: Crafting UI closed, resuming NPC");
				}
				ActiveCraftingVillager = null;
			}
		}
	}
}
namespace ValheimVillages.UI.ContextMenus
{
	[RegisterModObject("WorkOrderMenu")]
	public class WorkOrderMenu : MonoBehaviour
	{
		private enum Focus
		{
			Delete,
			Back,
			MinSlider,
			MaxSlider
		}

		private const int MinQuota = 1;

		private const int MaxQuota = 9999;

		private static WorkOrderMenu s_instance;

		private ItemData m_currentItem;

		private Image m_iconImage;

		private string m_itemDisplay = "";

		private GameObject m_itemLabel;

		private InputField m_maxInput;

		private Slider m_maxSlider;

		private int m_maximum = 10;

		private InputField m_minInput;

		private Slider m_minSlider;

		private int m_minimum = 1;

		private GameObject m_panelRoot;

		private string m_stationDisplay = "";

		private GameObject m_stationLabel;

		private GameObject m_currentLabel;

		private GameObject m_statusLabel;

		private bool m_updatingUI;

		private bool m_visible;

		private GameObject m_backButton;

		private GameObject m_deleteButton;

		private Focus m_focus = Focus.MinSlider;

		private GameObject m_focusBorder;

		private RectTransform m_lastBorderTarget;

		private bool m_ignoreXUntilReleased;

		private const float MinWidth = 340f;

		private const float MinHeight = 320f;

		private static readonly Color FocusBorderColor = new Color(1f, 0.78f, 0.28f, 0.95f);

		private const string ValueColor = "#FFA13C";

		private const string NoteColor = "#FFE300";

		public static bool IsVisible
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null)
				{
					return s_instance.m_visible;
				}
				return false;
			}
		}

		public static bool IsEditingText
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null && s_instance.m_visible)
				{
					if (!((Object)(object)s_instance.m_minInput != (Object)null) || !s_instance.m_minInput.isFocused)
					{
						if ((Object)(object)s_instance.m_maxInput != (Object)null)
						{
							return s_instance.m_maxInput.isFocused;
						}
						return false;
					}
					return true;
				}
				return false;
			}
		}

		public static void Show(ItemData item)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || !InventoryGui.IsVisible())
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Open a chest to configure this work order", 0, (Sprite)null);
				}
				return;
			}
			CleanupStaleInstances();
			if ((Object)(object)s_instance == (Object)null)
			{
				s_instance = new GameObject("WorkOrderMenu").AddComponent<WorkOrderMenu>();
			}
			s_instance.m_currentItem = item;
			s_instance.LoadFromItem(item);
			s_instance.EnsurePanel(instance);
			s_instance.SyncUIFromData();
			s_instance.PositionPanel(instance);
			s_instance.m_panelRoot.SetActive(true);
			s_instance.m_visible = true;
			s_instance.m_focus = Focus.MinSlider;
			s_instance.m_ignoreXUntilReleased = true;
			s_instance.m_lastBorderTarget = null;
		}

		public static void Hide()
		{
			if (!((Object)(object)s_instance == (Object)null))
			{
				s_instance.SaveToItem();
				s_instance.m_visible = false;
				s_instance.m_currentItem = null;
				if ((Object)(object)s_instance.m_panelRoot != (Object)null)
				{
					s_instance.m_panelRoot.SetActive(false);
				}
			}
		}

		private void Update()
		{
			if (!m_visible)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)9))
			{
				Hide();
				return;
			}
			if (ZInput.IsGamepadActive())
			{
				RouteActionButton();
				HandleNav();
			}
			if (!HandleActivate())
			{
				UpdateFocusVisual();
			}
		}

		private bool HandleActivate()
		{
			if (m_focus != Focus.Delete && m_focus != Focus.Back)
			{
				return false;
			}
			if (!ZInput.GetButtonDown("JoyButtonA") && !Input.GetKeyDown((KeyCode)101))
			{
				return false;
			}
			if (m_focus == Focus.Delete)
			{
				DeleteOrder();
			}
			else
			{
				Hide();
			}
			return true;
		}

		private void RouteActionButton()
		{
			if (m_ignoreXUntilReleased)
			{
				if (!ZInput.GetButton("JoyButtonX"))
				{
					m_ignoreXUntilReleased = false;
				}
				SetButtonGamepad(m_deleteButton, enabled: false);
				SetButtonGamepad(m_backButton, enabled: false);
			}
			else
			{
				bool flag = m_focus == Focus.Delete;
				SetButtonGamepad(m_deleteButton, flag);
				SetButtonGamepad(m_backButton, !flag);
			}
		}

		private static void SetButtonGamepad(GameObject button, bool enabled)
		{
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			UIGamePad component = button.GetComponent<UIGamePad>();
			if (!((Object)(object)component == (Object)null))
			{
				if (((Behaviour)component).enabled != enabled)
				{
					((Behaviour)component).enabled = enabled;
				}
				if (!enabled && (Object)(object)component.m_hint != (Object)null)
				{
					component.m_hint.SetActive(false);
				}
			}
		}

		private void HandleNav()
		{
			bool flag = ZInput.GetButtonDown("JoyLStickUp") || ZInput.GetButtonDown("JoyDPadUp");
			bool flag2 = ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyDPadDown");
			bool flag3 = ZInput.GetButtonDown("JoyLStickLeft") || ZInput.GetButtonDown("JoyDPadLeft");
			bool flag4 = ZInput.GetButtonDown("JoyLStickRight") || ZInput.GetButtonDown("JoyDPadRight");
			switch (m_focus)
			{
			case Focus.Delete:
				if (flag4)
				{
					m_focus = Focus.Back;
				}
				else if (flag2)
				{
					m_focus = Focus.MinSlider;
				}
				break;
			case Focus.Back:
				if (flag3)
				{
					m_focus = Focus.Delete;
				}
				else if (flag2)
				{
					m_focus = Focus.MinSlider;
				}
				break;
			case Focus.MinSlider:
				if (flag)
				{
					m_focus = Focus.Back;
				}
				else if (flag2)
				{
					m_focus = Focus.MaxSlider;
				}
				else if (flag3)
				{
					AdjustSlider(-1);
				}
				else if (flag4)
				{
					AdjustSlider(1);
				}
				break;
			case Focus.MaxSlider:
				if (flag)
				{
					m_focus = Focus.MinSlider;
				}
				else if (flag3)
				{
					AdjustSlider(-1);
				}
				else if (flag4)
				{
					AdjustSlider(1);
				}
				break;
			}
		}

		private void DeleteOrder()
		{
			ItemData currentItem = m_currentItem;
			m_visible = false;
			m_currentItem = null;
			if ((Object)(object)m_panelRoot != (Object)null)
			{
				m_panelRoot.SetActive(false);
			}
			if (currentItem == null)
			{
				return;
			}
			Inventory val = FindInventory(currentItem);
			if (val != null && val.RemoveItem(currentItem))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Work order removed", 0, (Sprite)null);
				}
			}
		}

		private static Inventory FindInventory(ItemData item)
		{
			Player localPlayer = Player.m_localPlayer;
			Inventory val = ((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null);
			if (val != null && val.ContainsItem(item))
			{
				return val;
			}
			InventoryGui instance = InventoryGui.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				InventoryGrid containerGrid = instance.ContainerGrid;
				obj = ((containerGrid != null) ? containerGrid.GetInventory() : null);
			}
			Inventory val2 = (Inventory)obj;
			if (val2 != null && val2.ContainsItem(item))
			{
				return val2;
			}
			return null;
		}

		private void AdjustSlider(int delta)
		{
			Slider val = ((m_focus == Focus.MinSlider) ? m_minSlider : m_maxSlider);
			if (!((Object)(object)val == (Object)null))
			{
				val.value = Mathf.Clamp(Mathf.RoundToInt(val.value) + delta, Mathf.RoundToInt(val.minValue), Mathf.RoundToInt(val.maxValue));
			}
		}

		private RectTransform FocusTarget()
		{
			return (RectTransform)(m_focus switch
			{
				Focus.Delete => (object)(((Object)(object)m_deleteButton != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null), 
				Focus.Back => (object)(((Object)(object)m_backButton != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null), 
				Focus.MinSlider => (object)(((Object)(object)m_minSlider != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null), 
				Focus.MaxSlider => (object)(((Object)(object)m_maxSlider != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null), 
				_ => null, 
			});
		}

		private void UpdateFocusVisual()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_focusBorder == (Object)null)
			{
				return;
			}
			RectTransform val = FocusTarget();
			if ((Object)(object)val == (Object)null || !ZInput.IsGamepadActive())
			{
				if (m_focusBorder.activeSelf)
				{
					m_focusBorder.SetActive(false);
				}
				return;
			}
			if ((Object)(object)val != (Object)(object)m_lastBorderTarget)
			{
				m_lastBorderTarget = val;
				RectTransform component = m_focusBorder.GetComponent<RectTransform>();
				((Transform)component).SetParent((Transform)(object)val, false);
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
				((Transform)component).SetAsLastSibling();
			}
			if (!m_focusBorder.activeSelf)
			{
				m_focusBorder.SetActive(true);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)m_panelRoot != (Object)null)
			{
				Object.Destroy((Object)(object)m_panelRoot);
			}
		}

		private static void CleanupStaleInstances()
		{
			WorkOrderMenu[] array = Object.FindObjectsOfType<WorkOrderMenu>();
			foreach (WorkOrderMenu workOrderMenu in array)
			{
				if ((Object)(object)workOrderMenu != (Object)(object)s_instance)
				{
					Object.Destroy((Object)(object)((Component)workOrderMenu).gameObject);
				}
			}
		}

		private void LoadFromItem(ItemData item)
		{
			string data = GetData(item, "wo_station", "Unknown");
			m_stationDisplay = FormatStationName(data);
			m_minimum = ((!int.TryParse(GetData(item, "wo_min", "1"), out var result)) ? 1 : result);
			m_maximum = (int.TryParse(GetData(item, "wo_max", "10"), out var result2) ? result2 : 10);
			string data2 = GetData(item, "wo_item_name", "");
			m_itemDisplay = (string.IsNullOrEmpty(data2) ? "Not set" : Localization.instance.Localize(data2));
		}

		private void SaveToItem()
		{
			if (m_currentItem != null)
			{
				if (m_currentItem.m_customData == null)
				{
					m_currentItem.m_customData = new Dictionary<string, string>();
				}
				m_currentItem.m_customData["wo_min"] = m_minimum.ToString();
				m_currentItem.m_customData["wo_max"] = m_maximum.ToString();
				m_currentItem.m_customData["wo_range"] = $"{m_minimum}-{m_maximum}";
				if (m_currentItem.m_shared != null)
				{
					m_currentItem.m_shared.m_description = $"{m_itemDisplay} ({m_minimum}-{m_maximum})" + "\nRight-click to change settings.";
				}
			}
		}

		private static string GetData(ItemData item, string key, string fallback)
		{
			if (item?.m_customData != null && item.m_customData.TryGetValue(key, out var value))
			{
				return value;
			}
			return fallback;
		}

		private static string FormatStationName(string raw)
		{
			return StationDisplay.Pretty(raw);
		}

		private void EnsurePanel(InventoryGui gui)
		{
			//IL_0034: 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_007a: Expected O, but got Unknown
			//IL_007a: Expected O, but got Unknown
			if (!((Object)(object)m_panelRoot != (Object)null))
			{
				Canvas componentInParent = ((Component)gui).GetComponentInParent<Canvas>();
				WorkOrderMenuElements workOrderMenuElements = WorkOrderMenuBuilder.Build(((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).transform : ((Component)gui).transform, new UnityAction(Hide), new UnityAction(DeleteOrder), OnMinSliderChanged, OnMaxSliderChanged, OnMinInputEnd, OnMaxInputEnd);
				m_panelRoot = workOrderMenuElements.Root;
				m_backButton = workOrderMenuElements.BackButton;
				m_deleteButton = workOrderMenuElements.DeleteButton;
				m_iconImage = workOrderMenuElements.IconImage;
				m_minSlider = workOrderMenuElements.MinSlider;
				m_minInput = workOrderMenuElements.MinInput;
				m_maxSlider = workOrderMenuElements.MaxSlider;
				m_maxInput = workOrderMenuElements.MaxInput;
				m_stationLabel = workOrderMenuElements.StationLabel;
				m_itemLabel = workOrderMenuElements.ItemLabel;
				m_currentLabel = workOrderMenuElements.CurrentLabel;
				m_statusLabel = workOrderMenuElements.StatusLabel;
				m_focusBorder = CreateFocusBorder(m_panelRoot.transform);
				(m_panelRoot.GetComponent<UIGroupHandler>() ?? m_panelRoot.AddComponent<UIGroupHandler>()).m_groupPriority = 10000;
				CanvasGroup obj = m_panelRoot.GetComponent<CanvasGroup>() ?? m_panelRoot.AddComponent<CanvasGroup>();
				obj.ignoreParentGroups = true;
				obj.interactable = true;
				obj.blocksRaycasts = true;
			}
		}

		private static GameObject CreateFocusBorder(Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			GameObject val = new GameObject("VV_FocusBorder", new Type[1] { typeof(RectTransform) });
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			AddFocusEdge((Transform)(object)component, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 3f));
			AddFocusEdge((Transform)(object)component, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 3f));
			AddFocusEdge((Transform)(object)component, new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(3f, 0f));
			AddFocusEdge((Transform)(object)component, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(3f, 0f));
			val.SetActive(false);
			return val;
		}

		private static void AddFocusEdge(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeDelta)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Edge", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = sizeDelta;
			component.anchoredPosition = Vector2.zero;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = FocusBorderColor;
			((Graphic)component2).raycastTarget = false;
		}

		private void PositionPanel(InventoryGui gui)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_panelRoot == (Object)null))
			{
				RectTransform player = gui.m_player;
				if (!((Object)(object)player == (Object)null))
				{
					RectTransform component = m_panelRoot.GetComponent<RectTransform>();
					((Transform)component).SetParent((Transform)(object)player, false);
					(m_panelRoot.GetComponent<LayoutElement>() ?? m_panelRoot.AddComponent<LayoutElement>()).ignoreLayout = true;
					Rect rect = player.rect;
					Vector2 size = ((Rect)(ref rect)).size;
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(0.5f, 0.5f);
					component.anchorMax = val;
					component.anchorMin = val;
					component.pivot = new Vector2(0.5f, 0.5f);
					component.anchoredPosition = Vector2.zero;
					component.sizeDelta = new Vector2(Mathf.Max(size.x, 340f) + 20f, Mathf.Max(size.y, 320f) + 20f);
					((Transform)component).SetAsLastSibling();
				}
			}
		}

		private void SyncUIFromData()
		{
			m_updatingUI = true;
			SetLabel(m_stationLabel, "Station: <color=#FFA13C>" + m_stationDisplay + "</color>");
			if ((Object)(object)m_iconImage != (Object)null)
			{
				Sprite[] array = m_currentItem?.m_shared?.m_icons;
				Sprite val = ((array != null && array.Length != 0) ? array[0] : null);
				m_iconImage.sprite = val;
				((Behaviour)m_iconImage).enabled = (Object)(object)val != (Object)null;
			}
			if ((Object)(object)m_minSlider != (Object)null)
			{
				m_minSlider.value = m_minimum;
			}
			if ((Object)(object)m_minInput != (Object)null)
			{
				m_minInput.text = m_minimum.ToString();
			}
			if ((Object)(object)m_maxSlider != (Object)null)
			{
				m_maxSlider.value = m_maximum;
			}
			if ((Object)(object)m_maxInput != (Object)null)
			{
				m_maxInput.text = m_maximum.ToString();
			}
			RefreshDynamicLabels();
			UpdateStatusAndCurrent();
			m_updatingUI = false;
		}

		private void UpdateStatusAndCurrent()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 scanPos = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			WorkOrderDiagnostics.Status status = WorkOrderDiagnostics.Describe(m_currentItem, scanPos);
			SetLabel(m_currentLabel, string.Format("Current Quantity: <color={0}>{1}</color>", "#FFA13C", status.CurrentCount));
			if (string.IsNullOrEmpty(status.Message))
			{
				SetLabel(m_statusLabel, "");
				return;
			}
			string text = status.Severity switch
			{
				WorkOrderDiagnostics.Severity.Warning => "#E8643C", 
				WorkOrderDiagnostics.Severity.Good => "#6FCF6F", 
				_ => "#FFFFFF", 
			};
			SetLabel(m_statusLabel, "<color=" + text + ">" + status.Message + "</color>");
		}

		private void RefreshDynamicLabels()
		{
			SetLabel(m_itemLabel, "Item: <color=#FFA13C>" + m_itemDisplay + "</color> " + string.Format("(Quota: <color={0}>{1}-{2}</color>)", "#FFE300", m_minimum, m_maximum));
		}

		private static void SetLabel(GameObject go, string text)
		{
			if (!((Object)(object)go == (Object)null))
			{
				VillagerUIFactory.SetTMPText(go, text);
			}
		}

		private void OnMinSliderChanged(float value)
		{
			if (!m_updatingUI)
			{
				m_minimum = Mathf.Clamp((int)value, 1, 9999);
				if (m_minimum > m_maximum)
				{
					m_maximum = m_minimum;
				}
				m_updatingUI = true;
				if ((Object)(object)m_minInput != (Object)null)
				{
					m_minInput.text = m_minimum.ToString();
				}
				if ((Object)(object)m_maxSlider != (Object)null)
				{
					m_maxSlider.value = m_maximum;
				}
				if ((Object)(object)m_maxInput != (Object)null)
				{
					m_maxInput.text = m_maximum.ToString();
				}
				RefreshDynamicLabels();
				m_updatingUI = false;
			}
		}

		private void OnMaxSliderChanged(float value)
		{
			if (!m_updatingUI)
			{
				m_maximum = Mathf.Clamp((int)value, 1, 9999);
				if (m_maximum < m_minimum)
				{
					m_minimum = m_maximum;
				}
				m_updatingUI = true;
				if ((Object)(object)m_maxInput != (Object)null)
				{
					m_maxInput.text = m_maximum.ToString();
				}
				if ((Object)(object)m_minSlider != (Object)null)
				{
					m_minSlider.value = m_minimum;
				}
				if ((Object)(object)m_minInput != (Object)null)
				{
					m_minInput.text = m_minimum.ToString();
				}
				RefreshDynamicLabels();
				m_updatingUI = false;
			}
		}

		private void OnMinInputEnd(string text)
		{
			if (!m_updatingUI && int.TryParse(text, out var result))
			{
				m_minimum = Mathf.Clamp(result, 1, 9999);
				if (m_minimum > m_maximum)
				{
					m_maximum = m_minimum;
				}
				m_updatingUI = true;
				if ((Object)(object)m_minSlider != (Object)null)
				{
					m_minSlider.value = m_minimum;
				}
				if ((Object)(object)m_minInput != (Object)null)
				{
					m_minInput.text = m_minimum.ToString();
				}
				if ((Object)(object)m_maxSlider != (Object)null)
				{
					m_maxSlider.value = m_maximum;
				}
				if ((Object)(object)m_maxInput != (Object)null)
				{
					m_maxInput.text = m_maximum.ToString();
				}
				RefreshDynamicLabels();
				m_updatingUI = false;
			}
		}

		private void OnMaxInputEnd(string text)
		{
			if (!m_updatingUI && int.TryParse(text, out var result))
			{
				m_maximum = Mathf.Clamp(result, 1, 9999);
				if (m_maximum < m_minimum)
				{
					m_minimum = m_maximum;
				}
				m_updatingUI = true;
				if ((Object)(object)m_maxSlider != (Object)null)
				{
					m_maxSlider.value = m_maximum;
				}
				if ((Object)(object)m_maxInput != (Object)null)
				{
					m_maxInput.text = m_maximum.ToString();
				}
				if ((Object)(object)m_minSlider != (Object)null)
				{
					m_minSlider.value = m_minimum;
				}
				if ((Object)(object)m_minInput != (Object)null)
				{
					m_minInput.text = m_minimum.ToString();
				}
				RefreshDynamicLabels();
				m_updatingUI = false;
			}
		}
	}
	public struct WorkOrderMenuElements
	{
		public GameObject Root;

		public GameObject BackButton;

		public GameObject DeleteButton;

		public Image IconImage;

		public Slider MinSlider;

		public InputField MinInput;

		public Slider MaxSlider;

		public InputField MaxInput;

		public GameObject StationLabel;

		public GameObject ItemLabel;

		public GameObject CurrentLabel;

		public GameObject StatusLabel;
	}
	public static class WorkOrderMenuBuilder
	{
		private const int MinQuota = 1;

		private const int SliderMax = 100;

		private const float PanelWidth = 340f;

		private const float PanelHeight = 360f;

		private const float RowHeight = 34f;

		private static readonly Color HeaderText = Color.white;

		private const float HeaderSize = 18f;

		private const float LabelSize = 16f;

		public static WorkOrderMenuElements Build(Transform parent, UnityAction onBack, UnityAction onDelete, UnityAction<float> onMinSlider, UnityAction<float> onMaxSlider, UnityAction<string> onMinInput, UnityAction<string> onMaxInput)
		{
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: 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_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			(GameObject root, Transform content) tuple = VillagerUIFactory.CreateDockedPanel(parent, "Work Order", 340f, 360f);
			GameObject item = tuple.root;
			Transform item2 = tuple.content;
			WorkOrderMenuElements result = new WorkOrderMenuElements
			{
				Root = item
			};
			Button val = VillagerUIFactory.CreateButton(item.transform, "Back", onBack);
			Vector2 val2 = default(Vector2);
			if ((Object)(object)val != (Object)null)
			{
				(((Component)val).GetComponent<LayoutElement>() ?? ((Component)val).gameObject.AddComponent<LayoutElement>()).ignoreLayout = true;
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				((Vector2)(ref val2))..ctor(1f, 1f);
				component.anchorMax = val2;
				component.anchorMin = val2;
				component.pivot = new Vector2(1f, 1f);
				component.sizeDelta = new Vector2(120f, 38f);
				component.anchoredPosition = new Vector2(-26f, -16f);
				result.BackButton = ((Component)val).gameObject;
			}
			Button val3 = VillagerUIFactory.CreateButton(item.transform, "Delete Order", onDelete);
			if ((Object)(object)val3 != (Object)null)
			{
				(((Component)val3).GetComponent<LayoutElement>() ?? ((Component)val3).gameObject.AddComponent<LayoutElement>()).ignoreLayout = true;
				RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
				((Vector2)(ref val2))..ctor(0f, 1f);
				component2.anchorMax = val2;
				component2.anchorMin = val2;
				component2.pivot = new Vector2(0f, 1f);
				component2.sizeDelta = new Vector2(140f, 38f);
				component2.anchoredPosition = new Vector2(26f, -16f);
				result.DeleteButton = ((Component)val3).gameObject;
			}
			GameObject val4 = VillagerUIFactory.CreateHorizontalGroup(item2, 12f, 46f, forceExpandWidth: false);
			result.IconImage = VillagerUIFactory.CreateIcon(val4.transform, 50f);
			GameObject val5 = VillagerUIFactory.CreateVerticalGroup(val4.transform, 4f);
			result.StationLabel = VillagerUIFactory.CreateLabel(val5.transform, "Station: ---", 18f, HeaderText);
			result.ItemLabel = VillagerUIFactory.CreateLabel(val5.transform, "Item: ---", 18f, HeaderText);
			VillagerUIFactory.CreateDivider(item2);
			VillagerUIFactory.CreateLabel(item2, "Minimum Quantity:", 16f, HeaderText);
			GameObject val6 = VillagerUIFactory.CreateHorizontalGroup(item2, 8f, 34f, forceExpandWidth: false);
			result.MinSlider = VillagerUIFactory.CreateSlider(val6.transform, 1f, 100f, wholeNumbers: true, onMinSlider);
			result.MinInput = VillagerUIFactory.CreateInputField(val6.transform, "1", onMinInput);
			VillagerUIFactory.CreateSpacer(item2, 4f);
			VillagerUIFactory.CreateLabel(item2, "Maximum Quantity:", 16f, HeaderText);
			GameObject val7 = VillagerUIFactory.CreateHorizontalGroup(item2, 8f, 34f, forceExpandWidth: false);
			result.MaxSlider = VillagerUIFactory.CreateSlider(val7.transform, 1f, 100f, wholeNumbers: true, onMaxSlider);
			result.MaxInput = VillagerUIFactory.CreateInputField(val7.transform, "10", onMaxInput);
			VillagerUIFactory.CreateSpacer(item2, 4f);
			result.CurrentLabel = VillagerUIFactory.CreateLabel(item2, "Current Quantity:", 16f, HeaderText);
			VillagerUIFactory.CreateFlexibleSpacer(item2);
			VillagerUIFactory.CreateDivider(item2);
			result.StatusLabel = VillagerUIFactory.CreateLabel(item2, "", 16f, HeaderText);
			return result;
		}
	}
}
namespace ValheimVillages.UI.Core
{
	public interface IVillagerTab
	{
		string TabName { get; }

		void OnDeselected();
	}
	public abstract class CraftingTabHostBase<TSubject> : MonoBehaviour
	{
		private const float UpdateInterval = 1f;

		private readonly Dictionary<Transform, bool> m_childSnapshot = new Dictionary<Transform, bool>();

		private readonly List<GameObject> m_clonedButtons = new List<GameObject>();

		private readonly List<GameObject> m_triggerHints = new List<GameObject>();

		private readonly List<GameObject> m_listElements = new List<GameObject>();

		protected readonly List<ITabContent<TSubject>> m_tabs = new List<ITabContent<TSubject>>();

		protected bool m_active;

		protected int m_firstCustomTabIndex;

		protected bool m_hasCraftingRecipes;

		protected float m_lastUpdateTime;

		protected string m_headerName;

		private GameObject m_mapImageObject;

		private int m_selectedListIndex = -1;

		protected TabHandler m_tabHandler;

		private const string ListItemPrefix = "VV_ListItem_";

		private Vector2? m_savedListRootAnchorMax;

		private Vector2? m_savedListRootAnchorMin;

		private Vector2? m_savedListRootPivot;

		private GameObject m_actionButton;

		private static readonly HashSet<string> s_craftingChildrenToHide = new HashSet<string>();

		protected abstract TSubject CurrentSubject { get; }

		protected abstract bool HasSubject { get; }

		protected virtual void Update()
		{
			if (!m_active || !HasSubject)
			{
				return;
			}
			int customIndex = GetCustomIndex();
			if (customIndex >= 0)
			{
				HandleCustomListGamepadNav();
			}
			if (!(Time.time - m_lastUpdateTime <= 1f))
			{
				m_lastUpdateTime = Time.time;
				if (customIndex >= 0)
				{
					m_tabs[customIndex].OnUpdate(CurrentSubject);
					RefreshCustomContent(customIndex);
				}
			}
		}

		private void HandleCustomListGamepadNav()
		{
			int count = m_listElements.Count;
			if (count == 0)
			{
				return;
			}
			int num;
			if (ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyDPadDown"))
			{
				num = 1;
			}
			else
			{
				if (!ZInput.GetButtonDown("JoyLStickUp") && !ZInput.GetButtonDown("JoyDPadUp"))
				{
					return;
				}
				num = -1;
			}
			int num2 = Mathf.Clamp(Mathf.Max(m_selectedListIndex, 0) + num, 0, count - 1);
			if (num2 != m_selectedListIndex)
			{
				OnListItemClicked(num2);
			}
		}

		protected virtual void LateUpdate()
		{
			if (!m_active || !HasSubject)
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if ((Object)(object)instance.m_tabCraft != (Object)null)
			{
				((Component)instance.m_tabCraft).gameObject.SetActive(false);
			}
			if ((Object)(object)instance.m_tabUpgrade != (Object)null)
			{
				((Component)instance.m_tabUpgrade).gameObject.SetActive(false);
			}
			bool active = ZInput.IsGamepadActive();
			foreach (GameObject triggerHint in m_triggerHints)
			{
				if ((Object)(object)triggerHint != (Object)null)
				{
					triggerHint.SetActive(active);
				}
			}
			int customIndex = GetCustomIndex();
			if (customIndex >= 0)
			{
				SuppressNativeRecipeElements(instance);
				UpdateSelectionVisuals();
				CraftingStationPatch.HideWorkOrderButton();
				PopulateDescription(instance, m_tabs[customIndex]);
				ReapplyChildHiding(instance);
				if (!string.IsNullOrEmpty(m_headerName))
				{
					VillagerUIFactory.SetCraftingStationName(instance, m_headerName);
				}
			}
		}

		protected virtual void OnDestroy()
		{
			TeardownTabHandler();
		}

		protected void SetupTabHandler()
		{
			InventoryGui instance = InventoryGui.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Button tabCraft = instance.m_tabCraft;
				obj = ((tabCraft != null) ? ((Component)tabCraft).transform.parent : null);
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			CleanupOrphanedTabObjects(val);
			m_tabHandler = ((Component)val).gameObject.AddComponent<TabHandler>();
			m_tabHandler.m_tabs = new List<Tab>();
			m_tabHandler.m_blockingElements = new List<GameObject>();
			if (m_hasCraftingRecipes)
			{
				((Component)instance.m_tabCraft).gameObject.SetActive(false);
				((Component)instance.m_tabUpgrade).gameObject.SetActive(false);
				AddNativeTabClone(instance, instance.m_tabCraft, isDefault: true);
				AddNativeTabClone(instance, instance.m_tabUpgrade, isDefault: false);
				m_firstCustomTabIndex = 2;
			}
			else
			{
				Button tabCraft2 = instance.m_tabCraft;
				if (tabCraft2 != null)
				{
					((Component)tabCraft2).gameObject.SetActive(false);
				}
				Button tabUpgrade = instance.m_tabUpgrade;
				if (tabUpgrade != null)
				{
					((Component)tabUpgrade).gameObject.SetActive(false);
				}
				m_firstCustomTabIndex = 0;
			}
			AddCustomTabs(instance);
			m_tabHandler.ActiveTabChanged += OnTabChanged;
			m_tabHandler.Init(true);
			ConfigureGamepadTabNav(instance);
			AddTriggerHints(instance);
		}

		private void AddTriggerHints(InventoryGui gui)
		{
			if (m_tabHandler?.m_tabs != null && m_tabHandler.m_tabs.Count > 1)
			{
				GameObject hintSrc = ((!((Object)(object)gui.m_tabCraft != (Object)null)) ? null : ((Component)gui.m_tabCraft).GetComponent<UIGamePad>()?.m_hint);
				GameObject hintSrc2 = ((!((Object)(object)gui.m_tabUpgrade != (Object)null)) ? null : ((Component)gui.m_tabUpgrade).GetComponent<UIGamePad>()?.m_hint);
				CloneHintOnto(hintSrc, m_tabHandler.m_tabs[0].m_button);
				CloneHintOnto(hintSrc2, m_tabHandler.m_tabs[m_tabHandler.m_tabs.Count - 1].m_button);
			}
		}

		private void CloneHintOnto(GameObject hintSrc, Button targetButton)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)hintSrc == (Object)null) && !((Object)(object)targetButton == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(hintSrc, ((Component)targetButton).transform);
				((Object)val).name = "VV_TabHint";
				RectTransform component = hintSrc.GetComponent<RectTransform>();
				RectTransform component2 = val.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
				{
					component2.anchorMin = component.anchorMin;
					component2.anchorMax = component.anchorMax;
					component2.pivot = component.pivot;
					component2.anchoredPosition = component.anchoredPosition;
					component2.sizeDelta = component.sizeDelta;
				}
				UIGamePad[] componentsInChildren = val.GetComponentsInChildren<UIGamePad>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Object.Destroy((Object)(object)componentsInChildren[i]);
				}
				val.SetActive(true);
				m_triggerHints.Add(val);
			}
		}

		private void ConfigureGamepadTabNav(InventoryGui gui)
		{
			string text = ((!((Object)(object)gui.m_tabCraft != (Object)null)) ? null : ((Component)gui.m_tabCraft).GetComponent<UIGamePad>()?.m_zinputKey);
			string text2 = ((!((Object)(object)gui.m_tabUpgrade != (Object)null)) ? null : ((Component)gui.m_tabUpgrade).GetComponent<UIGamePad>()?.m_zinputKey);
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(text2))
			{
				Debug.LogWarning((object)("[VV] Could not read native tab trigger keys (L='" + text + "', R='" + text2 + "') — gamepad tab switching stays disabled this session."));
			}
			else
			{
				m_tabHandler.m_cycling = false;
				m_tabHandler.m_gamepadInput = true;
				m_tabHandler.m_gamepadNavigateLeft = text;
				m_tabHandler.m_gamepadNavigateRight = text2;
			}
		}

		protected void TeardownTabHandler()
		{
			if ((Object)(object)m_tabHandler != (Object)null)
			{
				Object.Destroy((Object)(object)m_tabHandler);
				m_tabHandler = null;
			}
			foreach (GameObject clonedButton in m_clonedButtons)
			{
				if ((Object)(object)clonedButton != (Object)null)
				{
					Object.Destroy((Object)(object)clonedButton);
				}
			}
			m_clonedButtons.Clear();
			m_triggerHints.Clear();
			DestroyActionButton();
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Button tabCraft = instance.m_tabCraft;
				if (tabCraft != null)
				{
					((Component)tabCraft).gameObject.SetActive(true);
				}
				Button tabUpgrade = instance.m_tabUpgrade;
				if (tabUpgrade != null)
				{
					((Component)tabUpgrade).gameObject.SetActive(true);
				}
				if ((Object)(object)instance.m_tabCraft != (Object)null)
				{
					((Selectable)instance.m_tabCraft).interactable = true;
				}
				if ((Object)(object)instance.m_tabUpgrade != (Object)null)
				{
					((Selectable)instance.m_tabUpgrade).interactable = true;
				}
			}
		}

		private static void CleanupOrphanedTabObjects(Transform tabParent)
		{
			for (int num = tabParent.childCount - 1; num >= 0; num--)
			{
				Transform child = tabParent.GetChild(num);
				if (((Object)child).name.StartsWith("VV_"))
				{
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
			TabHandler[] components = ((Component)tabParent).GetComponents<TabHandler>();
			for (int i = 0; i < components.Length; i++)
			{
				Object.Destroy((Object)(object)components[i]);
			}
		}

		private void AddNativeTabClone(InventoryGui gui, Button template, bool isDefault)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CloneButton(template);
			((Object)val).name = "VV_Tab_" + ((Object)template).name;
			if ((Object)(object)gui != (Object)null && (Object)(object)template == (Object)(object)gui.m_tabCraft)
			{
				VillagerUIFactory.SetTMPText(val, "Orders");
			}
			RectTransform component = ((Component)template).GetComponent<RectTransform>();
			RectTransform component2 = val.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
			{
				component2.anchoredPosition = component.anchoredPosition;
			}
			Transform val2 = val.transform.Find("Selected");
			if ((Object)(object)val2 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
			m_clonedButtons.Add(val);
			m_tabHandler.m_tabs.Add(new Tab
			{
				m_button = val.GetComponent<Button>(),
				m_default = isDefault
			});
		}

		private void AddCustomTabs(InventoryGui gui)
		{
			//IL_0111: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			Button tabUpgrade = gui.m_tabUpgrade;
			if ((Object)(object)tabUpgrade == (Object)null)
			{
				return;
			}
			float num = ComputeTabSpacing(gui);
			object obj;
			if (!m_hasCraftingRecipes)
			{
				Button tabCraft = gui.m_tabCraft;
				obj = ((tabCraft != null) ? ((Component)tabCraft).GetComponent<RectTransform>() : null);
			}
			else
			{
				obj = ((Component)tabUpgrade).GetComponent<RectTransform>();
			}
			RectTransform val = (RectTransform)obj;
			int num2 = (m_hasCraftingRecipes ? 1 : 0);
			for (int i = 0; i < m_tabs.Count; i++)
			{
				GameObject val2 = CloneButton(tabUpgrade);
				((Object)val2).name = "VV_Tab_" + m_tabs[i].TabName;
				RectTransform component = val2.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)val != (Object)null)
				{
					component.anchoredPosition = val.anchoredPosition + new Vector2(num * (float)(i + num2), 0f);
				}
				VillagerUIFactory.SetTMPText(val2, m_tabs[i].TabName);
				Transform val3 = val2.transform.Find("Selected");
				if ((Object)(object)val3 != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val3).gameObject);
				}
				m_clonedButtons.Add(val2);
				m_tabHandler.m_tabs.Add(new Tab
				{
					m_button = val2.GetComponent<Button>(),
					m_default = (!m_hasCraftingRecipes && i == 0)
				});
			}
		}

		private static GameObject CloneButton(Button template)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, ((Component)template).transform.parent);
			(val.GetComponent<CanvasGroup>() ?? val.AddComponent<CanvasGroup>()).ignoreParentGroups = true;
			Button component = val.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				component.onClick = new ButtonClickedEvent();
			}
			UIGamePad[] componentsInChildren = val.GetComponentsInChildren<UIGamePad>(true);
			foreach (UIGamePad val2 in componentsInChildren)
			{
				if ((Object)(object)val2.m_hint != (Object)null)
				{
					Object.Destroy((Object)(object)val2.m_hint);
				}
				Object.Destroy((Object)(object)val2);
			}
			val.SetActive(true);
			return val;
		}

		private static float ComputeTabSpacing(InventoryGui gui)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Button tabCraft = gui.m_tabCraft;
			RectTransform val = ((tabCraft != null) ? ((Component)tabCraft).GetComponent<RectTransform>() : null);
			Button tabUpgrade = gui.m_tabUpgrade;
			RectTransform val2 = ((tabUpgrade != null) ? ((Component)tabUpgrade).GetComponent<RectTransform>() : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				float num = val2.anchoredPosition.x - val.anchoredPosition.x;
				if (num > 1f)
				{
					return num;
				}
			}
			return 100f;
		}

		private int GetCustomIndex()
		{
			if ((Object)(object)m_tabHandler == (Object)null)
			{
				return -1;
			}
			int num = m_tabHandler.GetActiveTab() - m_firstCustomTabIndex;
			if (num < 0 || num >= m_tabs.Count)
			{
				return -1;
			}
			return num;
		}

		private void OnTabChanged(int index)
		{
			foreach (ITabContent<TSubject> tab in m_tabs)
			{
				tab.OnDeselected();
			}
			int num = index - m_firstCustomTabIndex;
			if (num >= 0 && num < m_tabs.Count)
			{
				HideCraftingChildren();
				m_selectedListIndex = -1;
				m_tabs[num].OnSelected(CurrentSubject);
				RefreshCustomContent(num);
				return;
			}
			RestoreCraftingPanel();
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance != (Object)null)
			{
				switch (index)
				{
				case 0:
					instance.OnTabCraftPressed();
					break;
				case 1:
					instance.OnTabUpgradePressed();
					break;
				}
			}
		}

		private void RefreshCustomContent(int ci)
		{
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null) && ci >= 0 && ci < m_tabs.Count)
			{
				ITabContent<TSubject> tabContent = m_tabs[ci];
				List<TabListItemUI> list = tabContent.GetListItems(CurrentSubject) ?? new List<TabListItemUI>();
				PopulateRecipeList(instance, list);
				if (m_selectedListIndex < 0 && list.Count > 0)
				{
					m_selectedListIndex = 0;
				}
				UpdateSelectionVisuals();
				PopulateDescription(instance, tabContent);
			}
		}

		private void PopulateRecipeList(InventoryGui gui, List<TabListItemUI> items)
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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)
			//IL_00e0: 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_0102: 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_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			foreach (GameObject listElement in m_listElements)
			{
				if (!((Object)(object)listElement == (Object)null))
				{
					listElement.transform.SetParent((Transform)null);
					Object.Destroy((Object)(object)listElement);
				}
			}
			m_listElements.Clear();
			if ((Object)(object)gui.m_recipeListRoot != (Object)null)
			{
				foreach (Transform item in (Transform)gui.m_recipeListRoot)
				{
					((Component)item).gameObject.SetActive(false);
				}
			}
			if ((Object)(object)gui.m_recipeElementPrefab == (Object)null || (Object)(object)gui.m_recipeListRoot == (Object)null)
			{
				return;
			}
			RectTransform recipeListRoot = gui.m_recipeListRoot;
			if (!m_savedListRootAnchorMin.HasValue)
			{
				m_savedListRootAnchorMin = recipeListRoot.anchorMin;
				m_savedListRootAnchorMax = recipeListRoot.anchorMax;
				m_savedListRootPivot = recipeListRoot.pivot;
			}
			recipeListRoot.anchorMin = new Vector2(recipeListRoot.anchorMin.x, 1f);
			recipeListRoot.anchorMax = new Vector2(recipeListRoot.anchorMax.x, 1f);
			recipeListRoot.pivot = new Vector2(recipeListRoot.pivot.x, 1f);
			float num = 0f;
			for (int i = 0; i < items.Count; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(gui.m_recipeElementPrefab, (Transform)(object)gui.m_recipeListRoot);
				((Object)val).name = string.Format("{0}{1}", "VV_ListItem_", i);
				RectTransform component = val.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchoredPosition = new Vector2(0f, num);
					num -= gui.m_recipeListSpace;
				}
				CleanRecipeElement(val);
				Transform val2 = val.transform.Find("name");
				if ((Object)(object)val2 != (Object)null)
				{
					VillagerUIFactory.SetTMPText(((Component)val2).gameObject, items[i].TabName);
				}
				Transform val3 = val.transform.Find("icon");
				if ((Object)(object)val3 != (Object)null)
				{
					Image component2 = ((Component)val3).GetComponent<Image>();
					if ((Object)(object)component2 != (Object)null)
					{
						Sprite icon = items[i].Icon;
						if ((Object)(object)icon != (Object)null)
						{
							component2.sprite = icon;
						}
						else
						{
							((Behaviour)component2).enabled = false;
						}
					}
				}
				int idx = i;
				Button val4 = val.GetComponent<Button>();
				if ((Object)(object)val4 == (Object)null)
				{
					val4 = val.AddComponent<Button>();
				}
				((UnityEventBase)val4.onClick).RemoveAllListeners();
				((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
				{
					OnListItemClicked(idx);
				});
				val.SetActive(true);
				m_listElements.Add(val);
			}
			RectTransform recipeListRoot2 = gui.m_recipeListRoot;
			if ((Object)(object)recipeListRoot2 != (Object)null)
			{
				float num2 = (float)items.Count * gui.m_recipeListSpace;
				recipeListRoot2.SetSizeWithCurrentAnchors((Axis)1, num2);
			}
		}

		private void PopulateDescription(InventoryGui gui, ITabContent<TSubject> tab)
		{
			TabDetailDataUI tabDetailDataUI = ((m_selectedListIndex >= 0) ? tab.GetDetail(m_selectedListIndex, CurrentSubject) : null);
			if ((Object)(object)gui.m_recipeIcon != (Object)null)
			{
				((Behaviour)gui.m_recipeIcon).enabled = (Object)(object)tabDetailDataUI?.Icon != (Object)null;
				if ((Object)(object)tabDetailDataUI?.Icon != (Object)null)
				{
					gui.m_recipeIcon.sprite = tabDetailDataUI.Icon;
				}
			}
			RectTransform crafting = gui.m_crafting;
			Transform val = ((crafting != null) ? ((Transform)crafting).Find("Decription") : null);
			if ((Object)(object)val != (Object)null)
			{
				Transform val2 = val.Find("Name");
				if ((Object)(object)val2 != (Object)null)
				{
					VillagerUIFactory.SetTMPText(((Component)val2).gameObject, tabDetailDataUI?.Title ?? "");
				}
				Transform val3 = val.Find("Description");
				if ((Object)(object)val3 != (Object)null)
				{
					VillagerUIFactory.SetTMPText(((Component)val3).gameObject, tabDetailDataUI?.Description ?? "");
				}
			}
			UpdateMapImage(val, tabDetailDataUI?.MapTexture);
			ApplyTabAction(gui, tabDetailDataUI);
			HideDescriptionSubElements(gui);
		}

		private void ApplyTabAction(InventoryGui gui, TabDetailDataUI detail)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			if ((Object)(object)gui.m_craftButton == (Object)null)
			{
				return;
			}
			bool num = detail?.OnAction != null;
			((Component)gui.m_craftButton).gameObject.SetActive(false);
			if (!num)
			{
				if ((Object)(object)m_actionButton != (Object)null)
				{
					m_actionButton.SetActive(false);
				}
				return;
			}
			EnsureActionButton(gui);
			if ((Object)(object)m_actionButton == (Object)null)
			{
				return;
			}
			VillagerUIFactory.SetTMPText(m_actionButton, detail.ActionText ?? "Action");
			Button component = m_actionButton.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((Selectable)component).interactable = true;
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					detail.OnAction?.Invoke();
				});
			}
			m_actionButton.SetActive(true);
		}

		private void EnsureActionButton(InventoryGui gui)
		{
			if (!((Object)(object)m_actionButton != (Object)null) && !((Object)(object)gui.m_craftButton == (Object)null))
			{
				m_actionButton = Object.Instantiate<GameObject>(((Component)gui.m_craftButton).gameObject, ((Component)gui.m_craftButton).transform.parent);
				((Object)m_actionButton).name = "VV_TabActionButton";
				m_actionButton.SetActive(false);
			}
		}

		private void HideActionButton()
		{
			if ((Object)(object)m_actionButton != (Object)null)
			{
				m_actionButton.SetActive(false);
			}
		}

		private void DestroyActionButton()
		{
			if (!((Object)(object)m_actionButton == (Object)null))
			{
				Object.Destroy((Object)(object)m_actionButton);
				m_actionButton = null;
			}
		}

		private void UpdateMapImage(Transform descPanel, Texture2D texture)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			if ((Object)(object)texture == (Object)null)
			{
				if ((Object)(object)m_mapImageObject != (Object)null)
				{
					m_mapImageObject.SetActive(false);
				}
				return;
			}
			if ((Object)(object)m_mapImageObject == (Object)null && (Object)(object)descPanel != (Object)null)
			{
				m_mapImageObject = new GameObject("VV_MapImage", new Type[2]
				{
					typeof(RectTransform),
					typeof(RawImage)
				});
				m_mapImageObject.transform.SetParent(descPanel, false);
			}
			if ((Object)(object)m_mapImageObject != (Object)null)
			{
				RectTransform component = m_mapImageObject.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0.05f, 0.04f);
				component.anchorMax = new Vector2(0.95f, 0.7f);
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
				m_mapImageObject.SetActive(true);
				RawImage component2 = m_mapImageObject.GetComponent<RawImage>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.texture = (Texture)(object)texture;
				}
			}
		}

		private void OnListItemClicked(int index)
		{
			m_selectedListIndex = index;
			UpdateSelectionVisuals();
			int customIndex = GetCustomIndex();
			if (customIndex >= 0)
			{
				InventoryGui instance = InventoryGui.instance;
				if ((Object)(object)instance != (Object)null)
				{
					PopulateDescription(instance, m_tabs[customIndex]);
				}
			}
		}

		private void UpdateSelectionVisuals()
		{
			for (int i = 0; i < m_listElements.Count; i++)
			{
				GameObject val = m_listElements[i];
				if (!((Object)(object)val == (Object)null))
				{
					Transform val2 = val.transform.Find("selected");
					if ((Object)(object)val2 != (Object)null)
					{
						((Component)val2).gameObject.SetActive(i == m_selectedListIndex);
					}
				}
			}
		}

		private static void HideDescriptionSubElements(InventoryGui gui)
		{
			RectTransform crafting = gui.m_crafting;
			Transform val = ((crafting != null) ? ((Transform)crafting).Find("Decription") : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			string[] array = new string[6] { "SelectVariant", "CraftType", "UpgradePanel", "UpradePanel", "OLD_QualityPanel", "requirements" };
			foreach (string text in array)
			{
				Transform val2 = val.Find(text);
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(false);
				}
			}
		}

		private static void CleanRecipeElement(GameObject elem)
		{
			string[] array = new string[2] { "Durability", "QualityLevel" };
			foreach (string text in array)
			{
				Transform val = elem.transform.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			Transform val2 = elem.transform.Find("selected");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(false);
			}
		}

		private void SuppressNativeRecipeElements(InventoryGui gui)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if ((Object)(object)gui.m_recipeListRoot == (Object)null)
			{
				return;
			}
			HashSet<GameObject> hashSet = new HashSet<GameObject>(m_listElements);
			foreach (Transform item in (Transform)gui.m_recipeListRoot)
			{
				Transform val = item;
				((Component)val).gameObject.SetActive(hashSet.Contains(((Component)val).gameObject));
			}
		}

		private void ReapplyChildHiding(InventoryGui gui)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if ((Object)(object)gui?.m_crafting == (Object)null)
			{
				return;
			}
			foreach (Transform item in (Transform)gui.m_crafting)
			{
				Transform val = item;
				if (s_craftingChildrenToHide.Contains(((Object)val).name))
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private void HideCraftingChildren()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			if (m_childSnapshot.Count > 0)
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance?.m_crafting == (Object)null)
			{
				return;
			}
			foreach (Transform item in (Transform)instance.m_crafting)
			{
				Transform val = item;
				m_childSnapshot[val] = ((Component)val).gameObject.activeSelf;
				if (s_craftingChildrenToHide.Contains(((Object)val).name))
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		protected void RestoreCraftingPanel()
		{
			foreach (GameObject listElement in m_listElements)
			{
				if (!((Object)(object)listElement == (Object)null))
				{
					listElement.transform.SetParent((Transform)null);
					Object.Destroy((Object)(object)listElement);
				}
			}
			m_listElements.Clear();
			if ((Object)(object)m_mapImageObject != (Object)null)
			{
				Object.Destroy((Object)(object)m_mapImageObject);
				m_mapImageObject = null;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance?.m_recipeListRoot != (Object)null)
			{
				DestroyOrphanedListItems(instance.m_recipeListRoot);
				RestoreListRootLayout(instance.m_recipeListRoot);
			}
			foreach (KeyValuePair<Transform, bool> item in m_childSnapshot)
			{
				if ((Object)(object)item.Key != (Object)null)
				{
					((Component)item.Key).gameObject.SetActive(item.Value);
				}
			}
			m_childSnapshot.Clear();
			HideActionButton();
			if ((Object)(object)instance?.m_craftButton != (Object)null)
			{
				((Component)instance.m_craftButton).gameObject.SetActive(true);
			}
		}

		private static void DestroyOrphanedListItems(RectTransform listRoot)
		{
			for (int num = ((Transform)listRoot).childCount - 1; num >= 0; num--)
			{
				Transform child = ((Transform)listRoot).GetChild(num);
				if (((Object)child).name.StartsWith("VV_ListItem_"))
				{
					child.SetParent((Transform)null);
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
		}

		private void RestoreListRootLayout(RectTransform rootRT)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (m_savedListRootAnchorMin.HasValue)
			{
				rootRT.anchorMin = m_savedListRootAnchorMin.Value;
				rootRT.anchorMax = m_savedListRootAnchorMax.Value;
				rootRT.pivot = m_savedListRootPivot.Value;
				m_savedListRootAnchorMin = null;
				m_savedListRootAnchorMax = null;
				m_savedListRootPivot = null;
			}
		}
	}
	public interface IListPanelUI : IListPanel
	{
		List<TabListItemUI> GetListItems(VillagerBehaviorBridge villager);

		TabDetailDataUI GetDetail(int index, VillagerBehaviorBridge villager);
	}
	public interface IRegistryTabUI : ITabContent<RegistryContext>
	{
	}
	public interface ITabContent<in TSubject>
	{
		string TabName { get; }

		void OnSelected(TSubject subject);

		void OnDeselected();

		void OnUpdate(TSubject subject);

		List<TabListItemUI> GetListItems(TSubject subject);

		TabDetailDataUI GetDetail(int selectedIndex, TSubject subject);
	}
	public interface IVillagerTabUI : IVillagerTab, ITabContent<VillagerBehaviorBridge>
	{
	}
	public class TabListItemUI : TabListItem
	{
		public Sprite Icon { get; set; }
	}
	public class TabDetailDataUI : TabDetailData
	{
		public Sprite Icon { get; set; }

		public Texture2D MapTexture { get; set; }
	}
	public sealed class RegistryContext
	{
		public Vector3 RegistryPosition { get; }

		public string VillageId { get; }

		public RegistryContext(Vector3 registryPosition, string villageId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			RegistryPosition = registryPosition;
			VillageId = villageId;
		}
	}
	[RegisterModObject("RegistryTabManager")]
	public class RegistryTabManager : CraftingTabHostBase<RegistryContext>
	{
		private static RegistryTabManager s_instance;

		private RegistryContext m_context;

		protected override RegistryContext CurrentSubject => m_context;

		protected override bool HasSubject => m_context != null;

		public static bool IsActive
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null)
				{
					return s_instance.m_active;
				}
				return false;
			}
		}

		public static void Activate(RegistryContext context)
		{
			EnsureInstance();
			s_instance.m_context = context;
			s_instance.m_active = true;
			s_instance.m_hasCraftingRecipes = false;
			s_instance.m_lastUpdateTime = Time.time;
			s_instance.m_headerName = "Village Registry";
			s_instance.SetupTabHandler();
		}

		public static void Deactivate()
		{
			if ((Object)(object)s_instance == (Object)null)
			{
				return;
			}
			foreach (ITabContent<RegistryContext> tab in s_instance.m_tabs)
			{
				tab.OnDeselected();
			}
			s_instance.m_active = false;
			s_instance.m_context = null;
			s_instance.RestoreCraftingPanel();
			s_instance.TeardownTabHandler();
		}

		public static void RegisterTab(IRegistryTabUI tab)
		{
			EnsureInstance();
			s_instance.m_tabs.Add(tab);
		}

		private static void EnsureInstance()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!((Object)(object)s_instance != (Object)null))
			{
				GameObject val = new GameObject("RegistryTabManager");
				s_instance = val.AddComponent<RegistryTabManager>();
				Object.DontDestroyOnLoad((Object)val);
			}
		}
	}
	[RegisterModObject("VillagerTabManager")]
	public class VillagerTabManager : CraftingTabHostBase<VillagerBehaviorBridge>
	{
		private static VillagerTabManager s_instance;

		private VillagerBehaviorBridge m_villager;

		protected override VillagerBehaviorBridge CurrentSubject => m_villager;

		protected override bool HasSubject => (Object)(object)m_villager != (Object)null;

		public static bool IsCustomTabActive
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null && s_instance.m_active && (Object)(object)s_instance.m_tabHandler != (Object)null)
				{
					return s_instance.m_tabHandler.GetActiveTab() >= s_instance.m_firstCustomTabIndex;
				}
				return false;
			}
		}

		public static bool IsNonCrafterActive
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null && s_instance.m_active)
				{
					return !s_instance.m_hasCraftingRecipes;
				}
				return false;
			}
		}

		public static bool IsActive
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null)
				{
					return s_instance.m_active;
				}
				return false;
			}
		}

		public static bool IsUpgradeTabActive
		{
			get
			{
				if ((Object)(object)s_instance != (Object)null && s_instance.m_active && s_instance.m_hasCraftingRecipes && (Object)(object)s_instance.m_tabHandler != (Object)null)
				{
					return s_instance.m_tabHandler.GetActiveTab() == s_instance.m_firstCustomTabIndex - 1;
				}
				return false;
			}
		}

		public static void Activate(VillagerBehaviorBridge villager, bool hasCraftingRecipes)
		{
			EnsureInstance();
			s_instance.m_villager = villager;
			s_instance.m_active = true;
			s_instance.m_hasCraftingRecipes = hasCraftingRecipes;
			s_instance.m_lastUpdateTime = Time.time;
			string text = villager?.VillagerType;
			s_instance.m_headerName = (string.IsNullOrEmpty(text) ? "Villager" : (VillagerRegistry.Get(text)?.displayName ?? text));
			s_instance.SetupTabHandler();
		}

		public static void Deactivate()
		{
			if ((Object)(object)s_instance == (Object)null)
			{
				return;
			}
			foreach (ITabContent<VillagerBehaviorBridge> tab in s_instance.m_tabs)
			{
				tab.OnDeselected();
			}
			s_instance.m_active = false;
			s_instance.m_villager = null;
			s_instance.RestoreCraftingPanel();
			s_instance.TeardownTabHandler();
		}

		public static void RegisterTab(IVillagerTab tab)
		{
			EnsureInstance();
			s_instance.m_tabs.Add((IVillagerTabUI)tab);
		}

		private static void EnsureInstance()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!((Object)(object)s_instance != (Object)null))
			{
				GameObject val = new GameObject("VillagerTabManager");
				s_instance = val.AddComponent<VillagerTabManager>();
				Object.DontDestroyOnLoad((Object)val);
			}
		}
	}
	public static class VillagerUIFactory
	{
		private static readonly Color NativeHeaderColor = new Color(1f, 0.718f, 0.36f, 1f);

		private const float NativeHeaderSize = 32f;

		private static GameObject s_windowBg;

		private static readonly Color ValheimBeige = new Color(0.8529f, 0.725f, 0.5331f, 1f);

		private static readonly Color ValheimYellow = new Color(1f, 0.889f, 0f, 1f);

		private static GameObject s_textTemplate;

		public static (GameObject root, Transform content) CreateDockedPanel(Transform parent, string title, float width, float height)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			GameObject val = new GameObject("VV_Docked_" + title, new Type[2]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(width, height);
			GameObject windowBackgroundObject = GetWindowBackgroundObject();
			if ((Object)(object)windowBackgroundObject != (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(windowBackgroundObject, val.transform);
				((Object)val2).name = "VV_Bkg";
				val2.transform.SetAsFirstSibling();
				(val2.GetComponent<LayoutElement>() ?? val2.AddComponent<LayoutElement>()).ignoreLayout = true;
				RectTransform component = val2.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.pivot = new Vector2(0.5f, 0.5f);
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
				((Transform)component).localScale = Vector3.one;
			}
			else
			{
				((Graphic)val.AddComponent<Image>()).color = new Color(0.12f, 0.09f, 0.06f, 0.97f);
				Outline obj = val.AddComponent<Outline>();
				((Shadow)obj).effectColor = new Color(0.45f, 0.35f, 0.25f, 1f);
				((Shadow)obj).effectDistance = new Vector2(2f, -2f);
			}
			GameObject val3 = CreateLabel(val.transform, title, 32f, NativeHeaderColor);
			SetTMPProperties(val3, 32f, NativeHeaderColor, 514);
			(val3.GetComponent<LayoutElement>() ?? val3.AddComponent<LayoutElement>()).ignoreLayout = true;
			RectTransform component2 = val3.GetComponent<RectTransform>();
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(0.5f, 1f);
			component2.anchorMax = val4;
			component2.anchorMin = val4;
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = new Vector2(0f, -16f);
			VerticalLayoutGroup component3 = val.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component3).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 7f;
			((LayoutGroup)component3).padding = new RectOffset(24, 24, 56, 20);
			return (root: val, content: val.transform);
		}

		private static GameObject GetWindowBackgroundObject()
		{
			if ((Object)(object)s_windowBg != (Object)null)
			{
				return s_windowBg;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			RectTransform[] array = (RectTransform[])(object)new RectTransform[2] { instance.m_container, instance.m_player };
			foreach (RectTransform val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Image[] componentsInChildren = ((Component)val).GetComponentsInChildren<Image>(true);
				foreach (Image val2 in componentsInChildren)
				{
					if (!((Object)(object)val2.sprite == (Object)null) && ((Object)((Component)val2).gameObject).name == "Bkg")
					{
						s_windowBg = ((Component)val2).gameObject;
						return s_windowBg;
					}
				}
			}
			return s_windowBg;
		}

		public static Slider CreateSlider(Transform parent, float min, float max, bool wholeNumbers, UnityAction<float> onValueChanged)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0078: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: 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_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VV_Slider", new Type[2]
			{
				typeof(RectTransform),
				typeof(Slider)
			});
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = 20f;
			obj.flexibleWidth = 1f;
			GameObject val2 = new GameObject("Background", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.25f);
			component.anchorMax = new Vector2(1f, 0.75f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Graphic)val2.GetComponent<Image>()).color = new Color(0.15f, 0.12f, 0.08f, 0.9f);
			GameObject val3 = new GameObject("Fill Area", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.25f);
			component2.anchorMax = new Vector2(1f, 0.75f);
			component2.offsetMin = new Vector2(5f, 0f);
			component2.offsetMax = new Vector2(-15f, 0f);
			GameObject val4 = new GameObject("Fill", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val4.transform.SetParent(val3.transform, false);
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			((Graphic)val4.GetComponent<Image>()).color = new Color(1f, 0.631f, 0.235f, 0.8f);
			GameObject val5 = new GameObject("Handle Slide Area", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent(val.transform, false);
			RectTransform component4 = val5.GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = Vector2.one;
			component4.offsetMin = new Vector2(10f, 0f);
			component4.offsetMax = new Vector2(-10f, 0f);
			GameObject val6 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val6.transform.SetParent(val5.transform, false);
			RectTransform component5 = val6.GetComponent<RectTransform>();
			component5.sizeDelta = new Vector2(20f, 0f);
			component5.anchorMin = new Vector2(0f, 0f);
			component5.anchorMax = new Vector2(0f, 1f);
			((Graphic)val6.GetComponent<Image>()).color = ValheimBeige;
			Slider component6 = val.GetComponent<Slider>();
			component6.fillRect = component3;
			component6.handleRect = component5;
			((Selectable)component6).targetGraphic = (Graphic)(object)val6.GetComponent<Image>();
			component6.direction = (Direction)0;
			component6.minValue = min;
			component6.maxValue = max;
			component6.wholeNumbers = wholeNumbers;
			component6.value = min;
			if (onValueChanged != null)
			{
				((UnityEvent<float>)(object)component6.onValueChanged).AddListener(onValueChanged);
			}
			return component6;
		}

		public static InputField CreateInputField(Transform parent, string initialText, UnityAction<string> onEndEdit)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00d1: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VV_InputField", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(InputField)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.1f, 0.08f, 0.06f, 0.9f);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = 60f;
			obj.preferredHeight = 28f;
			obj.flexibleWidth = 0f;
			GameObject val2 = new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val2.transform.SetParent(val.transform, false);
			StretchFill(val2);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.offsetMin = new Vector2(4f, 2f);
			component.offsetMax = new Vector2(-4f, -2f);
			Text component2 = val2.GetComponent<Text>();
			component2.font = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
			component2.fontSize = 14;
			((Graphic)component2).color = ValheimBeige;
			component2.alignment = (TextAnchor)4;
			component2.supportRichText = false;
			Outline obj2 = val.AddComponent<Outline>();
			((Shadow)obj2).effectColor = new Color(0.35f, 0.28f, 0.18f, 1f);
			((Shadow)obj2).effectDistance = new Vector2(1f, -1f);
			InputField component3 = val.GetComponent<InputField>();
			component3.textComponent = component2;
			component3.text = initialText;
			component3.contentType = (ContentType)2;
			component3.characterLimit = 4;
			if (onEndEdit != null)
			{
				((UnityEvent<string>)(object)component3.onEndEdit).AddListener(onEndEdit);
			}
			return component3;
		}

		public static GameObject CreateLabel(Transform parent, string text, float fontSize = 16f, Color? color = null)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			EnsureTextTemplate();
			if ((Object)(object)s_textTemplate == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(s_textTemplate, parent);
			((Object)val).name = "VV_Label";
			SetTMPText(val, text);
			SetTMPProperties(val, fontSize, (Color)(((??)color) ?? ValheimBeige), 257);
			ContentSizeFitter obj = val.GetComponent<ContentSizeFitter>() ?? val.AddComponent<ContentSizeFitter>();
			obj.verticalFit = (FitMode)2;
			obj.horizontalFit = (FitMode)0;
			val.SetActive(true);
			return val;
		}

		public static Button CreateButton(Transform parent, string text, UnityAction onClick)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance?.m_craftButton == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)instance.m_craftButton).gameObject, parent);
			((Object)val).name = "VV_Btn_" + text;
			SetTMPText(val, text);
			LayoutElement obj = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
			obj.preferredHeight = 36f;
			obj.flexibleWidth = 1f;
			Button component = val.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener(onClick);
				((Selectable)component).interactable = true;
			}
			val.SetActive(true);
			return component;
		}

		public static GameObject CreateHorizontalGroup(Transform parent, float spacing = 4f, float height = 36f, bool forceExpandWidth = true)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			GameObject val = new GameObject("HGroup", new Type[2]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup)
			});
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup component = val.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = spacing;
			((LayoutGroup)component).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = forceExpandWidth;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.flexibleWidth = 1f;
			return val;
		}

		public static GameObject CreateVerticalGroup(Transform parent, float spacing = 2f)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			GameObject val = new GameObject("VGroup", new Type[2]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup)
			});
			val.transform.SetParent(parent, false);
			VerticalLayoutGroup component = val.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = spacing;
			((LayoutGroup)component).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			val.AddComponent<LayoutElement>().flexibleWidth = 1f;
			return val;
		}

		public static Image CreateIcon(Transform parent, float size)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VV_Icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = size;
			obj.preferredHeight = size;
			obj.flexibleWidth = 0f;
			Image component = val.GetComponent<Image>();
			component.preserveAspect = true;
			return component;
		}

		public static void CreateDivider(Transform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Divider", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.6f, 0.5f, 0.3f, 0.6f);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = 2f;
			obj.flexibleWidth = 1f;
		}

		public static void CreateFlexibleSpacer(Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("FlexSpacer", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.flexibleHeight = 1f;
			obj.flexibleWidth = 1f;
		}

		public static void CreateSpacer(Transform parent, float height = 8f)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Spacer", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.flexibleWidth = 1f;
		}

		private static void EnsureTextTemplate()
		{
			if ((Object)(object)s_textTemplate != (Object)null)
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			FieldInfo field = typeof(InventoryGui).GetField("m_craftingStationName", BindingFlags.Instance | BindingFlags.Public);
			if (!(field == null))
			{
				object? value = field.GetValue(instance);
				Component val = (Component)((value is Component) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					s_textTemplate = val.gameObject;
				}
			}
		}

		public static void SetCraftingStationName(InventoryGui gui, string text)
		{
			if (!((Object)(object)gui == (Object)null))
			{
				object? obj = typeof(InventoryGui).GetField("m_craftingStationName", BindingFlags.Instance | BindingFlags.Public)?.GetValue(gui);
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					SetTMPText(val.gameObject, text);
				}
			}
		}

		public static void SetTMPText(GameObject go, string text)
		{
			if ((Object)(object)go == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[UIFactory] SetTMPText called with null GameObject");
				}
				return;
			}
			Component val = FindTMP(go);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[UIFactory] SetTMPText: no TextMeshPro component under '" + ((Object)go).name + "'"));
				}
				return;
			}
			PropertyInfo property = ((object)val).GetType().GetProperty("text");
			if (property == null)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[UIFactory] SetTMPText: '" + ((object)val).GetType().Name + "' has no 'text' property"));
				}
				return;
			}
			Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
			if (val2 != null && !val2.enabled)
			{
				val2.enabled = true;
			}
			property.SetValue(val, text);
		}

		public static void SetTMPProperties(GameObject go, float fontSize, Color color, int alignment)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Component val = FindTMP(go);
			if (!((Object)(object)val == (Object)null))
			{
				Type type = ((object)val).GetType();
				type.GetProperty("fontSize")?.SetValue(val, fontSize);
				type.GetProperty("color")?.SetValue(val, color);
				type.GetProperty("enableWordWrapping")?.SetValue(val, true);
				PropertyInfo property = type.GetProperty("alignment");
				if (property != null)
				{
					property.SetValue(val, Enum.ToObject(property.PropertyType, alignment));
				}
			}
		}

		private static Component FindTMP(GameObject go)
		{
			Component[] componentsInChildren = go.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((object)val).GetType().Name.Contains("TextMeshPro"))
				{
					return val;
				}
			}
			return null;
		}

		private static void StretchFill(GameObject go)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
		}
	}
}
namespace ValheimVillages.Interfaces
{
	public interface IAbility
	{
		string Id { get; }

		string DisplayName { get; }

		string Description { get; }
	}
	public interface IBehavior
	{
		string Tag { get; }

		int Priority { get; }

		bool WantsControl(BehaviorContext ctx);

		void Update(float dt);

		void OnArrival(float dt);

		string GetStatusText();
	}
	public interface IContextMenu
	{
		string Id { get; }
	}
	public interface IListPanel
	{
		string Tag { get; }

		string ParentTab { get; }
	}
	public interface IPassiveEffect
	{
		string Id { get; }

		string DisplayName { get; }

		bool IsActive(Vector3 position);
	}
	public interface IPathUnreachableHandler
	{
		void OnPathUnreachable(Vector3 target);
	}
	public interface ITaskHandler
	{
		string TaskName { get; }
	}
	public interface IVillager
	{
		string VillagerName { get; }

		string VillagerType { get; }

		string UniqueID { get; }

		Vector3 HomeAnchor { get; }
	}
	public interface IVillagerMemory
	{
		Vector3 HomeAnchor { get; set; }

		void UpdateBestComfort(float comfort, Vector3 position);
	}
	public interface IVillagerStationLookup
	{
		Vector3 HomeAnchor { get; }
	}
	public interface IVillagerWorkContext : IVillagerStationLookup
	{
		string NpcName { get; }

		Vector3 Position { get; }
	}
	public interface IWorkScanBehavior
	{
		bool TryScanForWork(bool ignoreScanInterval = false);
	}
}
namespace ValheimVillages.IntegrationTests
{
	public static class InfoTabTests
	{
		[ModTest(Name = "Villager_InfoTab_HasVillageMapPanel", Order = 100)]
		public static void Villager_InfoTab_HasVillageMapPanel()
		{
			VillagerDef villagerDef = VillagerRegistry.Get("Blacksmith");
			ModAssert.NotNull(villagerDef, "Blacksmith VillagerDef should exist in VillagerRegistry");
			ModAssert.True(TagParser.HasTag(villagerDef.tags, "tab", "info"), "Blacksmith definition should have tab:info tag");
			IVillagerTab villagerTab = AttributeScanner.GetRegisteredTabs().FirstOrDefault((IVillagerTab t) => t.TabName == "Info");
			ModAssert.NotNull(villagerTab, "Info tab should be registered");
			ModAssert.True(villagerTab is IVillagerTabUI, "InfoTab must implement IVillagerTabUI for the renderer to display items");
			VillagerBehaviorBridge[] source = Object.FindObjectsOfType<VillagerBehaviorBridge>();
			VillagerBehaviorBridge villagerBehaviorBridge = source.FirstOrDefault((VillagerBehaviorBridge v) => v.VillagerType == "Blacksmith") ?? source.FirstOrDefault();
			if ((Object)(object)villagerBehaviorBridge == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[ModTest] No VillagerBehaviorBridge in world — skipping live item check");
				}
				return;
			}
			ModAssert.NotNull(villagerBehaviorBridge.AI, "Villager NPC exists but has no VillagerAI — hot reload or tagging bug");
			IVillagerTabUI obj = (IVillagerTabUI)villagerTab;
			obj.OnSelected(villagerBehaviorBridge);
			ModAssert.True(!obj.GetListItems(villagerBehaviorBridge).Any((TabListItemUI i) => i.TabName == "Village Map"), "Tasks tab should no longer have a standalone 'Village Map' list item — map moved into task details");
		}
	}
	public static class RegionWalkableCoverageTests
	{
		internal static readonly Vector3[] WalkablePositions = (Vector3[])(object)new Vector3[389]
		{
			new Vector3(-2276.57f, 39.03f, 1305.5f),
			new Vector3(-2276.74f, 39.04f, 1304.25f),
			new Vector3(-2276.9f, 39.13f, 1303.05f),
			new Vector3(-2276.94f, 39.31f, 1301.89f),
			new Vector3(-2276.88f, 39.39f, 1300.74f),
			new Vector3(-2276.81f, 39.46f, 1299.56f),
			new Vector3(-2276.63f, 39.69f, 1298.46f),
			new Vector3(-2276.34f, 39.68f, 1297.36f),
			new Vector3(-2276f, 39.35f, 1296.25f),
			new Vector3(-2275.5f, 38.94f, 1295.22f),
			new Vector3(-2274.84f, 38.86f, 1294.31f),
			new Vector3(-2274.09f, 38.91f, 1293.44f),
			new Vector3(-2273.29f, 38.93f, 1292.59f),
			new Vector3(-2272.5f, 38.94f, 1291.74f),
			new Vector3(-2271.68f, 38.97f, 1290.86f),
			new Vector3(-2270.88f, 38.99f, 1290.01f),
			new Vector3(-2270.12f, 38.59f, 1289.14f),
			new Vector3(-2269.26f, 37.96f, 1288.33f),
			new Vector3(-2268.28f, 37.85f, 1287.7f),
			new Vector3(-2267.26f, 37.82f, 1287.13f),
			new Vector3(-2266.31f, 38.14f, 1286.67f),
			new Vector3(-2265.43f, 38.62f, 1286.28f),
			new Vector3(-2264.5f, 39.13f, 1285.86f),
			new Vector3(-2263.62f, 39.61f, 1285.5f),
			new Vector3(-2262.66f, 40.12f, 1285.16f),
			new Vector3(-2261.75f, 40.6f, 1284.83f),
			new Vector3(-2260.86f, 41.08f, 1284.44f),
			new Vector3(-2259.79f, 41.17f, 1284.07f),
			new Vector3(-2258.6f, 41.17f, 1283.91f),
			new Vector3(-2257.44f, 41.17f, 1284f),
			new Vector3(-2256.34f, 41.17f, 1284.39f),
			new Vector3(-2255.25f, 41.17f, 1284.91f),
			new Vector3(-2254.18f, 41.17f, 1285.42f),
			new Vector3(-2253.09f, 41.17f, 1285.95f),
			new Vector3(-2252.08f, 41.17f, 1286.53f),
			new Vector3(-2251.17f, 41.17f, 1287.27f),
			new Vector3(-2250.29f, 41.17f, 1288.12f),
			new Vector3(-2249.45f, 41.17f, 1288.94f),
			new Vector3(-2248.55f, 41.17f, 1289.81f),
			new Vector3(-2247.68f, 41.17f, 1290.66f),
			new Vector3(-2246.83f, 41.17f, 1291.47f),
			new Vector3(-2245.99f, 41.17f, 1292.34f),
			new Vector3(-2245.14f, 41.17f, 1293.2f),
			new Vector3(-2244.32f, 41.17f, 1294.03f),
			new Vector3(-2243.49f, 41.17f, 1294.86f),
			new Vector3(-2242.68f, 41.17f, 1295.7f),
			new Vector3(-2241.94f, 41.17f, 1296.67f),
			new Vector3(-2241.4f, 41.17f, 1297.74f),
			new Vector3(-2241.18f, 41.18f, 1298.9f),
			new Vector3(-2241.12f, 41.17f, 1300.07f),
			new Vector3(-2241.06f, 41.17f, 1301.27f),
			new Vector3(-2241.08f, 41.17f, 1302.47f),
			new Vector3(-2241.12f, 41.17f, 1303.64f),
			new Vector3(-2241.13f, 41.17f, 1304.81f),
			new Vector3(-2241.13f, 41.17f, 1306f),
			new Vector3(-2241.17f, 41.17f, 1307.17f),
			new Vector3(-2241.34f, 41.17f, 1308.32f),
			new Vector3(-2241.99f, 41.17f, 1309.31f),
			new Vector3(-2242.79f, 41.17f, 1310.18f),
			new Vector3(-2243.59f, 41.17f, 1311.03f),
			new Vector3(-2244.39f, 41.17f, 1311.89f),
			new Vector3(-2245.25f, 41.17f, 1312.73f),
			new Vector3(-2246.1f, 41.17f, 1313.55f),
			new Vector3(-2246.95f, 41.17f, 1314.36f),
			new Vector3(-2247.86f, 41.17f, 1315.17f),
			new Vector3(-2248.82f, 41.17f, 1315.83f),
			new Vector3(-2249.92f, 41.17f, 1316.22f),
			new Vector3(-2251.08f, 41.17f, 1316.34f),
			new Vector3(-2252.25f, 41.17f, 1316.39f),
			new Vector3(-2253.46f, 40.99f, 1316.41f),
			new Vector3(-2254.59f, 40.4f, 1316.44f),
			new Vector3(-2255.72f, 39.83f, 1316.44f),
			new Vector3(-2256.82f, 39.28f, 1316.43f),
			new Vector3(-2257.9f, 38.74f, 1316.41f),
			new Vector3(-2259f, 38.18f, 1316.4f),
			new Vector3(-2260.13f, 37.63f, 1316.39f),
			new Vector3(-2261.25f, 37.26f, 1316.37f),
			new Vector3(-2262.43f, 37.22f, 1316.36f),
			new Vector3(-2263.65f, 37.21f, 1316.36f),
			new Vector3(-2264.84f, 37.17f, 1316.33f),
			new Vector3(-2266f, 37.24f, 1316.33f),
			new Vector3(-2267.18f, 37.34f, 1316.33f),
			new Vector3(-2268.4f, 37.38f, 1316.32f),
			new Vector3(-2269.54f, 37.49f, 1316.29f),
			new Vector3(-2270.61f, 37.88f, 1316.17f),
			new Vector3(-2271.58f, 38.31f, 1315.9f),
			new Vector3(-2272.38f, 38.62f, 1315.18f),
			new Vector3(-2273.21f, 38.81f, 1314.43f),
			new Vector3(-2274.18f, 38.86f, 1313.79f),
			new Vector3(-2275.11f, 39.12f, 1313.2f),
			new Vector3(-2275.93f, 39.33f, 1312.37f),
			new Vector3(-2276.49f, 39.32f, 1311.38f),
			new Vector3(-2276.78f, 39.35f, 1310.31f),
			new Vector3(-2277.08f, 38.95f, 1309.32f),
			new Vector3(-2277.13f, 38.96f, 1308.16f),
			new Vector3(-2277.24f, 38.99f, 1307f),
			new Vector3(-2277.15f, 39.02f, 1305.84f),
			new Vector3(-2276.81f, 39.03f, 1304.72f),
			new Vector3(-2276.23f, 39.11f, 1303.72f),
			new Vector3(-2275.51f, 39.28f, 1302.77f),
			new Vector3(-2274.71f, 39.36f, 1301.86f),
			new Vector3(-2273.88f, 39.37f, 1301.04f),
			new Vector3(-2272.98f, 39.35f, 1300.23f),
			new Vector3(-2272.18f, 38.93f, 1299.39f),
			new Vector3(-2271.48f, 38.52f, 1298.44f),
			new Vector3(-2270.94f, 38.15f, 1297.42f),
			new Vector3(-2270.63f, 37.95f, 1296.3f),
			new Vector3(-2270.29f, 37.98f, 1295.21f),
			new Vector3(-2269.87f, 37.98f, 1294.12f),
			new Vector3(-2269.27f, 37.95f, 1293.26f),
			new Vector3(-2269.08f, 37.84f, 1294.52f),
			new Vector3(-2269.07f, 37.67f, 1295.46f),
			new Vector3(-2269.09f, 37.46f, 1296.49f),
			new Vector3(-2269.09f, 37.43f, 1297.51f),
			new Vector3(-2269.09f, 37.44f, 1298.54f),
			new Vector3(-2269.03f, 37.31f, 1299.65f),
			new Vector3(-2268.69f, 37.22f, 1300.77f),
			new Vector3(-2268.33f, 37.23f, 1301.88f),
			new Vector3(-2268.2f, 37.25f, 1302.98f),
			new Vector3((float)Math.PI * -722f, 37.3f, 1304.13f),
			new Vector3(-2268.34f, 37.37f, 1305.35f),
			new Vector3(-2268.54f, 37.46f, 1306.48f),
			new Vector3(-2268.71f, 37.72f, 1307.56f),
			new Vector3(-2268f, 37.68f, 1308.45f),
			new Vector3(-2267.02f, 37.42f, 1309.08f),
			new Vector3(-2265.94f, 37.36f, 1309.51f),
			new Vector3(-2264.76f, 37.28f, 1309.87f),
			new Vector3(-2263.61f, 37.27f, 1310.08f),
			new Vector3(-2262.41f, 37.27f, 1309.95f),
			new Vector3(-2261.23f, 37.26f, 1309.66f),
			new Vector3(-2260.21f, 37.28f, 1309.11f),
			new Vector3(-2259.33f, 37.31f, 1308.37f),
			new Vector3(-2258.35f, 37.33f, 1308.3f),
			new Vector3(-2257.39f, 37.33f, 1308.3f),
			new Vector3(-2256.44f, 37.34f, 1308.17f),
			new Vector3(-2255.46f, 37.34f, 1308.42f),
			new Vector3(-2254.83f, 37.33f, 1308.51f),
			new Vector3(-2255.48f, 37.38f, 1307.55f),
			new Vector3(-2255.86f, 37.38f, 1306.44f),
			new Vector3(-2256.92f, 37.38f, 1305.99f),
			new Vector3(-2257.89f, 37.38f, 1305.37f),
			new Vector3(-2258.55f, 37.38f, 1304.38f),
			new Vector3(-2259.64f, 37.38f, 1304.16f),
			new Vector3(-2260.82f, 37.38f, 1304.19f),
			new Vector3(-2261.99f, 37.38f, 1304.16f),
			new Vector3(-2263.13f, 37.38f, 1303.94f),
			new Vector3(-2263.87f, 37.38f, 1303.14f),
			new Vector3(-2263.6f, 37.38f, 1301.98f),
			new Vector3(-2263.34f, 37.38f, 1300.83f),
			new Vector3(-2263.11f, 37.38f, 1299.72f),
			new Vector3(-2262.02f, 37.38f, 1299.34f),
			new Vector3(-2260.82f, 37.38f, 1299.33f),
			new Vector3(-2259.73f, 37.38f, 1299.69f),
			new Vector3(-2259.25f, 37.38f, 1300.74f),
			new Vector3(-2258.28f, 37.38f, 1301.08f),
			new Vector3(-2257.71f, 37.38f, 1300.14f),
			new Vector3(-2257.85f, 37.38f, 1299f),
			new Vector3(-2258.36f, 37.38f, 1297.9f),
			new Vector3(-2259.34f, 37.38f, 1297.2f),
			new Vector3(-2260.42f, 37.38f, 1296.85f),
			new Vector3(-2261.58f, 37.38f, 1296.95f),
			new Vector3(-2262.75f, 37.38f, 1296.89f),
			new Vector3(-2263.57f, 37.38f, 1297.45f),
			new Vector3(-2263.67f, 37.38f, 1298.62f),
			new Vector3(-2264.04f, 37.38f, 1299.73f),
			new Vector3(-2264.77f, 37.38f, 1300.63f),
			new Vector3(-2265.75f, 37.38f, 1301.23f),
			new Vector3(-2266.89f, 37.29f, 1301.11f),
			new Vector3(-2267.45f, 37.31f, 1300.18f),
			new Vector3(-2267.56f, 37.8f, 1299.22f),
			new Vector3(-2267.63f, 38.29f, 1298.23f),
			new Vector3(-2267.64f, 38.78f, 1297.25f),
			new Vector3(-2267.65f, 39.27f, 1296.28f),
			new Vector3(-2267.68f, 39.38f, 1295.16f),
			new Vector3(-2267.68f, 39.38f, 1294.4f),
			new Vector3(-2267.7f, 39.38f, 1293.22f),
			new Vector3(-2267.79f, 39.38f, 1292.01f),
			new Vector3(-2267.88f, 39.38f, 1290.84f),
			new Vector3(-2267.89f, 39.38f, 1291.87f),
			new Vector3(-2267.34f, 39.38f, 1291.96f),
			new Vector3(-2266.65f, 39.38f, 1292.46f),
			new Vector3(-2265.56f, 39.38f, 1292.61f),
			new Vector3(-2265.27f, 39.37f, 1291.9f),
			new Vector3(-2265.32f, 39.37f, 1290.98f),
			new Vector3(-2265.5f, 39.38f, 1290.4f),
			new Vector3(-2265.36f, 39.38f, 1291.75f),
			new Vector3(-2266.39f, 39.37f, 1291.97f),
			new Vector3(-2267.52f, 39.38f, 1291.95f),
			new Vector3(-2267.74f, 39.38f, 1292.45f),
			new Vector3(-2267.68f, 39.38f, 1293.6f),
			new Vector3(-2267.69f, 39.38f, 1294.74f),
			new Vector3(-2268.54f, 39.38f, 1294.63f),
			new Vector3(-2267.87f, 39.38f, 1295.34f),
			new Vector3(-2267.03f, 39.38f, 1294.66f),
			new Vector3(-2266.15f, 39.77f, 1294.4f),
			new Vector3(-2265.16f, 40.27f, 1294.41f),
			new Vector3(-2264.19f, 40.75f, 1294.42f),
			new Vector3(-2263.21f, 41.24f, 1294.43f),
			new Vector3(-2262.25f, 41.72f, 1294.44f),
			new Vector3(-2261.24f, 42.22f, 1294.47f),
			new Vector3(-2260.21f, 42.74f, 1294.49f),
			new Vector3(-2259.22f, 43.24f, 1294.47f),
			new Vector3(-2258.36f, 43.38f, 1293.74f),
			new Vector3(-2257.97f, 43.38f, 1292.64f),
			new Vector3(-2257.12f, 43.38f, 1291.94f),
			new Vector3(-2255.94f, 43.38f, 1291.69f),
			new Vector3(-2255.65f, 43.38f, 1292.64f),
			new Vector3(-2256.26f, 43.38f, 1293.46f),
			new Vector3(-2256.44f, 43.38f, 1294.61f),
			new Vector3(-2257.09f, 43.64f, 1295.08f),
			new Vector3(-2258.11f, 43.56f, 1295.04f),
			new Vector3(-2259.27f, 43.54f, 1295.02f),
			new Vector3(-2260.47f, 43.41f, 1294.84f),
			new Vector3(-2261.44f, 42.23f, 1294.67f),
			new Vector3(-2262.5f, 41.6f, 1294.49f),
			new Vector3(-2263.61f, 41.04f, 1294.33f),
			new Vector3(-2264.66f, 40.52f, 1294.42f),
			new Vector3(-2265.7f, 39.99f, 1294.73f),
			new Vector3(-2266.61f, 39.54f, 1294.6f),
			new Vector3(-2267.51f, 39.38f, 1295.18f),
			new Vector3(-2267.55f, 39.32f, 1296.24f),
			new Vector3(-2267.89f, 38.8f, 1297.22f),
			new Vector3(-2267.69f, 38.27f, 1298.29f),
			new Vector3(-2268.08f, 37.77f, 1299.28f),
			new Vector3(-2267.82f, 37.24f, 1300.33f),
			new Vector3(-2267.11f, 37.21f, 1301.21f),
			new Vector3(-2266.15f, 37.38f, 1301.5f),
			new Vector3(-2265.09f, 37.38f, 1301.04f),
			new Vector3(-2264.38f, 37.38f, 1300.22f),
			new Vector3(-2264.21f, 37.38f, 1299.07f),
			new Vector3(-2264.39f, 37.38f, 1297.88f),
			new Vector3(-2264.37f, 37.38f, 1296.77f),
			new Vector3(-2263.9f, 37.35f, 1295.71f),
			new Vector3(-2264.23f, 37.17f, 1294.77f),
			new Vector3(-2265.2f, 37.16f, 1294.11f),
			new Vector3(-2266.2f, 37.21f, 1294.44f),
			new Vector3(-2265.27f, 37.16f, 1294.48f),
			new Vector3(-2264.3f, 37.18f, 1294f),
			new Vector3(-2263.68f, 37.27f, 1293.03f),
			new Vector3(-2264.08f, 37.39f, 1291.94f),
			new Vector3(-2264.11f, 37.37f, 1291f),
			new Vector3(-2264.11f, 37.4f, 1289.95f),
			new Vector3(-2264.24f, 37.46f, 1288.83f),
			new Vector3(-2264.34f, 37.68f, 1287.75f),
			new Vector3(-2263.28f, 37.46f, 1287.47f),
			new Vector3(-2262.25f, 37.18f, 1287.93f),
			new Vector3(-2262.12f, 37.26f, 1289.01f),
			new Vector3(-2261.64f, 37.01f, 1290.08f),
			new Vector3(-2260.97f, 36.73f, 1291.03f),
			new Vector3(-2260.18f, 36.52f, 1291.94f),
			new Vector3(-2259.43f, 36.26f, 1292.88f),
			new Vector3(-2258.65f, 36.24f, 1293.79f),
			new Vector3(-2257.72f, 35.93f, 1294.48f),
			new Vector3(-2256.61f, 35.69f, 1294.57f),
			new Vector3(-2255.53f, 35.8f, 1294.22f),
			new Vector3(-2254.84f, 36.02f, 1293.38f),
			new Vector3(-2254.88f, 36.32f, 1292.31f),
			new Vector3(-2255.21f, 36.38f, 1291.21f),
			new Vector3(-2255.56f, 36.26f, 4053f / (float)Math.PI),
			new Vector3(-2256f, 36.08f, 1288.99f),
			new Vector3(-2256.45f, 35.93f, 1287.89f),
			new Vector3(-2256.92f, 35.83f, 1286.82f),
			new Vector3(-2257.53f, 35.95f, 1285.8f),
			new Vector3(-2258.37f, 36.2f, 1285.11f),
			new Vector3(-2259.54f, 36.42f, 1284.84f),
			new Vector3(-2260.57f, 36.8f, 1284.81f),
			new Vector3(-2260.82f, 36.84f, 1284.22f),
			new Vector3(-2260f, 36.55f, 1284.91f),
			new Vector3(-2258.86f, 36.3f, 1285.05f),
			new Vector3(-2257.69f, 36.06f, 1285.09f),
			new Vector3(-2257.14f, 35.83f, 1285.91f),
			new Vector3(-2256.03f, 35.59f, 1286.21f),
			new Vector3(-2254.81f, 35.47f, 1286.27f),
			new Vector3(-2253.64f, 35.28f, 1286.35f),
			new Vector3(-2252.57f, 35.03f, 1286.82f),
			new Vector3(-2252f, 34.92f, 1287.74f),
			new Vector3(-2252.68f, 35.13f, 1288.61f),
			new Vector3(-2253.44f, 35.5f, 1289.37f),
			new Vector3(-2254.12f, 35.92f, 1290.14f),
			new Vector3(-2254.59f, 36.3f, 1291.06f),
			new Vector3(-2254.75f, 36.37f, 1292.2f),
			new Vector3(-2254.25f, 36.08f, 1293.04f),
			new Vector3(-2254.88f, 36.36f, 1292.2f),
			new Vector3(-2254.7f, 36.33f, 1291.05f),
			new Vector3(-2253.73f, 36f, 1290.78f),
			new Vector3(-2252.7f, 35.81f, 1291.31f),
			new Vector3(-2252.13f, 35.87f, 1292.21f),
			new Vector3(-2251.81f, 35.79f, 1293.15f),
			new Vector3(-2250.84f, 35.69f, 1293.66f),
			new Vector3(-2250.04f, 35.5f, 1292.9f),
			new Vector3(-2249.54f, 35.28f, 1291.75f),
			new Vector3(-2249.1f, 34.76f, 1290.71f),
			new Vector3(-2248.1f, 34.49f, 1290.81f),
			new Vector3(-2247.44f, 34.75f, 1291.74f),
			new Vector3(-2247.1f, 34.88f, 1292.81f),
			new Vector3(-2247.38f, 35.02f, 1293.9f),
			new Vector3(-2247.99f, 35.4f, 1294.8f),
			new Vector3(-2248.33f, 35.76f, 1295.79f),
			new Vector3(-2248.59f, 36f, 1296.86f),
			new Vector3(-2249.08f, 36.18f, 1297.87f),
			new Vector3(-2248.96f, 36.29f, 1298.99f),
			new Vector3(-2248.06f, 35.97f, 1299.63f),
			new Vector3(-2246.93f, 35.97f, 1299.54f),
			new Vector3(-2246.3f, 36.05f, 1298.59f),
			new Vector3(-2245.98f, 36.06f, 1297.48f),
			new Vector3(-2245.51f, 35.73f, 1296.42f),
			new Vector3(-2244.76f, 35.31f, 1295.57f),
			new Vector3(-2243.79f, 34.99f, 1294.98f),
			new Vector3(-2243.24f, 34.79f, 1294.94f),
			new Vector3(-2244.6f, 35.28f, 1295.62f),
			new Vector3(-2244.82f, 35.6f, 1296.66f),
			new Vector3(-2244.23f, 35.54f, 1297.17f),
			new Vector3(-2243.16f, 35.32f, 1297.29f),
			new Vector3(-2242f, 35.07f, 1297.21f),
			new Vector3(-2241.36f, 34.91f, 1297.64f),
			new Vector3(-2242.04f, 35.19f, 1298.45f),
			new Vector3(-2242.46f, 35.29f, 1299.52f),
			new Vector3(-2242.51f, 35.09f, 1300.66f),
			new Vector3(-2243.2f, 35.14f, 1301.55f),
			new Vector3(-2244.33f, 35.42f, 1301.5f),
			new Vector3(-2245.15f, 35.75f, 1300.9f),
			new Vector3(-2246.25f, 35.97f, 1300.92f),
			new Vector3(-2247.36f, 35.96f, 1300.9f),
			new Vector3(-2248.53f, 35.88f, 1300.83f),
			new Vector3(-2249.67f, 36.04f, 1300.82f),
			new Vector3(-2250.81f, 36.12f, 1300.99f),
			new Vector3(-6121f / (float)Math.E, 35.93f, 1301.59f),
			new Vector3(-2251.8f, 36.21f, 1302.53f),
			new Vector3(-2250.98f, 36.33f, 1303.29f),
			new Vector3(-2250.07f, 36.18f, 1304.03f),
			new Vector3(-2249.42f, 35.87f, 1305f),
			new Vector3(-2248.83f, 35.19f, 1305.91f),
			new Vector3(-2247.85f, 34.82f, 1306.36f),
			new Vector3(-2247.15f, 35.01f, 1305.73f),
			new Vector3(-2246.3f, 35.18f, 1304.94f),
			new Vector3(-2245.38f, 35.1f, 1304.21f),
			new Vector3(-2244.59f, 35.17f, 1303.4f),
			new Vector3(-2244f, 35.26f, 1302.38f),
			new Vector3(-2243.56f, 35.25f, 1301.26f),
			new Vector3(-2242.73f, 35.19f, 1300.52f),
			new Vector3(-2242.01f, 34.86f, 1301.23f),
			new Vector3(-2242.1f, 34.84f, 1302.38f),
			new Vector3(-2242.9f, 34.88f, 1303.21f),
			new Vector3(-2243.92f, 34.91f, 1303.84f),
			new Vector3(-2244.94f, 34.99f, 1304.37f),
			new Vector3(-2245.83f, 35.16f, 1305.01f),
			new Vector3(-2246.11f, 35.01f, 1306.05f),
			new Vector3(-2245.11f, 34.81f, 1306.67f),
			new Vector3(-2243.95f, 34.69f, 1306.73f),
			new Vector3(-2242.87f, 34.84f, 1306.41f),
			new Vector3(-2241.79f, 34.84f, 1306.1f),
			new Vector3(-2241.51f, 35.03f, 1306.99f),
			new Vector3(-2242.36f, 34.89f, 1307.77f),
			new Vector3(-2243.48f, 34.7f, 1308.11f),
			new Vector3(-2244.04f, 34.9f, 1308.69f),
			new Vector3(-2242.94f, 34.81f, 1308.92f),
			new Vector3(-2242.52f, 35.09f, 1309.66f),
			new Vector3(-2243.22f, 35.23f, 1310.56f),
			new Vector3(-2243.97f, 35.23f, 1311.49f),
			new Vector3(-2244.99f, 35.31f, 1311.53f),
			new Vector3(-2245.77f, 35.17f, 1310.63f),
			new Vector3(-2246.65f, 35.09f, 1309.92f),
			new Vector3(-2247.55f, 35.59f, 1309.8f),
			new Vector3(-2248.2f, 36.09f, 1310.44f),
			new Vector3(-2248.28f, 36.4f, 1311.5f),
			new Vector3(-2247.93f, 36.3f, 1312.62f),
			new Vector3(-2247.67f, 36.28f, 1313.73f),
			new Vector3(-2248f, 36.59f, 1314.73f),
			new Vector3(-2248.83f, 36.75f, 1315.53f),
			new Vector3(-2249.95f, 36.86f, 1315.73f),
			new Vector3(-2251.09f, 36.99f, 1315.86f),
			new Vector3(-2252.21f, 37.08f, 1315.85f),
			new Vector3(-2253.22f, 37.11f, 1315.31f),
			new Vector3(-2254.3f, 37.16f, 1314.94f),
			new Vector3(-2255.47f, 37.28f, 1314.74f),
			new Vector3(-2256.62f, 37.28f, 1314.53f),
			new Vector3(-2257.23f, 37.31f, 1313.66f),
			new Vector3(-2256.54f, 37.27f, 1312.78f),
			new Vector3(-2255.7f, 37.25f, 1313.1f),
			new Vector3(-2254.79f, 37.26f, 1313.66f),
			new Vector3(-2253.76f, 37.23f, 1312.99f),
			new Vector3(-2252.9f, 37.14f, 1312.21f),
			new Vector3(-2252.68f, 37.18f, 1311.03f),
			new Vector3(-2252.53f, 37.29f, 1309.89f),
			new Vector3(-2252.47f, 37.26f, 1308.72f),
			new Vector3(-2252.53f, 37.14f, 1307.5f),
			new Vector3(-2252.62f, 37.06f, 1306.33f),
			new Vector3(-2252.77f, 37.15f, 1305.2f),
			new Vector3(-2252.91f, 37.08f, 1304.35f)
		};

		private const float MaxDistance = 3f;

		[ModTest(Name = "HNA_WalkableCoverage_AllPointsWithinCellSize", Order = 200)]
		public static void AllPointsWithinCellSize()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (!VillageRegistry.IsAnyAvailable)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[ModTest] skip name=walkable_coverage reason=hna_not_built");
				}
				return;
			}
			List<Vector3> list = CollectAllRegionCenters();
			if (list.Count == 0)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"[ModTest] HNA graph has no region centers — skipping walkable coverage test");
				}
				return;
			}
			int num = 0;
			int num2 = 0;
			float num3 = 0f;
			int num4 = -1;
			List<string> list2 = new List<string>();
			for (int i = 0; i < WalkablePositions.Length; i++)
			{
				Vector3 val = WalkablePositions[i];
				float num5 = NearestCenterDist3D(val, list);
				if (num5 <= 3f)
				{
					num++;
					continue;
				}
				num2++;
				if (num5 > num3)
				{
					num3 = num5;
					num4 = i;
				}
				if (list2.Count < 20)
				{
					list2.Add($"  [{i}] ({val.x:F1}, {val.y:F1}, {val.z:F1}) nearest={num5:F2}m");
				}
			}
			float num6 = 100f * (float)num / (float)WalkablePositions.Length;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[HNA Coverage] {num}/{WalkablePositions.Length} points within " + $"{3f}m (3D) of a region center ({num6:F1}%)");
			stringBuilder.AppendLine($"  Graph regions total: {list.Count}");
			if (num2 > 0)
			{
				stringBuilder.AppendLine($"  Uncovered: {num2} (worst: [{num4}] at {num3:F2}m)");
				foreach (string item in list2)
				{
					stringBuilder.AppendLine(item);
				}
				if (num2 > 20)
				{
					stringBuilder.AppendLine($"  ... and {num2 - 20} more");
				}
			}
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)stringBuilder.ToString());
			}
			ModAssert.True(num2 == 0, $"HNA coverage: {num2}/{WalkablePositions.Length} walkable points are " + $"farther than {3f}m (3D) from any region center " + $"(worst: [{num4}] at {num3:F2}m). Coverage={num6:F1}%");
		}

		[ModTest(Name = "HNA_WalkableCoverage_PointToRegionResolution", Order = 201)]
		public static void PointToRegionResolution()
		{
			//IL_0035: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (!VillageRegistry.IsAnyAvailable)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[ModTest] skip name=point_to_region reason=hna_not_built");
				}
				return;
			}
			int num = 0;
			int num2 = 0;
			List<string> list = new List<string>();
			for (int i = 0; i < WalkablePositions.Length; i++)
			{
				Vector3 val = WalkablePositions[i];
				RegionGraph regionGraph = VillageRegistry.GraphAt(val);
				if (regionGraph == null || !regionGraph.IsAvailable)
				{
					num2++;
					continue;
				}
				if (regionGraph.PointToRegionId(val) != null)
				{
					num++;
					continue;
				}
				num2++;
				if (list.Count < 20)
				{
					list.Add($"  [{i}] ({val.x:F1}, {val.y:F1}, {val.z:F1})");
				}
			}
			float num3 = 100f * (float)num / (float)WalkablePositions.Length;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[HNA PointToRegion] {num}/{WalkablePositions.Length} " + $"points resolve to a region ({num3:F1}%)");
			if (num2 > 0)
			{
				stringBuilder.AppendLine($"  Unresolved: {num2}");
				foreach (string item in list)
				{
					stringBuilder.AppendLine(item);
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)stringBuilder.ToString());
			}
			ModAssert.True(num2 == 0, $"HNA PointToRegion: {num2}/{WalkablePositions.Length} walkable points " + $"did not resolve to any region. Resolution={num3:F1}%");
		}

		[ModTest(Name = "HNA_WalkableCoverage_GraphHasMinimumRegions", Order = 199)]
		public static void GraphHasMinimumRegions()
		{
			if (!VillageRegistry.IsAnyAvailable)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[ModTest] skip name=minimum_regions reason=hna_not_built");
				}
				return;
			}
			List<Vector3> list = CollectAllRegionCenters();
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"[HNA MinRegions] Total region centers across all graphs: {list.Count}");
			}
			ModAssert.True(list.Count >= 10, "HNA graph should have at least 10 regions to cover the village, " + $"but has {list.Count}");
		}

		[ModTest(Name = "HNA_Pruning_AllRegionsHaveGroundBelow", Order = 202)]
		public static void AllRegionsHaveGroundBelow()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!VillageRegistry.IsAnyAvailable)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[ModTest] skip name=ground_below reason=hna_not_built");
				}
				return;
			}
			List<Vector3> list = CollectAllRegionCenters();
			int num = 0;
			int num2 = 0;
			List<string> list2 = new List<string>();
			foreach (Vector3 item in list)
			{
				if (CellValidator.HasGroundBelow(item))
				{
					num++;
					continue;
				}
				num2++;
				if (list2.Count < 10)
				{
					list2.Add($"  ({item.x:F1}, {item.y:F1}, {item.z:F1})");
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[HNA GroundBelow] {num}/{list.Count} regions have ground below");
			if (num2 > 0)
			{
				stringBuilder.AppendLine($"  Floating: {num2}");
				foreach (string item2 in list2)
				{
					stringBuilder.AppendLine(item2);
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)stringBuilder.ToString());
			}
			if (num2 > 0)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)($"[HNA GroundBelow] {num2}/{list.Count} region centers lack solid " + $"ground within {2f}m (may include restored graphs)"));
				}
			}
		}

		[ModTest(Name = "HNA_Pruning_AllRegionsHaveSufficientWidth", Order = 203)]
		public static void AllRegionsHaveSufficientWidth()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (!VillageRegistry.IsAnyAvailable)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[ModTest] skip name=surface_width reason=hna_not_built");
				}
				return;
			}
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.ResolveValheimHumanoidAgentTypeID();
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter filter = val;
			List<Vector3> list = CollectAllRegionCenters();
			int num = 0;
			int num2 = 0;
			List<string> list2 = new List<string>();
			foreach (Vector3 item in list)
			{
				if (CellValidator.IsSurfaceWideEnough(item, filter))
				{
					num++;
					continue;
				}
				num2++;
				if (list2.Count < 10)
				{
					list2.Add($"  ({item.x:F1}, {item.y:F1}, {item.z:F1})");
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[HNA SurfaceWidth] {num}/{list.Count} regions have " + $"sufficient width (>= {0.2f}m from edge)");
			if (num2 > 0)
			{
				stringBuilder.AppendLine($"  Too narrow: {num2}");
				foreach (string item2 in list2)
				{
					stringBuilder.AppendLine(item2);
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)stringBuilder.ToString());
			}
			if (num2 > 0)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)($"[HNA SurfaceWidth] {num2}/{list.Count} region centers are closer " + $"than {0.2f}m to a NavMesh edge (may include restored graphs)"));
				}
			}
		}

		private static List<Vector3> CollectAllRegionCenters()
		{
			List<Vector3> list = new List<Vector3>();
			foreach (RegionGraph item in VillageRegistry.AllGraphs())
			{
				list.AddRange(item.Diagnostics.GetAllRegionCenters());
			}
			return list;
		}

		private static float NearestCenterDist3D(Vector3 point, List<Vector3> centers)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MaxValue;
			for (int i = 0; i < centers.Count; i++)
			{
				float num2 = Vector3.Distance(point, centers[i]);
				if (num2 < num)
				{
					num = num2;
				}
			}
			return num;
		}
	}
}
namespace ValheimVillages.Helpers
{
	public static class UIHelpers
	{
		public static void ShowHudMessage(string text)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		public static void ShowHudNotification(string text)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, text, 0, (Sprite)null);
			}
		}

		public static void PrintConsole(string text)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
		}

		public static void CloseInventoryUI()
		{
			InventoryGui instance = InventoryGui.instance;
			if (instance != null)
			{
				instance.Hide();
			}
		}
	}
}
namespace ValheimVillages.Enums
{
	public enum TimeOfDay
	{
		Night,
		Morning,
		Day,
		Evening
	}
	public enum LocationType
	{
		Home,
		Shelter,
		Fire,
		Table,
		Chair,
		Farm,
		Animals,
		CraftStation,
		CookingStation
	}
	public enum BehaviorState
	{
		Idle,
		Wandering,
		Traveling,
		Patrolling,
		Exploring,
		Working,
		Alarmed,
		NeedsHelp
	}
	public enum TaskPriority
	{
		Low = 1,
		Medium,
		High
	}
}
namespace ValheimVillages.Diagnostics
{
	internal static class AgentDumpCommand
	{
		[DevCommand("Dump NavMesh villager agent registration state (slot 31)", Name = "vv_agent_dump")]
		public static void Run(ConsoleEventArgs args)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"[vv_agent_dump] IsRegistered={VillagerAgentType.IsRegistered} " + $"UnityAgentTypeID={VillagerAgentType.UnityAgentTypeID}");
			int settingsCount = NavMesh.GetSettingsCount();
			stringBuilder.AppendLine($"  Unity NavMesh settings count={settingsCount}");
			for (int i = 0; i < settingsCount; i++)
			{
				NavMeshBuildSettings settingsByIndex = NavMesh.GetSettingsByIndex(i);
				stringBuilder.AppendLine($"    unity[{i}] agentTypeID={((NavMeshBuildSettings)(ref settingsByIndex)).agentTypeID} radius={((NavMeshBuildSettings)(ref settingsByIndex)).agentRadius:F2} " + $"height={((NavMeshBuildSettings)(ref settingsByIndex)).agentHeight:F2} slope={((NavMeshBuildSettings)(ref settingsByIndex)).agentSlope:F0} climb={((NavMeshBuildSettings)(ref settingsByIndex)).agentClimb:F2}");
			}
			NavMeshBuildSettings settingsByID = NavMesh.GetSettingsByID(VillagerAgentType.UnityAgentTypeID);
			stringBuilder.AppendLine($"  GetSettingsByID({VillagerAgentType.UnityAgentTypeID}) -> " + $"agentTypeID={((NavMeshBuildSettings)(ref settingsByID)).agentTypeID} radius={((NavMeshBuildSettings)(ref settingsByID)).agentRadius:F2} " + $"height={((NavMeshBuildSettings)(ref settingsByID)).agentHeight:F2} slope={((NavMeshBuildSettings)(ref settingsByID)).agentSlope:F0} climb={((NavMeshBuildSettings)(ref settingsByID)).agentClimb:F2}");
			Pathfinding instance = Pathfinding.instance;
			if ((Object)(object)instance == (Object)null)
			{
				stringBuilder.AppendLine("  Pathfinding.instance NULL");
				Emit(stringBuilder);
				return;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
			IList list = typeof(Pathfinding).GetField("m_agentSettings", bindingAttr)?.GetValue(instance) as IList;
			Type? nestedType = typeof(Pathfinding).GetNestedType("AgentSettings", BindingFlags.NonPublic);
			FieldInfo fieldInfo = nestedType?.GetField("m_agentType");
			FieldInfo fieldInfo2 = nestedType?.GetField("m_build");
			stringBuilder.AppendLine($"  Pathfinding.m_agentSettings count={list?.Count}");
			if (list != null && fieldInfo != null && fieldInfo2 != null)
			{
				for (int j = 0; j < list.Count; j++)
				{
					object obj = list[j];
					if (obj == null)
					{
						stringBuilder.AppendLine($"    idx[{j}] null");
						continue;
					}
					object value = fieldInfo.GetValue(obj);
					NavMeshBuildSettings val = (NavMeshBuildSettings)fieldInfo2.GetValue(obj);
					stringBuilder.AppendLine($"    idx[{j}] m_agentType={value} agentTypeID={((NavMeshBuildSettings)(ref val)).agentTypeID} " + $"radius={((NavMeshBuildSettings)(ref val)).agentRadius:F2} climb={((NavMeshBuildSettings)(ref val)).agentClimb:F2}");
				}
			}
			Emit(stringBuilder);
		}

		private static void Emit(StringBuilder sb)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(sb.ToString());
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)sb.ToString());
			}
		}
	}
	internal sealed class AiEventRing
	{
		public enum EventKind
		{
			TargetSet,
			PathRecompute,
			StateChange
		}

		public readonly struct Event
		{
			public readonly float TimeSec;

			public readonly EventKind Kind;

			public readonly string Detail;

			public readonly Vector3 PosA;

			public readonly Vector3 PosB;

			public readonly int IntA;

			public Event(float t, EventKind kind, string detail, Vector3 posA, Vector3 posB, int intA)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				TimeSec = t;
				Kind = kind;
				Detail = detail;
				PosA = posA;
				PosB = posB;
				IntA = intA;
			}
		}

		private const int Capacity = 256;

		private readonly Event[] m_buffer = new Event[256];

		private int m_writeIdx;

		private int m_count;

		public int Count => m_count;

		public void RecordTargetSet(Vector3 newTarget, Vector3 prevTarget, string source)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Append(new Event(Time.time, EventKind.TargetSet, source ?? "unknown", newTarget, prevTarget, 0));
		}

		public void RecordPathRecompute(string result, int cornerCount, Vector3 target)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Append(new Event(Time.time, EventKind.PathRecompute, result ?? "unknown", target, Vector3.zero, cornerCount));
		}

		public void RecordStateChange(string prevState, string nextState, string reason)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			string detail = prevState + "->" + nextState + ":" + reason;
			Append(new Event(Time.time, EventKind.StateChange, detail, Vector3.zero, Vector3.zero, 0));
		}

		private void Append(Event ev)
		{
			m_buffer[m_writeIdx] = ev;
			m_writeIdx = (m_writeIdx + 1) % 256;
			if (m_count < 256)
			{
				m_count++;
			}
		}

		public List<Event> Snapshot(float nowSec, float lookbackSec)
		{
			List<Event> list = new List<Event>(m_count);
			int num = (m_writeIdx - m_count + 256) % 256;
			float num2 = nowSec - lookbackSec;
			for (int i = 0; i < m_count; i++)
			{
				Event item = m_buffer[(num + i) % 256];
				if (item.TimeSec >= num2)
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	internal static class CaptureAnchor
	{
		public readonly struct Result
		{
			public readonly bool HasAnchor;

			public readonly Vector3 Pos;

			public readonly float Yaw;

			public readonly float Pitch;

			public readonly string Reason;

			public Result(bool hasAnchor, Vector3 pos, float yaw, float pitch, string reason)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				HasAnchor = hasAnchor;
				Pos = pos;
				Yaw = yaw;
				Pitch = pitch;
				Reason = reason;
			}

			public static Result NoAnchor(string reason)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return new Result(hasAnchor: false, Vector3.zero, 0f, 0f, reason);
			}

			public static Result From(Vector3 anchorPos)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				return new Result(hasAnchor: true, anchorPos + Vector3.up * 45f, 0f, 90f, null);
			}

			public static Result At(Vector3 anchorXZ, float clearance)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				return new Result(hasAnchor: true, anchorXZ + Vector3.up * clearance, 0f, 90f, null);
			}
		}

		public const float VerticalClearance = 45f;

		public static Result Resolve(Vector3? preferNear = null)
		{
			//IL_0047: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> allAnchorPositions;
			try
			{
				allAnchorPositions = VillagerAIManager.GetAllAnchorPositions();
			}
			catch
			{
				return Result.NoAnchor("VillagerAIManager threw resolving anchors");
			}
			if (allAnchorPositions == null || allAnchorPositions.Count == 0)
			{
				return Result.NoAnchor("no seed anchors registered");
			}
			if (!preferNear.HasValue)
			{
				return Result.From(allAnchorPositions[0]);
			}
			Vector3 anchorPos = allAnchorPositions[0];
			float num = float.MaxValue;
			foreach (Vector3 item in allAnchorPositions)
			{
				float num2 = item.x - preferNear.Value.x;
				float num3 = item.z - preferNear.Value.z;
				float num4 = num2 * num2 + num3 * num3;
				if (num4 < num)
				{
					num = num4;
					anchorPos = item;
				}
			}
			return Result.From(anchorPos);
		}

		public static Result ResolveAt(Vector3 worldPos, float clearance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Result.At(worldPos, clearance);
		}
	}
	internal static class CaptureCommand
	{
		[DevCommand("Capture an orchestrated village screenshot + diagnostics sidecar", Name = "vv_capture")]
		public static void Capture()
		{
			DebugLog.Capture("manual");
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print("[vv_capture] Enqueued orchestrated capture (manual trigger)");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[vv_capture] Enqueued orchestrated capture (manual trigger)");
			}
		}

		[DevCommand("Capture at (x, z) [clearance=10m]: vv_capture_at <x> <z> [clearance]", Name = "vv_capture_at")]
		public static void CaptureAt(string xArg, string zArg, string clearanceArg = null)
		{
			//IL_00dd: 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)
			if (!float.TryParse(xArg, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !float.TryParse(zArg, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				Report("could not parse coords '" + xArg + "' '" + zArg + "' as floats");
				return;
			}
			float result3 = 10f;
			if (!string.IsNullOrEmpty(clearanceArg) && !float.TryParse(clearanceArg, NumberStyles.Float, CultureInfo.InvariantCulture, out result3))
			{
				Report("could not parse clearance '" + clearanceArg + "' as float, using 10m");
				result3 = 10f;
			}
			float num = 0f;
			float num2 = default(float);
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetSolidHeight(new Vector3(result, 500f, result2), ref num2, 550))
			{
				num = num2;
			}
			DebugLog.Capture(CaptureRequest.ForIncident("manual_at", "", "last_capture", new Vector3(result, num, result2), result3));
			Report($"enqueued at ({result:F1},{num:F1},{result2:F1}) clearance={result3:F1}m");
		}

		private static void Report(string state)
		{
			string text = "[vv_capture_at] " + state;
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}
	}
	internal static class FreezeTime
	{
		private const float DefaultFrozenTime = 0.5f;

		public static bool AutoFreezeOnLoad => false;

		public static void ApplyAutoFreeze()
		{
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				if (AutoFreezeOnLoad)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)"[FreezeTime] Auto-freeze deferred: EnvMan not yet alive. Run vv_freezetime once in-world to apply.");
					}
				}
			}
			else
			{
				SetFrozen(AutoFreezeOnLoad, 0.5f);
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)(AutoFreezeOnLoad ? $"[FreezeTime] Auto-frozen at time={0.5f:F2} on load." : "[FreezeTime] Day/night cycle left running (auto-freeze disabled)."));
				}
			}
		}

		[DevCommand("Freeze the day/night cycle (no arg=unfreeze; or pass a time 0..1)", Name = "vv_freezetime")]
		public static void Toggle(string arg = null)
		{
			float result;
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					instance.Print("[vv_freezetime] EnvMan not available — no world loaded?");
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"[vv_freezetime] EnvMan not available — no world loaded?");
				}
			}
			else if (string.IsNullOrEmpty(arg))
			{
				if (EnvMan.instance.m_debugTimeOfDay)
				{
					SetFrozen(frozen: false, 0f);
					Report($"unfrozen (was at time={EnvMan.instance.m_debugTime:F2})");
				}
				else
				{
					SetFrozen(frozen: true, 0.5f);
					Report($"frozen at time={0.5f:F2} (noon)");
				}
			}
			else if (!float.TryParse(arg, NumberStyles.Float, CultureInfo.InvariantCulture, out result))
			{
				Report("could not parse '" + arg + "' as a time-of-day (0..1)");
			}
			else
			{
				result = Mathf.Clamp01(result);
				SetFrozen(frozen: true, result);
				Report($"frozen at time={result:F2}");
			}
		}

		private static void SetFrozen(bool frozen, float timeOfDay)
		{
			EnvMan.instance.m_debugTimeOfDay = frozen;
			if (frozen)
			{
				EnvMan.instance.m_debugTime = timeOfDay;
			}
		}

		private static void Report(string state)
		{
			string text = "[vv_freezetime] " + state;
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}
	}
	internal static class IncidentRecorder
	{
		private const int DestBucketM = 4;

		private const float IncidentAnchorClearance = 10f;

		private const float EventRingLookbackSec = 30f;

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

		private static int s_nextIncidentSeq;

		public static void ClearOnLoad()
		{
			try
			{
				string path = IncidentsDir();
				if (Directory.Exists(path))
				{
					Directory.Delete(path, recursive: true);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[IncidentRecorder] Failed to clear incidents/ on load: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			s_keyToIncidentId.Clear();
			s_nextIncidentSeq = 0;
		}

		public static void Record(VillagerAI ai, Vector3 destPos, string failureKind)
		{
			_ = (Object)(object)ai == (Object)null;
		}

		private static string ComputeKey(VillagerAI ai, Vector3 destPos, string failureKind)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(destPos.x / 4f);
			int num2 = Mathf.RoundToInt(destPos.z / 4f);
			return $"{Sanitize(ai.UniqueId)}_{num}_{num2}_{failureKind}";
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "unknown";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			foreach (char c in s)
			{
				stringBuilder.Append((char.IsLetterOrDigit(c) || c == '_') ? c : '_');
			}
			return stringBuilder.ToString();
		}

		private static void BumpExisting(string incidentId)
		{
			try
			{
				string path = Path.Combine(Path.Combine(IncidentsDir(), incidentId), "incident.json");
				if (File.Exists(path))
				{
					string json = File.ReadAllText(path);
					json = BumpField(json, "occurrences");
					json = ReplaceField(json, "lastSeenUtc", "\"" + DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture) + "\"");
					File.WriteAllText(path, json);
					UpdateIndexBump(incidentId);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[IncidentRecorder] Bump failed for " + incidentId + ": " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static string BumpField(string json, string fieldName)
		{
			string text = "\"" + fieldName + "\":";
			int num = json.IndexOf(text, StringComparison.Ordinal);
			if (num < 0)
			{
				return json;
			}
			int num2 = num + text.Length;
			int i;
			for (i = num2; i < json.Length && (char.IsDigit(json[i]) || json[i] == ' '); i++)
			{
			}
			if (!int.TryParse(json.Substring(num2, i - num2).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return json;
			}
			return json.Substring(0, num2) + (result + 1).ToString(CultureInfo.InvariantCulture) + json.Substring(i);
		}

		private static string ReplaceField(string json, string fieldName, string newValueLiteral)
		{
			string text = "\"" + fieldName + "\":";
			int num = json.IndexOf(text, StringComparison.Ordinal);
			if (num < 0)
			{
				return json;
			}
			int i;
			for (i = num + text.Length; i < json.Length && json[i] == ' '; i++)
			{
			}
			if (i >= json.Length)
			{
				return json;
			}
			int j;
			if (json[i] == '"')
			{
				for (j = i + 1; j < json.Length && json[j] != '"'; j++)
				{
				}
				if (j < json.Length)
				{
					j++;
				}
			}
			else
			{
				for (j = i; j < json.Length && json[j] != ',' && json[j] != '}'; j++)
				{
				}
			}
			return json.Substring(0, i) + newValueLiteral + json.Substring(j);
		}

		private static void WriteIncidentBundle(VillagerAI ai, Vector3 destPos, string failureKind, string incidentId, string compositeKey)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(IncidentsDir(), incidentId);
			Directory.CreateDirectory(text);
			Vector3 val = (((Object)(object)((Component)ai).transform != (Object)null) ? ((Component)ai).transform.position : Vector3.zero);
			RegionGraph graph = VillageRegistry.GraphAt(val);
			StringBuilder stringBuilder = new StringBuilder(4096);
			stringBuilder.Append('{');
			stringBuilder.Append("\"incidentId\":\"").Append(JsonEscape(incidentId)).Append("\",");
			stringBuilder.Append("\"compositeKey\":\"").Append(JsonEscape(compositeKey)).Append("\",");
			stringBuilder.Append("\"failureKind\":\"").Append(JsonEscape(failureKind)).Append("\",");
			stringBuilder.Append("\"occurrences\":1,");
			stringBuilder.Append("\"firstSeenUtc\":\"").Append(DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)).Append("\",");
			stringBuilder.Append("\"lastSeenUtc\":\"").Append(DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)).Append("\",");
			AppendVillagerBlock(stringBuilder, ai, val);
			stringBuilder.Append(',');
			AppendDestinationBlock(stringBuilder, ai, destPos);
			stringBuilder.Append(',');
			AppendLastPathBlock(stringBuilder, ai);
			stringBuilder.Append(',');
			AppendHnaBlock(stringBuilder, graph, val, destPos);
			stringBuilder.Append(',');
			AppendRecentEventsBlock(stringBuilder, ai);
			stringBuilder.Append('}');
			File.WriteAllText(Path.Combine(text, "incident.json"), stringBuilder.ToString());
			UpdateIndexAdd(incidentId, ai, destPos, failureKind);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[IncidentRecorder] " + incidentId + ": dumped " + failureKind + " for " + ai.NpcName + " -> " + $"({destPos.x:F1},{destPos.z:F1})"));
			}
		}

		private static void AppendVillagerBlock(StringBuilder sb, VillagerAI ai, Vector3 pos)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			sb.Append("\"villager\":{");
			sb.Append("\"id\":\"").Append(JsonEscape(ai.UniqueId)).Append("\",");
			sb.Append("\"name\":\"").Append(JsonEscape(ai.NpcName)).Append("\",");
			sb.Append("\"type\":\"").Append(JsonEscape(ai.VillagerType.ToString())).Append("\",");
			sb.Append("\"state\":\"").Append(JsonEscape(ai.CurrentState.ToString())).Append("\",");
			sb.Append("\"pos\":").Append(JsonVec3(pos)).Append(',');
			Vector3 v = ((ai.Memory != null) ? ai.Memory.HomeAnchor : Vector3.zero);
			sb.Append("\"anchorPosition\":").Append(JsonVec3(v));
			sb.Append('}');
		}

		private static void AppendDestinationBlock(StringBuilder sb, VillagerAI ai, Vector3 destPos)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			sb.Append("\"destination\":{");
			sb.Append("\"pos\":").Append(JsonVec3(destPos));
			sb.Append('}');
		}

		private static void AppendLastPathBlock(StringBuilder sb, VillagerAI ai)
		{
			//IL_006c: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			sb.Append("\"lastPath\":{");
			sb.Append("\"available\":");
			List<Vector3> list = TryGetCurrentPathCorners(ai);
			if (list == null || list.Count == 0)
			{
				sb.Append("false}");
				return;
			}
			sb.Append("true,\"cornerCount\":").Append(list.Count).Append(",\"corners\":[");
			for (int i = 0; i < list.Count; i++)
			{
				if (i > 0)
				{
					sb.Append(',');
				}
				sb.Append(JsonVec3(list[i]));
			}
			sb.Append("]");
			sb.Append(",\"segmentCasts\":");
			AppendSegmentCasts(sb, ((Object)(object)((Component)ai).transform != (Object)null) ? ((Component)ai).transform.position : Vector3.zero, list);
			sb.Append('}');
		}

		private static void AppendSegmentCasts(StringBuilder sb, Vector3 villagerPos, List<Vector3> corners)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			sb.Append('[');
			int mask = LayerMask.GetMask(new string[5] { "Default", "static_solid", "piece", "blocker", "pathblocker" });
			Vector3 val = villagerPos;
			RaycastHit val6 = default(RaycastHit);
			for (int i = 0; i < corners.Count; i++)
			{
				if (i > 0)
				{
					sb.Append(',');
				}
				Vector3 val2 = corners[i];
				Vector3 val3 = val2 - val;
				float magnitude = ((Vector3)(ref val3)).magnitude;
				sb.Append("{\"segment\":").Append(i).Append(",\"distM\":")
					.Append(magnitude.ToString("F2", CultureInfo.InvariantCulture));
				if (magnitude < 0.001f)
				{
					sb.Append(",\"degenerate\":true}");
					val = val2;
					continue;
				}
				try
				{
					Vector3 val4 = val + Vector3.up * 0.5f;
					Vector3 val5 = val + Vector3.up * 1.35f;
					if (Physics.CapsuleCast(val4, val5, 0.4f, val3 / magnitude, ref val6, magnitude, mask, (QueryTriggerInteraction)1))
					{
						string s = (((Object)(object)((RaycastHit)(ref val6)).collider != (Object)null) ? ((Object)((RaycastHit)(ref val6)).collider).name : "(null)");
						int value = (((Object)(object)((RaycastHit)(ref val6)).collider != (Object)null) ? ((Component)((RaycastHit)(ref val6)).collider).gameObject.layer : (-1));
						sb.Append(",\"blocked\":true").Append(",\"hitName\":\"").Append(JsonEscape(s))
							.Append('"')
							.Append(",\"hitLayer\":")
							.Append(value)
							.Append(",\"hitDistM\":")
							.Append(((RaycastHit)(ref val6)).distance.ToString("F2", CultureInfo.InvariantCulture))
							.Append(",\"hitPos\":")
							.Append(JsonVec3(((RaycastHit)(ref val6)).point));
					}
					else
					{
						sb.Append(",\"blocked\":false");
					}
				}
				catch (Exception ex)
				{
					sb.Append(",\"castError\":\"").Append(JsonEscape(ex.GetType().Name)).Append('"');
				}
				sb.Append('}');
				val = val2;
			}
			sb.Append(']');
		}

		private static List<Vector3> TryGetCurrentPathCorners(VillagerAI ai)
		{
			try
			{
				return (typeof(VillagerAI).GetField("s_pathField", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null) as FieldInfo)?.GetValue(ai) as List<Vector3>;
			}
			catch
			{
				return null;
			}
		}

		private static void AppendHnaBlock(StringBuilder sb, RegionGraph graph, Vector3 villagerPos, Vector3 destPos)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			sb.Append("\"hna\":{");
			if (graph == null || !graph.IsAvailable)
			{
				sb.Append("\"available\":false}");
				return;
			}
			sb.Append("\"available\":true,");
			sb.Append("\"villageKey\":\"").Append(JsonEscape(graph.RegisteredVillageKey ?? "")).Append("\",");
			string text = graph.PointToRegionId(villagerPos);
			string text2 = graph.PointToRegionId(destPos);
			sb.Append("\"sourceRegionId\":").Append((text != null) ? ("\"" + JsonEscape(text) + "\"") : "null").Append(',');
			sb.Append("\"targetRegionId\":").Append((text2 != null) ? ("\"" + JsonEscape(text2) + "\"") : "null").Append(',');
			sb.Append("\"regionPathToSeed\":");
			if (text2 != null)
			{
				List<string> list = BfsAdjacencyStore.PathToSeed(text2);
				if (list != null)
				{
					sb.Append('[');
					for (int i = 0; i < list.Count; i++)
					{
						if (i > 0)
						{
							sb.Append(',');
						}
						sb.Append('"').Append(JsonEscape(list[i])).Append('"');
					}
					sb.Append(']');
				}
				else
				{
					sb.Append("null");
				}
			}
			else
			{
				sb.Append("null");
			}
			sb.Append(",\"adjacencyCount\":").Append(BfsAdjacencyStore.Adjacency.Count);
			sb.Append(",\"seedCount\":").Append(BfsAdjacencyStore.Seeds.Count);
			AppendNavMeshSample(sb, "navMeshAtSource", villagerPos);
			AppendNavMeshSample(sb, "navMeshAtTarget", destPos);
			sb.Append('}');
		}

		private static void AppendNavMeshSample(StringBuilder sb, string fieldName, Vector3 pos)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			sb.Append(",\"").Append(fieldName).Append("\":");
			try
			{
				NavMeshQueryFilter val = default(NavMeshQueryFilter);
				((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.ResolveValheimHumanoidAgentTypeID();
				((NavMeshQueryFilter)(ref val)).areaMask = -1;
				NavMeshQueryFilter val2 = val;
				NavMeshHit val3 = default(NavMeshHit);
				if (NavMesh.SamplePosition(pos, ref val3, 5f, val2))
				{
					sb.Append("{\"hit\":true,\"snappedPos\":").Append(JsonVec3(((NavMeshHit)(ref val3)).position)).Append(",\"deltaY\":")
						.Append((((NavMeshHit)(ref val3)).position.y - pos.y).ToString("R", CultureInfo.InvariantCulture))
						.Append('}');
				}
				else
				{
					sb.Append("{\"hit\":false}");
				}
			}
			catch
			{
				sb.Append("null");
			}
		}

		private static void AppendRecentEventsBlock(StringBuilder sb, VillagerAI ai)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			sb.Append("\"recentEvents\":[");
			float time = Time.time;
			List<AiEventRing.Event> list = ai.EventRing.Snapshot(time, 30f);
			for (int i = 0; i < list.Count; i++)
			{
				if (i > 0)
				{
					sb.Append(',');
				}
				AiEventRing.Event obj = list[i];
				sb.Append('{');
				sb.Append("\"tSec\":").Append((obj.TimeSec - time).ToString("F2", CultureInfo.InvariantCulture)).Append(",\"kind\":\"")
					.Append(obj.Kind.ToString())
					.Append('"')
					.Append(",\"detail\":\"")
					.Append(JsonEscape(obj.Detail))
					.Append('"');
				if (obj.Kind == AiEventRing.EventKind.TargetSet)
				{
					sb.Append(",\"newTarget\":").Append(JsonVec3(obj.PosA)).Append(",\"prevTarget\":")
						.Append(JsonVec3(obj.PosB));
				}
				else if (obj.Kind == AiEventRing.EventKind.PathRecompute)
				{
					sb.Append(",\"target\":").Append(JsonVec3(obj.PosA)).Append(",\"corners\":")
						.Append(obj.IntA);
				}
				sb.Append('}');
			}
			sb.Append(']');
		}

		private static void EnqueueIncidentScreenshots(VillagerAI ai, Vector3 destPos, string incidentId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			string incidentSubdir = Path.Combine("incidents", incidentId);
			Vector3 anchor = (((Object)(object)((Component)ai).transform != (Object)null) ? ((Component)ai).transform.position : Vector3.zero);
			DebugLog.Capture(CaptureRequest.ForIncident("incident_villager", incidentSubdir, "villager", anchor, 10f));
			DebugLog.Capture(CaptureRequest.ForIncident("incident_destination", incidentSubdir, "destination", destPos, 10f));
		}

		private static void UpdateIndexAdd(string incidentId, VillagerAI ai, Vector3 destPos, string failureKind)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string path = Path.Combine(IncidentsDir(), "INDEX.json");
				Directory.CreateDirectory(IncidentsDir());
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append('{').Append("\"id\":\"").Append(JsonEscape(incidentId))
					.Append("\",")
					.Append("\"villager\":\"")
					.Append(JsonEscape(ai.NpcName))
					.Append("\",")
					.Append("\"failureKind\":\"")
					.Append(JsonEscape(failureKind))
					.Append("\",")
					.Append("\"destination\":")
					.Append(JsonVec3(destPos))
					.Append(',')
					.Append("\"occurrences\":1,")
					.Append("\"firstSeenUtc\":\"")
					.Append(DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture))
					.Append("\"")
					.Append('}');
				if (!File.Exists(path))
				{
					File.WriteAllText(path, "{\"incidents\":[" + stringBuilder?.ToString() + "]}");
					return;
				}
				string text = File.ReadAllText(path);
				int num = text.LastIndexOf("]}", StringComparison.Ordinal);
				if (num < 0)
				{
					File.WriteAllText(path, "{\"incidents\":[" + stringBuilder?.ToString() + "]}");
					return;
				}
				int num2 = text.IndexOf('[');
				string text2 = ((num2 >= 0 && num - num2 > 1) ? "," : "") + stringBuilder;
				File.WriteAllText(path, text.Substring(0, num) + text2 + text.Substring(num));
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[IncidentRecorder] INDEX add failed: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void UpdateIndexBump(string incidentId)
		{
			try
			{
				string path = Path.Combine(IncidentsDir(), "INDEX.json");
				if (!File.Exists(path))
				{
					return;
				}
				string text = File.ReadAllText(path);
				string value = "\"id\":\"" + incidentId + "\"";
				int num = text.IndexOf(value, StringComparison.Ordinal);
				if (num < 0)
				{
					return;
				}
				string text2 = "\"occurrences\":";
				int num2 = text.IndexOf(text2, num, StringComparison.Ordinal);
				if (num2 >= 0)
				{
					int num3 = num2 + text2.Length;
					int i;
					for (i = num3; i < text.Length && char.IsDigit(text[i]); i++)
					{
					}
					if (int.TryParse(text.Substring(num3, i - num3), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						string contents = text.Substring(0, num3) + (result + 1).ToString(CultureInfo.InvariantCulture) + text.Substring(i);
						File.WriteAllText(path, contents);
					}
				}
			}
			catch
			{
			}
		}

		private static string IncidentsDir()
		{
			string path;
			try
			{
				path = Paths.ConfigPath;
			}
			catch
			{
				path = ".";
			}
			return Path.Combine(path, "vv_dumps", "incidents");
		}

		private static string JsonVec3(Vector3 v)
		{
			return "[" + v.x.ToString("R", CultureInfo.InvariantCulture) + "," + v.y.ToString("R", CultureInfo.InvariantCulture) + "," + v.z.ToString("R", CultureInfo.InvariantCulture) + "]";
		}

		private static string JsonEscape(string s)
		{
			return (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r")
				.Replace("\t", "\\t");
		}
	}
	internal static class PrefabDumpCommand
	{
		[DevCommand("Dump a prefab's transform hierarchy + meshes. Usage: vv_prefab_dump [name]", Name = "vv_prefab_dump")]
		public static void Dump(ConsoleEventArgs args)
		{
			string text = ((args.Args.Length >= 2) ? args.Args[1] : "piece_cartographytable");
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Print("[vv_prefab_dump] ZNetScene not ready");
				return;
			}
			GameObject prefab = instance.GetPrefab(text);
			if ((Object)(object)prefab == (Object)null)
			{
				Print("[vv_prefab_dump] prefab '" + text + "' not found");
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("[vv_prefab_dump] " + text);
			Walk(prefab.transform, 0, stringBuilder);
			Print(stringBuilder.ToString());
		}

		private static void Walk(Transform t, int depth, StringBuilder sb)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			string text = new string(' ', depth * 2) + "- " + ((Object)t).name;
			MeshFilter component = ((Component)t).GetComponent<MeshFilter>();
			if ((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null)
			{
				text += $"  [mesh:{((Object)component.sharedMesh).name} verts:{component.sharedMesh.vertexCount}]";
			}
			SkinnedMeshRenderer component2 = ((Component)t).GetComponent<SkinnedMeshRenderer>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component2.sharedMesh != (Object)null)
			{
				text += $"  [skinned:{((Object)component2.sharedMesh).name} verts:{component2.sharedMesh.vertexCount}]";
			}
			MeshRenderer component3 = ((Component)t).GetComponent<MeshRenderer>();
			if ((Object)(object)component3 != (Object)null && ((Renderer)component3).sharedMaterials != null)
			{
				StringBuilder stringBuilder = new StringBuilder();
				Material[] sharedMaterials = ((Renderer)component3).sharedMaterials;
				foreach (Material val in sharedMaterials)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(',');
					}
					stringBuilder.Append(((Object)(object)val != (Object)null) ? ((Object)val).name : "null");
				}
				Bounds bounds = ((Renderer)component3).bounds;
				Vector3 size = ((Bounds)(ref bounds)).size;
				text += $"  [mat:{stringBuilder}]  size=({size.x:F2},{size.y:F2},{size.z:F2})";
			}
			sb.AppendLine(text);
			for (int j = 0; j < t.childCount; j++)
			{
				Walk(t.GetChild(j), depth + 1, sb);
			}
		}

		private static void Print(string msg)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(msg);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)msg);
			}
		}
	}
	internal static class PurgeStaleCommand
	{
		[DevCommand("Report + purge stale (old-assembly) mod instances left by hot reloads", Name = "vv_purge_stale")]
		public static void Run(ConsoleEventArgs args)
		{
			string text = HotReloadHelper.PurgeStaleObjects();
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)text);
			}
		}
	}
	internal static class ReloadInfoCommand
	{
		[DevCommand("Report when this assembly was last (re)loaded by ScriptEngine", Name = "vv_reloadinfo")]
		public static void Report(ConsoleEventArgs args)
		{
			DateTime assemblyLoadedAt = Plugin.AssemblyLoadedAt;
			double totalSeconds = (DateTime.UtcNow - assemblyLoadedAt).TotalSeconds;
			string arg = "n/a";
			try
			{
				string location = typeof(Plugin).Assembly.Location;
				if (!string.IsNullOrEmpty(location) && File.Exists(location))
				{
					arg = File.GetLastWriteTimeUtc(location).ToString("HH:mm:ss") + "Z";
				}
			}
			catch (Exception ex)
			{
				arg = "error: " + ex.Message;
			}
			string text = $"[Reload] assembly loaded {assemblyLoadedAt:HH:mm:ss}Z ({totalSeconds:F0}s ago), " + $"hotReload={Plugin.LastLoadWasHotReload}, dllMtime={arg}";
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(text);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)text);
			}
		}
	}
}
namespace ValheimVillages.Dev
{
	public static class DamageStructuresCommand
	{
		[DevCommand("Damage nearby structures to test repair: vv_damage_structures [radius=15] [amount=40]", Name = "vv_damage_structures")]
		public static void Run(ConsoleEventArgs args)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			float result;
			float num = ((args.Length > 1 && float.TryParse(args[1], out result)) ? result : 15f);
			float result2;
			float num2 = ((args.Length > 2 && float.TryParse(args[2], out result2)) ? result2 : 40f);
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				Print("[vv_damage_structures] no local player");
				return;
			}
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			HashSet<WearNTear> hashSet = new HashSet<WearNTear>();
			int num3 = 0;
			foreach (WearNTear item in PhysicsHelper.GetAllInRadius<WearNTear>(position, num))
			{
				if (!((Object)(object)item == (Object)null) && hashSet.Add(item))
				{
					ZNetView component = ((Component)item).GetComponent<ZNetView>();
					if (!((Object)(object)component == (Object)null) && component.IsValid())
					{
						component.ClaimOwnership();
						item.ApplyDamage(num2, (HitData)null);
						num3++;
					}
				}
			}
			Print($"[vv_damage_structures] damaged {num3} structure(s) by {num2} within {num}m");
		}

		private static void Print(string msg)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(msg);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)msg);
			}
		}
	}
	public static class DropAllStateCommand
	{
		[DevCommand("Wipe ALL village/villager state to a clean slate. [--dry-run] to preview.", Name = "vv_drop_all_state")]
		public static void DropAll(ConsoleEventArgs args)
		{
			bool flag = HasFlag(args, "--dry-run");
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				Print("[vv_drop_all_state] ZDOMan not ready — aborting");
				return;
			}
			Dictionary<ZDOID, ZDO> value = Traverse.Create((object)instance).Field<Dictionary<ZDOID, ZDO>>("m_objectsByID").Value;
			if (value == null)
			{
				Print("[vv_drop_all_state] m_objectsByID unavailable — aborting");
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("[vv_drop_all_state]" + (flag ? " DRY RUN — nothing will be deleted" : ""));
			HashSet<int> vvHashes = CollectVvPrefabHashes();
			int recordPrefabHash = RecordPrefabFactory.RecordPrefabHash;
			int stableHashCode = StringExtensionMethods.GetStableHashCode("vv_village_registry");
			List<ZDO> list = new List<ZDO>();
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ZDO value3 in value.Values)
			{
				if (value3 != null)
				{
					string text = ClassifyForDeletion(value3, vvHashes, recordPrefabHash, stableHashCode);
					if (text != null)
					{
						list.Add(value3);
						dictionary[text] = ((!dictionary.TryGetValue(text, out var value2)) ? 1 : (value2 + 1));
					}
				}
			}
			stringBuilder.AppendLine($"  ZDOs to delete: {list.Count}");
			foreach (KeyValuePair<string, int> item in dictionary.OrderBy((KeyValuePair<string, int> k) => k.Key))
			{
				stringBuilder.AppendLine($"    {item.Key}: {item.Value}");
			}
			List<string> detail;
			int num = SweepInventories(remove: false, out detail);
			stringBuilder.AppendLine($"  vv_* items in inventories: {num}");
			foreach (string item2 in detail)
			{
				stringBuilder.AppendLine("    " + item2);
			}
			if (flag)
			{
				Print(stringBuilder.ToString());
				return;
			}
			long sessionID = ZDOMan.GetSessionID();
			ZNetScene instance2 = ZNetScene.instance;
			int num2 = 0;
			foreach (ZDO item3 in list)
			{
				if (!item3.IsOwner())
				{
					item3.SetOwner(sessionID);
				}
				ZNetView val = (((Object)(object)instance2 != (Object)null) ? instance2.FindInstance(item3) : null);
				if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null)
				{
					instance2.Destroy(((Component)val).gameObject);
				}
				else
				{
					instance.DestroyZDO(item3);
				}
				num2++;
			}
			List<string> detail2;
			int num3 = SweepInventories(remove: true, out detail2);
			VillageRegistry.ClearAll();
			VillagerAIManager.Clear();
			VillageStationRegistry.Clear();
			VillagePoiRegistry.Clear();
			VillageRoomCatalog.Clear();
			VillageAreaManager.Clear();
			BfsAdjacencyStore.Clear();
			RegionBuilder.ClearCachedState();
			GlobalTaskQueue.Clear();
			stringBuilder.AppendLine($"  → deleted {num2} ZDO(s), removed {num3} item(s); in-memory caches cleared.");
			Print(stringBuilder.ToString());
		}

		private static string ClassifyForDeletion(ZDO zdo, HashSet<int> vvHashes, int recordHash, int registryHash)
		{
			int prefab = zdo.GetPrefab();
			if (prefab == recordHash)
			{
				return "record-carrier";
			}
			if (prefab == registryHash)
			{
				return "registry-station";
			}
			if (prefab == VillagePrefabFactory.VillagePrefabHash)
			{
				return "village-carrier";
			}
			if (!string.IsNullOrEmpty(zdo.GetString("vv_record_id", "")) || !string.IsNullOrEmpty(zdo.GetString("vv_villager_type", "")))
			{
				return "villager-npc";
			}
			if (vvHashes.Contains(prefab))
			{
				return "vv-prefab";
			}
			return null;
		}

		private static HashSet<int> CollectVvPrefabHashes()
		{
			HashSet<int> hashSet = new HashSet<int>();
			ZNetScene instance = ZNetScene.instance;
			if (instance?.m_prefabs == null)
			{
				return hashSet;
			}
			foreach (GameObject prefab in instance.m_prefabs)
			{
				if (!((Object)(object)prefab == (Object)null) && ((Object)prefab).name.StartsWith("vv_", StringComparison.Ordinal))
				{
					hashSet.Add(StringExtensionMethods.GetStableHashCode(((Object)prefab).name));
				}
			}
			return hashSet;
		}

		private static int SweepInventories(bool remove, out List<string> detail)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			detail = new List<string>();
			int num = 0;
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				num += SweepInventory(((Humanoid)Player.m_localPlayer).GetInventory(), "player", remove, detail);
			}
			Container[] array = Object.FindObjectsByType<Container>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Container val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Inventory inventory = val.GetInventory();
					if (inventory != null)
					{
						Vector3 position = ((Component)val).transform.position;
						num += SweepInventory(inventory, $"chest@({position.x:F0},{position.z:F0})", remove, detail);
					}
				}
			}
			return num;
		}

		private static int SweepInventory(Inventory inv, string label, bool remove, List<string> detail)
		{
			if (inv == null)
			{
				return 0;
			}
			List<ItemData> list = inv.GetAllItems().Where(IsVvItem).ToList();
			foreach (ItemData item in list)
			{
				detail.Add($"{label}: {((Object)item.m_dropPrefab).name} x{item.m_stack}");
				if (remove)
				{
					inv.RemoveItem(item);
				}
			}
			return list.Count;
		}

		private static bool IsVvItem(ItemData item)
		{
			if ((Object)(object)item?.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name.StartsWith("vv_", StringComparison.Ordinal);
			}
			return false;
		}

		private static bool HasFlag(ConsoleEventArgs args, string flag)
		{
			if (args?.Args == null)
			{
				return false;
			}
			for (int i = 1; i < args.Args.Length; i++)
			{
				if (string.Equals(args.Args[i], flag, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static void Print(string msg)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(msg);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)msg);
			}
		}
	}
	public static class RepairProbeCommand
	{
		[DevCommand("Probe carpenter repair targeting (why damaged structures aren't repaired)", Name = "vv_repair_probe")]
		public static void Run(ConsoleEventArgs args)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: 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_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			VillagerAI villagerAI = null;
			foreach (VillagerAI value in VillagerAIManager.ActiveVillagers.Values)
			{
				if ((Object)(object)value != (Object)null && value.GetBehavior<RepairBehavior>() != null)
				{
					villagerAI = value;
					break;
				}
			}
			if ((Object)(object)villagerAI == (Object)null)
			{
				Print("[vv_repair_probe] no repair-capable villager active");
				return;
			}
			Vector3 homeAnchor = villagerAI.HomeAnchor;
			Vector3 position = villagerAI.Position;
			float num = 40f;
			Print($"[vv_repair_probe] {villagerAI.NpcName} anchor=({homeAnchor.x:F1},{homeAnchor.z:F1}) pos=({position.x:F1},{position.z:F1}) " + $"scanR={num} agentReg={VillagerAgentType.IsRegistered}");
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			NavMeshQueryFilter filter = val;
			RegionGraph regionGraph = VillageRegistry.GraphAt(homeAnchor);
			Print("  graph@anchor=" + ((regionGraph == null) ? "NULL" : "ok") + " anchorRegion=" + ((regionGraph == null) ? "-" : regionGraph.PointToRegionId(homeAnchor)));
			HashSet<WearNTear> hashSet = new HashSet<WearNTear>();
			List<(WearNTear, float)> list = new List<(WearNTear, float)>();
			int num2 = 0;
			foreach (WearNTear item in PhysicsHelper.GetAllInRadius<WearNTear>(homeAnchor, num))
			{
				if ((Object)(object)item == (Object)null || !hashSet.Add(item))
				{
					continue;
				}
				ZNetView component = ((Component)item).GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && component.IsValid())
				{
					num2++;
					if (!(item.GetHealthPercentage() >= 0.99f))
					{
						Vector3 val2 = ((Component)item).transform.position - position;
						list.Add((item, ((Vector3)(ref val2)).sqrMagnitude));
					}
				}
			}
			list.Sort(((WearNTear w, float dPosSq) a, (WearNTear w, float dPosSq) b) => a.dPosSq.CompareTo(b.dPosSq));
			Print($"  {num2} valid structures in scan range; {list.Count} damaged");
			int num3 = 0;
			NavMeshHit val4 = default(NavMeshHit);
			NavMeshHit val5 = default(NavMeshHit);
			NavMeshHit val6 = default(NavMeshHit);
			NavMeshHit val8 = default(NavMeshHit);
			foreach (var (val3, num4) in list)
			{
				if (num3++ >= 15)
				{
					break;
				}
				Vector3 position2 = ((Component)val3).transform.position;
				bool flag = NavMesh.SamplePosition(position2, ref val4, 6f, filter);
				string text = "snap-fail";
				if (flag)
				{
					bool flag2 = NavMesh.SamplePosition(position, ref val5, 3f, filter);
					bool flag3 = NavMesh.SamplePosition(((NavMeshHit)(ref val4)).position, ref val6, 3f, filter);
					if (flag2 && flag3)
					{
						NavMeshPath val7 = new NavMeshPath();
						NavMesh.CalculatePath(((NavMeshHit)(ref val5)).position, ((NavMeshHit)(ref val6)).position, filter, val7);
						text = ((object)val7.status/*cast due to .constrained prefix*/).ToString();
					}
					else
					{
						text = $"sample(from={flag2},to={flag3})";
					}
				}
				string text2 = "snap-fail";
				if (flag && regionGraph != null)
				{
					string text3 = regionGraph.PointToRegionId(((NavMeshHit)(ref val4)).position);
					text2 = (string.IsNullOrEmpty(text3) ? "<none>" : text3);
				}
				string text4 = "<unreach>";
				if (regionGraph != null && regionGraph.TryFindNearestLookupCell(position2, (Vector3 p) => NavMesh.SamplePosition(p, ref val8, 2f, filter), out var worldPos, out var regionId, 6f))
				{
					text4 = $"{regionId}@({worldPos.x:F1},{worldPos.z:F1})";
				}
				string text5 = ((Object)((Component)val3).gameObject).name.Replace("(Clone)", "");
				Print($"  {text5} @({position2.x:F1},{position2.y:F1},{position2.z:F1}) hp={val3.GetHealthPercentage():P0} " + $"d={Mathf.Sqrt(num4):F1}m snap={flag} path={text} rawRegion={text2} resolved={text4}");
			}
		}

		private static void Print(string msg)
		{
			Console instance = Console.instance;
			if (instance != null)
			{
				instance.Print(msg);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)msg);
			}
		}
	}
}
namespace ValheimVillages.Behaviors
{
	public static class BehaviorFactory
	{
		private static readonly Dictionary<string, Func<VillagerAI, IBehavior>> s_creators = new Dictionary<string, Func<VillagerAI, IBehavior>>
		{
			{
				"patrol",
				(VillagerAI ai) => new PerimeterPatrolBehavior(ai)
			},
			{
				"combat",
				(VillagerAI ai) => new CombatBehavior(ai)
			},
			{
				"flee",
				(VillagerAI ai) => new FleeBehavior(ai)
			},
			{
				"craft",
				(VillagerAI ai) => new CraftingBehaviorAdapter(ai)
			},
			{
				"farming",
				(VillagerAI ai) => new FarmBehaviorAdapter(ai)
			},
			{
				"tidy",
				(VillagerAI ai) => new TidyBehavior(ai)
			},
			{
				"repair",
				(VillagerAI ai) => new RepairBehavior(ai)
			},
			{
				"haul",
				(VillagerAI ai) => new HaulBehavior(ai)
			}
		};

		public static List<IBehavior> CreateBehaviors(VillagerAI ai, IReadOnlyList<string> behaviorTags)
		{
			List<IBehavior> list = new List<IBehavior>();
			if (behaviorTags == null)
			{
				return list;
			}
			foreach (string behaviorTag in behaviorTags)
			{
				if (s_creators.TryGetValue(behaviorTag, out var value))
				{
					list.Add(value(ai));
					continue;
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[BehaviorFactory] Unknown behavior tag: '" + behaviorTag + "'"));
				}
			}
			list.Sort((IBehavior a, IBehavior b) => b.Priority.CompareTo(a.Priority));
			return list;
		}
	}
	public enum FarmSubState
	{
		Idle,
		GatheringSeeds,
		TravelingToFarm,
		WalkingToPlantSpot,
		Planting,
		TravelingToHarvest,
		Harvesting,
		CollectingDrops,
		ReturningToChest,
		Depositing
	}
	public class FarmingContext
	{
		public int CarriedHarvestCount;

		public Pickable CurrentHarvestTarget;

		public int CurrentIngredientIndex;

		public Vector3 FarmPosition;

		public int HarvestedCount;

		public List<IngredientSource> IngredientSources;

		public bool IsHarvestingPass;

		public Vector3? NextPlantPosition;

		public float PlantCooldown;

		public float PlantGrowRadius;

		public GameObject PlantPiecePrefab;

		public int PlantedThisSession;

		public Recipe Recipe;

		public int SeedsGathered;

		public Container SourceContainer;

		public WorkOrderMatch WorkOrder;
	}
	public interface IBehaviorPersistence
	{
		void Save(ZDO zdo);

		void Load(ZDO zdo);
	}
}
namespace ValheimVillages.Behaviors.Work
{
	[RegisterBehavior("craft")]
	public class CraftingBehaviorAdapter : IBehavior, IWorkScanBehavior, IPathUnreachableHandler
	{
		private readonly VillagerAI m_ai;

		public CraftingBehavior Crafting { get; }

		public string Tag => "craft";

		public int Priority => 50;

		public CraftingBehaviorAdapter(VillagerAI ai)
		{
			m_ai = ai;
			Crafting = new CraftingBehavior(ai);
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			return m_ai.CurrentState == BehaviorState.Working;
		}

		public void Update(float dt)
		{
			Crafting?.UpdateWorkAI(dt);
		}

		public void OnArrival(float dt)
		{
			Crafting?.HandleWorkArrival(dt);
		}

		public void OnPathUnreachable(Vector3 target)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)string.Format("[Work:{0}] Path unreachable to {1}; abandoning work.", m_ai?.NpcName ?? "?", target));
			}
			Crafting?.AbandonWorkPublic("path unreachable after recovery attempts");
		}

		public string GetStatusText()
		{
			if (Crafting == null)
			{
				return "";
			}
			FarmingBehavior farmingBehavior = Crafting.FarmingBehavior;
			if (farmingBehavior != null && farmingBehavior.IsWorking)
			{
				return $"Farming: {Crafting.FarmingBehavior.SubState}";
			}
			if (m_ai.CurrentState == BehaviorState.Working)
			{
				return $"Working: {Crafting.SubState}";
			}
			return "Idle";
		}

		public bool TryScanForWork(bool ignoreScanInterval = false)
		{
			return Crafting?.TryScanForWork(ignoreScanInterval) ?? false;
		}

		public void SetFarmingBehavior(FarmingBehavior farming)
		{
			Crafting?.SetFarmingBehavior(farming);
		}

		public void Save(ZDO zdo)
		{
		}

		public void Load(ZDO zdo)
		{
		}
	}
	[RegisterBehavior("farming")]
	public class FarmBehaviorAdapter : IBehavior
	{
		private readonly VillagerAI m_ai;

		public FarmingBehavior Farming { get; }

		public string Tag => "farming";

		public int Priority => 50;

		public FarmBehaviorAdapter(VillagerAI ai)
		{
			m_ai = ai;
			Farming = new FarmingBehavior(ai);
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			return false;
		}

		public void Update(float dt)
		{
		}

		public void OnArrival(float dt)
		{
		}

		public string GetStatusText()
		{
			FarmingBehavior farming = Farming;
			if (farming != null && farming.IsWorking)
			{
				return $"Farming: {Farming.SubState}";
			}
			return "";
		}

		public void LinkToCraftingAdapter(CraftingBehaviorAdapter crafting)
		{
			crafting?.SetFarmingBehavior(Farming);
		}

		public void Save(ZDO zdo)
		{
		}

		public void Load(ZDO zdo)
		{
		}
	}
}
namespace ValheimVillages.Behaviors.Tidy
{
	[RegisterBehavior("haul")]
	public class HaulBehavior : IBehavior
	{
		private enum Phase
		{
			None,
			ToDrop,
			ToChest
		}

		private const float ScanInterval = 8f;

		private const float MaxLegSeconds = 20f;

		private const float UnreachableCooldown = 30f;

		private readonly VillagerAI m_ai;

		private readonly Dictionary<ZDOID, float> m_skipUntil = new Dictionary<ZDOID, float>();

		private Container m_targetChest;

		private ItemDrop m_targetDrop;

		private float m_legDeadline;

		private float m_lastScanTime;

		private bool m_navIssued;

		private Phase m_phase;

		public string Tag => "haul";

		public int Priority => 55;

		public HaulBehavior(VillagerAI ai)
		{
			m_ai = ai;
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			if (m_phase != Phase.None)
			{
				return true;
			}
			if (m_ai.CurrentState != BehaviorState.Idle)
			{
				return false;
			}
			if (m_ai.IsInBackoff)
			{
				return false;
			}
			if (Time.time - m_lastScanTime < 8f)
			{
				return false;
			}
			m_lastScanTime = Time.time;
			return FindHaulTarget();
		}

		public void Update(float dt)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time > m_legDeadline && m_phase != Phase.None)
			{
				BlacklistTarget();
				Reset();
				return;
			}
			switch (m_phase)
			{
			case Phase.ToDrop:
				if (!IsDropValid(m_targetDrop))
				{
					Reset();
				}
				else if (!m_navIssued)
				{
					if (!TryWalk(((Component)m_targetDrop).transform.position, "haul: go to junk"))
					{
						BlacklistTarget();
						Reset();
					}
					else
					{
						m_navIssued = true;
					}
				}
				break;
			case Phase.ToChest:
				if ((Object)(object)m_targetChest == (Object)null)
				{
					Reset();
				}
				else if (!m_navIssued)
				{
					if (!TryWalk(((Component)m_targetChest).transform.position, "haul: carry to chest"))
					{
						Reset();
					}
					else
					{
						m_navIssued = true;
					}
				}
				break;
			}
		}

		private bool TryWalk(Vector3 target, string label)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (!VillageStationRegistry.TryResolveApproach(target, m_ai.Position, out var approach, m_ai.HomeAnchor))
			{
				return false;
			}
			return m_ai.NavTo(approach, BehaviorState.Traveling, label, snapToApproach: false);
		}

		public void OnArrival(float dt)
		{
			switch (m_phase)
			{
			case Phase.ToDrop:
				ArriveAtDrop();
				break;
			case Phase.ToChest:
				ArriveAtChest();
				break;
			default:
				Reset();
				break;
			}
		}

		public string GetStatusText()
		{
			return m_phase switch
			{
				Phase.ToDrop => "Collecting stray items", 
				Phase.ToChest => "Storing items in a chest", 
				_ => "", 
			};
		}

		private bool FindHaulTarget()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			Vector3 homeAnchor = m_ai.HomeAnchor;
			float radius = 32f;
			List<Container> list = ContainerScanner.FindNearbyContainers(homeAnchor, radius);
			if (list.Count == 0)
			{
				return false;
			}
			HashSet<ItemDrop> hashSet = new HashSet<ItemDrop>();
			ItemDrop val = null;
			Container targetChest = null;
			float num = float.MaxValue;
			foreach (ItemDrop item in PhysicsHelper.GetAllInRadius<ItemDrop>(homeAnchor, radius))
			{
				if ((Object)(object)item == (Object)null || !hashSet.Add(item) || !IsDropValid(item) || IsBlacklisted(item))
				{
					continue;
				}
				float num2 = Vector3.Distance(((Component)item).transform.position, homeAnchor);
				if (!(num2 >= num))
				{
					Container val2 = FindAcceptingChest(list, item.m_itemData);
					if (!((Object)(object)val2 == (Object)null))
					{
						val = item;
						targetChest = val2;
						num = num2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			m_targetDrop = val;
			m_targetChest = targetChest;
			BeginLeg(Phase.ToDrop);
			return true;
		}

		private void ArriveAtDrop()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDropValid(m_targetDrop))
			{
				Reset();
				return;
			}
			if ((Object)(object)m_targetChest == (Object)null || !ContainerScanner.CanAcceptItemData(m_targetChest, m_targetDrop.m_itemData))
			{
				List<Container> containers = ContainerScanner.FindNearbyContainers(m_ai.HomeAnchor, 32f);
				m_targetChest = FindAcceptingChest(containers, m_targetDrop.m_itemData);
			}
			if ((Object)(object)m_targetChest == (Object)null)
			{
				Reset();
			}
			else
			{
				BeginLeg(Phase.ToChest);
			}
		}

		private void ArriveAtChest()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDropValid(m_targetDrop))
			{
				Reset();
				return;
			}
			ItemData val = m_targetDrop.m_itemData.Clone();
			bool flag = ContainerScanner.TryDepositItemData(m_targetChest, val);
			if (!flag)
			{
				foreach (Container item in ContainerScanner.FindNearbyContainers(m_ai.HomeAnchor, 32f))
				{
					if (ContainerScanner.CanAcceptItemData(item, val))
					{
						flag = ContainerScanner.TryDepositItemData(item, val.Clone());
						if (flag)
						{
							break;
						}
					}
				}
			}
			if (flag)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)($"[Haul:{m_ai.NpcName}] Stored {val.m_stack}x " + DropName(m_targetDrop) + " in a chest."));
				}
				DestroyDrop(m_targetDrop);
			}
			Reset();
		}

		private static Container FindAcceptingChest(List<Container> containers, ItemData item)
		{
			foreach (Container container in containers)
			{
				if (ContainerScanner.CanAcceptItemData(container, item))
				{
					return container;
				}
			}
			return null;
		}

		private void BeginLeg(Phase phase)
		{
			m_phase = phase;
			m_navIssued = false;
			m_legDeadline = Time.time + 20f;
		}

		private static bool IsDropValid(ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null || drop.m_itemData == null)
			{
				return false;
			}
			ZNetView component = ((Component)drop).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null)
			{
				return component.IsValid();
			}
			return false;
		}

		private static string DropName(ItemDrop drop)
		{
			if (!((Object)(object)drop.m_itemData?.m_dropPrefab != (Object)null))
			{
				return ((Object)((Component)drop).gameObject).name.Replace("(Clone)", "").Trim();
			}
			return ((Object)drop.m_itemData.m_dropPrefab).name;
		}

		private static void DestroyDrop(ItemDrop drop)
		{
			if (!((Object)(object)drop == (Object)null))
			{
				ZNetView component = ((Component)drop).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid())
				{
					component.ClaimOwnership();
				}
				if ((Object)(object)component != (Object)null && component.IsValid())
				{
					ZNetScene.instance.Destroy(((Component)drop).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)drop).gameObject);
				}
			}
		}

		private static ZDOID DropId(ItemDrop drop)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			ZNetView val = (((Object)(object)drop != (Object)null) ? ((Component)drop).GetComponent<ZNetView>() : null);
			if (!((Object)(object)val != (Object)null) || val.GetZDO() == null)
			{
				return ZDOID.None;
			}
			return val.GetZDO().m_uid;
		}

		private bool IsBlacklisted(ItemDrop drop)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = DropId(drop);
			if (val == ZDOID.None)
			{
				return false;
			}
			if (!m_skipUntil.TryGetValue(val, out var value))
			{
				return false;
			}
			if (Time.time >= value)
			{
				m_skipUntil.Remove(val);
				return false;
			}
			return true;
		}

		private void BlacklistTarget()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = DropId(m_targetDrop);
			if (val != ZDOID.None)
			{
				m_skipUntil[val] = Time.time + 30f;
			}
		}

		private void Reset()
		{
			m_phase = Phase.None;
			m_targetDrop = null;
			m_targetChest = null;
			m_navIssued = false;
			m_ai.SetState(BehaviorState.Idle);
		}
	}
	[RegisterBehavior("tidy")]
	public class TidyBehavior : IBehavior
	{
		private const float ScanInterval = 10f;

		private const float ItemPickupRadius = 3f;

		private readonly VillagerAI m_ai;

		private bool m_active;

		private float m_lastScanTime;

		private CookingStation m_targetStation;

		public string Tag => "tidy";

		public int Priority => 60;

		public TidyBehavior(VillagerAI ai)
		{
			m_ai = ai;
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			if (m_active)
			{
				return true;
			}
			if (Time.time - m_lastScanTime < 10f)
			{
				return false;
			}
			m_lastScanTime = Time.time;
			return FindDirtyStation();
		}

		public void Update(float dt)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!m_active && !((Object)(object)m_targetStation == (Object)null))
			{
				m_active = true;
				if (!m_ai.NavTo(((Component)m_targetStation).transform.position, BehaviorState.Traveling, "tidy cooking station"))
				{
					Reset();
				}
			}
		}

		public void OnArrival(float dt)
		{
			if ((Object)(object)m_targetStation == (Object)null)
			{
				Reset();
				return;
			}
			CleanStation(m_targetStation);
			Reset();
		}

		public string GetStatusText()
		{
			if (m_active)
			{
				if (!((Object)(object)m_targetStation != (Object)null))
				{
					return "Looking for mess";
				}
				return "Tidying cooking station";
			}
			return "";
		}

		private bool FindDirtyStation()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (VillageStationRegistry.TryFindStation<CookingStation>(m_ai.GetMemory().HomeAnchor, (Func<CookingStation, bool>)HasDoneOrBurntItems, out Vector3 _, out CookingStation component))
			{
				m_targetStation = component;
				return true;
			}
			return false;
		}

		private static bool HasDoneOrBurntItems(CookingStation station)
		{
			ZNetView component = ((Component)station).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || component.GetZDO() == null)
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			int num = ((station.m_slots != null) ? station.m_slots.Length : 0);
			for (int i = 0; i < num; i++)
			{
				if (!string.IsNullOrEmpty(zDO.GetString("slot" + i, "")) && zDO.GetInt("slotstatus" + i, 0) >= 1)
				{
					return true;
				}
			}
			return false;
		}

		private void CleanStation(CookingStation station)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)station).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || component.GetZDO() == null)
			{
				return;
			}
			ZDO zDO = component.GetZDO();
			int num = ((station.m_slots != null) ? station.m_slots.Length : 0);
			List<string> list = new List<string>();
			for (int i = 0; i < num; i++)
			{
				string text = zDO.GetString("slot" + i, "");
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num2 = zDO.GetInt("slotstatus" + i, 0);
				if (num2 >= 1)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)$"[Tidy:{m_ai.NpcName}] Removing slot {i} ({text}, status={num2})");
					}
					component.InvokeRPC("RPC_RemoveDoneItem", new object[2]
					{
						((Component)station).transform.position,
						i
					});
					PickupDroppedItem(station, text);
					list.Add(text);
				}
			}
			if (list.Count > 0)
			{
				DepositToNearbyContainer(station, list);
			}
		}

		private static void PickupDroppedItem(CookingStation station, string slotItemName)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (((Object)(object)station.m_spawnPoint != (Object)null) ? station.m_spawnPoint.position : ((Component)station).transform.position);
			List<ItemDrop> allInRadius = PhysicsHelper.GetAllInRadius<ItemDrop>(val, 3f);
			ItemDrop val2 = null;
			float num = float.MaxValue;
			foreach (ItemDrop item in allInRadius)
			{
				if ((Object)(object)item == (Object)null || item.m_itemData == null)
				{
					continue;
				}
				GameObject dropPrefab = item.m_itemData.m_dropPrefab;
				if (!((((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? ((Object)((Component)item).gameObject).name.Replace("(Clone)", "").Trim()) != slotItemName))
				{
					float num2 = Vector3.Distance(((Component)item).transform.position, val);
					if (num2 < num)
					{
						val2 = item;
						num = num2;
					}
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				ZNetView component = ((Component)val2).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.GetZDO() != null)
				{
					ZNetScene.instance.Destroy(((Component)val2).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
			}
		}

		private static void DepositToNearbyContainer(CookingStation station, List<string> itemNames)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			List<Container> list = ContainerScanner.FindNearbyContainers(((Component)station).transform.position, 20f);
			if (list.Count == 0)
			{
				return;
			}
			foreach (string itemName in itemNames)
			{
				using List<Container>.Enumerator enumerator2 = list.GetEnumerator();
				while (enumerator2.MoveNext() && !ContainerScanner.TryDepositItem(enumerator2.Current, itemName, 1))
				{
				}
			}
		}

		private void Reset()
		{
			m_active = false;
			m_targetStation = null;
			m_ai.SetState(BehaviorState.Idle);
		}
	}
}
namespace ValheimVillages.Behaviors.Repair
{
	[RegisterBehavior("repair")]
	public class RepairBehavior : IBehavior
	{
		private const float ScanInterval = 8f;

		private const float MaxLegSeconds = 20f;

		private const float UnreachableCooldown = 30f;

		private const float DamagedThreshold = 0.99f;

		private const float CriticalDurability = 0.45f;

		private const float RepairRange = 3f;

		private const int MaxReachabilityChecks = 12;

		private const float ApproachSnapRadius = 2f;

		private readonly VillagerAI m_ai;

		private readonly Dictionary<ZDOID, float> m_skipUntil = new Dictionary<ZDOID, float>();

		private bool m_active;

		private Vector3 m_approach;

		private float m_legDeadline;

		private float m_lastScanTime;

		private bool m_navIssued;

		private WearNTear m_target;

		public string Tag => "repair";

		public int Priority => 35;

		public RepairBehavior(VillagerAI ai)
		{
			m_ai = ai;
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			if (m_active)
			{
				return true;
			}
			if (m_ai.CurrentState != BehaviorState.Idle)
			{
				return false;
			}
			if (m_ai.IsInBackoff)
			{
				return false;
			}
			if (Time.time - m_lastScanTime < 8f)
			{
				return false;
			}
			m_lastScanTime = Time.time;
			return FindDamaged();
		}

		public void Update(float dt)
		{
			//IL_0044: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if (!IsValid(m_target))
			{
				Reset();
				return;
			}
			if (Time.time > m_legDeadline)
			{
				Blacklist();
				Reset();
				return;
			}
			m_ai.RequestFastReselect(0.25f);
			Vector3 val = m_ai.Position - ((Component)m_target).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude <= 9f)
			{
				DoRepairSweep();
				Reset();
			}
			else if (!m_navIssued)
			{
				if (!m_ai.NavTo(m_approach, BehaviorState.Traveling, "repair: go to structure", snapToApproach: false))
				{
					Blacklist();
					Reset();
				}
				else
				{
					m_navIssued = true;
				}
			}
		}

		public void OnArrival(float dt)
		{
			DoRepairSweep();
			Reset();
		}

		private void DoRepairSweep()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			HashSet<WearNTear> hashSet = new HashSet<WearNTear>();
			int num = 0;
			foreach (WearNTear item in PhysicsHelper.GetAllInRadius<WearNTear>(m_ai.Position, 3f))
			{
				if (!((Object)(object)item == (Object)null) && hashSet.Add(item) && IsValid(item) && item.Repair())
				{
					num++;
				}
			}
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Repair:{m_ai.NpcName}] Repaired {num} structure(s).");
				}
			}
		}

		public string GetStatusText()
		{
			if (!m_active)
			{
				return "";
			}
			return "Repairing structures";
		}

		private bool FindDamaged()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			Vector3 homeAnchor = m_ai.HomeAnchor;
			float radius = 40f;
			Vector3 position = m_ai.Position;
			HashSet<WearNTear> hashSet = new HashSet<WearNTear>();
			List<(WearNTear, float, float)> list = new List<(WearNTear, float, float)>();
			foreach (WearNTear item2 in PhysicsHelper.GetAllInRadius<WearNTear>(homeAnchor, radius))
			{
				if (!((Object)(object)item2 == (Object)null) && hashSet.Add(item2) && IsValid(item2) && !IsBlacklisted(item2))
				{
					float healthPercentage = item2.GetHealthPercentage();
					if (!(healthPercentage >= 0.99f))
					{
						Vector3 val = ((Component)item2).transform.position - position;
						list.Add((item2, ((Vector3)(ref val)).sqrMagnitude, healthPercentage));
					}
				}
			}
			if (list.Count == 0)
			{
				return false;
			}
			list.Sort(delegate((WearNTear wnt, float distSq, float hp) a, (WearNTear wnt, float distSq, float hp) b)
			{
				bool flag = a.hp < 0.45f;
				bool flag2 = b.hp < 0.45f;
				return (flag != flag2) ? ((!flag) ? 1 : (-1)) : a.distSq.CompareTo(b.distSq);
			});
			int num = 0;
			foreach (var item3 in list)
			{
				WearNTear item = item3.Item1;
				if (num++ >= 12)
				{
					break;
				}
				if (TryResolveReachableApproach(((Component)item).transform.position, out var approach))
				{
					m_target = item;
					m_approach = approach;
					m_active = true;
					m_navIssued = false;
					m_legDeadline = Time.time + 20f;
					return true;
				}
			}
			return false;
		}

		private bool TryResolveReachableApproach(Vector3 piecePos, out Vector3 approach)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			approach = Vector3.zero;
			if (!VillagerAgentType.IsRegistered)
			{
				return false;
			}
			RegionGraph regionGraph = VillageRegistry.GraphAt(m_ai.HomeAnchor);
			if (regionGraph == null)
			{
				return false;
			}
			NavMeshHit val2 = default(NavMeshHit);
			if (!regionGraph.TryFindNearestLookupCell(piecePos, (Vector3 pos) => NavMesh.SamplePosition(pos, ref val2, 2f, AgentFilter()), out var worldPos, out var _, 3f))
			{
				return false;
			}
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(worldPos, ref val, 2f, AgentFilter()))
			{
				return false;
			}
			approach = ((NavMeshHit)(ref val)).position;
			return true;
		}

		private static NavMeshQueryFilter AgentFilter()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			NavMeshQueryFilter result = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref result)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref result)).areaMask = -1;
			return result;
		}

		private static bool IsValid(WearNTear wnt)
		{
			if ((Object)(object)wnt == (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)wnt).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null)
			{
				return component.IsValid();
			}
			return false;
		}

		private static ZDOID PieceId(WearNTear wnt)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			ZNetView val = (((Object)(object)wnt != (Object)null) ? ((Component)wnt).GetComponent<ZNetView>() : null);
			if (!((Object)(object)val != (Object)null) || val.GetZDO() == null)
			{
				return ZDOID.None;
			}
			return val.GetZDO().m_uid;
		}

		private bool IsBlacklisted(WearNTear wnt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = PieceId(wnt);
			if (val == ZDOID.None)
			{
				return false;
			}
			if (!m_skipUntil.TryGetValue(val, out var value))
			{
				return false;
			}
			if (Time.time >= value)
			{
				m_skipUntil.Remove(val);
				return false;
			}
			return true;
		}

		private void Blacklist()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = PieceId(m_target);
			if (val != ZDOID.None)
			{
				m_skipUntil[val] = Time.time + 30f;
			}
		}

		private void Reset()
		{
			m_active = false;
			m_target = null;
			m_navIssued = false;
			m_ai.SetState(BehaviorState.Idle);
		}
	}
}
namespace ValheimVillages.Behaviors.Patrol
{
	public static class PatrolPersistence
	{
		private const string ZdoWaypoints = "vv_guard_waypoints";

		private const string ZdoWpIndex = "vv_guard_wp_index";

		private const string ZdoDiscovery = "vv_guard_discovery";

		private const string ZdoHnaRoute = "vv_guard_hna_route";

		public static void Save(PatrolStateMachine patrol, ZDO zdo)
		{
			if (patrol != null && zdo != null)
			{
				var (waypoints, num, flag, flag2) = patrol.GetPersistentState();
				zdo.Set("vv_guard_discovery", flag ? 1 : 0);
				zdo.Set("vv_guard_wp_index", num);
				zdo.Set("vv_guard_waypoints", SerializeWaypoints(waypoints));
				zdo.Set("vv_guard_hna_route", flag2 ? 1 : 0);
			}
		}

		public static void Load(PatrolStateMachine patrol, ZDO zdo)
		{
			if (patrol != null && zdo != null)
			{
				bool num = zdo.GetInt("vv_guard_discovery", 0) == 1;
				int wpIndex = zdo.GetInt("vv_guard_wp_index", 0);
				List<VillagerWaypoint> list = DeserializeWaypoints(zdo.GetString("vv_guard_waypoints", ""));
				bool isHna = zdo.GetInt("vv_guard_hna_route", 0) == 1;
				if (num && list != null && list.Count != 0)
				{
					patrol.RestoreState(list, wpIndex, isHna);
				}
			}
		}

		private static string SerializeWaypoints(List<VillagerWaypoint> waypoints)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (waypoints == null || waypoints.Count == 0)
			{
				return "";
			}
			string[] array = new string[waypoints.Count];
			for (int i = 0; i < waypoints.Count; i++)
			{
				VillagerWaypoint villagerWaypoint = waypoints[i];
				Vector3 position = villagerWaypoint.Position;
				string text = (string.IsNullOrEmpty(villagerWaypoint.StrategyId) ? "default" : villagerWaypoint.StrategyId);
				int num = (villagerWaypoint.Active ? 1 : 0);
				array[i] = string.Format(CultureInfo.InvariantCulture, "{0:F1},{1:F1},{2:F1},{3},{4}", position.x, position.y, position.z, text, num);
			}
			return string.Join("|", array);
		}

		private static List<VillagerWaypoint> DeserializeWaypoints(string data)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(data))
			{
				return null;
			}
			List<VillagerWaypoint> list = new List<VillagerWaypoint>();
			string[] array = data.Split(new char[1] { '|' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ',' });
				if (array2.Length >= 3 && float.TryParse(array2[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					string strategyId = ((array2.Length >= 4 && !string.IsNullOrEmpty(array2[3])) ? array2[3] : "default");
					bool active = array2.Length < 5 || array2[4] != "0";
					VillagerWaypoint item = new VillagerWaypoint(new Vector3(result, result2, result3), strategyId)
					{
						Active = active
					};
					list.Add(item);
				}
			}
			if (list.Count <= 0)
			{
				return null;
			}
			return list;
		}
	}
	public static class PatrolRouteBuilder
	{
		private struct Node
		{
			public Vector3 Pos;

			public Vector3 OutDir;
		}

		private const float DedupXZ = 1.5f;

		private const float AheadCutoff = -0.3f;

		private const float ForwardWeight = 1.5f;

		private const float NormalDecimateDeg = 25f;

		private const float InsetDistance = 0.7f;

		private const float MaxInsetDistance = 3f;

		private const float InsetStep = 0.5f;

		private const float SampleRadius = 1f;

		public static List<Vector3> Build(List<(string cellId, Vector3 worldCenter, Vector3 outwardDir)> boundaryCells, Vector3? navAnchor = null)
		{
			//IL_0096: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			if (boundaryCells == null || boundaryCells.Count < 3)
			{
				return list;
			}
			List<Node> list2 = Dedup(boundaryCells);
			if (list2.Count < 3)
			{
				return list;
			}
			List<int> list3 = TangentWalk(list2);
			List<Node> list4 = new List<Node>(list3.Count);
			foreach (int item in list3)
			{
				list4.Add(list2[item]);
			}
			List<Node> list5 = NormalDecimate(list4, 25f);
			if (list5.Count < 3)
			{
				list5 = list4;
			}
			if (navAnchor.HasValue)
			{
				if (!TrySampleAnchor(navAnchor.Value, out var onMesh, out var filter))
				{
					return list;
				}
				int num = 0;
				foreach (Node item2 in list5)
				{
					if (TryResolveReachable(item2, onMesh, filter, out var result))
					{
						list.Add(result);
					}
					else
					{
						num++;
					}
				}
				if (num > 0)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)($"[PatrolRoute] Dropped {num} vertex/vertices unreachable from the " + "anchor (wall-junction geometry or graph link the navmesh doesn't honor)"));
					}
				}
			}
			else
			{
				foreach (Node item3 in list5)
				{
					list.Add(Inset(item3, 0.7f));
				}
			}
			return list;
		}

		private static List<Node> Dedup(List<(string cellId, Vector3 worldCenter, Vector3 outwardDir)> cells)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			List<Node> list = new List<Node>();
			float num = 2.25f;
			foreach (var cell in cells)
			{
				Vector3 item = cell.worldCenter;
				Vector3 item2 = cell.outwardDir;
				bool flag = false;
				foreach (Node item3 in list)
				{
					if (DistXZSq(item, item3.Pos) < num)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(new Node
					{
						Pos = item,
						OutDir = item2
					});
				}
			}
			return list;
		}

		private static List<int> TangentWalk(List<Node> nodes)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			int count = nodes.Count;
			List<int> list = new List<int>(count);
			bool[] array = new bool[count];
			int num = 0;
			for (int i = 1; i < count; i++)
			{
				if (nodes[i].Pos.x < nodes[num].Pos.x)
				{
					num = i;
				}
			}
			list.Add(num);
			array[num] = true;
			int index = num;
			for (int j = 1; j < count; j++)
			{
				Node node = nodes[index];
				float num2 = 0f - node.OutDir.z;
				float x = node.OutDir.x;
				int num3 = -1;
				float num4 = float.MaxValue;
				int num5 = -1;
				float num6 = float.MaxValue;
				for (int k = 0; k < count; k++)
				{
					if (array[k])
					{
						continue;
					}
					float num7 = nodes[k].Pos.x - node.Pos.x;
					float num8 = nodes[k].Pos.z - node.Pos.z;
					float num9 = num7 * num7 + num8 * num8;
					if (num9 < num6)
					{
						num6 = num9;
						num5 = k;
					}
					float num10 = Mathf.Sqrt(num9);
					if (num10 < 0.0001f)
					{
						continue;
					}
					float num11 = (num7 * num2 + num8 * x) / num10;
					if (!(num11 < -0.3f))
					{
						float num12 = num10 - 1.5f * num11;
						if (num12 < num4)
						{
							num4 = num12;
							num3 = k;
						}
					}
				}
				int num13 = ((num3 >= 0) ? num3 : num5);
				if (num13 < 0)
				{
					break;
				}
				list.Add(num13);
				array[num13] = true;
				index = num13;
			}
			return list;
		}

		private static List<Node> NormalDecimate(List<Node> ring, float minTurnDeg)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (ring.Count < 3)
			{
				return new List<Node>(ring);
			}
			float num = Mathf.Cos(minTurnDeg * ((float)Math.PI / 180f));
			List<Node> list = new List<Node> { ring[0] };
			Vector2 val = Flatten(ring[0].OutDir);
			for (int i = 1; i < ring.Count; i++)
			{
				Vector2 val2 = Flatten(ring[i].OutDir);
				if (Vector2.Dot(val2, val) <= num)
				{
					list.Add(ring[i]);
					val = val2;
				}
			}
			return list;
		}

		private static Vector3 Inset(Node n, float distance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Vector3 outDir = n.OutDir;
			outDir.y = 0f;
			if (((Vector3)(ref outDir)).sqrMagnitude < 0.0001f)
			{
				return n.Pos;
			}
			((Vector3)(ref outDir)).Normalize();
			return n.Pos - outDir * distance;
		}

		private static bool TrySampleAnchor(Vector3 anchor, out Vector3 onMesh, out NavMeshQueryFilter filter)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			NavMeshQueryFilter val = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref val)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref val)).areaMask = -1;
			filter = val;
			NavMeshHit val2 = default(NavMeshHit);
			if (VillagerAgentType.IsRegistered && NavMesh.SamplePosition(anchor, ref val2, 3f, filter))
			{
				onMesh = ((NavMeshHit)(ref val2)).position;
				return true;
			}
			onMesh = anchor;
			return false;
		}

		private static bool TryResolveReachable(Node n, Vector3 anchor, NavMeshQueryFilter filter, out Vector3 result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			NavMeshPath val = new NavMeshPath();
			NavMeshHit val2 = default(NavMeshHit);
			for (float num = 0.7f; num <= 3.001f; num += 0.5f)
			{
				if (NavMesh.SamplePosition(Inset(n, num), ref val2, 1f, filter) && NavMesh.CalculatePath(anchor, ((NavMeshHit)(ref val2)).position, filter, val) && (int)val.status == 0)
				{
					result = ((NavMeshHit)(ref val2)).position;
					return true;
				}
			}
			result = default(Vector3);
			return false;
		}

		private static Vector2 Flatten(Vector3 v)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(v.x, v.z);
			if (!(((Vector2)(ref val)).sqrMagnitude > 1E-06f))
			{
				return Vector2.zero;
			}
			return ((Vector2)(ref val)).normalized;
		}

		private static float DistXZSq(Vector3 a, Vector3 b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2;
		}
	}
	public class PatrolStateMachine
	{
		private readonly VillagerAI m_ai;

		private readonly IVillager m_villager;

		private int m_currentWaypointIndex;

		private bool m_hnaPartitionRequested;

		private List<VillagerWaypoint> m_patrolWaypoints;

		private int m_helpWaypointIndex = -1;

		private Vector3 m_helpPosition;

		private bool m_autoResetAttempted;

		public bool IsDiscoveryComplete { get; private set; }

		public Vector3 HomeAnchor => (Vector3)(((??)m_ai?.Memory?.HomeAnchor) ?? Vector3.zero);

		public int WaypointCount => m_patrolWaypoints?.Count ?? 0;

		public int ActiveWaypointCount => m_patrolWaypoints?.Count((VillagerWaypoint w) => w.Active) ?? 0;

		public IReadOnlyList<VillagerWaypoint> PatrolWaypoints => m_patrolWaypoints;

		public bool IsHnaRoute { get; private set; }

		public int HelpWaypointIndex => m_helpWaypointIndex;

		public Vector3 HelpPosition => m_helpPosition;

		public PatrolStateMachine(IVillager villager)
		{
			m_villager = villager;
		}

		public PatrolStateMachine(VillagerAI ai)
		{
			m_ai = ai;
			m_villager = new VillagerAdapter(ai.Villager);
		}

		public (List<VillagerWaypoint> waypoints, int wpIndex, bool complete, bool isHna) GetPersistentState()
		{
			return (waypoints: m_patrolWaypoints, wpIndex: m_currentWaypointIndex, complete: IsDiscoveryComplete, isHna: IsHnaRoute);
		}

		public void ResetDiscovery()
		{
			m_autoResetAttempted = false;
			ResetDiscoveryInternal("manual");
		}

		private void ResetDiscoveryInternal(string reason)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("[Patrol:" + m_villager.VillagerName + "] Discovery reset (" + reason + ")"));
			}
			m_patrolWaypoints?.Clear();
			m_currentWaypointIndex = 0;
			IsDiscoveryComplete = false;
			IsHnaRoute = false;
			m_hnaPartitionRequested = false;
			m_helpWaypointIndex = -1;
			m_ai.SetState(BehaviorState.Idle);
			StartDiscovery();
		}

		public void RestoreState(List<VillagerWaypoint> waypoints, int wpIndex, bool isHna = false)
		{
			m_patrolWaypoints = waypoints;
			m_currentWaypointIndex = wpIndex % (waypoints?.Count ?? 1);
			IsDiscoveryComplete = true;
			IsHnaRoute = isHna;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Patrol:{m_villager.VillagerName}] Restored {m_patrolWaypoints.Count} waypoints" + $" (hna={isHna}), index={m_currentWaypointIndex}"));
			}
		}

		public void UpdatePatrolAI(float dt)
		{
			if (m_ai.IsInBackoff)
			{
				return;
			}
			switch (m_ai.CurrentState)
			{
			default:
				_ = 7;
				break;
			case BehaviorState.Idle:
				if (!IsDiscoveryComplete)
				{
					StartDiscovery();
				}
				else
				{
					AdvanceToNextWaypoint();
				}
				break;
			case BehaviorState.Patrolling:
				break;
			}
		}

		public void HandleArrival(float dt)
		{
			if (m_ai.CurrentState == BehaviorState.Patrolling)
			{
				AdvanceToNextWaypoint();
			}
			else
			{
				m_ai.SetState(BehaviorState.Idle);
			}
		}

		private string GetVillageId()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			VillagerAI ai = m_ai;
			object obj;
			if (ai == null)
			{
				obj = null;
			}
			else
			{
				ZNetView nView = ai.NView;
				if (nView == null)
				{
					obj = null;
				}
				else
				{
					ZDO zDO = nView.GetZDO();
					obj = ((zDO != null) ? zDO.GetString("vv_village_id", "") : null);
				}
			}
			string text = (string)obj;
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			Village villageAt = VillageRegistry.GetVillageAt(m_ai.Memory.HomeAnchor);
			if (villageAt != null)
			{
				return villageAt.VillageId;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("[Patrol:" + m_villager?.VillagerName + "] guard has no vv_village_id and no village " + $"covers its anchor {m_ai.Memory.HomeAnchor}; waiting for a partition (not minting)."));
			}
			return null;
		}

		private void StartDiscovery()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			string villageId = GetVillageId();
			RegionGraph regionGraph = VillageRegistry.FindById(villageId)?.Graph;
			if (regionGraph == null || !regionGraph.IsAvailable)
			{
				if (!m_hnaPartitionRequested)
				{
					m_hnaPartitionRequested = true;
					Vector3 homeAnchor = m_ai.Memory.HomeAnchor;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)("[Patrol:" + m_villager.VillagerName + "] HNA graph unavailable, requesting hna_partition build"));
					}
					GlobalTaskQueue.Enqueue(new VillagerTask
					{
						Name = "hna_partition",
						SourceId = "patrol:" + m_ai.UniqueId,
						Priority = TaskPriority.Medium,
						TimeoutSeconds = 30f,
						Attributes = new Dictionary<string, string>
						{
							{ "village_id", villageId },
							{
								"anchor_x",
								homeAnchor.x.ToString("F2", CultureInfo.InvariantCulture)
							},
							{
								"anchor_z",
								homeAnchor.z.ToString("F2", CultureInfo.InvariantCulture)
							}
						}
					});
				}
				return;
			}
			List<Vector3> list = PatrolRouteBuilder.Build(regionGraph.GetBoundaryCells(), m_ai.Memory.HomeAnchor);
			if (list.Count >= 3)
			{
				m_patrolWaypoints = list.Select((Vector3 p) => new VillagerWaypoint(p, "default")).ToList();
				IsHnaRoute = true;
				m_hnaPartitionRequested = false;
				CompleteHnaDiscovery();
			}
		}

		private void CompleteHnaDiscovery()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			m_currentWaypointIndex = 0;
			IsDiscoveryComplete = true;
			SaveState();
			Vector3 position = m_patrolWaypoints[0].Position;
			Vector3 position2 = m_patrolWaypoints[m_patrolWaypoints.Count - 1].Position;
			Vector3 val = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)($"[Patrol:{m_villager.VillagerName}] HNA boundary discovery complete, {m_patrolWaypoints.Count} waypoints. " + $"First=({position.x:F1},{position.y:F1},{position.z:F1}) " + $"Last=({position2.x:F1},{position2.y:F1},{position2.z:F1}) " + $"Player=({val.x:F1},{val.y:F1},{val.z:F1})"));
			}
			AdvanceToNextWaypoint();
		}

		private void SaveState()
		{
			VillagerAI ai = m_ai;
			object obj;
			if (ai == null)
			{
				obj = null;
			}
			else
			{
				ZNetView nView = ai.NView;
				obj = ((nView != null) ? nView.GetZDO() : null);
			}
			ZDO val = (ZDO)obj;
			if (val != null)
			{
				PatrolPersistence.Save(this, val);
			}
		}

		private void AdvanceToNextWaypoint()
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			if (m_patrolWaypoints == null || ActiveWaypointCount == 0)
			{
				m_ai.SetState(BehaviorState.Idle);
				return;
			}
			int count = m_patrolWaypoints.Count;
			int num = m_currentWaypointIndex;
			for (int i = 0; i < count; i++)
			{
				num = (num + 1) % count;
				if (m_patrolWaypoints[num].Active)
				{
					break;
				}
			}
			if (!m_patrolWaypoints[num].Active)
			{
				m_ai.SetState(BehaviorState.Idle);
				return;
			}
			if (num <= m_currentWaypointIndex)
			{
				m_autoResetAttempted = false;
			}
			m_currentWaypointIndex = num;
			VillagerWaypoint villagerWaypoint = m_patrolWaypoints[num];
			if (m_ai.NavTo(villagerWaypoint.Position, BehaviorState.Patrolling, $"patrol:W{num}", snapToApproach: true, null, directOrder: false, resetPath: false))
			{
				return;
			}
			if (!m_autoResetAttempted)
			{
				m_autoResetAttempted = true;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)($"[Patrol:{m_villager.VillagerName}] No approach to waypoint {num} " + $"({villagerWaypoint.Position.x:F1},{villagerWaypoint.Position.y:F1},{villagerWaypoint.Position.z:F1}) — " + "attempting one automatic patrol-reset before parking in NeedsHelp."));
				}
				ResetDiscoveryInternal("auto-heal");
				return;
			}
			m_helpWaypointIndex = num;
			m_helpPosition = villagerWaypoint.Position;
			string text = $"No reachable approach to waypoint {num}.";
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogError((object)("[Patrol:" + m_villager.VillagerName + "] NeedsHelp: " + text + " " + $"({villagerWaypoint.Position.x:F1},{villagerWaypoint.Position.y:F1},{villagerWaypoint.Position.z:F1}) — " + "patrol parked, fix route/geometry then vv_patrol_reset."));
			}
			VillagerActivityLog.Instance.RecordBlocked(m_villager.UniqueID, "Patrol", null, null, text, villagerWaypoint.Position);
			m_ai.SetState(BehaviorState.NeedsHelp);
		}
	}
	[RegisterBehavior("patrol")]
	public class PerimeterPatrolBehavior : IBehavior
	{
		private readonly VillagerAI m_ai;

		private readonly PatrolStateMachine m_patrol;

		public string Tag => "patrol";

		public int Priority => 30;

		public bool IsDiscoveryComplete => m_patrol?.IsDiscoveryComplete ?? false;

		public Vector3 HomeAnchor => m_patrol?.HomeAnchor ?? Vector3.zero;

		public int HelpWaypointIndex => m_patrol?.HelpWaypointIndex ?? (-1);

		public Vector3 HelpPosition => m_patrol?.HelpPosition ?? Vector3.zero;

		public int WaypointCount => m_patrol?.WaypointCount ?? 0;

		public int ActiveWaypointCount => m_patrol?.ActiveWaypointCount ?? 0;

		public IReadOnlyList<VillagerWaypoint> PatrolWaypoints => m_patrol?.PatrolWaypoints;

		public bool IsHnaRoute => m_patrol?.IsHnaRoute ?? false;

		public PerimeterPatrolBehavior(VillagerAI ai)
		{
			m_ai = ai;
			m_patrol = new PatrolStateMachine(ai);
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			return m_patrol != null;
		}

		public void Update(float dt)
		{
			m_patrol?.UpdatePatrolAI(dt);
		}

		public void OnArrival(float dt)
		{
			m_patrol?.HandleArrival(dt);
		}

		public string GetStatusText()
		{
			if (m_patrol == null)
			{
				return "";
			}
			switch (m_ai.CurrentState)
			{
			case BehaviorState.NeedsHelp:
				return $"Needs help: waypoint {m_patrol.HelpWaypointIndex}";
			case BehaviorState.Patrolling:
				return $"Patrolling ({m_patrol.ActiveWaypointCount} waypoints)";
			default:
				if (!m_patrol.IsDiscoveryComplete)
				{
					return "Mapping village";
				}
				return "On patrol";
			}
		}

		public void Save(ZDO zdo)
		{
			if (m_patrol != null && zdo != null)
			{
				PatrolPersistence.Save(m_patrol, zdo);
			}
		}

		public void Load(ZDO zdo)
		{
			if (m_patrol != null && zdo != null)
			{
				PatrolPersistence.Load(m_patrol, zdo);
			}
		}

		public void ResetDiscovery()
		{
			m_patrol?.ResetDiscovery();
		}
	}
}
namespace ValheimVillages.Behaviors.Farming
{
	public class FarmingBehavior
	{
		private readonly VillagerAI m_ai;

		private readonly IVillager m_villager;

		private FarmingContext m_context;

		public FarmSubState SubState { get; private set; }

		public bool IsWorking => SubState != FarmSubState.Idle;

		public string CurrentItemPrefab => m_context?.WorkOrder?.ItemPrefabName;

		public FarmingBehavior(IVillager villager)
		{
			m_villager = villager;
		}

		public FarmingBehavior(VillagerAI ai)
		{
			m_ai = ai;
			m_villager = new VillagerAdapter(ai.Villager);
		}

		public void BeginFarming(FarmingContext context)
		{
			if (context == null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[Farming:" + m_villager.VillagerName + "] Null context"));
				}
				return;
			}
			m_context = context;
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)("[Farming:" + m_villager.VillagerName + "] Starting farm work: " + context.WorkOrder.ItemPrefabName + " " + $"(harvested: {context.HarvestedCount}/{context.WorkOrder.MaxQuantity})"));
			}
			VillagerActivityLog.Instance.Record(m_villager.UniqueID, context.WorkOrder.ItemPrefabName, "start", "farming");
			if (context.IsHarvestingPass && (Object)(object)context.CurrentHarvestTarget != (Object)null)
			{
				BeginHarvestPass();
			}
			else
			{
				BeginGatheringSeeds();
			}
		}

		public void UpdateWorkAI(float dt)
		{
			if (m_context == null)
			{
				AbandonWork("lost context");
			}
			else
			{
				UpdatePlantingCooldown(dt);
			}
		}

		public void HandleWorkArrival(float dt)
		{
			if (m_context == null)
			{
				AbandonWork("lost context on arrival");
				return;
			}
			switch (SubState)
			{
			case FarmSubState.GatheringSeeds:
				OnArrivedAtSeedChest();
				return;
			case FarmSubState.TravelingToFarm:
				OnArrivedAtFarm();
				return;
			case FarmSubState.WalkingToPlantSpot:
				OnArrivedAtPlantSpot(dt);
				return;
			case FarmSubState.TravelingToHarvest:
				OnArrivedAtCrop();
				return;
			case FarmSubState.ReturningToChest:
				OnArrivedAtOutputChest();
				return;
			case FarmSubState.Planting:
			case FarmSubState.Harvesting:
			case FarmSubState.CollectingDrops:
			case FarmSubState.Depositing:
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)$"[Farming:{m_villager.VillagerName}] Unexpected arrival in {SubState}");
			}
			AbandonWork("unexpected arrival");
		}

		public void GiveUpStuckWork(string reason)
		{
			AbandonWork(reason);
		}

		private void FinishWork()
		{
			string taskName = m_context?.WorkOrder?.ItemPrefabName ?? "farming";
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[Farming:" + m_villager.VillagerName + "] Farming session complete " + $"({m_context?.HarvestedCount ?? 0} harvested, " + $"{m_context?.PlantedThisSession ?? 0} planted)"));
			}
			VillagerActivityLog.Instance.Record(m_villager.UniqueID, taskName, "complete", "farming");
			m_context = null;
			SubState = FarmSubState.Idle;
			m_ai.SetState(BehaviorState.Idle);
			m_ai.CraftingBehavior?.TryScanForWork(ignoreScanInterval: true);
		}

		private void AbandonWork(string reason)
		{
			string taskName = m_context?.WorkOrder?.ItemPrefabName ?? "farming";
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("[Farming:" + m_villager.VillagerName + "] Abandoning farming: " + reason));
			}
			VillagerActivityLog.Instance.Record(m_villager.UniqueID, taskName, "abandon", reason);
			m_context = null;
			SubState = FarmSubState.Idle;
			m_ai.SetState(BehaviorState.Idle);
		}

		private void BeginHarvestPass()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_context.CurrentHarvestTarget == (Object)null)
			{
				Pickable val = HarvestHelper.FindNearestHarvestableCrop(m_ai, m_context.WorkOrder.ItemPrefabName, 20f);
				if ((Object)(object)val == (Object)null)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)("[Farming:" + m_ai.NpcName + "] No more crops to harvest"));
					}
					if (m_context.HarvestedCount < m_context.WorkOrder.MaxQuantity)
					{
						BeginGatheringSeeds();
					}
					else
					{
						FinishWork();
					}
					return;
				}
				m_context.CurrentHarvestTarget = val;
			}
			SubState = FarmSubState.TravelingToHarvest;
			if (!m_ai.NavTo(((Component)m_context.CurrentHarvestTarget).transform.position, BehaviorState.Working, "crop"))
			{
				AbandonWork("no reachable approach to crop");
				return;
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogDebug((object)("[Farming:" + m_ai.NpcName + "] Walking to crop at " + $"{((Component)m_context.CurrentHarvestTarget).transform.position}"));
			}
		}

		private void OnArrivedAtCrop()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			m_ai.Instance.StopMoving();
			Pickable currentHarvestTarget = m_context.CurrentHarvestTarget;
			if ((Object)(object)currentHarvestTarget == (Object)null || !currentHarvestTarget.CanBePicked())
			{
				m_context.CurrentHarvestTarget = null;
				BeginHarvestPass();
				return;
			}
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			GameObject itemPrefab = currentHarvestTarget.m_itemPrefab;
			dictionary.Add("targetName", ((itemPrefab != null) ? ((Object)itemPrefab).name : null) ?? "NULL");
			dictionary.Add("targetPos", ((object)((Component)currentHarvestTarget).transform.position/*cast due to .constrained prefix*/).ToString());
			dictionary.Add("targetGO", ((Object)((Component)currentHarvestTarget).gameObject).name);
			DebugLog.Append("FarmingHarvestWorkflow.cs:OnArrivedAtCrop", "About to harvest crop", dictionary, "A,D", "run1");
			Character character = m_ai.Character;
			Humanoid npc = (Humanoid)(object)((character is Humanoid) ? character : null);
			HarvestHelper.HarvestCrop(currentHarvestTarget, npc);
			m_context.CurrentHarvestTarget = null;
			Vector3 position = ((Component)currentHarvestTarget).transform.position;
			CollectDropsThenReturnToChest(position);
		}

		private void OnArrivedAtOutputChest()
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)("[Farming:" + m_ai.NpcName + "] Arrived at output chest"));
			}
			if (m_context.CarriedHarvestCount > 0)
			{
				Container sourceContainer = m_context.SourceContainer;
				if ((Object)(object)sourceContainer == (Object)null)
				{
					AbandonWork("output container lost");
					return;
				}
				string itemPrefabName = m_context.WorkOrder.ItemPrefabName;
				int carriedHarvestCount = m_context.CarriedHarvestCount;
				if (!ContainerScanner.TryDepositItem(sourceContainer, itemPrefabName, carriedHarvestCount))
				{
					AbandonWork("chest full, cannot deposit");
					return;
				}
				m_context.HarvestedCount += carriedHarvestCount;
				m_context.CarriedHarvestCount = 0;
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)($"[Farming:{m_ai.NpcName}] Deposited {carriedHarvestCount}x {itemPrefabName} " + $"(total: {m_context.HarvestedCount}/{m_context.WorkOrder.MaxQuantity})"));
				}
			}
			if (m_context.HarvestedCount >= m_context.WorkOrder.MaxQuantity)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)("[Farming:" + m_ai.NpcName + "] Work order complete!"));
				}
				FinishWork();
			}
			else
			{
				BeginHarvestPass();
			}
		}

		private void CollectDropsThenReturnToChest(Vector3 harvestPos)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			string itemPrefabName = m_context.WorkOrder.ItemPrefabName;
			int num = 2 - m_context.CarriedHarvestCount;
			if (num <= 0)
			{
				WalkToOutputChest();
				return;
			}
			int num2 = CollectItemDropsIntoCarry(harvestPos, 3f, itemPrefabName, num);
			if (num2 > 0)
			{
				m_context.CarriedHarvestCount += num2;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)($"[Farming:{m_ai.NpcName}] Carrying {num2}x {itemPrefabName} " + $"(carried: {m_context.CarriedHarvestCount}, total harvested: {m_context.HarvestedCount})"));
				}
			}
			if (m_context.CarriedHarvestCount > 0)
			{
				WalkToOutputChest();
			}
			else if (m_context.HarvestedCount >= m_context.WorkOrder.MaxQuantity)
			{
				FinishWork();
			}
			else
			{
				BeginHarvestPass();
			}
		}

		private void WalkToOutputChest()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Container sourceContainer = m_context.SourceContainer;
			if ((Object)(object)sourceContainer == (Object)null)
			{
				AbandonWork("output container lost");
				return;
			}
			SubState = FarmSubState.ReturningToChest;
			if (!m_ai.NavTo(((Component)sourceContainer).transform.position, BehaviorState.Working, "deposit chest"))
			{
				AbandonWork("no reachable approach to deposit chest");
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)$"[Farming:{m_ai.NpcName}] Walking to container to deposit {m_context.CarriedHarvestCount}x");
			}
		}

		private unsafe static int CollectItemDropsIntoCarry(Vector3 center, float radius, string prefabName, int maxTake)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Collider[] array = Physics.OverlapSphere(center, radius);
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			List<string> list = new List<string>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				if (num >= maxTake)
				{
					break;
				}
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				num2++;
				ItemDrop componentInParent = ((Component)val).GetComponentInParent<ItemDrop>();
				if ((Object)(object)componentInParent == (Object)null || componentInParent.m_itemData == null)
				{
					continue;
				}
				num3++;
				if ((Object)(object)componentInParent.m_itemData.m_dropPrefab == (Object)null)
				{
					num4++;
					list.Add("NULL_PREFAB|go=" + ((Object)((Component)componentInParent).gameObject).name);
					continue;
				}
				if (((Object)componentInParent.m_itemData.m_dropPrefab).name != prefabName)
				{
					num5++;
					list.Add(((Object)componentInParent.m_itemData.m_dropPrefab).name + "|go=" + ((Object)((Component)componentInParent).gameObject).name);
					continue;
				}
				int stack = componentInParent.m_itemData.m_stack;
				if (stack > 0)
				{
					int num6 = Mathf.Min(stack, maxTake - num);
					ItemData itemData = componentInParent.m_itemData;
					itemData.m_stack -= num6;
					if (componentInParent.m_itemData.m_stack <= 0)
					{
						Object.Destroy((Object)(object)((Component)componentInParent).gameObject);
					}
					num += num6;
				}
			}
			DebugLog.Append("FarmingHarvestWorkflow.cs:CollectItemDropsIntoCarry", "Collect result", new Dictionary<string, object>
			{
				{ "prefabName", prefabName },
				{ "maxTake", maxTake },
				{ "totalCollected", num },
				{ "collidersFound", num2 },
				{ "itemDropsFound", num3 },
				{ "nullPrefabCount", num4 },
				{ "nameMismatchCount", num5 },
				{
					"mismatchNames",
					string.Join(";", list)
				},
				{
					"center",
					((object)(*(Vector3*)(&center))/*cast due to .constrained prefix*/).ToString()
				},
				{ "radius", radius }
			}, "A,D", "run1");
			return num;
		}

		private void BeginGatheringSeeds()
		{
			if (m_context.IngredientSources == null || m_context.IngredientSources.Count == 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[Farming:" + m_ai.NpcName + "] No seeds to plant"));
				}
				FinishWork();
			}
			else
			{
				m_context.CurrentIngredientIndex = 0;
				WalkToNextSeedChest();
			}
		}

		private void WalkToNextSeedChest()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (m_context.CurrentIngredientIndex >= m_context.IngredientSources.Count)
			{
				BeginTravelingToFarm();
				return;
			}
			IngredientSource ingredientSource = m_context.IngredientSources[m_context.CurrentIngredientIndex];
			if ((Object)(object)ingredientSource.Container == (Object)null)
			{
				AbandonWork("seed container destroyed");
				return;
			}
			SubState = FarmSubState.GatheringSeeds;
			if (!m_ai.NavTo(((Component)ingredientSource.Container).transform.position, BehaviorState.Working, "seed chest"))
			{
				AbandonWork("no reachable approach to seed chest");
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)("[Farming:" + m_ai.NpcName + "] Walking to seed chest for " + ingredientSource.PrefabName));
			}
		}

		private void OnArrivedAtSeedChest()
		{
			IngredientSource ingredientSource = m_context.IngredientSources[m_context.CurrentIngredientIndex];
			if ((Object)(object)ingredientSource.Container == (Object)null)
			{
				AbandonWork("seed chest inaccessible");
				return;
			}
			ContainerScanner.RemoveIngredients(new List<IngredientSource> { ingredientSource });
			m_context.SeedsGathered += ingredientSource.Amount;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)$"[Farming:{m_ai.NpcName}] Took {ingredientSource.Amount}x {ingredientSource.PrefabName}");
			}
			m_context.CurrentIngredientIndex++;
			WalkToNextSeedChest();
		}

		private void BeginTravelingToFarm()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			SubState = FarmSubState.TravelingToFarm;
			if (!m_ai.NavTo(m_context.FarmPosition, BehaviorState.Working, "farm"))
			{
				AbandonWork("no reachable approach to farm");
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Farming:{m_ai.NpcName}] Walking to farm at {m_context.FarmPosition}");
			}
		}

		private void OnArrivedAtFarm()
		{
			if ((Object)(object)m_context.PlantPiecePrefab == (Object)null)
			{
				AbandonWork("no plant piece prefab");
			}
			else
			{
				TryFindAndWalkToNextPlantSpot();
			}
		}

		private void TryFindAndWalkToNextPlantSpot()
		{
			//IL_0087: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: 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_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			if (m_context.SeedsGathered <= 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[Farming:" + m_ai.NpcName + "] All seeds planted " + $"(total session: {m_context.PlantedThisSession})"));
				}
				FinishWork();
				return;
			}
			Plant component = m_context.PlantPiecePrefab.GetComponent<Plant>();
			float growRadius = (((Object)(object)component != (Object)null) ? component.m_growRadius : 0.5f);
			Vector3? val = PlantingHelper.FindPlantingPosition(m_context.FarmPosition, 20f, growRadius);
			if (!val.HasValue)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogDebug((object)("[Farming:" + m_ai.NpcName + "] No more valid planting positions"));
				}
				FinishWork();
				return;
			}
			m_context.NextPlantPosition = val.Value;
			SubState = FarmSubState.WalkingToPlantSpot;
			if (!m_ai.NavTo(val.Value, BehaviorState.Working, "plant spot"))
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogDebug((object)$"[Farming:{m_ai.NpcName}] Plant spot {val.Value} unreachable; finishing.");
				}
				FinishWork();
				return;
			}
			DebugLog.Append("FarmingWorkflow.cs:TryFindAndWalkToNextPlantSpot", "Walking to plant spot", new Dictionary<string, object>
			{
				{
					"position",
					((object)val.Value/*cast due to .constrained prefix*/).ToString()
				},
				{ "seedsRemaining", m_context.SeedsGathered },
				{ "plantedSoFar", m_context.PlantedThisSession }
			}, "H3", "run1");
			ManualLogSource log4 = Plugin.Log;
			if (log4 != null)
			{
				log4.LogDebug((object)$"[Farming:{m_ai.NpcName}] Walking to plant spot at {val.Value}");
			}
		}

		private void OnArrivedAtPlantSpot(float dt)
		{
			//IL_002e: 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)
			if (!m_context.NextPlantPosition.HasValue)
			{
				AbandonWork("lost plant target");
				return;
			}
			float num = Vector3.Distance(((Component)m_ai.Instance).transform.position, m_context.NextPlantPosition.Value);
			if (num > 1.5f)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[Farming:" + m_ai.NpcName + "] Can't reach plant spot " + $"({num:F1}m away), skipping to find another"));
				}
				m_context.NextPlantPosition = null;
				TryFindAndWalkToNextPlantSpot();
			}
			else
			{
				SubState = FarmSubState.Planting;
				m_context.PlantCooldown = dt - 4f;
				m_ai.Instance.StopMoving();
			}
		}

		private void UpdatePlantingCooldown(float dt)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (SubState != FarmSubState.Planting)
			{
				return;
			}
			if (!m_context.NextPlantPosition.HasValue)
			{
				AbandonWork("lost plant target during cooldown");
				return;
			}
			m_context.PlantCooldown += 0.5f;
			if (m_context.PlantCooldown < dt)
			{
				return;
			}
			m_context.PlantCooldown = dt - 4f;
			if ((Object)(object)PlantingHelper.PlacePlant(m_context.PlantPiecePrefab, m_context.NextPlantPosition.Value) != (Object)null)
			{
				m_context.PlantedThisSession++;
				m_context.SeedsGathered--;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[Farming:" + m_ai.NpcName + "] Planted " + ((Object)m_context.PlantPiecePrefab).name + " " + $"(planted: {m_context.PlantedThisSession}, seeds left: {m_context.SeedsGathered})"));
				}
			}
			else
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[Farming:" + m_ai.NpcName + "] Failed to place plant"));
				}
			}
			m_context.NextPlantPosition = null;
			TryFindAndWalkToNextPlantSpot();
		}
	}
	public static class FarmSettings
	{
		public const float PlantSearchRadius = 20f;

		public const float HarvestScanRadius = 20f;

		public const int MaxPlantsPerSession = 10;

		public const int MaxHarvestCarryPerTrip = 2;

		public const float PlantCooldownSeconds = 2f;

		public const float PlantProximityRequired = 1.5f;
	}
	public static class HarvestHelper
	{
		public const float HarvestScanRadius = 20f;

		private static readonly FieldInfo s_pickedField = typeof(Pickable).GetField("m_picked", BindingFlags.Instance | BindingFlags.NonPublic);

		public static List<Pickable> FindHarvestableCrops(Vector3 center, float radius, string outputItemName)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			List<Pickable> list = new List<Pickable>();
			HashSet<int> hashSet = new HashSet<int>();
			Collider[] array = Physics.OverlapSphere(center, radius);
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Pickable componentInParent = ((Component)val).GetComponentInParent<Pickable>();
					if (!((Object)(object)componentInParent == (Object)null) && hashSet.Add(((Object)componentInParent).GetInstanceID()) && !IsAlreadyPicked(componentInParent) && !((Object)(object)componentInParent.m_itemPrefab == (Object)null) && !(((Object)componentInParent.m_itemPrefab).name != outputItemName) && componentInParent.CanBePicked())
					{
						list.Add(componentInParent);
					}
				}
			}
			return list;
		}

		public static Pickable FindNearestHarvestableCrop(VillagerAI ai, string outputItemName, float radius)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return FindNearestHarvestableCrop(((Component)ai).transform.position, outputItemName, radius);
		}

		public static Pickable FindNearestHarvestableCrop(Vector3 currentPosition, string outputItemName, float radius)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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)
			Pickable result = null;
			float num = float.MaxValue;
			List<Vector3> list = new List<Vector3> { currentPosition };
			foreach (KnownLocation poi in VillagePoiRegistry.GetPois(currentPosition, LocationType.Farm))
			{
				list.Add(poi.Position);
			}
			foreach (Vector3 item in list)
			{
				foreach (Pickable item2 in FindHarvestableCrops(item, radius, outputItemName))
				{
					float num2 = Vector3.Distance(currentPosition, ((Component)item2).transform.position);
					if (num2 < num)
					{
						num = num2;
						result = item2;
					}
				}
			}
			return result;
		}

		public static bool HarvestCrop(Pickable pickable, Humanoid npc)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pickable == (Object)null || (Object)(object)npc == (Object)null)
			{
				return false;
			}
			if (!pickable.CanBePicked())
			{
				return false;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				GameObject itemPrefab = pickable.m_itemPrefab;
				log.LogInfo((object)("[Farming] Harvesting " + (((itemPrefab != null) ? ((Object)itemPrefab).name : null) ?? "?") + " " + $"at {((Component)pickable).transform.position}"));
			}
			return pickable.Interact(npc, false, false);
		}

		public static int CountHarvestableCrops(VillagerAI ai, string outputItemName, float radius)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KnownLocation poi in VillagePoiRegistry.GetPois(((Component)ai).transform.position, LocationType.Farm))
			{
				num += FindHarvestableCrops(poi.Position, radius, outputItemName).Count;
			}
			return num;
		}

		private static bool IsAlreadyPicked(Pickable pickable)
		{
			if (s_pickedField == null)
			{
				return false;
			}
			return (bool)s_pickedField.GetValue(pickable);
		}
	}
	public static class PlantingHelper
	{
		private static int s_spaceMask;

		private static readonly Collider[] s_overlapBuffer = (Collider[])(object)new Collider[128];

		public unsafe static Vector3? FindPlantingPosition(Vector3 center, float searchRadius, float growRadius)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			EnsureSpaceMask();
			float num = Mathf.Max(growRadius * 2f, 1.5f);
			DebugLog.Append("PlantingHelper.cs:FindPlantingPosition", "Spacing check start", new Dictionary<string, object>
			{
				{ "plantSpacing", num },
				{ "growRadius", growRadius },
				{ "searchRadius", searchRadius },
				{
					"center",
					((object)(*(Vector3*)(&center))/*cast due to .constrained prefix*/).ToString()
				}
			}, "H3", "run1");
			for (float num2 = 0f; num2 <= searchRadius; num2 += num)
			{
				int num3 = ((num2 < 0.1f) ? 1 : Mathf.Max(4, Mathf.RoundToInt((float)Math.PI * 2f * num2 / num)));
				for (int i = 0; i < num3; i++)
				{
					float num4 = (float)Math.PI * 2f * (float)i / (float)num3;
					Vector3 val = center + new Vector3(Mathf.Cos(num4) * num2, 0f, Mathf.Sin(num4) * num2);
					if (GetTerrainHeight(val, out var height))
					{
						val.y = height;
						if (IsCultivated(val) && HasGrowSpace(val, growRadius, num))
						{
							return val;
						}
					}
				}
			}
			return null;
		}

		public static GameObject PlacePlant(GameObject piecePrefab, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)piecePrefab == (Object)null)
			{
				return null;
			}
			Quaternion val = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
			GameObject val2 = Object.Instantiate<GameObject>(piecePrefab, position, val);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Piece component = val2.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				component.SetCreator(0L);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Farming] Planted {((Object)piecePrefab).name} at {position}");
			}
			return val2;
		}

		public static bool IsCultivated(Vector3 worldPos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Heightmap val = Heightmap.FindHeightmap(worldPos);
			if ((Object)(object)val != (Object)null)
			{
				return val.IsCultivated(worldPos);
			}
			return false;
		}

		private static bool GetTerrainHeight(Vector3 worldPos, out float height)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			height = 0f;
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			height = ZoneSystem.instance.GetGroundHeight(worldPos);
			return height > -1000f;
		}

		private static bool HasGrowSpace(Vector3 candidate, float growRadius, float plantSpacing)
		{
			//IL_0008: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(growRadius, plantSpacing);
			int num2 = Physics.OverlapSphereNonAlloc(candidate, num, s_overlapBuffer, s_spaceMask);
			float num3 = growRadius * growRadius;
			float num4 = plantSpacing * plantSpacing;
			for (int i = 0; i < num2; i++)
			{
				Collider val = s_overlapBuffer[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Plant componentInParent = ((Component)val).GetComponentInParent<Plant>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					float num5 = candidate.x - ((Component)componentInParent).transform.position.x;
					float num6 = candidate.z - ((Component)componentInParent).transform.position.z;
					if (num5 * num5 + num6 * num6 < num4)
					{
						return false;
					}
					continue;
				}
				Pickable componentInParent2 = ((Component)val).GetComponentInParent<Pickable>();
				if ((Object)(object)componentInParent2 != (Object)null)
				{
					float num7 = candidate.x - ((Component)componentInParent2).transform.position.x;
					float num8 = candidate.z - ((Component)componentInParent2).transform.position.z;
					if (num7 * num7 + num8 * num8 < num4)
					{
						return false;
					}
				}
				else
				{
					Vector3 val2 = candidate - val.ClosestPoint(candidate);
					if (((Vector3)(ref val2)).sqrMagnitude < num3)
					{
						return false;
					}
				}
			}
			return true;
		}

		private static void EnsureSpaceMask()
		{
			if (s_spaceMask == 0)
			{
				s_spaceMask = LayerMask.GetMask(new string[5] { "Default", "static_solid", "Default_small", "piece", "piece_nonsolid" });
			}
		}
	}
}
namespace ValheimVillages.Behaviors.Crafting
{
	public class CraftingBehavior
	{
		private readonly VillagerAI m_ai;

		private readonly IVillager m_villager;

		private WorkOrderContext m_context;

		private float m_lastScanTime;

		private bool m_scanPending;

		private static readonly MethodInfo s_smelterGetProcessedQueueSize = typeof(Smelter).GetMethod("GetProcessedQueueSize", BindingFlags.Instance | BindingFlags.NonPublic);

		private const int OutputBatchPerTrip = 5;

		private string LogName => m_ai?.NpcName ?? m_villager.VillagerName;

		private string UniqueIdForLog => m_ai?.UniqueId ?? m_villager.UniqueID;

		public FarmingBehavior FarmingBehavior { get; private set; }

		public WorkSubState SubState { get; private set; }

		public string LastWorkNote { get; private set; } = "(none)";

		public bool IsWorking
		{
			get
			{
				if (SubState == WorkSubState.Idle)
				{
					return FarmingBehavior?.IsWorking ?? false;
				}
				return true;
			}
		}

		public string CurrentItemPrefab
		{
			get
			{
				object obj = m_context?.WorkOrder?.ItemPrefabName;
				if (obj == null)
				{
					FarmingBehavior farmingBehavior = FarmingBehavior;
					if (farmingBehavior == null)
					{
						return null;
					}
					obj = farmingBehavior.CurrentItemPrefab;
				}
				return (string)obj;
			}
		}

		public bool IsWaitingForCooking
		{
			get
			{
				if (SubState == WorkSubState.Crafting && (Object)(object)m_context?.CookingStationRef != (Object)null)
				{
					return !m_context.CookingRemovalRequested;
				}
				return false;
			}
		}

		public bool IsWaitingForSmelter
		{
			get
			{
				if (SubState == WorkSubState.Crafting && (Object)(object)m_context?.SmelterRef != (Object)null)
				{
					return !m_context.SmelterRemovalRequested;
				}
				return false;
			}
		}

		public CraftingBehavior(ValheimVillages.Villager.Villager villagerInstance)
		{
			m_villager = new VillagerAdapter(villagerInstance);
		}

		public CraftingBehavior(VillagerAI ai)
		{
			m_ai = ai;
			m_villager = new VillagerAdapter(ai.Villager);
		}

		internal void SetWorkNote(string note)
		{
			LastWorkNote = note;
		}

		public void SetFarmingBehavior(FarmingBehavior fb)
		{
			FarmingBehavior = fb;
		}

		public bool TryScanForWork(bool ignoreScanInterval = false)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (IsWorking)
			{
				return false;
			}
			if (m_scanPending)
			{
				return false;
			}
			if (m_villager.VillagerType == "villager")
			{
				return false;
			}
			if (!ignoreScanInterval && Time.time - m_lastScanTime < 6f)
			{
				return false;
			}
			m_lastScanTime = Time.time;
			Vector3 homeAnchor = m_villager.HomeAnchor;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogDebug((object)("[WorkScan:" + m_villager.VillagerName + "] Enqueueing work order scan. " + $"VillagerType={m_villager.VillagerType}, HomeAnchor=({homeAnchor.x:F2},{homeAnchor.y:F2},{homeAnchor.z:F2})"));
			}
			m_scanPending = true;
			GlobalTaskQueue.Enqueue(new VillagerTask
			{
				Name = "work_order_scan",
				SourceId = m_villager.UniqueID,
				Priority = TaskPriority.Medium,
				TimeoutSeconds = 30f,
				Attributes = new Dictionary<string, string>
				{
					{ "villager_id", m_villager.UniqueID },
					{ "villager_type", m_villager.VillagerType },
					{
						"home_x",
						homeAnchor.x.ToString("F2", CultureInfo.InvariantCulture)
					},
					{
						"home_y",
						homeAnchor.y.ToString("F2", CultureInfo.InvariantCulture)
					},
					{
						"home_z",
						homeAnchor.z.ToString("F2", CultureInfo.InvariantCulture)
					}
				},
				Callback = OnWorkOrderScanResult
			});
			return false;
		}

		private void OnWorkOrderScanResult(TaskResult result)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			m_scanPending = false;
			if (!result.Success)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("[WorkScan:" + LogName + "] Scan failed: " + result.Error));
				}
			}
			else
			{
				if (IsWorking)
				{
					return;
				}
				if (result.Payload is FarmingContext farmingContext)
				{
					if (FarmingBehavior != null)
					{
						ManualLogSource log2 = Plugin.Log;
						if (log2 != null)
						{
							log2.LogInfo((object)("[WorkScan:" + LogName + "] Scan result: farming " + farmingContext.WorkOrder.ItemPrefabName));
						}
						FarmingBehavior.BeginFarming(farmingContext);
					}
					else
					{
						ManualLogSource log3 = Plugin.Log;
						if (log3 != null)
						{
							log3.LogWarning((object)("[WorkScan:" + LogName + "] Farming context but no FarmingBehavior"));
						}
					}
				}
				else if (!(result.Payload is WorkOrderContext workOrderContext))
				{
					SetWorkNote($"scan: no work payload @ t={Time.time:F0}");
				}
				else
				{
					ManualLogSource log4 = Plugin.Log;
					if (log4 != null)
					{
						log4.LogInfo((object)("[WorkScan:" + LogName + "] Scan result: starting work on " + $"{workOrderContext.WorkOrder.ItemPrefabName} at {workOrderContext.CraftStationPosition}"));
					}
					m_context = workOrderContext;
					SetWorkNote($"start {workOrderContext.WorkOrder.ItemPrefabName} @ t={Time.time:F0}");
					VillagerActivityLog.Instance.Record(UniqueIdForLog, workOrderContext.WorkOrder.ItemPrefabName, "start", "crafting");
					BeginFueling();
				}
			}
		}

		public void UpdateWorkAI(float dt)
		{
			if (FarmingBehavior != null && FarmingBehavior.IsWorking)
			{
				FarmingBehavior.UpdateWorkAI(dt);
			}
			else if (m_context == null)
			{
				AbandonWork("lost context");
			}
			else if (SubState == WorkSubState.Crafting && !TryPollCookingStation() && !TryPollSmelter() && Time.time - m_context.CraftStartTime >= 5f)
			{
				CompleteCraft();
			}
		}

		public void HandleWorkArrival(float dt)
		{
			if (FarmingBehavior != null && FarmingBehavior.IsWorking)
			{
				FarmingBehavior.HandleWorkArrival(dt);
				return;
			}
			if (m_context == null)
			{
				AbandonWork("lost context on arrival");
				return;
			}
			switch (SubState)
			{
			case WorkSubState.GatheringFuel:
				OnArrivedAtFuelContainer();
				return;
			case WorkSubState.FuelingStation:
				OnArrivedAtFuelTarget();
				return;
			case WorkSubState.GatheringIngredients:
				OnArrivedAtIngredientChest();
				return;
			case WorkSubState.TravelingToStation:
				OnArrivedAtStation();
				return;
			case WorkSubState.ReturningToChest:
				OnArrivedAtOutputChest();
				return;
			case WorkSubState.Crafting:
				m_ai?.ClearWaypoint();
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)$"[Work:{LogName}] Unexpected arrival in sub-state {SubState}");
			}
			AbandonWork("unexpected arrival");
		}

		private bool TryWalkTo(Vector3 target, WorkSubState substate, string targetDescription)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_ai == (Object)null)
			{
				return false;
			}
			if (!VillageStationRegistry.TryResolveApproach(target, m_ai.Position, out var approach, m_ai.HomeAnchor))
			{
				AbandonWork($"no HNA-valid approach to {targetDescription} @ ({target.x:F1},{target.y:F1},{target.z:F1})");
				return false;
			}
			SubState = substate;
			return m_ai.NavTo(approach, BehaviorState.Working, targetDescription, snapToApproach: false);
		}

		private static int GetSmelterProcessedQueueSize(Smelter smelter)
		{
			if ((Object)(object)smelter == (Object)null || s_smelterGetProcessedQueueSize == null)
			{
				return 0;
			}
			try
			{
				return (int)s_smelterGetProcessedQueueSize.Invoke(smelter, null);
			}
			catch
			{
				return 0;
			}
		}

		private void AbandonWork(string reason)
		{
			SetWorkNote($"abandon[{SubState}]: {reason} @ t={Time.time:F0}");
			if (m_context != null && m_context.HeldItems.Count > 0)
			{
				RollbackHeldItems(m_context.HeldItems, reason);
			}
			m_context = null;
			SubState = WorkSubState.Idle;
			if ((Object)(object)m_ai != (Object)null)
			{
				m_ai.SetState(BehaviorState.Idle, (VillagerWaypoint)null);
			}
		}

		private void RollbackHeldItems(List<HeldItem> held, string reason)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			foreach (HeldItem item in held)
			{
				if (item == null || string.IsNullOrEmpty(item.PrefabName) || item.Amount <= 0)
				{
					continue;
				}
				if ((Object)(object)item.SourceContainer != (Object)null && ContainerScanner.TryDepositItem(item.SourceContainer, item.PrefabName, item.Amount))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)($"[Work:{LogName}] Rollback ({reason}): returned {item.Amount}x " + item.PrefabName + " to source container."));
					}
					continue;
				}
				Vector3 val = (((Object)(object)m_ai != (Object)null && (Object)(object)((Component)m_ai).transform != (Object)null) ? ((Component)m_ai).transform.position : Vector3.zero);
				ZNetScene instance = ZNetScene.instance;
				GameObject val2 = ((instance != null) ? instance.GetPrefab(item.PrefabName) : null);
				if ((Object)(object)val2 == (Object)null)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogError((object)($"[Work:{LogName}] Rollback ({reason}): LOST {item.Amount}x " + item.PrefabName + " — prefab not found and source unavailable."));
					}
					continue;
				}
				for (int i = 0; i < item.Amount; i++)
				{
					Vector3 val3 = val + new Vector3(Random.Range(-0.3f, 0.3f), 0.3f, Random.Range(-0.3f, 0.3f));
					Object.Instantiate<GameObject>(val2, val3, Quaternion.identity);
				}
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[Work:" + LogName + "] Rollback (" + reason + "): source container unavailable for " + $"{item.Amount}x {item.PrefabName}; dropped at villager position " + $"({val.x:F1},{val.y:F1},{val.z:F1})."));
				}
			}
			held.Clear();
		}

		public void AbandonWorkPublic(string reason)
		{
			AbandonWork(reason);
		}

		private void BeginFueling()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			WorkOrderContext context = m_context;
			if (context == null || !context.FuelRequirement.HasValue || (Object)(object)m_context.FuelContainer == (Object)null)
			{
				BeginGatheringIngredients();
				return;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[Work:" + LogName + "] Fueling required (" + m_context.FuelRequirement.Value.FuelItemPrefab + "), walking to fuel container"));
			}
			TryWalkTo(((Component)m_context.FuelContainer).transform.position, WorkSubState.GatheringFuel, "fuel container");
		}

		private void OnArrivedAtFuelContainer()
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (m_context == null || (Object)(object)m_ai == (Object)null || !m_context.FuelRequirement.HasValue)
			{
				AbandonWork("lost fuel context");
				return;
			}
			FuelNeed value = m_context.FuelRequirement.Value;
			Container fuelContainer = m_context.FuelContainer;
			if ((Object)(object)fuelContainer == (Object)null)
			{
				AbandonWork("fuel container inaccessible");
				return;
			}
			Inventory inventory = fuelContainer.GetInventory();
			if (inventory == null || ContainerScanner.CountByPrefab(inventory, value.FuelItemPrefab) <= 0)
			{
				AbandonWork("fuel no longer available in container");
				return;
			}
			ContainerScanner.RemoveIngredients(new List<IngredientSource>
			{
				new IngredientSource
				{
					PrefabName = value.FuelItemPrefab,
					Amount = 1,
					Container = fuelContainer
				}
			});
			m_context.HeldItems.Add(new HeldItem
			{
				SourceContainer = fuelContainer,
				PrefabName = value.FuelItemPrefab,
				Amount = 1
			});
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[Work:" + LogName + "] Picked up 1x " + value.FuelItemPrefab + ", walking to fuel target"));
			}
			TryWalkTo(value.FuelTargetPosition, WorkSubState.FuelingStation, "fuel target");
		}

		private void OnArrivedAtFuelTarget()
		{
			if (m_context == null || !m_context.FuelRequirement.HasValue)
			{
				AbandonWork("lost fuel context at target");
				return;
			}
			FuelNeed value = m_context.FuelRequirement.Value;
			if ((Object)(object)value.FireplaceRef != (Object)null)
			{
				ZNetView component = ((Component)value.FireplaceRef).GetComponent<ZNetView>();
				if (!((Object)(object)component != (Object)null) || component.GetZDO() == null)
				{
					AbandonWork("fireplace ZNetView invalid");
					return;
				}
				component.InvokeRPC("RPC_AddFuel", Array.Empty<object>());
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[Work:" + LogName + "] Added fuel to Fireplace"));
				}
			}
			else if ((Object)(object)value.SmelterRef != (Object)null)
			{
				ZNetView component2 = ((Component)value.SmelterRef).GetComponent<ZNetView>();
				if (!((Object)(object)component2 != (Object)null) || component2.GetZDO() == null)
				{
					AbandonWork("smelter ZNetView invalid for fueling");
					return;
				}
				component2.InvokeRPC("RPC_AddFuel", Array.Empty<object>());
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("[Work:" + LogName + "] Added fuel to Smelter (" + ((Object)((Component)value.SmelterRef).gameObject).name + ")"));
				}
			}
			else if ((Object)(object)value.CookingStationRef != (Object)null)
			{
				ZNetView component3 = ((Component)value.CookingStationRef).GetComponent<ZNetView>();
				if (!((Object)(object)component3 != (Object)null) || component3.GetZDO() == null)
				{
					AbandonWork("cooking station ZNetView invalid for fueling");
					return;
				}
				component3.InvokeRPC("RPC_AddFuel", Array.Empty<object>());
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)("[Work:" + LogName + "] Added fuel to CookingStation"));
				}
			}
			m_context.FuelRequirement = null;
			m_context.FuelContainer = null;
			ClearHeldItem(value.FuelItemPrefab, 1);
			BeginGatheringIngredients();
		}

		private void ClearHeldItem(string prefabName, int amount)
		{
			if (m_context == null || string.IsNullOrEmpty(prefabName))
			{
				return;
			}
			for (int i = 0; i < m_context.HeldItems.Count; i++)
			{
				HeldItem heldItem = m_context.HeldItems[i];
				if (heldItem != null && !(heldItem.PrefabName != prefabName) && heldItem.Amount == amount)
				{
					m_context.HeldItems.RemoveAt(i);
					break;
				}
			}
		}

		private void BeginGatheringIngredients()
		{
			if (m_context?.IngredientSources == null || m_context.IngredientSources.Count == 0)
			{
				BeginTravelingToStation();
				return;
			}
			m_context.CurrentIngredientIndex = 0;
			WalkToNextIngredientChest();
		}

		private bool TryPollCookingStation()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			CookingStation val = m_context?.CookingStationRef;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (m_context.CookingRemovalRequested)
			{
				return true;
			}
			if (!StationFinder.IsCookingStationReady(val))
			{
				AbandonWork("cooking station fire went out");
				return true;
			}
			ZNetView component = ((Component)val).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || component.GetZDO() == null)
			{
				return false;
			}
			int num = ((val.m_slots != null) ? val.m_slots.Length : 0);
			ZDO zDO = component.GetZDO();
			for (int i = 0; i < num; i++)
			{
				string text = zDO.GetString("slot" + i, "");
				if (!string.IsNullOrEmpty(text) && zDO.GetInt("slotstatus" + i, 0) >= 1)
				{
					m_context.CookingRemovalRequested = true;
					component.InvokeRPC("RPC_RemoveDoneItem", new object[2]
					{
						((Component)val).transform.position,
						i
					});
					TryPickupDroppedItem(val, text);
					m_context.CraftedCount++;
					BeginReturningToChest();
					return true;
				}
			}
			return true;
		}

		private bool TryPollSmelter()
		{
			Smelter val = m_context?.SmelterRef;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (m_context.SmelterRemovalRequested)
			{
				return true;
			}
			if ((Object)(object)val.m_fuelItem != (Object)null && !StationFinder.IsSmelterReady(val))
			{
				AbandonWork("smelter fuel ran out before output");
				return true;
			}
			int num = CollectSmelterOutput(val, 5);
			if (num > 0)
			{
				m_context.SmelterRemovalRequested = true;
				m_context.CraftedCount += num;
				BeginReturningToChest();
			}
			return true;
		}

		private int CollectSmelterOutput(Smelter smelter, int maxItems)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (((Object)(object)smelter.m_outputPoint != (Object)null) ? smelter.m_outputPoint.position : ((Component)smelter).transform.position);
			string text = m_context.WorkOrder?.ItemPrefabName;
			if (string.IsNullOrEmpty(text))
			{
				return 0;
			}
			List<ItemDrop> allInRadius = PhysicsHelper.GetAllInRadius<ItemDrop>(val, 10f);
			List<(ItemDrop, float)> list = new List<(ItemDrop, float)>();
			foreach (ItemDrop item2 in allInRadius)
			{
				if (!((Object)(object)item2 == (Object)null) && item2.m_itemData != null)
				{
					GameObject dropPrefab = item2.m_itemData.m_dropPrefab;
					if (!((((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? ((Object)((Component)item2).gameObject).name.Replace("(Clone)", "").Trim()) != text))
					{
						list.Add((item2, Vector3.Distance(((Component)item2).transform.position, val)));
					}
				}
			}
			if (list.Count == 0)
			{
				return 0;
			}
			list.Sort(((ItemDrop drop, float dist) a, (ItemDrop drop, float dist) b) => a.dist.CompareTo(b.dist));
			int num = Mathf.Min(maxItems, list.Count);
			if ((Object)(object)m_context.SourceContainer == (Object)null)
			{
				num = 0;
			}
			else
			{
				while (num > 0 && !ContainerScanner.CanAcceptItem(m_context.SourceContainer, text, num))
				{
					num--;
				}
			}
			if (num <= 0)
			{
				return 0;
			}
			int num2 = 0;
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				if (num2 >= num)
				{
					break;
				}
				ItemDrop item = list[num3].Item1;
				ZNetView component = ((Component)item).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.GetZDO() != null)
				{
					ZNetScene.instance.Destroy(((Component)item).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				num2++;
			}
			if (num2 <= 0)
			{
				return 0;
			}
			m_context.HeldItems.Add(new HeldItem
			{
				SourceContainer = m_context.SourceContainer,
				PrefabName = text,
				Amount = num2
			});
			return num2;
		}

		private void TryPickupDroppedItem(CookingStation station, string slotItemName)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (((Object)(object)station.m_spawnPoint != (Object)null) ? station.m_spawnPoint.position : ((Component)station).transform.position);
			List<ItemDrop> allInRadius = PhysicsHelper.GetAllInRadius<ItemDrop>(val, 3f);
			ItemDrop val2 = null;
			float num = float.MaxValue;
			foreach (ItemDrop item in allInRadius)
			{
				if ((Object)(object)item == (Object)null || item.m_itemData == null)
				{
					continue;
				}
				GameObject dropPrefab = item.m_itemData.m_dropPrefab;
				if (!((((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? ((Object)((Component)item).gameObject).name.Replace("(Clone)", "").Trim()) != slotItemName))
				{
					float num2 = Vector3.Distance(((Component)item).transform.position, val);
					if (num2 < num)
					{
						val2 = item;
						num = num2;
					}
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				ZNetView component = ((Component)val2).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.GetZDO() != null)
				{
					ZNetScene.instance.Destroy(((Component)val2).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
			}
		}

		private void CompleteCraft()
		{
			if (m_context == null)
			{
				AbandonWork("lost context in CompleteCraft");
				return;
			}
			if ((Object)(object)m_context.CookingStationRef != (Object)null)
			{
				string text = m_context.WorkOrder?.ItemPrefabName;
				if (!string.IsNullOrEmpty(text) && (Object)(object)m_context.SourceContainer != (Object)null)
				{
					ContainerScanner.TryDepositItem(m_context.SourceContainer, text, 1);
					m_context.CookingItemAlreadyInChest = true;
				}
			}
			else if ((Object)(object)m_context.SmelterRef != (Object)null)
			{
				string text2 = m_context.WorkOrder?.ItemPrefabName;
				if (!string.IsNullOrEmpty(text2) && (Object)(object)m_context.SourceContainer != (Object)null)
				{
					ContainerScanner.TryDepositItem(m_context.SourceContainer, text2, 1);
					m_context.SmelterItemAlreadyInChest = true;
				}
			}
			else
			{
				m_context.CraftedCount++;
			}
			BeginReturningToChest();
		}

		private void BeginReturningToChest()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (m_context == null || (Object)(object)m_ai == (Object)null)
			{
				AbandonWork("lost context in BeginReturningToChest");
			}
			else if ((Object)(object)m_context.SourceContainer == (Object)null)
			{
				FinishWork();
			}
			else
			{
				TryWalkTo(((Component)m_context.SourceContainer).transform.position, WorkSubState.ReturningToChest, "source chest");
			}
		}

		private void FinishWork()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_ai != (Object)null && m_context != null && m_context.CraftStationPosition != Vector3.zero)
			{
				m_ai.LingerUntilTime = Time.time + 15f;
				m_ai.LingerAtPos = m_context.CraftStationPosition;
			}
			if (m_context != null && m_context.HeldItems.Count > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)($"[Work:{LogName}] FinishWork with {m_context.HeldItems.Count} uncommitted " + "HeldItems — workflow regression, rolling back as if AbandonWork."));
				}
				RollbackHeldItems(m_context.HeldItems, "finish_with_uncommitted");
			}
			m_context = null;
			SubState = WorkSubState.Idle;
			if ((Object)(object)m_ai != (Object)null)
			{
				m_ai.SetState(BehaviorState.Idle, (VillagerWaypoint)null);
			}
		}

		private void OnArrivedAtIngredientChest()
		{
			if (m_context == null || (Object)(object)m_ai == (Object)null)
			{
				return;
			}
			if (m_context.CurrentIngredientIndex >= m_context.IngredientSources.Count)
			{
				BeginTravelingToStation();
				return;
			}
			IngredientSource ingredientSource = m_context.IngredientSources[m_context.CurrentIngredientIndex];
			if ((Object)(object)ingredientSource.Container == (Object)null)
			{
				AbandonWork("ingredient chest inaccessible");
				return;
			}
			ContainerScanner.RemoveIngredients(new List<IngredientSource> { ingredientSource });
			m_context.HeldItems.Add(new HeldItem
			{
				SourceContainer = ingredientSource.Container,
				PrefabName = ingredientSource.PrefabName,
				Amount = ingredientSource.Amount
			});
			m_context.CurrentIngredientIndex++;
			WalkToNextIngredientChest();
		}

		private void OnArrivedAtStation()
		{
			if (m_context == null)
			{
				return;
			}
			m_context.CraftStartTime = Time.time;
			SubState = WorkSubState.Crafting;
			m_ai?.ClearWaypoint();
			SetWorkNote($"crafting @ station t={Time.time:F0}");
			Smelter smelterRef = m_context.SmelterRef;
			if ((Object)(object)smelterRef != (Object)null && !string.IsNullOrEmpty(m_context.SmelterInputItemName))
			{
				if (!StationFinder.IsSmelterReady(smelterRef))
				{
					AbandonWork("smelter not ready (no fuel)");
					return;
				}
				ZNetView component = ((Component)smelterRef).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || component.GetZDO() == null)
				{
					AbandonWork("smelter ZNetView invalid");
					return;
				}
				m_context.SmelterProcessedAtStart = GetSmelterProcessedQueueSize(smelterRef);
				component.InvokeRPC("RPC_AddOre", new object[1] { m_context.SmelterInputItemName });
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[Work:" + LogName + "] Added 1x " + m_context.SmelterInputItemName + " to Smelter (" + ((Object)((Component)smelterRef).gameObject).name + ")"));
				}
				ClearHeldItem(m_context.SmelterInputItemName, 1);
				return;
			}
			CookingStation cookingStationRef = m_context.CookingStationRef;
			if (!((Object)(object)cookingStationRef != (Object)null) || string.IsNullOrEmpty(m_context.CookingInputItemName))
			{
				return;
			}
			if (!StationFinder.IsCookingStationReady(cookingStationRef))
			{
				AbandonWork("cooking station not ready (fire or fuel)");
				return;
			}
			if (!StationFinder.HasFreeSlot(cookingStationRef))
			{
				AbandonWork("cooking station full");
				return;
			}
			ZNetView component2 = ((Component)cookingStationRef).GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null && component2.GetZDO() != null)
			{
				component2.InvokeRPC("RPC_AddItem", new object[1] { m_context.CookingInputItemName });
				ClearHeldItem(m_context.CookingInputItemName, 1);
				ItemConversion val = cookingStationRef.m_conversion?.Find((ItemConversion c) => (Object)(object)c.m_from != (Object)null && ((Object)((Component)c.m_from).gameObject).name == m_context.CookingInputItemName);
				if (val != null)
				{
					m_context.CraftCookTimeSeconds = val.m_cookTime;
				}
			}
			else
			{
				AbandonWork("cooking station ZNetView invalid");
			}
		}

		private void OnArrivedAtOutputChest()
		{
			if (m_context == null)
			{
				AbandonWork("lost context at output chest");
				return;
			}
			if (!m_context.CookingItemAlreadyInChest && !m_context.SmelterItemAlreadyInChest && (Object)(object)m_context.SourceContainer != (Object)null)
			{
				string outputPrefab = m_context.WorkOrder?.ItemPrefabName;
				if (!string.IsNullOrEmpty(outputPrefab))
				{
					int num = 0;
					foreach (HeldItem heldItem in m_context.HeldItems)
					{
						if (heldItem != null && heldItem.PrefabName == outputPrefab)
						{
							num += heldItem.Amount;
						}
					}
					if (num <= 0)
					{
						num = 1;
					}
					if (ContainerScanner.TryDepositItem(m_context.SourceContainer, outputPrefab, num))
					{
						m_context.HeldItems.RemoveAll((HeldItem h) => h != null && h.PrefabName == outputPrefab);
					}
				}
			}
			m_context.CookingItemAlreadyInChest = false;
			m_context.SmelterItemAlreadyInChest = false;
			m_context.CookingRemovalRequested = false;
			m_context.SmelterRemovalRequested = false;
			int num2 = m_context.WorkOrder?.MaxQuantity ?? 1;
			if (m_context.CraftedCount < num2)
			{
				BeginGatheringIngredients();
			}
			else
			{
				FinishWork();
			}
		}

		private void BeginTravelingToStation()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_ai != (Object)null && m_context != null)
			{
				TryWalkTo(m_context.CraftStationPosition, WorkSubState.TravelingToStation, "craft station");
			}
		}

		private void WalkToNextIngredientChest()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (m_context == null || (Object)(object)m_ai == (Object)null)
			{
				return;
			}
			if (m_context.CurrentIngredientIndex >= m_context.IngredientSources.Count)
			{
				BeginTravelingToStation();
				return;
			}
			IngredientSource ingredientSource = m_context.IngredientSources[m_context.CurrentIngredientIndex];
			if ((Object)(object)ingredientSource.Container == (Object)null)
			{
				AbandonWork("ingredient container destroyed");
			}
			else
			{
				TryWalkTo(((Component)ingredientSource.Container).transform.position, WorkSubState.GatheringIngredients, "ingredient chest");
			}
		}
	}
}
namespace ValheimVillages.Behaviors.Combat
{
	[RegisterBehavior("combat")]
	public class CombatBehavior : IBehavior
	{
		private const float EngagedTickSec = 0.1f;

		private static readonly int s_losMask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "piece", "terrain" });

		private readonly VillagerAI m_ai;

		private float m_lastAttackTime;

		private float m_lastRepathTime;

		private float m_lastScanTime;

		private Character m_target;

		private Vector3? m_losDest;

		private float m_nextLosSearch;

		private int m_losSearchFails;

		private Character m_ignoredTarget;

		private float m_ignoreUntil;

		public string Tag => "combat";

		public int Priority => 100;

		public CombatBehavior(VillagerAI ai)
		{
			m_ai = ai;
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			if (!HasUsableWeapon())
			{
				return false;
			}
			if (IsValidTarget(m_target))
			{
				return true;
			}
			if (Time.time - m_lastScanTime < 1f)
			{
				return false;
			}
			m_lastScanTime = Time.time;
			m_target = AcquireTarget();
			return (Object)(object)m_target != (Object)null;
		}

		public void Update(float dt)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			if (!IsValidTarget(m_target))
			{
				Disengage();
				return;
			}
			Humanoid humanoid = m_ai.Humanoid;
			m_ai.RequestFastReselect(0.1f);
			EnsureWeaponEquipped(humanoid);
			ItemData currentWeapon = humanoid.GetCurrentWeapon();
			if (currentWeapon == null)
			{
				Disengage();
				return;
			}
			Vector3 position = m_ai.Position;
			Vector3 position2 = ((Component)m_target).transform.position;
			float num = Vector3.Distance(position, position2);
			Vector3 val = m_target.GetCenterPoint() - position;
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				m_ai.Character.SetLookDir(((Vector3)(ref val)).normalized, 0f);
			}
			float num2 = Mathf.Max(2f, currentWeapon.m_shared.m_aiAttackRange);
			if (num > num2)
			{
				Repath(position2);
				return;
			}
			if (HasLineOfSight(humanoid))
			{
				m_losDest = null;
				m_losSearchFails = 0;
				m_ai.ClearWaypoint();
				TryAttack(humanoid, currentWeapon);
				return;
			}
			UpdateLosDestination(num2);
			if (m_losDest.HasValue)
			{
				Repath(m_losDest.Value);
			}
			else if (m_losSearchFails >= 3)
			{
				IgnoreAndDisengage();
			}
			else
			{
				m_ai.ClearWaypoint();
			}
		}

		public void OnArrival(float dt)
		{
		}

		public string GetStatusText()
		{
			if ((Object)(object)m_target == (Object)null)
			{
				return "";
			}
			string text = (string.IsNullOrEmpty(m_target.m_name) ? "enemy" : Localization.instance.Localize(m_target.m_name));
			return "Fighting " + text;
		}

		private Character AcquireTarget()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			Character character = m_ai.Character;
			Vector3 position = m_ai.Position;
			Vector3 homeAnchor = m_ai.HomeAnchor;
			float num = 625f;
			float num2 = 1600f;
			Character result = null;
			float num3 = float.MaxValue;
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if ((Object)(object)allCharacter == (Object)null || (Object)(object)allCharacter == (Object)(object)character || allCharacter.IsDead() || ((Object)(object)allCharacter == (Object)(object)m_ignoredTarget && Time.time < m_ignoreUntil) || !BaseAI.IsEnemy(character, allCharacter))
				{
					continue;
				}
				Vector3 position2 = ((Component)allCharacter).transform.position;
				Vector3 val = position2 - homeAnchor;
				if (!(((Vector3)(ref val)).sqrMagnitude > num2))
				{
					val = position2 - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if ((sqrMagnitude <= num || ThreatensVillage(position2, homeAnchor)) && sqrMagnitude < num3)
					{
						num3 = sqrMagnitude;
						result = allCharacter;
					}
				}
			}
			return result;
		}

		private static bool ThreatensVillage(Vector3 enemyPos, Vector3 guardAnchor)
		{
			//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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			float num = 1600f;
			float num2 = 324f;
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				VillagerAI value = activeVillager.Value;
				if ((Object)(object)value == (Object)null)
				{
					continue;
				}
				Vector3 val = value.HomeAnchor - guardAnchor;
				if (!(((Vector3)(ref val)).sqrMagnitude > num))
				{
					val = enemyPos - value.Position;
					if (((Vector3)(ref val)).sqrMagnitude <= num2)
					{
						return true;
					}
				}
			}
			return false;
		}

		private bool IsValidTarget(Character c)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null || c.IsDead())
			{
				return false;
			}
			float num = 1600f;
			Vector3 val = ((Component)c).transform.position - m_ai.HomeAnchor;
			return ((Vector3)(ref val)).sqrMagnitude <= num;
		}

		private void Disengage()
		{
			m_target = null;
			if (m_ai.CurrentState != BehaviorState.Idle)
			{
				m_ai.SetState(BehaviorState.Idle);
			}
		}

		private bool HasUsableWeapon()
		{
			Humanoid humanoid = m_ai.Humanoid;
			if (humanoid.GetCurrentWeapon() != null)
			{
				return true;
			}
			return FindEnemyWeapon(humanoid) != null;
		}

		private static void EnsureWeaponEquipped(Humanoid h)
		{
			if (h.GetCurrentWeapon() == null)
			{
				ItemData val = FindEnemyWeapon(h);
				if (val != null)
				{
					h.EquipItem(val, false);
				}
			}
		}

		private static ItemData FindEnemyWeapon(Humanoid h)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = h.GetInventory();
			List<ItemData> list = ((inventory != null) ? inventory.GetAllItems() : null);
			if (list == null)
			{
				return null;
			}
			foreach (ItemData item in list)
			{
				if (item != null && item.IsWeapon() && (int)item.m_shared.m_aiTargetType == 0)
				{
					return item;
				}
			}
			return null;
		}

		private void TryAttack(Humanoid humanoid, ItemData weapon)
		{
			float num = Mathf.Max(0.5f, weapon.m_shared.m_aiAttackInterval);
			if (!(Time.time - m_lastAttackTime < num) && ((BaseAI)m_ai).CanUseAttack(weapon) && ((Character)humanoid).StartAttack(m_target, false))
			{
				m_lastAttackTime = Time.time;
			}
		}

		private void Repath(Vector3 dest)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!(Time.time - m_lastRepathTime < 0.35f))
			{
				m_lastRepathTime = Time.time;
				m_ai.NavTo(dest, BehaviorState.Alarmed, "engage", snapToApproach: false);
			}
		}

		private bool HasLineOfSight(Humanoid humanoid)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			return IsClear(((Component)humanoid).transform.position + Vector3.up * 1.5f, m_target.GetCenterPoint());
		}

		private static bool IsClear(Vector3 from, Vector3 to)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.01f)
			{
				return true;
			}
			return !Physics.Raycast(from, val / magnitude, magnitude, s_losMask, (QueryTriggerInteraction)1);
		}

		private void UpdateLosDestination(float weaponRange)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!(Time.time < m_nextLosSearch))
			{
				m_nextLosSearch = Time.time + 0.4f;
				if (FindFiringPosition(weaponRange, out var result))
				{
					m_losDest = result;
					m_losSearchFails = 0;
				}
				else
				{
					m_losDest = null;
					m_losSearchFails++;
				}
			}
		}

		private bool FindFiringPosition(float weaponRange, out Vector3 result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: 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)
			result = Vector3.zero;
			if (!VillagerAgentType.IsRegistered)
			{
				return false;
			}
			NavMeshQueryFilter val = AgentFilter();
			Vector3 position = m_ai.Position;
			Vector3 position2 = ((Component)m_target).transform.position;
			Vector3 centerPoint = m_target.GetCenterPoint();
			float num = Mathf.Clamp(weaponRange * 0.6f, 4f, 12f);
			NavMeshHit val2 = default(NavMeshHit);
			bool flag = NavMesh.SamplePosition(position, ref val2, 3f, val);
			Vector3 val3 = (flag ? ((NavMeshHit)(ref val2)).position : position);
			float num2 = float.MaxValue;
			bool result2 = false;
			int num3 = 12;
			NavMeshHit val4 = default(NavMeshHit);
			for (int i = 0; i < num3; i++)
			{
				float num4 = (float)Math.PI * 2f / (float)num3 * (float)i;
				if (!NavMesh.SamplePosition(position2 + new Vector3(Mathf.Cos(num4), 0f, Mathf.Sin(num4)) * num, ref val4, 2.5f, val))
				{
					continue;
				}
				Vector3 val5 = ((NavMeshHit)(ref val4)).position - position;
				float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
				if (sqrMagnitude >= num2 || !IsClear(((NavMeshHit)(ref val4)).position + Vector3.up * 1.5f, centerPoint))
				{
					continue;
				}
				if (flag)
				{
					NavMeshPath val6 = new NavMeshPath();
					NavMesh.CalculatePath(val3, ((NavMeshHit)(ref val4)).position, val, val6);
					if ((int)val6.status != 0)
					{
						continue;
					}
				}
				num2 = sqrMagnitude;
				result = ((NavMeshHit)(ref val4)).position;
				result2 = true;
			}
			return result2;
		}

		private void IgnoreAndDisengage()
		{
			m_ignoredTarget = m_target;
			m_ignoreUntil = Time.time + 8f;
			m_losDest = null;
			m_losSearchFails = 0;
			Disengage();
		}

		private static NavMeshQueryFilter AgentFilter()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			NavMeshQueryFilter result = default(NavMeshQueryFilter);
			((NavMeshQueryFilter)(ref result)).agentTypeID = VillagerAgentType.UnityAgentTypeID;
			((NavMeshQueryFilter)(ref result)).areaMask = -1;
			return result;
		}
	}
	[RegisterBehavior("flee")]
	public class FleeBehavior : IBehavior
	{
		private const float FleeTickSec = 0.1f;

		private readonly VillagerAI m_ai;

		private float m_lastRepathTime;

		private float m_lastScanTime;

		private bool m_runningToGuard;

		private Character m_threat;

		public string Tag => "flee";

		public int Priority => 100;

		public FleeBehavior(VillagerAI ai)
		{
			m_ai = ai;
		}

		public bool WantsControl(BehaviorContext ctx)
		{
			if (IsStillDangerous(m_threat))
			{
				return true;
			}
			if (Time.time - m_lastScanTime < 1f)
			{
				return false;
			}
			m_lastScanTime = Time.time;
			m_threat = FindNearestThreat(16f);
			return (Object)(object)m_threat != (Object)null;
		}

		public void Update(float dt)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (!IsStillDangerous(m_threat))
			{
				Calm();
				return;
			}
			m_ai.RequestFastReselect(0.1f);
			Vector3 position = m_ai.Position;
			Vector3 position2 = ((Component)m_threat).transform.position;
			VillagerAI villagerAI = FindNearestGuard();
			Vector3 target;
			if ((Object)(object)villagerAI != (Object)null)
			{
				Vector3 val = villagerAI.Position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				val = position - position2;
				if (sqrMagnitude > ((Vector3)(ref val)).sqrMagnitude)
				{
					m_runningToGuard = true;
					target = villagerAI.Position;
					goto IL_0099;
				}
			}
			m_runningToGuard = false;
			target = SafeSpot(position, position2);
			goto IL_0099;
			IL_0099:
			if (Time.time - m_lastRepathTime >= 0.35f)
			{
				m_lastRepathTime = Time.time;
				m_ai.NavTo(target, BehaviorState.Alarmed, "flee", snapToApproach: false);
			}
		}

		public void OnArrival(float dt)
		{
		}

		public string GetStatusText()
		{
			if ((Object)(object)m_threat == (Object)null)
			{
				return "";
			}
			if (!m_runningToGuard)
			{
				return "Hiding from danger!";
			}
			return "Fleeing to a guard!";
		}

		private bool IsStillDangerous(Character c)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null || c.IsDead())
			{
				return false;
			}
			float num = 576f;
			Vector3 val = ((Component)c).transform.position - m_ai.Position;
			return ((Vector3)(ref val)).sqrMagnitude <= num;
		}

		private Character FindNearestThreat(float radius)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Character character = m_ai.Character;
			Vector3 position = m_ai.Position;
			float num = radius * radius;
			Character result = null;
			float num2 = float.MaxValue;
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (!((Object)(object)allCharacter == (Object)null) && !((Object)(object)allCharacter == (Object)(object)character) && !allCharacter.IsDead() && BaseAI.IsEnemy(character, allCharacter))
				{
					Vector3 val = ((Component)allCharacter).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (!(sqrMagnitude > num) && sqrMagnitude < num2)
					{
						num2 = sqrMagnitude;
						result = allCharacter;
					}
				}
			}
			return result;
		}

		private VillagerAI FindNearestGuard()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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)
			Vector3 position = m_ai.Position;
			VillagerAI result = null;
			float num = float.MaxValue;
			foreach (KeyValuePair<string, VillagerAI> activeVillager in VillagerAIManager.ActiveVillagers)
			{
				VillagerAI value = activeVillager.Value;
				if (!((Object)(object)value == (Object)null) && !((Object)(object)value == (Object)(object)m_ai) && value.GetBehavior<CombatBehavior>() != null)
				{
					Vector3 val = value.Position - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						result = value;
					}
				}
			}
			return result;
		}

		private Vector3 SafeSpot(Vector3 myPos, Vector3 threatPos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = myPos - threatPos;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			Vector3 homeAnchor = m_ai.HomeAnchor;
			if (homeAnchor != Vector3.zero)
			{
				val = homeAnchor - threatPos;
				if (((Vector3)(ref val)).sqrMagnitude > sqrMagnitude)
				{
					return homeAnchor;
				}
			}
			Vector3 val2 = myPos - threatPos;
			val2.y = 0f;
			if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				val2 = ((Component)m_ai.Character).transform.forward;
			}
			return myPos + ((Vector3)(ref val2)).normalized * 14f;
		}

		private void Calm()
		{
			m_threat = null;
			m_runningToGuard = false;
			if (m_ai.CurrentState != BehaviorState.Idle)
			{
				m_ai.SetState(BehaviorState.Idle);
			}
		}
	}
}
namespace ValheimVillages.Attributes
{
	public static class AttributeScanner
	{
		private static readonly Dictionary<string, IAbility> s_abilities = new Dictionary<string, IAbility>();

		private static readonly Dictionary<string, IPassiveEffect> s_passives = new Dictionary<string, IPassiveEffect>();

		private static readonly List<IVillagerTab> s_tabs = new List<IVillagerTab>();

		private static readonly List<IListPanel> s_panels = new List<IListPanel>();

		private static readonly List<IContextMenu> s_contextMenus = new List<IContextMenu>();

		private static readonly Dictionary<string, Func<VillagerAI, IBehavior>> s_behaviorCreators = new Dictionary<string, Func<VillagerAI, IBehavior>>();

		private static readonly HashSet<string> s_modObjectNames = new HashSet<string>();

		private static readonly List<(string Name, string Description)> s_devCommands = new List<(string, string)>();

		public static void ScanAndRegister(Assembly assembly)
		{
			s_abilities.Clear();
			s_passives.Clear();
			s_tabs.Clear();
			s_panels.Clear();
			s_contextMenus.Clear();
			s_behaviorCreators.Clear();
			s_modObjectNames.Clear();
			s_devCommands.Clear();
			RegisterDevCommands(assembly);
			RegisterTaskHandlers(assembly);
			RegisterAbilities(assembly);
			RegisterPassives(assembly);
			RegisterTabs(assembly);
			RegisterRegistryTabs(assembly);
			RegisterListPanels(assembly);
			RegisterContextMenus(assembly);
			RegisterBehaviors(assembly);
			CollectModObjectNames(assembly);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("[AttributeScanner] Registered: " + $"{s_abilities.Count} abilities, {s_passives.Count} passives, " + $"{s_tabs.Count} tabs, {s_panels.Count} panels, " + $"{s_contextMenus.Count} context menus, " + $"{s_behaviorCreators.Count} behaviors, " + $"{s_modObjectNames.Count} mod objects"));
			}
		}

		public static void InvokeObjectDBRegistrations(Assembly assembly, ObjectDB db)
		{
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttribute<RegisterObjectDBAttribute>() == null)
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ObjectDB))
					{
						methodInfo.Invoke(null, new object[1] { db });
						continue;
					}
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] Skipping [RegisterObjectDB] on " + type.Name + "." + methodInfo.Name + ": expected (ObjectDB) parameter"));
					}
				}
			}
		}

		private static void RegisterTaskHandlers(Assembly assembly)
		{
			int num = 0;
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<RegisterTaskHandlerAttribute>() == null)
				{
					continue;
				}
				if (!typeof(ITaskHandler).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterTaskHandler] but does not implement ITaskHandler"));
					}
				}
				else
				{
					TaskHandlerRegistry.Register((ITaskHandler)Activator.CreateInstance(type));
					num++;
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogDebug((object)$"[AttributeScanner] Registered {num} task handlers");
			}
		}

		public static void InvokeAllCleanup(Assembly assembly)
		{
			int num = 0;
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttribute<RegisterCleanupAttribute>() == null)
					{
						continue;
					}
					if (methodInfo.GetParameters().Length == 0)
					{
						methodInfo.Invoke(null, null);
						num++;
						continue;
					}
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] Skipping [RegisterCleanup] on " + type.Name + "." + methodInfo.Name + ": must be parameterless"));
					}
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogDebug((object)$"[AttributeScanner] Invoked {num} cleanup methods");
			}
		}

		private static void RegisterDevCommands(Assembly assembly)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			int num = 0;
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					DevCommandAttribute customAttribute = methodInfo.GetCustomAttribute<DevCommandAttribute>();
					if (customAttribute == null)
					{
						continue;
					}
					string text = customAttribute.Name ?? DeriveCommandName(type, methodInfo);
					ParameterInfo[] parameters = methodInfo.GetParameters();
					ConsoleEventFailable val;
					if (parameters.Length == 0)
					{
						MethodInfo m = methodInfo;
						val = (ConsoleEventFailable)delegate
						{
							m.Invoke(null, null);
							return (object)null;
						};
					}
					else
					{
						if (parameters.Length != 1 || !(parameters[0].ParameterType == typeof(ConsoleEventArgs)))
						{
							ManualLogSource log = Plugin.Log;
							if (log != null)
							{
								log.LogWarning((object)("[AttributeScanner] Skipping [DevCommand] on " + type.Name + "." + methodInfo.Name + ": unsupported parameter signature"));
							}
							continue;
						}
						MethodInfo m2 = methodInfo;
						val = (ConsoleEventFailable)delegate(ConsoleEventArgs args)
						{
							m2.Invoke(null, new object[1] { args });
							return (object)null;
						};
					}
					new ConsoleCommand(text, customAttribute.Description, val, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
					s_devCommands.Add((text, customAttribute.Description));
					num++;
				}
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogDebug((object)$"[AttributeScanner] Registered {num} dev commands");
			}
		}

		private static string DeriveCommandName(Type type, MethodInfo method)
		{
			return (type.Name + "_" + method.Name).ToLowerInvariant();
		}

		public static IReadOnlyList<(string Name, string Description)> GetRegisteredDevCommands()
		{
			return s_devCommands;
		}

		private static void CollectModObjectNames(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				RegisterModObjectAttribute customAttribute = types[i].GetCustomAttribute<RegisterModObjectAttribute>();
				if (customAttribute != null)
				{
					s_modObjectNames.Add(customAttribute.GameObjectName);
				}
			}
		}

		public static HashSet<string> GetModObjectNames(Assembly assembly)
		{
			if (s_modObjectNames.Count == 0)
			{
				CollectModObjectNames(assembly);
			}
			return s_modObjectNames;
		}

		private static void RegisterAbilities(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				RegisterAbilityAttribute customAttribute = type.GetCustomAttribute<RegisterAbilityAttribute>();
				if (customAttribute == null)
				{
					continue;
				}
				if (!typeof(IAbility).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterAbility] but does not implement IAbility"));
					}
				}
				else
				{
					IAbility value = (IAbility)Activator.CreateInstance(type);
					s_abilities[customAttribute.Id] = value;
				}
			}
		}

		public static IAbility GetAbility(string id)
		{
			s_abilities.TryGetValue(id, out var value);
			return value;
		}

		public static IReadOnlyDictionary<string, IAbility> GetAllAbilities()
		{
			return s_abilities;
		}

		private static void RegisterPassives(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				RegisterPassiveAttribute customAttribute = type.GetCustomAttribute<RegisterPassiveAttribute>();
				if (customAttribute == null)
				{
					continue;
				}
				if (!typeof(IPassiveEffect).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterPassive] but does not implement IPassiveEffect"));
					}
				}
				else
				{
					IPassiveEffect value = (IPassiveEffect)Activator.CreateInstance(type);
					s_passives[customAttribute.Id] = value;
				}
			}
		}

		public static IPassiveEffect GetPassive(string id)
		{
			s_passives.TryGetValue(id, out var value);
			return value;
		}

		public static IReadOnlyDictionary<string, IPassiveEffect> GetAllPassives()
		{
			return s_passives;
		}

		private static void RegisterTabs(Assembly assembly)
		{
			List<(Type, RegisterTabAttribute)> list = new List<(Type, RegisterTabAttribute)>();
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				RegisterTabAttribute customAttribute = type.GetCustomAttribute<RegisterTabAttribute>();
				if (customAttribute == null)
				{
					continue;
				}
				if (!typeof(IVillagerTab).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterTab] but does not implement IVillagerTab"));
					}
				}
				else
				{
					list.Add((type, customAttribute));
				}
			}
			foreach (var item in list.OrderBy<(Type, RegisterTabAttribute), int>(((Type type, RegisterTabAttribute attr) t) => t.attr.Order))
			{
				var (type2, _) = item;
				if (!(item.Item2.Id == "debug"))
				{
					IVillagerTab villagerTab = (IVillagerTab)Activator.CreateInstance(type2);
					s_tabs.Add(villagerTab);
					VillagerTabManager.RegisterTab(villagerTab);
				}
			}
		}

		public static IReadOnlyList<IVillagerTab> GetRegisteredTabs()
		{
			return s_tabs;
		}

		private static void RegisterRegistryTabs(Assembly assembly)
		{
			List<(Type, RegisterRegistryTabAttribute)> list = new List<(Type, RegisterRegistryTabAttribute)>();
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				RegisterRegistryTabAttribute customAttribute = type.GetCustomAttribute<RegisterRegistryTabAttribute>();
				if (customAttribute == null)
				{
					continue;
				}
				if (!typeof(IRegistryTabUI).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterRegistryTab] but does not implement IRegistryTabUI"));
					}
				}
				else
				{
					list.Add((type, customAttribute));
				}
			}
			int num = 0;
			foreach (var item in list.OrderBy<(Type, RegisterRegistryTabAttribute), int>(((Type type, RegisterRegistryTabAttribute attr) t) => t.attr.Order))
			{
				RegistryTabManager.RegisterTab((IRegistryTabUI)Activator.CreateInstance(item.Item1));
				num++;
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogDebug((object)$"[AttributeScanner] Registered {num} registry tabs");
			}
		}

		private static void RegisterListPanels(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<RegisterListPanelAttribute>() == null)
				{
					continue;
				}
				if (!typeof(IListPanel).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterListPanel] but does not implement IListPanel"));
					}
					continue;
				}
				IListPanel listPanel = (IListPanel)Activator.CreateInstance(type);
				s_panels.Add(listPanel);
				if (listPanel.ParentTab == "info")
				{
					InfoTab.RegisterPanel(listPanel);
				}
				else if (listPanel.ParentTab == "debug")
				{
					DebugTab.RegisterPanel(listPanel);
				}
			}
		}

		public static List<IListPanel> GetListPanels(string parentTab)
		{
			return s_panels.Where((IListPanel p) => p.ParentTab == parentTab).ToList();
		}

		private static void RegisterContextMenus(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<RegisterContextMenuAttribute>() == null)
				{
					continue;
				}
				if (!typeof(IContextMenu).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterContextMenu] but does not implement IContextMenu"));
					}
				}
				else
				{
					IContextMenu item = (IContextMenu)Activator.CreateInstance(type);
					s_contextMenus.Add(item);
				}
			}
		}

		public static IReadOnlyList<IContextMenu> GetContextMenus()
		{
			return s_contextMenus;
		}

		private static void RegisterBehaviors(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				RegisterBehaviorAttribute customAttribute = type.GetCustomAttribute<RegisterBehaviorAttribute>();
				if (customAttribute == null)
				{
					continue;
				}
				if (!typeof(IBehavior).IsAssignableFrom(type))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[AttributeScanner] " + type.Name + " has [RegisterBehavior] but does not implement IBehavior"));
					}
				}
				else
				{
					Type capturedType = type;
					s_behaviorCreators[customAttribute.Tag] = (VillagerAI ai) => (IBehavior)Activator.CreateInstance(capturedType, Object.op_Implicit((Object)(object)ai));
				}
			}
		}

		public static IBehavior CreateBehavior(string tag, VillagerAI owner)
		{
			if (s_behaviorCreators.TryGetValue(tag, out var value))
			{
				return value(owner);
			}
			return null;
		}

		public static bool HasBehavior(string tag)
		{
			return s_behaviorCreators.ContainsKey(tag);
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class DevCommandAttribute : Attribute
	{
		public string Description { get; }

		public string Name { get; set; }

		public DevCommandAttribute(string description)
		{
			Description = description;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class ModTestAttribute : Attribute
	{
		public string Name { get; set; }

		public int Order { get; set; }
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterAbilityAttribute : Attribute
	{
		public string Id { get; }

		public RegisterAbilityAttribute(string id)
		{
			Id = id;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterBehaviorAttribute : Attribute
	{
		public string Tag { get; }

		public RegisterBehaviorAttribute(string tag)
		{
			Tag = tag;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class RegisterCleanupAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterContextMenuAttribute : Attribute
	{
		public string Id { get; }

		public RegisterContextMenuAttribute(string id)
		{
			Id = id;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterListPanelAttribute : Attribute
	{
		public string Id { get; }

		public string ParentTab { get; }

		public RegisterListPanelAttribute(string id, string parentTab)
		{
			Id = id;
			ParentTab = parentTab;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterModObjectAttribute : Attribute
	{
		public string GameObjectName { get; }

		public RegisterModObjectAttribute(string gameObjectName)
		{
			GameObjectName = gameObjectName;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class RegisterObjectDBAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterPassiveAttribute : Attribute
	{
		public string Id { get; }

		public RegisterPassiveAttribute(string id)
		{
			Id = id;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterRegistryTabAttribute : Attribute
	{
		public string Id { get; }

		public int Order { get; set; }

		public RegisterRegistryTabAttribute(string id)
		{
			Id = id;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterTabAttribute : Attribute
	{
		public string Id { get; }

		public int Order { get; set; }

		public RegisterTabAttribute(string id)
		{
			Id = id;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class RegisterTaskHandlerAttribute : Attribute
	{
	}
}
namespace ValheimVillages.Abilities
{
	public interface IPlayerAbility : IAbility
	{
		bool HasLearned(Player player);

		void Learn(Player player);

		void Activate(Player player);
	}
	public class SE_MountainStride : StatusEffect
	{
		public const string EffectName = "SE_MountainStride";

		public const float Duration = 300f;

		public const float Cooldown = 1200f;

		private static Sprite s_icon;

		public static Sprite Icon
		{
			get
			{
				if (!((Object)(object)s_icon != (Object)null))
				{
					return s_icon = CreateBuffIcon();
				}
				return s_icon;
			}
		}

		public SE_MountainStride()
		{
			//IL_0029: 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)
			base.m_name = "SE_MountainStride";
			base.m_ttl = 300f;
			base.m_tooltip = "Immune to sliding on steep terrain";
			base.m_startMessageType = (MessageType)2;
			base.m_startMessage = "Mountain Stride activated";
			base.m_stopMessageType = (MessageType)2;
			base.m_stopMessage = "Mountain Stride faded";
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			if ((Object)(object)base.m_icon == (Object)null)
			{
				base.m_icon = Icon;
			}
		}

		private static Sprite CreateBuffIcon()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_006d: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			int num = 32;
			Texture2D val = new Texture2D(num, num);
			Color[] array = (Color[])(object)new Color[num * num];
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.2f, 0.35f, 0.5f, 0.9f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.7f, 0.7f, 0.75f, 1f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0.95f, 0.95f, 1f, 1f);
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = val2;
			}
			for (int j = 0; j < num; j++)
			{
				for (int k = 0; k < num; k++)
				{
					int num2 = num / 2;
					int num3 = 6;
					int num4 = 26;
					float num5 = (float)(j - num3) / (float)(num4 - num3);
					if (j >= num3 && j <= num4)
					{
						float num6 = (1f - num5) * ((float)num / 2f - 2f);
						if ((float)Mathf.Abs(k - num2) <= num6)
						{
							array[j * num + k] = ((j > num4 - 6) ? val4 : val3);
						}
					}
				}
			}
			val.SetPixels(array);
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f));
		}
	}
	public static class VillagerAbilityManager
	{
		public const string MountainStrideKey = "vv_ability_mountain_stride";

		private static float s_cooldownRemaining;

		private static readonly KeyCode ActivationKey = (KeyCode)114;

		public static bool HasLearnedMountainStride()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				return ((Humanoid)localPlayer).HaveUniqueKey("vv_ability_mountain_stride");
			}
			return false;
		}

		public static void LearnMountainStride()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if (((Humanoid)localPlayer).HaveUniqueKey("vv_ability_mountain_stride"))
			{
				((Character)localPlayer).Message((MessageType)2, "You already know Mountain Stride", 0, (Sprite)null);
				return;
			}
			((Humanoid)localPlayer).AddUniqueKey("vv_ability_mountain_stride");
			((Character)localPlayer).Message((MessageType)2, "Learned Mountain Stride! Press R to activate.", 0, (Sprite)null);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[Mountaineer] Player learned Mountain Stride");
			}
		}

		public static bool ActivateMountainStride()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			if (!HasLearnedMountainStride())
			{
				((Character)localPlayer).Message((MessageType)2, "You haven't learned this technique yet", 0, (Sprite)null);
				return false;
			}
			if (s_cooldownRemaining > 0f)
			{
				int num = Mathf.CeilToInt(s_cooldownRemaining / 60f);
				((Character)localPlayer).Message((MessageType)2, $"Mountain Stride not ready ({num}m remaining)", 0, (Sprite)null);
				return false;
			}
			if (((Character)localPlayer).InAttack() || ((Character)localPlayer).InDodge() || !((Character)localPlayer).CanMove() || ((Character)localPlayer).IsKnockedBack() || ((Character)localPlayer).IsStaggering())
			{
				return false;
			}
			SEMan sEMan = ((Character)localPlayer).GetSEMan();
			int stableHashCode = StringExtensionMethods.GetStableHashCode("SE_MountainStride");
			if (sEMan.HaveStatusEffect(stableHashCode))
			{
				((Character)localPlayer).Message((MessageType)2, "Mountain Stride is already active", 0, (Sprite)null);
				return false;
			}
			sEMan.AddStatusEffect(stableHashCode, false, 0, 0f);
			s_cooldownRemaining = 1200f;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[Mountaineer] Mountain Stride activated");
			}
			return true;
		}

		public static void Update(float dt)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (s_cooldownRemaining > 0f)
			{
				s_cooldownRemaining -= dt;
			}
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !Menu.IsVisible() && !Console.IsVisible() && !TextInput.IsVisible() && !Minimap.IsOpen() && !InventoryGui.IsVisible() && Input.GetKeyDown(ActivationKey) && HasLearnedMountainStride())
			{
				ActivateMountainStride();
			}
		}

		public static float GetCooldownRemaining()
		{
			return Mathf.Max(0f, s_cooldownRemaining);
		}

		public static bool IsActive()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode("SE_MountainStride");
			return ((Character)localPlayer).GetSEMan().HaveStatusEffect(stableHashCode);
		}

		[DevCommand("Reset Mountain Stride cooldown", Name = "vv_ability_reset_cooldown")]
		public static void ResetCooldown()
		{
			s_cooldownRemaining = 0f;
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, "Mountain Stride cooldown reset", 0, (Sprite)null);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[Mountaineer] Cooldown reset via debug command");
			}
		}

		[DevCommand("Teach the local player Mountain Stride (test)", Name = "vv_ability_learn")]
		public static void LearnCommand()
		{
			LearnMountainStride();
		}

		[DevCommand("Log HNA attributes for current player position to BepInEx log (region, bounds, heights)", Name = "vv_hna_debug_player")]
		public static void LogHnaPlayerPosition(ConsoleEventArgs args)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)((Component)localPlayer).transform == (Object)null)
			{
				if ((Object)(object)Console.instance != (Object)null)
				{
					Console.instance.Print("No local player.");
				}
				return;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			PathTelemetry.LogHnaPlayerDebug(position);
			if ((Object)(object)Console.instance != (Object)null)
			{
				Console.instance.Print($"HNA player debug written: pos=({position.x:F1},{position.y:F1},{position.z:F1})");
			}
		}
	}
}
namespace ValheimVillages.Abilities.SpawnBlock
{
	[HarmonyPatch(typeof(SpawnSystem), "UpdateSpawnList")]
	public static class SpawnProtectionPatch
	{
		private static readonly List<int> s_disabledSpawnerIndices = new List<int>();

		private static List<SpawnData> s_lastSpawners;

		private static void Prefix(List<SpawnData> spawners, DateTime currentTime, bool eventSpawners, SpawnSystem __instance)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (eventSpawners || VillageAreaManager.AreaCount == 0)
			{
				return;
			}
			s_disabledSpawnerIndices.Clear();
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null || allPlayers.Count == 0)
			{
				return;
			}
			bool flag = false;
			foreach (Player item in allPlayers)
			{
				if (!((Object)(object)item == (Object)null) && VillageAreaManager.IsInsideAnyVillage(((Component)item).transform.position))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return;
			}
			for (int i = 0; i < spawners.Count; i++)
			{
				SpawnData val = spawners[i];
				if (val == null || !val.m_enabled)
				{
					continue;
				}
				bool flag2 = true;
				foreach (Player item2 in allPlayers)
				{
					if (!((Object)(object)item2 == (Object)null))
					{
						Vector3 position = ((Component)item2).transform.position;
						if (!VillageAreaManager.IsInsideAnyVillage(position))
						{
							flag2 = false;
							break;
						}
						if (!AllSpawnPositionsInsideVillage(position))
						{
							flag2 = false;
							break;
						}
					}
				}
				if (flag2)
				{
					val.m_enabled = false;
					s_disabledSpawnerIndices.Add(i);
				}
			}
			s_lastSpawners = spawners;
		}

		private static void Postfix()
		{
			if (s_lastSpawners == null || s_disabledSpawnerIndices.Count == 0)
			{
				return;
			}
			foreach (int s_disabledSpawnerIndex in s_disabledSpawnerIndices)
			{
				if (s_disabledSpawnerIndex < s_lastSpawners.Count && s_lastSpawners[s_disabledSpawnerIndex] != null)
				{
					s_lastSpawners[s_disabledSpawnerIndex].m_enabled = true;
				}
			}
			s_disabledSpawnerIndices.Clear();
			s_lastSpawners = null;
		}

		private static bool AllSpawnPositionsInsideVillage(Vector3 playerPos)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			float num = 60f;
			int num2 = 0;
			for (int i = 0; i < 8; i++)
			{
				float num3 = (float)i * 45f * ((float)Math.PI / 180f);
				if (VillageAreaManager.IsInsideAnyVillage(playerPos + new Vector3(Mathf.Cos(num3) * num, 0f, Mathf.Sin(num3) * num)))
				{
					num2++;
				}
			}
			return num2 >= 6;
		}
	}
	[RegisterPassive("spawnblock")]
	public class SpawnBlockPassiveEffect : IPassiveEffect
	{
		public string Id => "spawnblock";

		public string DisplayName => "Spawn Protection";

		public bool IsActive(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return VillageAreaManager.IsInsideAnyVillage(position);
		}
	}
}
namespace ValheimVillages.Abilities.MountainStride
{
	public static class AbilityHud
	{
		private const string CloneName = "VV_AbilityHud";

		private static readonly Color CooldownTint = new Color(1f, 1f, 1f, 0.4f);

		private static GameObject s_root;

		private static Image s_icon;

		private static GameObject s_nameGO;

		private static GameObject s_cooldownGO;

		private static void EnsureBuilt(Hud hud)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)s_root != (Object)null) && !((Object)(object)hud == (Object)null) && !((Object)(object)hud.m_gpRoot == (Object)null) && !((Object)(object)hud.m_gpIcon == (Object)null))
			{
				Transform parent = ((Transform)hud.m_gpRoot).parent;
				Transform val = parent.Find("VV_AbilityHud");
				if ((Object)(object)val != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
				}
				RectTransform val2 = Object.Instantiate<RectTransform>(hud.m_gpRoot, parent);
				((Object)val2).name = "VV_AbilityHud";
				Vector2 anchoredPosition = hud.m_gpRoot.anchoredPosition;
				Rect rect = hud.m_gpRoot.rect;
				val2.anchoredPosition = anchoredPosition + new Vector2(((Rect)(ref rect)).width + 12f, 0f);
				s_root = ((Component)val2).gameObject;
				s_icon = FindLike<Image>((Transform)(object)hud.m_gpRoot, (Transform)(object)val2, ((Component)hud.m_gpIcon).transform);
				object? obj = AccessTools.Field(typeof(Hud), "m_gpName")?.GetValue(hud);
				Component val3 = (Component)((obj is Component) ? obj : null);
				object? obj2 = AccessTools.Field(typeof(Hud), "m_gpCooldown")?.GetValue(hud);
				Component val4 = (Component)((obj2 is Component) ? obj2 : null);
				s_nameGO = FindChild((Transform)(object)hud.m_gpRoot, (Transform)(object)val2, ((Object)(object)val3 != (Object)null) ? val3.transform : null);
				s_cooldownGO = FindChild((Transform)(object)hud.m_gpRoot, (Transform)(object)val2, ((Object)(object)val4 != (Object)null) ? val4.transform : null);
				s_root.SetActive(false);
			}
		}

		public static void Refresh(Hud hud)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			EnsureBuilt(hud);
			if ((Object)(object)s_root == (Object)null)
			{
				return;
			}
			if (!VillagerAbilityManager.HasLearnedMountainStride())
			{
				if (s_root.activeSelf)
				{
					s_root.SetActive(false);
				}
				return;
			}
			if (!s_root.activeSelf)
			{
				s_root.SetActive(true);
			}
			float cooldownRemaining = VillagerAbilityManager.GetCooldownRemaining();
			if ((Object)(object)s_icon != (Object)null)
			{
				s_icon.sprite = SE_MountainStride.Icon;
				((Graphic)s_icon).color = ((cooldownRemaining > 0f) ? CooldownTint : Color.white);
			}
			if ((Object)(object)s_nameGO != (Object)null)
			{
				VillagerUIFactory.SetTMPText(s_nameGO, "Mountain Stride");
			}
			if ((Object)(object)s_cooldownGO != (Object)null)
			{
				VillagerUIFactory.SetTMPText(s_cooldownGO, (cooldownRemaining > 0f) ? StatusEffect.GetTimeString(cooldownRemaining, false, false) : Localization.instance.Localize("$hud_ready"));
			}
		}

		[RegisterCleanup]
		public static void Cleanup()
		{
			if ((Object)(object)s_root != (Object)null)
			{
				Object.Destroy((Object)(object)s_root);
			}
			s_root = null;
			s_icon = null;
			s_nameGO = null;
			s_cooldownGO = null;
		}

		private static T FindLike<T>(Transform origRoot, Transform cloneRoot, Transform origChild) where T : Component
		{
			GameObject val = FindChild(origRoot, cloneRoot, origChild);
			if (!((Object)(object)val != (Object)null))
			{
				return default(T);
			}
			return val.GetComponent<T>();
		}

		private static GameObject FindChild(Transform origRoot, Transform cloneRoot, Transform origChild)
		{
			if ((Object)(object)origChild == (Object)null)
			{
				return null;
			}
			string text = RelativePath(origRoot, origChild);
			Transform val = (string.IsNullOrEmpty(text) ? cloneRoot : cloneRoot.Find(text));
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).gameObject;
		}

		private static string RelativePath(Transform root, Transform child)
		{
			List<string> list = new List<string>();
			Transform val = child;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Insert(0, ((Object)val).name);
				val = val.parent;
			}
			return string.Join("/", list);
		}
	}
	[HarmonyPatch(typeof(Hud), "Update")]
	public static class AbilityHud_Update_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(Hud __instance)
		{
			AbilityHud.Refresh(__instance);
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	public static class MountainStride_ObjectDB_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(ObjectDB __instance)
		{
			RegisterStatusEffect(__instance);
		}

		[RegisterObjectDB]
		public static void RegisterStatusEffect(ObjectDB db)
		{
			if ((Object)(object)db == (Object)null)
			{
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode("SE_MountainStride");
			if (!((Object)(object)db.GetStatusEffect(stableHashCode) != (Object)null))
			{
				SE_MountainStride sE_MountainStride = ScriptableObject.CreateInstance<SE_MountainStride>();
				((Object)sE_MountainStride).name = "SE_MountainStride";
				db.m_StatusEffects.Add((StatusEffect)(object)sE_MountainStride);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[Mountaineer] Registered SE_MountainStride status effect");
				}
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	public static class MountainStride_ObjectDBCopy_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(ObjectDB __instance)
		{
			MountainStride_ObjectDB_Patch.RegisterStatusEffect(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	public static class MountainStride_PlayerUpdate_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				VillagerAbilityManager.Update(Time.deltaTime);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "ApplySlide")]
	public static class MountainStride_ApplySlide_Patch
	{
		private static FieldInfo s_slippageField;

		[HarmonyPrefix]
		public static bool Prefix(Character __instance)
		{
			if (!__instance.IsPlayer())
			{
				return true;
			}
			SEMan sEMan = __instance.GetSEMan();
			if (sEMan == null)
			{
				return true;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode("SE_MountainStride");
			if (!sEMan.HaveStatusEffect(stableHashCode))
			{
				return true;
			}
			if (s_slippageField == null)
			{
				s_slippageField = typeof(Character).GetField("m_slippage", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			s_slippageField?.SetValue(__instance, 0f);
			return false;
		}
	}
	[RegisterAbility("mountainstride")]
	public class MountainStrideAbility : IPlayerAbility, IAbility
	{
		public string Id => "mountainstride";

		public string DisplayName => "Mountain Stride";

		public string Description => "Grants immunity to sliding on steep mountain terrain for 5 minutes. " + $"Cooldown: {20f:F0} minutes.";

		public bool HasLearned(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return ((Humanoid)player).HaveUniqueKey("vv_ability_mountain_stride");
			}
			return false;
		}

		public void Learn(Player player)
		{
			VillagerAbilityManager.LearnMountainStride();
		}

		public void Activate(Player player)
		{
			VillagerAbilityManager.ActivateMountainStride();
		}
	}
}