using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Ezomic.Core;
using Grove;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Stow;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("Thijssen Software")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 Robbin Thijssen")]
[assembly: AssemblyDescription("Plant an ancient seed, feed it greydwarf blood, and a forest spirit answers.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d8f84037b24170229ade3950fc81695a7ecb19df")]
[assembly: AssemblyProduct("Vaettir")]
[assembly: AssemblyTitle("Vaettir")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Stow
{
	internal static class CarriedItem
	{
		private const float CarrySize = 0.17f;

		private static readonly Dictionary<string, GameObject> Templates = new Dictionary<string, GameObject>();

		private static GameObject _holder;

		public static void Invalidate()
		{
			foreach (GameObject value in Templates.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			Templates.Clear();
		}

		public static GameObject For(ItemData item)
		{
			return For(ItemGroups.PrefabNameOf(item));
		}

		public static GameObject For(string prefabName)
		{
			GameObject val = Template(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(val);
			obj.SetActive(true);
			return obj;
		}

		private static GameObject Template(string prefabName)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if (string.IsNullOrEmpty(prefabName))
			{
				return null;
			}
			if (Templates.TryGetValue(prefabName, out var value))
			{
				return value;
			}
			Templates[prefabName] = null;
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_holder == (Object)null)
			{
				_holder = new GameObject("StowCarriedItems");
				_holder.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_holder);
			}
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			ZNetView.m_forceDisableInit = true;
			GameObject val;
			try
			{
				val = Object.Instantiate<GameObject>(itemPrefab, _holder.transform);
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			((Object)val).name = "carried_" + prefabName;
			Strip(val);
			GameObject val2 = Fit(val);
			if ((Object)(object)val2 == (Object)null)
			{
				Object.DestroyImmediate((Object)(object)val);
				return null;
			}
			Templates[prefabName] = val2;
			return val2;
		}

		private static void Strip(GameObject clone)
		{
			List<Component> list = new List<Component>();
			MonoBehaviour[] componentsInChildren = clone.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					list.Add((Component)(object)val);
				}
			}
			Collider[] componentsInChildren2 = clone.GetComponentsInChildren<Collider>(true);
			foreach (Collider val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					list.Add((Component)(object)val2);
				}
			}
			Rigidbody[] componentsInChildren3 = clone.GetComponentsInChildren<Rigidbody>(true);
			foreach (Rigidbody val3 in componentsInChildren3)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					list.Add((Component)(object)val3);
				}
			}
			ParticleSystem[] componentsInChildren4 = clone.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val4 in componentsInChildren4)
			{
				if ((Object)(object)val4 != (Object)null)
				{
					list.Add((Component)(object)val4);
				}
			}
			TrailRenderer[] componentsInChildren5 = clone.GetComponentsInChildren<TrailRenderer>(true);
			foreach (TrailRenderer val5 in componentsInChildren5)
			{
				if ((Object)(object)val5 != (Object)null)
				{
					list.Add((Component)(object)val5);
				}
			}
			Light[] componentsInChildren6 = clone.GetComponentsInChildren<Light>(true);
			foreach (Light val6 in componentsInChildren6)
			{
				if ((Object)(object)val6 != (Object)null)
				{
					list.Add((Component)(object)val6);
				}
			}
			AudioSource[] componentsInChildren7 = clone.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val7 in componentsInChildren7)
			{
				if ((Object)(object)val7 != (Object)null)
				{
					list.Add((Component)(object)val7);
				}
			}
			foreach (Component item in list)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)item);
				}
			}
			ParticleSystemRenderer[] componentsInChildren8 = clone.GetComponentsInChildren<ParticleSystemRenderer>(true);
			foreach (ParticleSystemRenderer val8 in componentsInChildren8)
			{
				if ((Object)(object)val8 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val8);
				}
			}
			Renderer[] componentsInChildren9 = clone.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val9 in componentsInChildren9)
			{
				if (!((Object)(object)val9 == (Object)null))
				{
					val9.shadowCastingMode = (ShadowCastingMode)0;
					val9.receiveShadows = false;
				}
			}
		}

		private static GameObject Fit(GameObject clone)
		{
			//IL_0002: 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_0048: 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_0061: 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)
			//IL_00fb: 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_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_00c4: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0180: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = default(Bounds);
			bool found = false;
			Matrix4x4 worldToLocalMatrix = clone.transform.worldToLocalMatrix;
			MeshFilter[] componentsInChildren = clone.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sharedMesh == (Object)null))
				{
					Grow(ref bounds, ref found, worldToLocalMatrix * ((Component)val).transform.localToWorldMatrix, val.sharedMesh.bounds);
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = clone.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.sharedMesh == (Object)null))
				{
					Grow(ref bounds, ref found, worldToLocalMatrix * ((Component)val2).transform.localToWorldMatrix, val2.sharedMesh.bounds);
				}
			}
			if (!found)
			{
				return null;
			}
			float num = Mathf.Max(((Bounds)(ref bounds)).size.x, Mathf.Max(((Bounds)(ref bounds)).size.y, ((Bounds)(ref bounds)).size.z));
			if (num <= 0.0001f)
			{
				return null;
			}
			float num2 = 0.17f / num;
			Quaternion val3 = Quaternion.Euler(-24f, 17f, 9f);
			GameObject val4 = new GameObject(((Object)clone).name + "_display");
			val4.transform.SetParent(_holder.transform, false);
			clone.transform.SetParent(val4.transform, false);
			clone.transform.localRotation = val3;
			clone.transform.localScale = new Vector3(num2, num2, num2);
			clone.transform.localPosition = -(val3 * (((Bounds)(ref bounds)).center * num2));
			return val4;
		}

		private static void Grow(ref Bounds bounds, ref bool found, Matrix4x4 local, Bounds mesh)
		{
			//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_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_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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			Vector3 val = ((Matrix4x4)(ref local)).MultiplyPoint3x4(((Bounds)(ref mesh)).min);
			Vector3 val2 = ((Matrix4x4)(ref local)).MultiplyPoint3x4(((Bounds)(ref mesh)).max);
			if (!found)
			{
				bounds = new Bounds(val, Vector3.zero);
				found = true;
			}
			((Bounds)(ref bounds)).Encapsulate(val);
			((Bounds)(ref bounds)).Encapsulate(val2);
		}
	}
	internal class Carrier : MonoBehaviour
	{
		private enum Phase
		{
			Flying,
			Fading
		}

		public const float Orbit = 0.34f;

		public static float Spin = 24f;

		public static float BobHeight = 0.045f;

		public static float BobPeriod = 3.1f;

		public static float DriftMin = 4f;

		public static float DriftMax = 13f;

		private const float Awake = 1.6f;

		private static readonly int EmissionColour = Shader.PropertyToID("_EmissionColor");

		private Renderer[] _renderers;

		private MaterialPropertyBlock _block;

		public static float FadeTime = 0.45f;

		public Transform Body;

		public Transform Hoop;

		public Transform Sling;

		public Transform Hook;

		private readonly List<Transform> _rings = new List<Transform>();

		private readonly List<Transform> _motes = new List<Transform>();

		private readonly List<float> _moteAngle = new List<float>();

		private readonly List<float> _moteRate = new List<float>();

		private Light _light;

		private Phase _phase;

		private SpiritTrips.Flight _flight;

		private bool _hasFlight;

		private float _fade;

		private Vector3 _spin;

		private Vector3 _rest;

		private float _bobPhase;

		private float _pulsePhase;

		private float _scale = 1f;

		private GameObject _cargo;

		public static Color LightColour => ForestSpirit.LightColour;

		public static float LightRange => ForestSpirit.LightRange;

		public static float PulseDepth => ForestSpirit.PulseDepth;

		public static float PulsePeriod => ForestSpirit.PulsePeriod;

		private void Start()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_0080: 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)
			Random random = new Random(((Object)this).GetInstanceID());
			_spin = new Vector3(Signed(random), Signed(random), Signed(random));
			_bobPhase = (float)random.NextDouble() * (float)Math.PI * 2f;
			_pulsePhase = (float)random.NextDouble() * (float)Math.PI * 2f;
			_scale = ((Component)this).transform.localScale.x;
			_rest = (((Object)(object)Body != (Object)null) ? Body.localPosition : Vector3.zero);
			CollectMotes(random);
			MakeLight();
		}

		private static float Signed(Random random)
		{
			float num = 1f + (float)random.NextDouble();
			if (random.Next(2) != 0)
			{
				return num;
			}
			return 0f - num;
		}

		private void CollectMotes(Random random)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_008a: 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)
			if ((Object)(object)Hoop == (Object)null)
			{
				return;
			}
			foreach (Transform item in Hoop)
			{
				Transform val = item;
				if (!((Object)val).name.StartsWith("ring"))
				{
					continue;
				}
				_rings.Add(val);
				foreach (Transform item2 in val)
				{
					Transform val2 = item2;
					if (((Object)val2).name.StartsWith("mote"))
					{
						_motes.Add(val2);
						_moteAngle.Add(Mathf.Atan2(val2.localPosition.y, val2.localPosition.x) * 57.29578f);
						float num = DriftMin + (float)random.NextDouble() * (DriftMax - DriftMin);
						_moteRate.Add((random.Next(2) == 0) ? (0f - num) : num);
					}
				}
			}
		}

		private void MakeLight()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0061: 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_0093: Expected O, but got Unknown
			GameObject val = new GameObject("carrier_light");
			val.transform.SetParent(((Object)(object)Body != (Object)null) ? Body : ((Component)this).transform, false);
			_light = val.AddComponent<Light>();
			_light.type = (LightType)2;
			_light.range = LightRange;
			_light.color = LightColour;
			_light.intensity = 1.6f;
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			_block = new MaterialPropertyBlock();
			_light.shadows = (LightShadows)0;
		}

		public void Follow(SpiritTrips.Flight flight)
		{
			if (_phase != Phase.Fading)
			{
				_flight = flight;
				_hasFlight = true;
			}
		}

		public void Carry(GameObject model)
		{
			//IL_004f: 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)
			Release();
			if (!((Object)(object)model == (Object)null))
			{
				_cargo = model;
				_cargo.transform.SetParent(((Object)(object)Hook != (Object)null) ? Hook : ((Component)this).transform, false);
				_cargo.transform.localPosition = Vector3.zero;
				_cargo.transform.localRotation = Quaternion.identity;
			}
		}

		public void Release()
		{
			if (!((Object)(object)_cargo == (Object)null))
			{
				Object.Destroy((Object)(object)_cargo);
				_cargo = null;
			}
		}

		public void Dismiss()
		{
			if (_phase != Phase.Fading)
			{
				Release();
				_fade = FadeTime;
				_phase = Phase.Fading;
			}
		}

		private void Update()
		{
			//IL_0035: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			float deltaTime = Time.deltaTime;
			switch (_phase)
			{
			case Phase.Flying:
				if (_hasFlight)
				{
					((Component)this).transform.position = _flight.At(SpiritTrips.Now);
				}
				break;
			case Phase.Fading:
			{
				_fade -= deltaTime;
				if (_fade <= 0f)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
					return;
				}
				float num = Mathf.Clamp01(_fade / Mathf.Max(0.01f, FadeTime));
				((Component)this).transform.localScale = Vector3.one * _scale * num;
				if ((Object)(object)_light != (Object)null)
				{
					_light.intensity = 1.6f * num;
				}
				break;
			}
			}
			Animate(Time.time, deltaTime);
		}

		private void Animate(float time, float delta)
		{
			//IL_0015: 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_00ae: 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)
			if ((Object)(object)Hoop != (Object)null)
			{
				Hoop.Rotate(_spin * Spin * delta, (Space)1);
			}
			float num = Spin * delta;
			for (int i = 0; i < _rings.Count; i++)
			{
				if (!((Object)(object)_rings[i] == (Object)null))
				{
					_rings[i].Rotate(0f, 0f, num, (Space)1);
				}
			}
			if ((Object)(object)Body != (Object)null)
			{
				float num2 = Mathf.Sin(time * ((float)Math.PI * 2f / BobPeriod) + _bobPhase);
				Body.localPosition = _rest + new Vector3(0f, num2 * BobHeight, 0f);
			}
			Drift(delta);
			Sway(time);
			Pulse(time);
		}

		private void Drift(float delta)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _motes.Count; i++)
			{
				if (!((Object)(object)_motes[i] == (Object)null))
				{
					_moteAngle[i] += _moteRate[i] * delta;
					float num = _moteAngle[i] * ((float)Math.PI / 180f);
					_motes[i].localPosition = new Vector3(Mathf.Cos(num) * 0.34f, Mathf.Sin(num) * 0.34f, 0f);
				}
			}
		}

		private void Sway(float time)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Sling == (Object)null))
			{
				Sling.localRotation = Quaternion.Euler(Mathf.Sin(time * 1.7f) * 4.5f, 0f, Mathf.Cos(time * 1.3f) * 5.5f);
			}
		}

		private void Pulse(float time)
		{
			//IL_0063: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_light == (Object)null || _phase == Phase.Fading)
			{
				return;
			}
			float num = Mathf.Sin(time * ((float)Math.PI * 2f / PulsePeriod) + _pulsePhase);
			float num2 = 1f + num * PulseDepth;
			_light.intensity = 1.6f * num2;
			if (_renderers == null || _block == null)
			{
				return;
			}
			Color val = LightColour * num2;
			Renderer[] renderers = _renderers;
			foreach (Renderer val2 in renderers)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Material sharedMaterial = val2.sharedMaterial;
					if (!((Object)(object)sharedMaterial == (Object)null) && sharedMaterial.HasProperty(EmissionColour))
					{
						val2.GetPropertyBlock(_block);
						_block.SetColor(EmissionColour, val);
						val2.SetPropertyBlock(_block);
					}
				}
			}
		}
	}
	internal static class CarrierModel
	{
		private const string HeartMesh = "grove_spirit_heart.obj";

		private const string HoopMesh = "grove_spirit_hoop.obj";

		private const string MoteMesh = "grove_spirit_mote.obj";

		private const int Rings = 2;

		private const int Motes = 6;

		private static readonly bool ShowHoop;

		private const float SlingDrop = 0.155f;

		private const float TetherHigh = 0.035f;

		private const float TetherLow = 0.09f;

		private static ModelData _heart;

		private static ModelData _hoop;

		private static ModelData _mote;

		private static bool _missing;

		public static void Invalidate()
		{
			_heart = null;
			_hoop = null;
			_mote = null;
			_missing = false;
		}

		public static Carrier Build(Vector3 at)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00d8: 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: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			if (!LoadMeshes())
			{
				return null;
			}
			float num = Mathf.Max(0.05f, StowConfig.CarrierScale.Value);
			GameObject val = new GameObject("stow_carrier");
			val.transform.position = at;
			val.transform.localScale = new Vector3(num, num, num);
			GameObject val2 = new GameObject("body");
			val2.transform.SetParent(val.transform, false);
			Part(val2.transform, "heart", _heart);
			GameObject val3 = new GameObject("rings");
			val3.transform.SetParent(val2.transform, false);
			BuildRings(val3.transform);
			GameObject val4 = new GameObject("sling");
			val4.transform.SetParent(val2.transform, false);
			val4.transform.localPosition = new Vector3(0f, -0.34f, 0f);
			Bead(val4.transform, "tether_high", 0.035f, 1.2f);
			Bead(val4.transform, "tether_low", 0.09f, 0.92f);
			GameObject val5 = new GameObject("hook");
			val5.transform.SetParent(val4.transform, false);
			val5.transform.localPosition = new Vector3(0f, -0.155f, 0f);
			Flare.Attach(val2.transform, 0.884f);
			Carrier carrier = val.AddComponent<Carrier>();
			carrier.Body = val2.transform;
			carrier.Hoop = val3.transform;
			carrier.Sling = val4.transform;
			carrier.Hook = val5.transform;
			return carrier;
		}

		private static void BuildRings(Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0049: 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)
			for (int i = 0; i < 2; i++)
			{
				GameObject val = new GameObject("ring" + i);
				val.transform.SetParent(parent, false);
				val.transform.localRotation = Quaternion.Euler(90f + 90f * (float)i, 0f, 0f);
				if (ShowHoop)
				{
					Part(val.transform, "hoop", _hoop);
				}
				for (int j = 0; j < 6; j++)
				{
					float num = (60f * (float)j + 12f * (float)i) * ((float)Math.PI / 180f);
					Part(val.transform, "mote" + i + "_" + j, _mote).transform.localPosition = new Vector3(Mathf.Cos(num) * 0.34f, Mathf.Sin(num) * 0.34f, 0f);
				}
			}
		}

		private static GameObject Bead(Transform parent, string name, float drop, float size)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Part(parent, name, _mote);
			obj.transform.localPosition = new Vector3(0f, 0f - drop, 0f);
			obj.transform.localScale = new Vector3(size, size, size);
			return obj;
		}

		private static GameObject Part(Transform parent, string name, ModelData model)
		{
			//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_0013: 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_0049: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<MeshFilter>().sharedMesh = model.Mesh;
			MeshRenderer obj = val.AddComponent<MeshRenderer>();
			((Renderer)obj).sharedMaterials = Skins.Skin(model.Groups);
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)obj).receiveShadows = false;
			return val;
		}

		private static bool LoadMeshes()
		{
			if (_heart != null && _hoop != null && _mote != null)
			{
				return true;
			}
			if (_missing)
			{
				return false;
			}
			string? directoryName = Path.GetDirectoryName(typeof(CarrierModel).Assembly.Location);
			_heart = ObjMesh.Load(Path.Combine(directoryName, "grove_spirit_heart.obj"));
			_hoop = ObjMesh.Load(Path.Combine(directoryName, "grove_spirit_hoop.obj"));
			_mote = ObjMesh.Load(Path.Combine(directoryName, "grove_spirit_mote.obj"));
			if (_heart != null && _hoop != null && _mote != null)
			{
				Dress(_heart);
				Dress(_hoop);
				Dress(_mote);
				return true;
			}
			_missing = true;
			StowRuntime.Log.LogError((object)"Carrier meshes are missing from beside the dll - the post will move things instantly instead. Expected grove_spirit_heart.obj, grove_spirit_hoop.obj and grove_spirit_mote.obj.");
			return false;
		}

		private static void Dress(ModelData model)
		{
			Skins.Skin(model.Groups);
			Skins.Remap(model.Mesh, model.Groups);
		}
	}
	internal class CarryRun
	{
		private enum Errand
		{
			Stow,
			Fetch,
			Tidy,
			Resting
		}

		private sealed class Courier
		{
			public Errand Errand;

			public ItemData Item;

			public Container Target;

			public Container Source;

			public bool Outbound;

			public SpiritTrips.Flight Flight;

			public double ReadyAt;

			public bool Idle(double now)
			{
				return now >= ReadyAt;
			}
		}

		private const float ScanInterval = 3f;

		private const float PostHover = 0.45f;

		private const float ChestHover = 0.35f;

		private readonly StowPost _post;

		private readonly List<Courier> _couriers = new List<Courier>();

		private readonly List<ItemData> _reserved = new List<ItemData>();

		private readonly List<Container> _touched = new List<Container>();

		private Transform _heartwood;

		private float _nextScan;

		private int _moved;

		public bool Working => _couriers.Count > 0;

		public CarryRun(StowPost post)
		{
			_post = post;
		}

		public void Wake()
		{
			_nextScan = 0f;
		}

		public void Abandon()
		{
			if (_couriers.Count != 0 || _reserved.Count != 0 || _moved != 0)
			{
				_couriers.Clear();
				_reserved.Clear();
				_touched.Clear();
				_moved = 0;
				Publish();
			}
		}

		public void Tick()
		{
			Container val = (((Object)(object)_post != (Object)null) ? _post.Container : null);
			Inventory val2 = (((Object)(object)val != (Object)null) ? val.GetInventory() : null);
			if (val2 == null)
			{
				Abandon();
				return;
			}
			ZNetView component = ((Component)_post).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
			{
				Abandon();
				return;
			}
			double now = SpiritTrips.Now;
			for (int num = _couriers.Count - 1; num >= 0; num--)
			{
				Courier courier = _couriers[num];
				if (courier.Idle(now))
				{
					if (courier.Outbound)
					{
						Land(courier, val2, component);
					}
					else
					{
						Arrive(courier, component);
						if (!Dispatch(courier, val2, now))
						{
							Retire(courier, num);
						}
					}
				}
			}
			Recruit(val2, now);
			Publish();
			foreach (Courier courier2 in _couriers)
			{
				if (courier2.Errand != Errand.Resting)
				{
					return;
				}
			}
			_reserved.Clear();
			if (_moved > 0)
			{
				Announce();
			}
		}

		private void Land(Courier courier, Inventory inventory, ZNetView nview)
		{
			//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_00c3: 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)
			ItemData item = courier.Item;
			Errand errand = courier.Errand;
			Container source = courier.Source;
			Container target = courier.Target;
			Vector3 to = courier.Flight.To;
			courier.Outbound = false;
			bool flag = false;
			bool flag2 = false;
			string cargo = null;
			nview.ClaimOwnership();
			switch (errand)
			{
			case Errand.Stow:
				flag = !Move(inventory, target, item, ref cargo, celebrate: true);
				break;
			case Errand.Fetch:
				flag2 = Ready(source, item);
				if (flag2)
				{
					cargo = ItemGroups.PrefabNameOf(item);
				}
				break;
			case Errand.Tidy:
				flag = !Move(Held(source), target, item, ref cargo, celebrate: true);
				break;
			}
			if (!flag2)
			{
				courier.Item = null;
				courier.Source = null;
				if (!flag && item != null)
				{
					_reserved.Remove(item);
				}
			}
			courier.Target = null;
			Launch(courier, to, Home(), cargo, SpiritTrips.Now);
		}

		private bool Ready(Container source, ItemData item)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Inventory val = Held(source);
			Inventory val2 = (((Object)(object)_post.Container != (Object)null) ? _post.Container.GetInventory() : null);
			if (val != null && val2 != null && item != null && val.ContainsItem(item) && val2.CanAddItem(item, -1))
			{
				return Depositor.Usable(source, ((Component)_post).transform.position, StowConfig.Range.Value);
			}
			return false;
		}

		private void Arrive(Courier courier, ZNetView nview)
		{
			if (courier.Errand == Errand.Fetch && courier.Item != null)
			{
				ItemData item = courier.Item;
				Container source = courier.Source;
				courier.Item = null;
				courier.Source = null;
				nview.ClaimOwnership();
				string cargo = null;
				Move(Held(source), _post.Container, item, ref cargo, celebrate: true);
				_reserved.Remove(item);
			}
		}

		private static Inventory Held(Container container)
		{
			if (!((Object)(object)container == (Object)null))
			{
				return container.GetInventory();
			}
			return null;
		}

		private bool Move(Inventory from, Container into, ItemData item, ref string cargo, bool celebrate)
		{
			//IL_0028: 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)
			if (from == null || (Object)(object)into == (Object)null || item == null)
			{
				return true;
			}
			if (!from.ContainsItem(item))
			{
				return true;
			}
			if (!Depositor.Usable(into, ((Component)_post).transform.position, StowConfig.Range.Value))
			{
				return true;
			}
			cargo = ItemGroups.PrefabNameOf(item);
			bool emptied;
			int num = Depositor.Deposit(from, into, item, out emptied);
			if (num <= 0)
			{
				StowRuntime.Log.LogWarning((object)("A container offered room for " + item.m_shared.m_name + " and then accepted none - not trying it again this run."));
				return false;
			}
			_moved += num;
			if (!_touched.Contains(into))
			{
				_touched.Add(into);
			}
			if (celebrate && (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.instance.m_moveItemEffects != null)
			{
				InventoryGui.instance.m_moveItemEffects.Create(((Component)into).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			}
			return true;
		}

		private bool Dispatch(Courier courier, Inventory inventory, double now)
		{
			//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_0027: 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_0040: 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_007d: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			Container container = _post.Container;
			Vector3 position = ((Component)_post).transform.position;
			if (Available(inventory) && Depositor.NextTrip(inventory, position, _reserved, out var item, out var target))
			{
				Begin(courier, Errand.Stow, item, null, target, AimAt(target), ItemGroups.PrefabNameOf(item), now, "carrying");
				return true;
			}
			if (Available(inventory) && Depositor.NextFetch(container, position, _reserved, out item, out var source))
			{
				Begin(courier, Errand.Fetch, item, source, null, AimAt(source), null, now, "fetching");
				return true;
			}
			if (PostRules.Tidy(container) && Depositor.NextTidy(position, _reserved, out item, out source, out target))
			{
				Begin(courier, Errand.Tidy, item, source, target, AimAt(source), null, now, "tidying");
				return true;
			}
			if (PostRules.Where(container) != PostRules.Presence.LivesHere)
			{
				return false;
			}
			if (courier.Errand != Errand.Resting)
			{
				courier.Errand = Errand.Resting;
				courier.Item = null;
				courier.Source = null;
				courier.Target = null;
				courier.Outbound = false;
				Launch(courier, courier.Flight.To, Home(), null, now);
			}
			courier.ReadyAt = now + 3.0;
			return true;
		}

		private void Begin(Courier courier, Errand errand, ItemData item, Container source, Container target, Vector3 aim, string cargo, double now, string verb)
		{
			//IL_0051: 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_0056: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			courier.Errand = errand;
			courier.Item = item;
			courier.Source = source;
			courier.Target = target;
			courier.Outbound = true;
			_reserved.Add(item);
			Vector3 val = ((courier.Flight.Duration > 0f) ? courier.Flight.To : Home());
			Launch(courier, val, aim, cargo, now);
			if (StowConfig.Verbose.Value)
			{
				StowRuntime.Log.LogInfo((object)(verb + " " + item.m_stack + "x " + item.m_shared.m_name));
			}
		}

		private void Recruit(Inventory inventory, double now)
		{
			int num = Mathf.Clamp(StowConfig.Couriers.Value, 1, 8);
			if (_couriers.Count >= num)
			{
				return;
			}
			Container container = _post.Container;
			if ((inventory.NrOfItems() != 0 || PostRules.Fetch(container).Count != 0 || PostRules.Tidy(container) || PostRules.Where(container) == PostRules.Presence.LivesHere) && !(Time.time < _nextScan))
			{
				_nextScan = Time.time + 3f;
				Courier courier = new Courier
				{
					ReadyAt = now
				};
				_couriers.Add(courier);
				if (!Dispatch(courier, inventory, now))
				{
					_couriers.Remove(courier);
				}
			}
		}

		private void Retire(Courier courier, int index)
		{
			if (courier.Item != null)
			{
				_reserved.Remove(courier.Item);
			}
			_couriers.RemoveAt(index);
		}

		private bool Available(Inventory inventory)
		{
			if (inventory.NrOfItems() == 0)
			{
				return false;
			}
			Container container = _post.Container;
			if (!((Object)(object)container == (Object)null))
			{
				return !container.IsInUse();
			}
			return true;
		}

		public void Instant(Inventory inventory)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			int chestCount;
			int moved = Depositor.Distribute(inventory, ((Component)_post).transform.position, out chestCount);
			_moved = moved;
			_touched.Clear();
			Announce(chestCount);
		}

		private void Announce()
		{
			Announce(_touched.Count);
		}

		private void Announce(int chests)
		{
			int moved = _moved;
			_moved = 0;
			_touched.Clear();
			if (StowConfig.Messages.Value && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Container container = _post.Container;
				Inventory val = (((Object)(object)container != (Object)null) ? container.GetInventory() : null);
				int num = ((val != null) ? val.NrOfItems() : 0);
				string text = ((moved != 0) ? ("Stowed " + moved + " item" + ((moved == 1) ? "" : "s") + " into " + chests + " chest" + ((chests == 1) ? "" : "s") + ".") : ((num > 0) ? "Nothing here has a home yet." : ""));
				if (num > 0 && moved > 0)
				{
					text = text + " " + num + " left waiting.";
				}
				if (text.Length != 0)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize(text), 0, (Sprite)null);
				}
			}
		}

		private void Launch(Courier courier, Vector3 from, Vector3 to, string cargo, double now)
		{
			//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_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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_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_00a5: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(from.y, to.y) + Mathf.Max(0f, StowConfig.CarrierCruise.Value);
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor((from.x + to.x) * 0.5f, num, (from.z + to.z) * 0.5f);
			float num2 = Mathf.Max(0.4f, StowConfig.CarrierSpeed.Value);
			float num3 = Vector3.Distance(from, val) + Vector3.Distance(val, to);
			float num4 = Mathf.Max(0.35f, num3 / num2);
			courier.Flight = new SpiritTrips.Flight
			{
				From = from,
				Control = val,
				To = to,
				Cargo = cargo,
				Start = now,
				Duration = num4
			};
			courier.ReadyAt = now + (double)num4 + (double)Mathf.Max(0f, StowConfig.CarrierPause.Value);
		}

		private void Publish()
		{
			ZNetView val = (((Object)(object)_post != (Object)null) ? ((Component)_post).GetComponent<ZNetView>() : null);
			if ((Object)(object)val == (Object)null || !val.IsValid() || !val.IsOwner())
			{
				return;
			}
			List<SpiritTrips.Flight> list = new List<SpiritTrips.Flight>();
			foreach (Courier courier in _couriers)
			{
				list.Add(courier.Flight);
			}
			SpiritTrips.Publish(val, SpiritTrips.Encode(list));
		}

		private Vector3 Home()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_heartwood == (Object)null)
			{
				_heartwood = ((Component)_post).transform.Find("post_visual/heartwood");
			}
			if (!((Object)(object)_heartwood != (Object)null))
			{
				return Above(((Component)_post).transform, 0.45f, 1f);
			}
			return _heartwood.position;
		}

		private static Vector3 AimAt(Container container)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return Above(((Component)container).transform, 0.35f, 0.5f);
		}

		private static Vector3 Above(Transform thing, float clearance, float fallback)
		{
			//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_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_002a: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = thing.position;
			Collider componentInChildren = ((Component)thing).GetComponentInChildren<Collider>();
			float num;
			if (!((Object)(object)componentInChildren != (Object)null))
			{
				num = position.y + fallback;
			}
			else
			{
				Bounds bounds = componentInChildren.bounds;
				num = ((Bounds)(ref bounds)).max.y;
			}
			float num2 = num;
			return new Vector3(position.x, num2 + clearance, position.z);
		}
	}
	internal static class ChestFilter
	{
		public sealed class Rule
		{
			public Container Container;

			public float Distance;

			public bool Configured;

			public bool CatchesAll;

			public readonly HashSet<string> Items = new HashSet<string>();

			public readonly List<ItemGroup> Groups = new List<ItemGroup>();

			public readonly HashSet<string> NotItems = new HashSet<string>();

			public readonly List<ItemGroup> NotGroups = new List<ItemGroup>();

			public int Match(ItemData item)
			{
				if (item == null || item.m_shared == null)
				{
					return -1;
				}
				string name = item.m_shared.m_name;
				if (Excludes(name))
				{
					return -1;
				}
				if (Configured)
				{
					if (Items.Contains(name))
					{
						return 3;
					}
					foreach (ItemGroup group in Groups)
					{
						if (group.Members.Contains(name))
						{
							return 2;
						}
					}
					if (!CatchesAll)
					{
						return -1;
					}
					return 1;
				}
				if (!StowConfig.MatchContents.Value)
				{
					return -1;
				}
				Inventory inventory = Container.GetInventory();
				if (inventory == null || !inventory.ContainsItemByName(name))
				{
					return -1;
				}
				return 0;
			}

			public bool Refuses(ItemData item)
			{
				if (item != null && item.m_shared != null)
				{
					return Excludes(item.m_shared.m_name);
				}
				return false;
			}

			private bool Excludes(string shared)
			{
				if (NotItems.Contains(shared))
				{
					return true;
				}
				foreach (ItemGroup notGroup in NotGroups)
				{
					if (notGroup.Members.Contains(shared))
					{
						return true;
					}
				}
				return false;
			}
		}

		private const string ZFilter = "stowFilter";

		public const string CatchAll = "*";

		public const int TierNone = -1;

		public const int TierContents = 0;

		public const int TierCatchAll = 1;

		public const int TierGroup = 2;

		public const int TierItem = 3;

		public static string Read(Container container)
		{
			ZDO val = Zdo(container);
			if (val != null)
			{
				return val.GetString("stowFilter", "");
			}
			return "";
		}

		public static void Write(Container container, IEnumerable<string> entries)
		{
			ZNetView val = (((Object)(object)container == (Object)null) ? null : ((Component)container).GetComponent<ZNetView>());
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				val.ClaimOwnership();
				val.GetZDO().Set("stowFilter", string.Join(",", Clean(entries).ToArray()));
			}
		}

		public static List<string> Entries(Container container)
		{
			return Clean(Read(container).Split(new char[1] { ',' }));
		}

		private static List<string> Clean(IEnumerable<string> entries)
		{
			List<string> list = new List<string>();
			if (entries == null)
			{
				return list;
			}
			foreach (string entry in entries)
			{
				if (entry != null)
				{
					string text = entry.Trim();
					if (text.Length != 0 && !list.Contains(text))
					{
						list.Add(text);
					}
				}
			}
			return list;
		}

		public static bool IsGroup(string entry)
		{
			if (entry != null && entry.Length > 1)
			{
				return entry[0] == '@';
			}
			return false;
		}

		public static string GroupId(string entry)
		{
			if (!IsGroup(entry))
			{
				return null;
			}
			return entry.Substring(1);
		}

		public static bool IsExclusion(string entry)
		{
			if (entry != null && entry.Length > 1)
			{
				return entry[0] == '-';
			}
			return false;
		}

		public static string Bare(string entry)
		{
			if (!IsExclusion(entry))
			{
				return entry;
			}
			return entry.Substring(1);
		}

		public static Rule RuleFor(Container container, float distance)
		{
			Rule rule = new Rule
			{
				Container = container,
				Distance = distance
			};
			foreach (string item in Entries(container))
			{
				bool flag = IsExclusion(item);
				string text = Bare(item);
				if (text == "*")
				{
					if (!flag)
					{
						rule.CatchesAll = true;
						rule.Configured = true;
					}
					continue;
				}
				if (IsGroup(text))
				{
					ItemGroup itemGroup = ItemGroups.Find(GroupId(text));
					if (itemGroup != null)
					{
						if (flag)
						{
							rule.NotGroups.Add(itemGroup);
							continue;
						}
						rule.Groups.Add(itemGroup);
						rule.Configured = true;
					}
					continue;
				}
				string text2 = ItemGroups.SharedNameOf(text);
				if (text2 != null)
				{
					if (flag)
					{
						rule.NotItems.Add(text2);
						continue;
					}
					rule.Items.Add(text2);
					rule.Configured = true;
				}
			}
			return rule;
		}

		public static bool Matches(List<string> entries, ItemData item)
		{
			if (entries == null || item == null || item.m_shared == null)
			{
				return false;
			}
			string name = item.m_shared.m_name;
			bool result = false;
			foreach (string entry in entries)
			{
				bool flag = IsExclusion(entry);
				string text = Bare(entry);
				if (text == "*" || ((!IsGroup(text)) ? (ItemGroups.SharedNameOf(text) == name) : (ItemGroups.Find(GroupId(text))?.Members.Contains(name) ?? false)))
				{
					if (flag)
					{
						return false;
					}
					result = true;
				}
			}
			return result;
		}

		public static string Summary(Container container)
		{
			List<string> list = Entries(container);
			if (list.Count == 0)
			{
				return null;
			}
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			foreach (string item2 in list)
			{
				bool flag = IsExclusion(item2);
				string text = Bare(item2);
				string item;
				if (text == "*")
				{
					item = "anything else";
				}
				else if (IsGroup(text))
				{
					ItemGroup itemGroup = ItemGroups.Find(GroupId(text));
					item = ((itemGroup != null) ? itemGroup.Display.ToLowerInvariant() : GroupId(text));
				}
				else
				{
					item = ItemGroups.DisplayNameOf(text);
				}
				(flag ? list3 : list2).Add(item);
			}
			string text2 = string.Join(", ", list2.ToArray());
			if (list3.Count == 0)
			{
				return text2;
			}
			string text3 = "not " + string.Join(" or ", list3.ToArray());
			if (text2.Length != 0)
			{
				return text2 + " - " + text3;
			}
			return text3;
		}

		private static ZDO Zdo(Container container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return null;
			}
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			if (!((Object)(object)component != (Object)null) || !component.IsValid())
			{
				return null;
			}
			return component.GetZDO();
		}
	}
	internal static class Depositor
	{
		private sealed class Plan
		{
			public ItemData Item;

			public int Tier;
		}

		private static readonly Collider[] Hits = (Collider[])(object)new Collider[256];

		private static HashSet<string> _neverStow;

		private static string _neverStowRaw;

		public static int Distribute(Inventory source, Vector3 origin, out int chestCount, Predicate<ItemData> allow = null)
		{
			//IL_0015: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			chestCount = 0;
			if (source == null || !ItemGroups.Ready)
			{
				return 0;
			}
			List<ChestFilter.Rule> list = new List<ChestFilter.Rule>();
			CollectChests(origin, list);
			if (list.Count == 0)
			{
				return 0;
			}
			List<Plan> list2 = new List<Plan>();
			foreach (ItemData item in new List<ItemData>(source.GetAllItems()))
			{
				if (allow == null || allow(item))
				{
					int num = BestTier(list, item);
					if (num != -1)
					{
						list2.Add(new Plan
						{
							Item = item,
							Tier = num
						});
					}
				}
			}
			if (list2.Count == 0)
			{
				return 0;
			}
			list2.Sort((Plan a, Plan b) => b.Tier.CompareTo(a.Tier));
			int num2 = 0;
			List<Container> list3 = new List<Container>();
			foreach (Plan item2 in list2)
			{
				num2 += Place(source, list, item2.Item, list3);
			}
			foreach (Container item3 in list3)
			{
				if ((Object)(object)InventoryGui.instance != (Object)null && InventoryGui.instance.m_moveItemEffects != null)
				{
					InventoryGui.instance.m_moveItemEffects.Create(((Component)item3).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				}
			}
			chestCount = list3.Count;
			return num2;
		}

		public static void Run(Player player)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (!ItemGroups.Ready)
			{
				Announce("Item catalogue not loaded yet.");
				return;
			}
			int chestCount;
			int num = Distribute(((Humanoid)player).GetInventory(), ((Component)player).transform.position, out chestCount, (ItemData item) => Stowable(player, item));
			if (num == 0)
			{
				Announce("Nothing here belongs in those chests.");
				return;
			}
			Announce("Stowed " + num + " item" + ((num == 1) ? "" : "s") + " into " + chestCount + " chest" + ((chestCount == 1) ? "" : "s") + ".");
		}

		private static int Place(Inventory source, List<ChestFilter.Rule> rules, ItemData item, List<Container> touched)
		{
			int num = 0;
			while (item.m_stack > 0)
			{
				Container val = BestChestWithRoom(rules, item);
				if ((Object)(object)val == (Object)null)
				{
					break;
				}
				bool emptied;
				int num2 = Deposit(source, val, item, out emptied);
				if (num2 < 0)
				{
					break;
				}
				num += num2;
				if (num2 > 0 && !touched.Contains(val))
				{
					touched.Add(val);
				}
				if (emptied || num2 == 0)
				{
					break;
				}
			}
			return num;
		}

		public static int Deposit(Inventory source, Container target, ItemData item, out bool emptied)
		{
			emptied = false;
			if (source == null || (Object)(object)target == (Object)null || item == null)
			{
				return -1;
			}
			ZNetView component = ((Component)target).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return -1;
			}
			Inventory inventory = target.GetInventory();
			if (inventory == null)
			{
				return -1;
			}
			component.ClaimOwnership();
			int value = StowConfig.ItemsPerTrip.Value;
			int num = ((value > 0) ? Mathf.Min(value, item.m_stack) : item.m_stack);
			ItemData val = item.Clone();
			val.m_stack = num;
			int num2 = (inventory.AddItem(val) ? num : (num - val.m_stack));
			item.m_stack -= num2;
			if (item.m_stack <= 0)
			{
				source.RemoveItem(item);
				emptied = true;
			}
			if (num2 > 0 && StowConfig.Verbose.Value)
			{
				StowRuntime.Log.LogInfo((object)("stowed " + num2 + "x " + item.m_shared.m_name + " into " + target.m_name));
			}
			return num2;
		}

		public static bool NextFetch(Container post, Vector3 origin, List<ItemData> reserved, out ItemData item, out Container source)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			item = null;
			source = null;
			if ((Object)(object)post == (Object)null || !ItemGroups.Ready)
			{
				return false;
			}
			List<string> list = PostRules.Fetch(post);
			if (list.Count == 0)
			{
				return false;
			}
			Inventory inventory = post.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			List<ChestFilter.Rule> list2 = new List<ChestFilter.Rule>();
			CollectChests(origin, list2);
			foreach (ChestFilter.Rule item2 in list2)
			{
				Inventory inventory2 = item2.Container.GetInventory();
				if (inventory2 == null)
				{
					continue;
				}
				foreach (ItemData allItem in inventory2.GetAllItems())
				{
					if ((reserved == null || !reserved.Contains(allItem)) && ChestFilter.Matches(list, allItem) && inventory.CanAddItem(allItem, -1))
					{
						item = allItem;
						source = item2.Container;
						return true;
					}
				}
			}
			return false;
		}

		public static bool NextTidy(Vector3 origin, List<ItemData> reserved, out ItemData item, out Container source, out Container target)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			item = null;
			source = null;
			target = null;
			if (!ItemGroups.Ready)
			{
				return false;
			}
			List<ChestFilter.Rule> list = new List<ChestFilter.Rule>();
			CollectChests(origin, list);
			if (list.Count < 2)
			{
				return false;
			}
			foreach (ChestFilter.Rule item2 in list)
			{
				Inventory inventory = item2.Container.GetInventory();
				if (inventory == null)
				{
					continue;
				}
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if ((reserved == null || !reserved.Contains(allItem)) && item2.Match(allItem) == -1 && item2.Refuses(allItem))
					{
						Container val = BestChestWithRoom(list, allItem);
						if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)item2.Container))
						{
							item = allItem;
							source = item2.Container;
							target = val;
							return true;
						}
					}
				}
			}
			return false;
		}

		public static bool NextTrip(Inventory source, Vector3 origin, List<ItemData> reserved, out ItemData item, out Container target)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			item = null;
			target = null;
			if (source == null || !ItemGroups.Ready)
			{
				return false;
			}
			List<ChestFilter.Rule> list = new List<ChestFilter.Rule>();
			CollectChests(origin, list);
			if (list.Count == 0)
			{
				return false;
			}
			List<Plan> list2 = new List<Plan>();
			foreach (ItemData allItem in source.GetAllItems())
			{
				if (reserved == null || !reserved.Contains(allItem))
				{
					int num = BestTier(list, allItem);
					if (num != -1)
					{
						list2.Add(new Plan
						{
							Item = allItem,
							Tier = num
						});
					}
				}
			}
			if (list2.Count == 0)
			{
				return false;
			}
			list2.Sort((Plan a, Plan b) => b.Tier.CompareTo(a.Tier));
			foreach (Plan item2 in list2)
			{
				Container val = BestChestWithRoom(list, item2.Item);
				if (!((Object)(object)val == (Object)null))
				{
					item = item2.Item;
					target = val;
					return true;
				}
			}
			return false;
		}

		private static int BestTier(List<ChestFilter.Rule> rules, ItemData item)
		{
			int num = -1;
			foreach (ChestFilter.Rule rule in rules)
			{
				int num2 = rule.Match(item);
				if (num2 > num)
				{
					num = num2;
				}
			}
			return num;
		}

		public static Container BestChestWithRoom(List<ChestFilter.Rule> rules, ItemData item)
		{
			ChestFilter.Rule rule = null;
			int num = -1;
			foreach (ChestFilter.Rule rule2 in rules)
			{
				int num2 = rule2.Match(item);
				if (num2 != -1 && num2 >= num && (num2 != num || rule == null || !(rule2.Distance >= rule.Distance)))
				{
					Inventory inventory = rule2.Container.GetInventory();
					if (inventory != null && inventory.CanAddItem(item, 1))
					{
						rule = rule2;
						num = num2;
					}
				}
			}
			return rule?.Container;
		}

		public static void CollectChests(Vector3 point, List<ChestFilter.Rule> into)
		{
			//IL_0011: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			into.Clear();
			float value = StowConfig.Range.Value;
			int num = Physics.OverlapSphereNonAlloc(point, value, Hits);
			List<Container> list = new List<Container>();
			for (int i = 0; i < num; i++)
			{
				Container componentInParent = ((Component)Hits[i]).GetComponentInParent<Container>();
				if (!((Object)(object)componentInParent == (Object)null) && !list.Contains(componentInParent))
				{
					list.Add(componentInParent);
					if (Usable(componentInParent, point, value))
					{
						into.Add(ChestFilter.RuleFor(componentInParent, Vector3.Distance(((Component)componentInParent).transform.position, point)));
					}
				}
			}
		}

		public static bool Usable(Container container, Vector3 point, float range)
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			if (StowPost.Is(container))
			{
				return false;
			}
			if (Vector3.Distance(((Component)container).transform.position, point) > range)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponentInParent<Vagon>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)container).GetComponentInParent<Ship>() != (Object)null)
			{
				return false;
			}
			if ((int)container.m_privacy != 2)
			{
				return false;
			}
			if (container.IsInUse())
			{
				return false;
			}
			if (container.m_checkGuardStone && !PrivateArea.CheckAccess(((Component)container).transform.position, 0f, true, false))
			{
				return false;
			}
			return true;
		}

		private static bool Stowable(Player player, ItemData item)
		{
			if (item == null || item.m_shared == null)
			{
				return false;
			}
			if (item.m_equipped || ((Humanoid)player).IsItemEquiped(item))
			{
				return false;
			}
			if (StowConfig.KeepHotbar.Value && item.m_gridPos.y == 0)
			{
				return false;
			}
			string text = ItemGroups.PrefabNameOf(item);
			if (text != null && NeverStow().Contains(text))
			{
				return false;
			}
			return true;
		}

		private static HashSet<string> NeverStow()
		{
			string text = StowConfig.NeverStow.Value ?? "";
			if (_neverStow != null && text == _neverStowRaw)
			{
				return _neverStow;
			}
			_neverStowRaw = text;
			_neverStow = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array = text.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					_neverStow.Add(text2);
				}
			}
			return _neverStow;
		}

		private static void Announce(string message)
		{
			if (StowConfig.Messages.Value && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize(message), 0, (Sprite)null);
			}
		}
	}
	internal static class FilterPanel
	{
		public static class Styles
		{
			public static GUIStyle Window;

			public static GUIStyle Title;

			public static GUIStyle Dim;

			public static GUIStyle Caption;

			public static GUIStyle CellOn;

			public static GUIStyle CellOff;

			public static GUIStyle CellNot;

			public static GUIStyle Chip;

			public static GUIStyle Row;

			public static GUIStyle Field;

			public static GUIStyle List;

			public static Texture2D RuleLine;

			private static bool _built;

			public static void Build()
			{
				//IL_000e: 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_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//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: Expected O, but got Unknown
				//IL_0053: Expected O, but got Unknown
				//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_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_0090: 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: Expected O, but got Unknown
				//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_00ca: 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_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_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Expected O, but got Unknown
				//IL_011f: 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_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_0155: 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_0164: Expected O, but got Unknown
				//IL_0169: Expected O, but got Unknown
				//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_01b7: 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_01cb: Expected O, but got Unknown
				//IL_01d0: Expected O, but got Unknown
				//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_01f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Expected O, but got Unknown
				if (!_built)
				{
					_built = true;
					RuleLine = Theme.Solid(Theme.Rule);
					Window = new GUIStyle(GUI.skin.window)
					{
						padding = new RectOffset(14, 14, 12, 12),
						border = new RectOffset(1, 1, 1, 1)
					};
					Paint(Window, Theme.Bordered(Theme.Bg, Theme.Rule));
					Title = Label(14, Theme.Gold);
					Dim = Label(12, Theme.Dim);
					Caption = Label(12, Theme.Dim);
					Caption.margin = new RectOffset(0, 0, 2, 4);
					CellOff = Button(13, Theme.Ink, Theme.Row);
					CellOn = Button(13, Theme.Bg, Theme.Gold);
					CellNot = Button(13, Theme.Gold, Theme.Bg);
					Chip = Button(12, Theme.Gold, Theme.Panel);
					Chip.padding = new RectOffset(8, 8, 2, 2);
					Row = Button(13, Theme.Ink, Color.clear);
					Row.alignment = (TextAnchor)3;
					Field = new GUIStyle(GUI.skin.textField)
					{
						fontSize = 13,
						padding = new RectOffset(6, 6, 3, 3)
					};
					if ((Object)(object)Theme.Mono != (Object)null)
					{
						Field.font = Theme.Mono;
					}
					Field.normal.textColor = Theme.Ink;
					Field.focused.textColor = Theme.Ink;
					List = new GUIStyle(GUI.skin.box)
					{
						padding = new RectOffset(2, 2, 2, 2)
					};
					Paint(List, Theme.Bordered(Theme.Panel, Theme.Rule));
					List.border = new RectOffset(1, 1, 1, 1);
				}
			}

			private static GUIStyle Label(int size, Color colour)
			{
				//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_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//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_0034: Expected O, but got Unknown
				//IL_0034: 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: Expected O, but got Unknown
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				GUIStyle val = new GUIStyle(GUI.skin.label)
				{
					fontSize = size,
					padding = new RectOffset(0, 0, 1, 1),
					margin = new RectOffset(0, 0, 0, 0),
					wordWrap = false,
					clipping = (TextClipping)1
				};
				if ((Object)(object)Theme.Mono != (Object)null)
				{
					val.font = Theme.Mono;
				}
				val.normal.textColor = colour;
				return val;
			}

			private static GUIStyle Button(int size, Color ink, Color fill)
			{
				//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_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_002c: Expected O, but got Unknown
				//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_003b: Expected O, but got Unknown
				//IL_003b: 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: Expected O, but got Unknown
				//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_0070: 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_0094: 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)
				GUIStyle val = new GUIStyle(GUI.skin.button)
				{
					fontSize = size,
					alignment = (TextAnchor)4,
					padding = new RectOffset(4, 4, 2, 2),
					margin = new RectOffset(0, 0, 0, 0),
					wordWrap = false,
					clipping = (TextClipping)1
				};
				if ((Object)(object)Theme.Mono != (Object)null)
				{
					val.font = Theme.Mono;
				}
				Paint(val, (fill == Color.clear) ? Theme.Clear() : Theme.Solid(fill));
				val.normal.textColor = ink;
				val.hover.textColor = ink;
				val.active.textColor = ink;
				val.focused.textColor = ink;
				return val;
			}

			private static void Paint(GUIStyle style, Texture2D texture)
			{
				style.normal.background = texture;
				style.hover.background = texture;
				style.active.background = texture;
				style.focused.background = texture;
				style.onNormal.background = texture;
				style.onHover.background = texture;
				style.onActive.background = texture;
				style.onFocused.background = texture;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static WindowFunction <0>__DrawWindow;

			public static Action <1>__CommitChest;
		}

		private const float WindowWidth = 520f;

		private const float CellWidth = 118f;

		private const float CellGap = 4f;

		private const int Columns = 4;

		private static Rect _window = new Rect(90f, 90f, 520f, 0f);

		private static Container _container;

		private static List<string> _entries = new List<string>();

		private static List<string> _edit;

		private static Action _save;

		private static string _search = "";

		private static Vector2 _searchScroll;

		public static bool IsOpen { get; private set; }

		private static void Editing(List<string> entries, Action commit)
		{
			_edit = entries;
			_save = commit;
		}

		public static void Open(Container container)
		{
			//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)
			if (!((Object)(object)container == (Object)null))
			{
				_container = container;
				_entries = ChestFilter.Entries(container);
				_search = "";
				_searchScroll = Vector2.zero;
				IsOpen = true;
			}
		}

		public static void Close()
		{
			IsOpen = false;
			_container = null;
			_search = "";
		}

		public static void Draw()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0052: Expected O, but got Unknown
			if (!IsOpen)
			{
				return;
			}
			if ((Object)(object)_container == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				Close();
				return;
			}
			Styles.Build();
			Rect window = _window;
			object obj = <>O.<0>__DrawWindow;
			if (obj == null)
			{
				WindowFunction val = DrawWindow;
				<>O.<0>__DrawWindow = val;
				obj = (object)val;
			}
			_window = GUILayout.Window(356372, window, (WindowFunction)obj, GUIContent.none, Styles.Window, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(520f) });
		}

		private static void DrawWindow(int id)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			DrawHeader();
			Caption("GROUPS");
			DrawGroupGrid(_entries, CommitChest, 118f, 4f, 4);
			GUILayout.Space(6f);
			Caption("SINGLE ITEMS");
			DrawItemPicker(_entries, CommitChest, ref _search, ref _searchScroll);
			DrawItemChips(_entries, CommitChest, 520f);
			GUILayout.Space(6f);
			Rule();
			DrawFooter();
			GUI.DragWindow(new Rect(0f, 0f, 10000f, 22f));
		}

		private static void DrawHeader()
		{
			Inventory inventory = _container.GetInventory();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			if (inventory != null)
			{
				HashSet<string> hashSet = new HashSet<string>();
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if (allItem != null && allItem.m_shared != null)
					{
						hashSet.Add(allItem.m_shared.m_name);
					}
				}
				num = hashSet.Count;
				num2 = inventory.NrOfItems();
				num3 = inventory.GetWidth() * inventory.GetHeight();
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(Localization.instance.Localize(_container.m_name), Styles.Title, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.Label("holds " + num + " kind" + ((num == 1) ? "" : "s") + "  ·  " + num2 + "/" + num3 + " slots", Styles.Dim, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			Rule();
		}

		public static void DrawGroupGrid(List<string> entries, Action commit, float cellWidth, float cellGap, int columns)
		{
			Editing(entries, commit);
			DrawGroups(cellWidth, cellGap, columns);
		}

		private static void DrawGroups(float CellWidth, float CellGap, int Columns)
		{
			IList<ItemGroup> groups = ItemGroups.Groups;
			int num = groups.Count + 1;
			int num2 = (num + Columns - 1) / Columns;
			for (int i = 0; i < num2; i++)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				for (int j = 0; j < Columns; j++)
				{
					int num3 = i * Columns + j;
					if (num3 >= num)
					{
						GUILayout.Space(CellWidth + CellGap);
						continue;
					}
					if (num3 < groups.Count)
					{
						ItemGroup itemGroup = groups[num3];
						Cell(itemGroup.Display, "@" + itemGroup.Id, CellWidth);
					}
					else
					{
						Cell("Anything else", "*", CellWidth);
					}
					if (j < Columns - 1)
					{
						GUILayout.Space(CellGap);
					}
				}
				GUILayout.EndHorizontal();
				GUILayout.Space(CellGap);
			}
		}

		private static void Cell(string label, string entry, float CellWidth)
		{
			bool num = _edit.Contains("-" + entry);
			bool flag = _edit.Contains(entry);
			GUIStyle val = (num ? Styles.CellNot : (flag ? Styles.CellOn : Styles.CellOff));
			if (GUILayout.Button(num ? ("not " + label) : label, val, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(CellWidth),
				GUILayout.Height(24f)
			}))
			{
				Cycle(entry);
			}
		}

		public static void DrawItemPicker(List<string> entries, Action commit, ref string search, ref Vector2 scroll)
		{
			//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_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)
			Editing(entries, commit);
			_search = search;
			_searchScroll = scroll;
			DrawItemPicker();
			search = _search;
			scroll = _searchScroll;
		}

		private static void DrawItemPicker()
		{
			//IL_00ab: 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_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)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			_search = GUILayout.TextField(_search, Styles.Field, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(22f) });
			if (GUILayout.Button("add", Styles.CellOff, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(52f),
				GUILayout.Height(22f)
			}))
			{
				AddFirstMatch();
			}
			GUILayout.EndHorizontal();
			if (_search.Trim().Length == 0)
			{
				return;
			}
			List<string> list = Matches(_search.Trim());
			if (list.Count == 0)
			{
				GUILayout.Label("   nothing matches", Styles.Dim, Array.Empty<GUILayoutOption>());
				return;
			}
			_searchScroll = GUILayout.BeginScrollView(_searchScroll, false, true, GUIStyle.none, GUI.skin.verticalScrollbar, Styles.List, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(120f) });
			foreach (string item in list)
			{
				if (GUILayout.Button(" " + ItemGroups.DisplayNameOf(item), Styles.Row, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(20f) }))
				{
					if (Event.current != null && Event.current.shift)
					{
						Refuse(item);
					}
					else
					{
						Toggle(item);
					}
					_search = "";
					_searchScroll = Vector2.zero;
					break;
				}
			}
			GUILayout.EndScrollView();
			Caption("shift-click to refuse an item instead of holding it");
		}

		public static void DrawItemChips(List<string> entries, Action commit, float windowWidth)
		{
			Editing(entries, commit);
			DrawItemChips(windowWidth);
		}

		private static void DrawItemChips(float WindowWidth)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (string item in _edit)
			{
				string text = ChestFilter.Bare(item);
				if (!ChestFilter.IsGroup(text) && !(text == "*"))
				{
					list.Add(item);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			GUILayout.Space(4f);
			float num = WindowWidth - 40f;
			float num2 = 0f;
			bool flag = false;
			string text2 = null;
			foreach (string item2 in list)
			{
				bool flag2 = ChestFilter.IsExclusion(item2);
				string text3 = ItemGroups.DisplayNameOf(ChestFilter.Bare(item2));
				string text4 = (flag2 ? ("not " + text3) : text3) + "  ×";
				float num3 = Styles.Chip.CalcSize(new GUIContent(text4)).x + 4f;
				if (!flag || num2 + num3 > num)
				{
					if (flag)
					{
						GUILayout.FlexibleSpace();
						GUILayout.EndHorizontal();
					}
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					flag = true;
					num2 = 0f;
				}
				if (GUILayout.Button(text4, Styles.Chip, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(num3),
					GUILayout.Height(20f)
				}))
				{
					text2 = item2;
				}
				num2 += num3 + 4f;
			}
			if (flag)
			{
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
			}
			if (text2 != null)
			{
				Toggle(text2);
			}
		}

		private static List<string> Matches(string text)
		{
			List<string> list = new List<string>();
			if ((Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_items == null)
			{
				return list;
			}
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (!((Object)(object)item == (Object)null) && list.Count < 60 && (ItemGroups.DisplayNameOf(((Object)item).name).IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)item).name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0) && !list.Contains(((Object)item).name))
				{
					list.Add(((Object)item).name);
				}
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			return list;
		}

		private static void AddFirstMatch()
		{
			//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)
			string text = _search.Trim();
			if (text.Length != 0)
			{
				List<string> list = Matches(text);
				if (list.Count != 0)
				{
					Toggle(list[0]);
					_search = "";
					_searchScroll = Vector2.zero;
				}
			}
		}

		private static void DrawFooter()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Learn from contents", Styles.CellOff, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
			{
				LearnFromContents();
			}
			GUILayout.Space(4f);
			if (GUILayout.Button("Clear", Styles.CellOff, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
			{
				_entries.Clear();
				CommitChest();
			}
			GUILayout.Space(4f);
			if (GUILayout.Button("Close", Styles.CellOff, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
			{
				Close();
			}
			GUILayout.EndHorizontal();
		}

		private static void LearnFromContents()
		{
			Editing(_entries, CommitChest);
			Inventory inventory = _container.GetInventory();
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				string text = ItemGroups.PrefabNameOf(allItem);
				if (text != null && !_edit.Contains(text))
				{
					_edit.Add(text);
				}
			}
			Commit();
		}

		private static void Toggle(string entry)
		{
			if (_edit.Contains(entry))
			{
				_edit.Remove(entry);
			}
			else
			{
				_edit.Add(entry);
			}
			Commit();
		}

		private static void Refuse(string entry)
		{
			string item = "-" + entry;
			_edit.Remove(entry);
			if (!_edit.Contains(item))
			{
				_edit.Add(item);
			}
			Commit();
		}

		private static void Cycle(string entry)
		{
			string item = "-" + entry;
			if (_edit.Contains(entry))
			{
				_edit.Remove(entry);
				_edit.Add(item);
			}
			else if (_edit.Contains(item))
			{
				_edit.Remove(item);
			}
			else
			{
				_edit.Add(entry);
			}
			Commit();
		}

		private static void Commit()
		{
			if (_save != null)
			{
				_save();
			}
		}

		private static void CommitChest()
		{
			ChestFilter.Write(_container, _entries);
			RulesButton.Refresh();
		}

		public static void Caption(string text)
		{
			GUILayout.Label(text, Styles.Caption, Array.Empty<GUILayoutOption>());
		}

		public static void Rule()
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(1f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, 1f), (Texture)(object)Styles.RuleLine);
			GUILayout.Space(5f);
		}
	}
	internal static class Flare
	{
		private const string FlareMaterial = "light_glow";

		private static GameObject _template;

		private static bool _searched;

		public static void Invalidate()
		{
			_template = null;
			_searched = false;
		}

		public static GameObject Attach(Transform parent, float scale)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Template();
			if ((Object)(object)val == (Object)null || (Object)(object)parent == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(val, parent, false);
			((Object)obj).name = "flare";
			obj.transform.localPosition = Vector3.zero;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = new Vector3(scale, scale, scale);
			obj.SetActive(true);
			return obj;
		}

		private static GameObject Template()
		{
			if ((Object)(object)_template != (Object)null || _searched)
			{
				return _template;
			}
			_searched = true;
			string[] array = (StowConfig.FlareDonors.Value ?? "").Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				GameObject val = PropIndex.Find(text);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				GameObject val2 = FindFlare(val);
				if (!((Object)(object)val2 == (Object)null))
				{
					_template = Clone(val2);
					if (!((Object)(object)_template == (Object)null))
					{
						StowRuntime.Log.LogInfo((object)("Flare borrowed from " + text + "/" + ((Object)val2).name + "."));
						return _template;
					}
				}
			}
			StowRuntime.Log.LogWarning((object)"No flare donor resolved - spirits will be lit but will not halo. Set FlareDonors to a prefab that has one.");
			return null;
		}

		private static GameObject FindFlare(GameObject donor)
		{
			Renderer[] componentsInChildren = donor.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Material sharedMaterial = val.sharedMaterial;
					if (!((Object)(object)sharedMaterial == (Object)null) && ((Object)sharedMaterial).name.StartsWith("light_glow"))
					{
						return ((Component)val).gameObject;
					}
				}
			}
			return null;
		}

		private static GameObject Clone(GameObject source)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("StowFlareTemplate");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			ZNetView.m_forceDisableInit = true;
			GameObject val2;
			try
			{
				val2 = Object.Instantiate<GameObject>(source, val.transform);
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			MonoBehaviour[] componentsInChildren = val2.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val3 in componentsInChildren)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val3);
				}
			}
			return val2;
		}
	}
	internal sealed class ItemGroup
	{
		public string Id;

		public string Display;

		public readonly HashSet<string> Members = new HashSet<string>();
	}
	internal static class ItemGroups
	{
		private static readonly List<ItemGroup> All = new List<ItemGroup>();

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

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

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

		private static bool _built;

		public static IList<ItemGroup> Groups
		{
			get
			{
				Build();
				return All;
			}
		}

		public static bool Ready
		{
			get
			{
				Build();
				return _built;
			}
		}

		public static void Invalidate()
		{
			_built = false;
			All.Clear();
			ById.Clear();
			SharedByPrefab.Clear();
			PrefabBySharedName.Clear();
		}

		public static ItemGroup Find(string id)
		{
			Build();
			if (!ById.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}

		public static string SharedNameOf(string prefabName)
		{
			Build();
			if (!SharedByPrefab.TryGetValue(prefabName, out var value))
			{
				return null;
			}
			return value;
		}

		public static string PrefabNameOf(ItemData item)
		{
			if (item == null || item.m_shared == null)
			{
				return null;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name;
			}
			Build();
			if (!PrefabBySharedName.TryGetValue(item.m_shared.m_name, out var value))
			{
				return null;
			}
			return value;
		}

		public static string DisplayNameOf(string prefabName)
		{
			Build();
			if (!SharedByPrefab.TryGetValue(prefabName, out var value))
			{
				return prefabName;
			}
			if (Localization.instance == null)
			{
				return value;
			}
			return Localization.instance.Localize(value);
		}

		private static void Build()
		{
			//IL_01f7: 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_01fe: 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_0267: Expected I4, but got Unknown
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Invalid comparison between Unknown and I4
			if (_built || (Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_items == null)
			{
				return;
			}
			All.Clear();
			ById.Clear();
			SharedByPrefab.Clear();
			PrefabBySharedName.Clear();
			ItemGroup ore = Group("ore", "Ore");
			ItemGroup bars = Group("bars", "Bars & ingots");
			ItemGroup fuel = Group("fuel", "Fuel");
			ItemGroup wood = Group("wood", "Wood");
			ItemGroup raw = Group("raw", "Raw food");
			ItemGroup itemGroup = Group("cooked", "Cooked food");
			ItemGroup itemGroup2 = Group("mead", "Mead & potions");
			ItemGroup itemGroup3 = Group("seeds", "Seeds & crops");
			ItemGroup itemGroup4 = Group("building", "Building materials");
			ItemGroup itemGroup5 = Group("material", "Crafting materials");
			ItemGroup itemGroup6 = Group("gear", "Weapons & armour");
			ItemGroup itemGroup7 = Group("ammo", "Ammo");
			ItemGroup itemGroup8 = Group("trophies", "Trophies");
			ItemGroup itemGroup9 = Group("fish", "Fish");
			ItemGroup itemGroup10 = Group("valuable", "Valuables");
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null) && component.m_itemData != null && component.m_itemData.m_shared != null)
				{
					SharedData shared = component.m_itemData.m_shared;
					SharedByPrefab[((Object)item).name] = shared.m_name;
					if (!PrefabBySharedName.ContainsKey(shared.m_name))
					{
						PrefabBySharedName[shared.m_name] = ((Object)item).name;
					}
					ItemType itemType = shared.m_itemType;
					switch (itemType - 1)
					{
					case 12:
						itemGroup8.Members.Add(shared.m_name);
						break;
					case 8:
					case 22:
						itemGroup7.Members.Add(shared.m_name);
						break;
					case 20:
						itemGroup9.Members.Add(shared.m_name);
						break;
					case 0:
						itemGroup5.Members.Add(shared.m_name);
						break;
					case 2:
					case 3:
					case 4:
					case 5:
					case 6:
					case 10:
					case 11:
					case 13:
					case 14:
					case 16:
					case 17:
					case 18:
					case 21:
					case 23:
						itemGroup6.Members.Add(shared.m_name);
						break;
					}
					if (shared.m_food > 0f)
					{
						itemGroup.Members.Add(shared.m_name);
					}
					else if ((int)shared.m_itemType == 2)
					{
						itemGroup2.Members.Add(shared.m_name);
					}
					if (shared.m_value > 0)
					{
						itemGroup10.Members.Add(shared.m_name);
					}
				}
			}
			ReadStations(ore, bars, fuel, raw, itemGroup, itemGroup2);
			ReadPieceTable("Hammer", itemGroup4);
			ReadPieceTable("Cultivator", itemGroup3);
			SplitFirewood(ore, bars, fuel, wood);
			All.RemoveAll((ItemGroup g) => g.Members.Count == 0);
			ById.Clear();
			foreach (ItemGroup item2 in All)
			{
				ById[item2.Id] = item2;
			}
			_built = All.Count > 0;
			if (!_built || StowConfig.Verbose == null || !StowConfig.Verbose.Value)
			{
				return;
			}
			foreach (ItemGroup item3 in All)
			{
				StowRuntime.Log.LogInfo((object)("group " + item3.Id + ": " + item3.Members.Count + " items"));
			}
		}

		private static ItemGroup Group(string id, string display)
		{
			ItemGroup itemGroup = new ItemGroup
			{
				Id = id,
				Display = display
			};
			All.Add(itemGroup);
			ById[id] = itemGroup;
			return itemGroup;
		}

		private static void ReadStations(ItemGroup ore, ItemGroup bars, ItemGroup fuel, ItemGroup raw, ItemGroup cooked, ItemGroup mead)
		{
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null || instance.m_prefabs == null)
			{
				return;
			}
			foreach (GameObject prefab in instance.m_prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Smelter component = prefab.GetComponent<Smelter>();
				if ((Object)(object)component != (Object)null)
				{
					Add(fuel, component.m_fuelItem);
					if (component.m_conversion != null)
					{
						foreach (ItemConversion item in component.m_conversion)
						{
							if (item != null)
							{
								Add(ore, item.m_from);
								Add(bars, item.m_to);
							}
						}
					}
				}
				CookingStation component2 = prefab.GetComponent<CookingStation>();
				if ((Object)(object)component2 != (Object)null)
				{
					Add(fuel, component2.m_fuelItem);
					if (component2.m_conversion != null)
					{
						foreach (ItemConversion item2 in component2.m_conversion)
						{
							if (item2 != null)
							{
								Add(raw, item2.m_from);
								Add(cooked, item2.m_to);
							}
						}
					}
				}
				Fireplace component3 = prefab.GetComponent<Fireplace>();
				if ((Object)(object)component3 != (Object)null)
				{
					Add(fuel, component3.m_fuelItem);
				}
				Fermenter component4 = prefab.GetComponent<Fermenter>();
				if (!((Object)(object)component4 != (Object)null) || component4.m_conversion == null)
				{
					continue;
				}
				foreach (ItemConversion item3 in component4.m_conversion)
				{
					if (item3 != null)
					{
						Add(mead, item3.m_from);
						Add(mead, item3.m_to);
					}
				}
			}
		}

		private static void ReadPieceTable(string toolPrefabName, ItemGroup into)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(toolPrefabName);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
			{
				return;
			}
			PieceTable buildPieces = component.m_itemData.m_shared.m_buildPieces;
			if ((Object)(object)buildPieces == (Object)null || buildPieces.m_pieces == null)
			{
				return;
			}
			foreach (GameObject piece in buildPieces.m_pieces)
			{
				if ((Object)(object)piece == (Object)null)
				{
					continue;
				}
				Piece component2 = piece.GetComponent<Piece>();
				if ((Object)(object)component2 == (Object)null || component2.m_resources == null)
				{
					continue;
				}
				Requirement[] resources = component2.m_resources;
				foreach (Requirement val in resources)
				{
					if (val != null)
					{
						Add(into, val.m_resItem);
					}
				}
			}
		}

		private static void SplitFirewood(ItemGroup ore, ItemGroup bars, ItemGroup fuel, ItemGroup wood)
		{
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null || instance.m_prefabs == null)
			{
				return;
			}
			foreach (GameObject prefab in instance.m_prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Smelter component = prefab.GetComponent<Smelter>();
				if ((Object)(object)component == (Object)null || component.m_conversion == null)
				{
					continue;
				}
				foreach (ItemConversion item in component.m_conversion)
				{
					if (item == null || (Object)(object)item.m_from == (Object)null || (Object)(object)item.m_to == (Object)null)
					{
						continue;
					}
					string text = SharedNameOfDrop(item.m_to);
					if (text != null && fuel.Members.Contains(text))
					{
						string text2 = SharedNameOfDrop(item.m_from);
						if (text2 != null)
						{
							ore.Members.Remove(text2);
							bars.Members.Remove(text);
							wood.Members.Add(text2);
						}
					}
				}
			}
		}

		private static void Add(ItemGroup group, ItemDrop drop)
		{
			string text = SharedNameOfDrop(drop);
			if (text != null)
			{
				group.Members.Add(text);
			}
		}

		private static string SharedNameOfDrop(ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null || drop.m_itemData == null || drop.m_itemData.m_shared == null)
			{
				return null;
			}
			return drop.m_itemData.m_shared.m_name;
		}
	}
	internal static class PostModel
	{
		public const string GlowGroup = "core";

		private static readonly Dictionary<string, string[]> Donors = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"wood",
				new string[3] { "wood_wall", "wood_beam", "piece_chest_wood" }
			},
			{
				"iron",
				new string[5] { "piece_cauldron", "piece_chest_blackmetal", "forge", "blackforge", "piece_stonecutter" }
			},
			{
				"stone",
				new string[3] { "stone_wall_2x1", "piece_stonecutter", "smelter" }
			}
		};

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

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

		public const string HeartwoodAnchor = "heartwood";

		private static string ModelFile => StowConfig.PostModelFile.Value;

		private static string ColliderFile => Path.ChangeExtension(ModelFile, ".col");

		public static bool Apply(GameObject prefab)
		{
			return Apply(prefab, ModelFile, "post_visual", heartwood: true);
		}

		public static bool Apply(GameObject prefab, string modelFile, string visualName, bool heartwood)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00a9: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			string directoryName = Path.GetDirectoryName(typeof(PostModel).Assembly.Location);
			ModelData modelData = ObjMesh.Load(Path.Combine(directoryName, modelFile));
			if (modelData == null || (Object)(object)modelData.Mesh == (Object)null)
			{
				StowRuntime.Log.LogWarning((object)("No " + modelFile + " beside the dll - falling back to the donor's own look."));
				return false;
			}
			MeshRenderer[] componentsInChildren = prefab.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
				}
			}
			GameObject val2 = new GameObject(visualName);
			val2.transform.SetParent(prefab.transform, false);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			val2.AddComponent<MeshFilter>().sharedMesh = modelData.Mesh;
			((Renderer)val2.AddComponent<MeshRenderer>()).sharedMaterials = SkinsFor(modelData.Groups);
			Remap(modelData.Mesh, modelData.Groups);
			if (heartwood)
			{
				Heartwood(prefab, val2.transform, modelData);
			}
			ReplaceColliders(prefab, Path.Combine(directoryName, Path.ChangeExtension(modelFile, ".col")));
			StowRuntime.Log.LogInfo((object)string.Format("{0} loaded: {1} verts, {2} tris, groups [{3}].", modelFile, modelData.Mesh.vertexCount, modelData.Mesh.triangles.Length / 3, string.Join(", ", modelData.Groups)));
			return true;
		}

		private static void Heartwood(GameObject prefab, Transform visual, ModelData model)
		{
			//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_006d: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//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_008b: 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: Expected O, but got Unknown
			//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_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_00f2: 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)
			int num = Array.FindIndex(model.Groups, (string group) => string.Equals(group, "core", StringComparison.OrdinalIgnoreCase));
			if (num < 0)
			{
				return;
			}
			int[] triangles = model.Mesh.GetTriangles(num);
			if (triangles != null && triangles.Length != 0)
			{
				Vector3[] vertices = model.Mesh.vertices;
				Vector3 val = vertices[triangles[0]];
				Vector3 val2 = val;
				int[] array = triangles;
				foreach (int num3 in array)
				{
					val = Vector3.Min(val, vertices[num3]);
					val2 = Vector3.Max(val2, vertices[num3]);
				}
				GameObject val3 = new GameObject("heartwood");
				val3.transform.SetParent(visual, false);
				val3.transform.localPosition = (val + val2) * 0.5f;
				Light obj = val3.AddComponent<Light>();
				obj.type = (LightType)2;
				obj.range = StowConfig.PostLightRange.Value;
				obj.color = Carrier.LightColour;
				obj.intensity = StowConfig.PostLightIntensity.Value;
				obj.shadows = (LightShadows)0;
				Flare.Attach(val3.transform, StowConfig.PostFlareScale.Value);
				StowRuntime.Log.LogInfo((object)("Heartwood found at " + ((object)val3.transform.localPosition/*cast due to .constrained prefix*/).ToString() + " - the post is lit and the spirit starts there."));
			}
		}

		public static Material[] SkinsFor(string[] groups)
		{
			Material[] array = (Material[])(object)new Material[groups.Length];
			for (int i = 0; i < groups.Length; i++)
			{
				array[i] = Borrow(groups[i]);
				if ((Object)(object)array[i] == (Object)null)
				{
					StowRuntime.Log.LogWarning((object)("No material found for group '" + groups[i] + "'."));
				}
			}
			return array;
		}

		public static void Invalidate()
		{
			Cache.Clear();
			Atlas.Clear();
		}

		private static Material Borrow(string group)
		{
			//IL_00c3: 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 (Cache.TryGetValue(group, out var value))
			{
				return value;
			}
			string[] array = DonorsFor(group);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				GameObject val = PropIndex.Find(text);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				MeshRenderer[] componentsInChildren = val.GetComponentsInChildren<MeshRenderer>(true);
				foreach (MeshRenderer val2 in componentsInChildren)
				{
					Material sharedMaterial = ((Renderer)val2).sharedMaterial;
					if (!((Object)(object)sharedMaterial == (Object)null) && !((Object)(object)sharedMaterial.shader == (Object)null) && sharedMaterial.HasProperty("_MainTex") && !((Object)(object)sharedMaterial.GetTexture("_MainTex") == (Object)null))
					{
						Cache[group] = sharedMaterial;
						Atlas[group] = UvRegion((Renderer)(object)val2);
						StowRuntime.Log.LogInfo((object)$"Group '{group}' skinned with {((Object)sharedMaterial).name} from {text} (shader {((Object)sharedMaterial.shader).name}), atlas {Atlas[group]}.");
						return sharedMaterial;
					}
				}
			}
			Cache[group] = null;
			return null;
		}

		private static string[] DonorsFor(string group)
		{
			if (string.Equals(group, "core", StringComparison.OrdinalIgnoreCase))
			{
				return (StowConfig.PostGlowDonors.Value ?? "").Split(new char[1] { ',' });
			}
			if (!Donors.TryGetValue(group, out var value))
			{
				return Donors["wood"];
			}
			return value;
		}

		private static Rect UvRegion(Renderer renderer)
		{
			//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_020f: 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_0055: 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_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_0093: 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_020a: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(0f, 0f, 1f, 1f);
			MeshFilter val2 = (((Object)(object)renderer != (Object)null) ? ((Component)renderer).GetComponent<MeshFilter>() : null);
			Mesh val3 = (((Object)(object)val2 != (Object)null) ? val2.sharedMesh : null);
			if ((Object)(object)val3 == (Object)null)
			{
				return val;
			}
			Vector2[] uv;
			int[] triangles;
			try
			{
				if (!val3.isReadable)
				{
					return val;
				}
				uv = val3.uv;
				triangles = val3.triangles;
			}
			catch
			{
				return val;
			}
			if (uv == null || uv.Length == 0 || triangles == null || triangles.Length < 3)
			{
				return val;
			}
			float num = 0f;
			Rect result = val;
			for (int i = 0; i + 2 < triangles.Length; i += 3)
			{
				int num2 = triangles[i];
				int num3 = triangles[i + 1];
				int num4 = triangles[i + 2];
				if (num2 >= uv.Length || num3 >= uv.Length || num4 >= uv.Length)
				{
					continue;
				}
				float num5 = Mathf.Min(uv[num2].x, Mathf.Min(uv[num3].x, uv[num4].x));
				float num6 = Mathf.Max(uv[num2].x, Mathf.Max(uv[num3].x, uv[num4].x));
				float num7 = Mathf.Min(uv[num2].y, Mathf.Min(uv[num3].y, uv[num4].y));
				float num8 = Mathf.Max(uv[num2].y, Mathf.Max(uv[num3].y, uv[num4].y));
				float num9 = num6 - num5;
				float num10 = num8 - num7;
				if (!(num9 <= 0.005f) && !(num10 <= 0.005f) && !(num9 > 1f) && !(num10 > 1f))
				{
					float num11 = num9 * num10;
					if (!(num11 <= num))
					{
						num = num11;
						((Rect)(ref result))..ctor(num5, num7, num9, num10);
					}
				}
			}
			if (!(num > 0f))
			{
				return val;
			}
			return result;
		}

		public static void Remap(Mesh mesh, string[] groups)
		{
			//IL_00e6: 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)
			if ((Object)(object)mesh == (Object)null || groups == null)
			{
				return;
			}
			Vector2[] uv = mesh.uv;
			if (uv == null || uv.Length == 0)
			{
				return;
			}
			int num = Mathf.Min(groups.Length, mesh.subMeshCount);
			int num2 = 0;
			bool[] array = new bool[uv.Length];
			for (int i = 0; i < num; i++)
			{
				if (!Atlas.TryGetValue(groups[i], out var value) || (((Rect)(ref value)).width >= 0.999f && ((Rect)(ref value)).height >= 0.999f))
				{
					continue;
				}
				int[] triangles = mesh.GetTriangles(i);
				foreach (int num3 in triangles)
				{
					if (num3 >= 0 && num3 < uv.Length && !array[num3])
					{
						array[num3] = true;
						uv[num3] = new Vector2(((Rect)(ref value)).x + Mathf.Clamp01(uv[num3].x) * ((Rect)(ref value)).width, ((Rect)(ref value)).y + Mathf.Clamp01(uv[num3].y) * ((Rect)(ref value)).height);
					}
				}
				num2++;
			}
			if (num2 != 0)
			{
				mesh.uv = uv;
				StowRuntime.Log.LogInfo((object)("Remapped UVs into the atlas for " + num2 + " group(s)."));
			}
		}

		private static void ReplaceColliders(GameObject prefab, string path)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0117: 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)
			if (!File.Exists(path))
			{
				StowRuntime.Log.LogWarning((object)"No collider file beside the dll - keeping the donor's collision.");
				return;
			}
			List<string[]> list = new List<string[]>();
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0 && !text.StartsWith("#"))
				{
					string[] array2 = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
					if (array2.Length >= 7 && array2[0] == "box")
					{
						list.Add(array2);
					}
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			Collider[] componentsInChildren = prefab.GetComponentsInChildren<Collider>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			GameObject val = new GameObject("post_collision");
			val.transform.SetParent(prefab.transform, false);
			foreach (string[] item in list)
			{
				BoxCollider obj = val.AddComponent<BoxCollider>();
				obj.center = new Vector3(float.Parse(item[1], invariantCulture), float.Parse(item[2], invariantCulture), float.Parse(item[3], invariantCulture));
				obj.size = new Vector3(float.Parse(item[4], invariantCulture), float.Parse(item[5], invariantCulture), float.Parse(item[6], invariantCulture));
			}
			StowRuntime.Log.LogInfo((object)("Post collision: " + list.Count + " boxes."));
		}
	}
	internal static class PostRules
	{
		public enum Presence
		{
			OnlyWorking,
			LivesHere
		}

		private const string ZFetch = "stowFetch";

		private const string ZTidy = "stowTidy";

		private const string ZPresence = "stowPresence";

		public static List<string> Fetch(Container container)
		{
			return Clean(Read(container, "stowFetch"));
		}

		public static void SetFetch(Container container, IEnumerable<string> entries)
		{
			Write(container, "stowFetch", string.Join(",", Clean(entries).ToArray()));
		}

		public static bool Wants(Container post, ItemData item)
		{
			List<string> list = Fetch(post);
			if (list.Count == 0)
			{
				return false;
			}
			return ChestFilter.Matches(list, item);
		}

		public static bool Tidy(Container container)
		{
			return Read(container, "stowTidy") == "1";
		}

		public static void SetTidy(Container container, bool on)
		{
			Write(container, "stowTidy", on ? "1" : "");
		}

		public static Presence Where(Container container)
		{
			if (!(Read(container, "stowPresence") == "1"))
			{
				return Presence.OnlyWorking;
			}
			return Presence.LivesHere;
		}

		public static void SetPresence(Container container, Presence presence)
		{
			Write(container, "stowPresence", (presence == Presence.LivesHere) ? "1" : "");
		}

		private static string Read(Container container, string key)
		{
			ZNetView val = (((Object)(object)container == (Object)null) ? null : ((Component)container).GetComponent<ZNetView>());
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				return val.GetZDO().GetString(key, "");
			}
			return "";
		}

		private static void Write(Container container, string key, string value)
		{
			ZNetView val = (((Object)(object)container == (Object)null) ? null : ((Component)container).GetComponent<ZNetView>());
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				val.ClaimOwnership();
				val.GetZDO().Set(key, value ?? "");
			}
		}

		private static List<string> Clean(IEnumerable<string> entries)
		{
			List<string> list = new List<string>();
			if (entries == null)
			{
				return list;
			}
			foreach (string entry in entries)
			{
				if (entry != null)
				{
					string text = entry.Trim();
					if (text.Length != 0 && !list.Contains(text))
					{
						list.Add(text);
					}
				}
			}
			return list;
		}

		private static List<string> Clean(string packed)
		{
			return Clean((packed ?? "").Split(new char[1] { ',' }));
		}
	}
	internal static class RulesButton
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__OnPressed;
		}

		private static Button _button;

		private static TMP_Text _label;

		public static void Sync(InventoryGui gui, Container container)
		{
			if (!((Object)(object)gui == (Object)null) && (!((Object)(object)_button == (Object)null) || Build(gui)))
			{
				bool flag = (Object)(object)container != (Object)null && !StowPost.Is(container);
				if (((Component)_button).gameObject.activeSelf != flag)
				{
					((Component)_button).gameObject.SetActive(flag);
				}
				if (flag)
				{
					int count = ChestFilter.Entries(container).Count;
					_label.text = ((count == 0) ? "Holds…" : ("Holds " + count));
				}
			}
		}

		public static void Hide()
		{
			if ((Object)(object)_button != (Object)null)
			{
				((Component)_button).gameObject.SetActive(false);
			}
		}

		public static void Refresh()
		{
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Sync(instance, StowPatches.CurrentContainer(instance));
			}
		}

		private static bool Build(InventoryGui gui)
		{
			//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_0088: Expected O, but got Unknown
			//IL_00f3: 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_0103: 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)
			Button stackAllButton = gui.m_stackAllButton;
			if ((Object)(object)stackAllButton == (Object)null)
			{
				return false;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)stackAllButton).gameObject, ((Component)stackAllButton).transform.parent);
			((Object)val).name = "StowRulesButton";
			_button = val.GetComponent<Button>();
			if ((Object)(object)_button == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return false;
			}
			((UnityEventBase)_button.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = _button.onClick;
			object obj = <>O.<0>__OnPressed;
			if (obj == null)
			{
				UnityAction val2 = OnPressed;
				<>O.<0>__OnPressed = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			_label = val.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)_label != (Object)null)
			{
				_label.text = "Holds…";
				Localize component = ((Component)_label).GetComponent<Localize>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
			}
			RectTransform component2 = val.GetComponent<RectTransform>();
			RectTransform component3 = ((Component)stackAllButton).GetComponent<RectTransform>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component3 != (Object)null)
			{
				Vector2 anchoredPosition = component3.anchoredPosition;
				Rect rect = component3.rect;
				component2.anchoredPosition = anchoredPosition - new Vector2(0f, ((Rect)(ref rect)).height + 4f);
			}
			StowRuntime.Log.LogInfo((object)"Rules button added to the container window.");
			return true;
		}

		private static void OnPressed()
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Container val = StowPatches.CurrentContainer(instance);
			if (!((Object)(object)val == (Object)null))
			{
				if (FilterPanel.IsOpen)
				{
					FilterPanel.Close();
				}
				else
				{
					FilterPanel.Open(val);
				}
			}
		}
	}
	internal static class SpiritTrips
	{
		public struct Flight
		{
			public Vector3 From;

			public Vector3 Control;

			public Vector3 To;

			public double Start;

			public float Duration;

			public string Cargo;

			public double EndsAt => Start + (double)Duration;

			public Vector3 At(double now)
			{
				//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_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_0067: 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_007a: Unknown result type (might be due to invalid IL or missing references)
				float num = ((Duration <= 0f) ? 1f : Mathf.Clamp01((float)((now - Start) / (double)Duration)));
				num = num * num * (3f - 2f * num);
				float num2 = 1f - num;
				return num2 * num2 * From + 2f * num2 * num * Control + num * num * To;
			}
		}

		public const string ZTrips = "stowTrips";

		private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;

		public static double Now
		{
			get
			{
				if (!((Object)(object)ZNet.instance != (Object)null))
				{
					return Time.time;
				}
				return ZNet.instance.GetTimeSeconds();
			}
		}

		public static string Read(ZNetView nview)
		{
			if (!((Object)(object)nview == (Object)null) && nview.IsValid())
			{
				return nview.GetZDO().GetString("stowTrips", "");
			}
			return "";
		}

		public static void Publish(ZNetView nview, string trips)
		{
			if (!((Object)(object)nview == (Object)null) && nview.IsValid() && !(Read(nview) == trips))
			{
				nview.GetZDO().Set("stowTrips", trips ?? "");
			}
		}

		public static string Encode(IEnumerable<Flight> flights)
		{
			//IL_002d: 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)
			StringBuilder stringBuilder = new StringBuilder();
			foreach (Flight flight in flights)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(';');
				}
				Vector(stringBuilder, flight.From);
				stringBuilder.Append(':');
				Vector(stringBuilder, flight.Control);
				stringBuilder.Append(':');
				Vector(stringBuilder, flight.To);
				stringBuilder.Append(':');
				stringBuilder.Append(flight.Cargo ?? "").Append(':');
				double start = flight.Start;
				stringBuilder.Append(start.ToString("0.###", Culture)).Append(':');
				float duration = flight.Duration;
				stringBuilder.Append(duration.ToString("0.###", Culture));
			}
			return stringBuilder.ToString();
		}

		public static List<Flight> Decode(string text)
		{
			//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_00af: 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)
			List<Flight> list = new List<Flight>();
			if (string.IsNullOrEmpty(text))
			{
				return list;
			}
			string[] array = text.Split(new char[1] { ';' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ':' });
				if (array2.Length == 6 && Vector(array2[0], out var value) && Vector(array2[1], out var value2) && Vector(array2[2], out var value3) && double.TryParse(array2[4], NumberStyles.Float, Culture, out var result) && float.TryParse(array2[5], NumberStyles.Float, Culture, out var result2))
				{
					list.Add(new Flight
					{
						From = value,
						Control = value2,
						To = value3,
						Cargo = array2[3],
						Start = result,
						Duration = result2
					});
				}
			}
			return list;
		}

		private static void Vector(StringBuilder text, Vector3 value)
		{
			text.Append(value.x.ToString("0.##", Culture)).Append(',').Append(value.y.ToString("0.##", Culture))
				.Append(',')
				.Append(value.z.ToString("0.##", Culture));
		}

		private static bool Vector(string text, out Vector3 value)
		{
			//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_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)
			value = Vector3.zero;
			string[] array = (text ?? "").Split(new char[1] { ',' });
			if (array.Length != 3)
			{
				return false;
			}
			if (!float.TryParse(array[0], NumberStyles.Float, Culture, out var result))
			{
				return false;
			}
			if (!float.TryParse(array[1], NumberStyles.Float, Culture, out var result2))
			{
				return false;
			}
			if (!float.TryParse(array[2], NumberStyles.Float, Culture, out var result3))
			{
				return false;
			}
			value = new Vector3(result, result2, result3);
			return true;
		}
	}
	internal class SpiritView
	{
		private readonly StowPost _post;

		private readonly List<Carrier> _spirits = new List<Carrier>();

		private string _showing = "";

		public SpiritView(StowPost post)
		{
			_post = post;
		}

		public void Tick()
		{
			ZNetView val = (((Object)(object)_post != (Object)null) ? ((Component)_post).GetComponent<ZNetView>() : null);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				Clear();
				return;
			}
			if (!StowConfig.CarrierEnabled.Value)
			{
				Clear();
				return;
			}
			string text = SpiritTrips.Read(val);
			if (!(text == _showing))
			{
				_showing = text;
				Show(SpiritTrips.Decode(text));
			}
		}

		public void Clear()
		{
			if (_spirits.Count == 0 && _showing.Length == 0)
			{
				return;
			}
			foreach (Carrier spirit in _spirits)
			{
				if ((Object)(object)spirit != (Object)null)
				{
					spirit.Dismiss();
				}
			}
			_spirits.Clear();
			_showing = "";
		}

		private void Show(List<SpiritTrips.Flight> flights)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			for (int num = _spirits.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_spirits[num] == (Object)null)
				{
					_spirits.RemoveAt(num);
				}
			}
			while (_spirits.Count > flights.Count)
			{
				int index = _spirits.Count - 1;
				if ((Object)(object)_spirits[index] != (Object)null)
				{
					_spirits[index].Dismiss();
				}
				_spirits.RemoveAt(index);
			}
			while (_spirits.Count < flights.Count)
			{
				Carrier carrier = CarrierModel.Build(flights[_spirits.Count].From);
				if ((Object)(object)carrier == (Object)null)
				{
					return;
				}
				_spirits.Add(carrier);
			}
			for (int i = 0; i < flights.Count; i++)
			{
				if (!((Object)(object)_spirits[i] == (Object)null))
				{
					_spirits[i].Follow(flights[i]);
					_spirits[i].Carry(Cargo(flights[i].Cargo));
				}
			}
		}

		private static GameObject Cargo(string prefabName)
		{
			if (!string.IsNullOrEmpty(prefabName))
			{
				return CarriedItem.For(prefabName);
			}
			return null;
		}
	}
	internal static class StowConfig
	{
		public static ConfigEntry<bool> PostEnabled;

		public static ConfigEntry<string> PostName;

		public static ConfigEntry<string> PostCost;

		public static ConfigEntry<int> PostWidth;

		public static ConfigEntry<int> PostHeight;

		public static ConfigEntry<string> PostDonor;

		public static ConfigEntry<string> PostModelFile;

		public static ConfigEntry<float> PostScale;

		public static ConfigEntry<string> LookForProps;

		public static ConfigEntry<float> Range;

		public static ConfigEntry<bool> MatchContents;

		public static ConfigEntry<bool> Messages;

		public static ConfigEntry<bool> CarrierEnabled;

		public static ConfigEntry<int> Couriers;

		public static ConfigEntry<float> CarrierSpeed;

		public static ConfigEntry<float> CarrierPause;

		public static ConfigEntry<int> ItemsPerTrip;

		public static ConfigEntry<float> CarrierCruise;

		public static ConfigEntry<float> CarrierScale;

		public static ConfigEntry<string> PostGlowDonors;

		public static ConfigEntry<string> FlareDonors;

		public static ConfigEntry<float> PostLightRange;

		public static ConfigEntry<float> PostLightIntensity;

		public static ConfigEntry<float> PostFlareScale;

		public static ConfigEntry<KeyboardShortcut> KeyStow;

		public static ConfigEntry<KeyboardShortcut> KeyConfigure;

		public static ConfigEntry<bool> KeepHotbar;

		public static ConfigEntry<string> NeverStow;

		public static ConfigEntry<bool> Verbose;

		public static void Bind(ConfigFile config)
		{
			//IL_02da: 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)
			PostEnabled = config.Bind<bool>("Post", "PostEnabled", true, "Add the stowing post to the hammer.");
			PostName = config.Bind<string>("Post", "PostName", "Stowing post", "What the piece and its window are called.");
			PostCost = config.Bind<string>("Post", "PostCost", "FineWood:20,IronNails:20", "What it costs to build, as Item:Amount pairs. Nails put it past the forge rather than in the first camp: a post that sorts a storage room should arrive when there is a storage room to sort. An item name that does not resolve is logged and skipped, which makes the post cheaper rather than unbuildable - check the log after editing this.");
			PostWidth = config.Bind<int>("Post", "PostWidth", 6, "Slots across. Wide and shallow on purpose: the post is a table you pass things over, not somewhere to keep them.");
			PostHeight = config.Bind<int>("Post", "PostHeight", 2, "Slots down.");
			PostDonor = config.Bind<string>("Post", "PostDonor", "piece_chest_wood", "The vanilla piece the post is cloned from. It keeps the donor's Container, Piece and WearNTear - only the label and the visuals change.");
			PostModelFile = config.Bind<string>("Post", "PostModelFile", "stow_post_canopy.obj", "The hand-built mesh the post wears, beside the dll. Its .col sidecar and its _icon.png are picked up automatically, and wherever its `core` group sits is where the post is lit and where the spirit is born - so a different model moves all three without anything here changing. The plain shapes from tools/post_designs.py ship alongside it: stow_post_rack.obj, stow_post_chute.obj, stow_post_table.obj, stow_post_barrow.obj - none of those carry a heartwood.");
			PostScale = config.Bind<float>("Post", "PostScale", 1f, "Scale of the whole piece.");
			LookForProps = config.Bind<string>("Post", "LookForProps", "", "Comma-separated words. On startup, logs every loaded prop whose name contains one. Nothing is grafted from these - the post's shape is its own - but each material group is skinned from a real vanilla prefab, and this is how to find one worth borrowing from. Try: wood, forge, stone.");
			Range = config.Bind<float>("Sorting", "Range", 12f, "How far a chest may be from the post and still be stowed into. Measured from the post, through walls - a storage room is still one room when the shelves are behind a pillar.");
			MatchContents = config.Bind<bool>("Sorting", "MatchContents", true, "Let a chest that has been given no rules still take more of what it already holds. This is what makes the mod useful before you have configured anything, and it is the lowest-priority match: any chest that actually asked for the item wins over one that merely has some.");
			Messages = config.Bind<bool>("Sorting", "Messages", true, "Corner message summarising what went where. With the carrier on this arrives when the last trip lands, not when you close the post.");
			CarrierEnabled = config.Bind<bool>("Carrier", "CarrierEnabled", true, "A spirit carries the items to the chests, one stack per trip, instead of the post emptying itself the instant you close it. Turn this off and the post goes back to moving everything at once - the sorting is identical either way, only the waiting changes.");
			Couriers = config.Bind<int>("Carrier", "Couriers", 1, "How many spirits a post flies at once. One is the deliberate default: the point is watching a thing carry a thing, and three of them make it a conveyor belt. Raise it if a post that serves twenty chests takes longer to clear than you want to stand there.");
			CarrierSpeed = config.Bind<float>("Carrier", "CarrierSpeed", 2.6f, "Metres per second in the air. A brisk walk. Faster than a run and the trip is over before you have looked at it.");
			CarrierPause = config.Bind<float>("Carrier", "CarrierPause", 0.5f, "Seconds spent hovering at each end, loading and unloading. Without a pause the spirit bounces off the chest and the delivery is invisible.");
			ItemsPerTrip = config.Bind<int>("Carrier", "ItemsPerTrip", 10, "How many items a spirit carries in one trip. A stack of fifty wood leaves the post ten at a time and takes five trips, so a big load looks like a big load rather than crossing the room in one go. 0 carries the whole stack however large, which is what this did before. This is the number the post upgrades are meant to raise.");
			CarrierCruise = config.Bind<float>("Carrier", "CarrierCruise", 1.1f, "How high above the higher end it arcs. This is what carries it over furniture and walls: it flies rather than walks, so nothing here has to know what pathing is.");
			CarrierScale = config.Bind<float>("Carrier", "CarrierScale", 0.62f, "Scale of the spirit.\nThe carrier is the Vaettir spirit and now wears its mesh exactly, which is built knee-to-chest rather than the forearm-across copy Stow used to generate for itself. 0.62 is that ratio, so the carrier is the size it has always been on screen and the only thing that changed is the model underneath being the right one.\nSet it to 1 for a full-size spirit. That is the honest reading - it is the same being either way - but it is a large thing to have crossing a storage room with a crate under it, so the default keeps what was already there rather than resizing anyone's post without asking.");
			PostLightRange = config.Bind<float>("Post", "PostLightRange", 7f, "How far the heartwood in the post throws light. It is a lamp in a storage room as well as a component, and this is the number that decides which.");
			PostLightIntensity = config.Bind<float>("Post", "PostLightIntensity", 1.15f, "Brightness of that light. The mesh itself does not glow - vanilla paints emission into a texture and a borrowed material lands our UVs on the black part of it - so this and the flare are the whole effect.");
			PostFlareScale = config.Bind<float>("Post", "PostFlareScale", 0.75f, "Size of the halo on the post's heartwood, relative to the donor's own. The dvergr lantern it is lifted from is a metre and a bit across.");
			FlareDonors = config.Bind<string>("Carrier", "FlareDonors", "piece_dvergr_lantern,guard_stone,piece_walltorch,fire_pit", "Prefabs to lift the halo off, best first. What is taken is the child named flare - a ParticleSystem wearing light_glow - which is how every glowing thing in the game actually reads as glowing. The mesh's own emission is a painted texture that is almost entirely black, so a borrowed emissive material lands our UVs on the black part and does nothing. The lantern is first because its flare is a single soft halo; guard_stone works but hangs four other billboards off itself.");
			PostGlowDonors = config.Bind<string>("Post", "PostGlowDonors", "piece_dvergr_lantern,guard_stone,piece_walltorch,fire_pit", "Prefabs to lift the post's glowing recess from, best first - the first that resolves and has an albedo wins. This used to skin the carrying spirit too, under the name CarrierGlowDonors, and the two spirits came out wearing different materials from different lists: the one you commune with took stone from fire_pit and the one carrying your ore took the dvergr lantern's metal. They are one creature, so the carrier reads Spirit/GlowDonors now and this list serves only the post. The old comment here called fire_pit leading the list a real bug, on the grounds that a fire pit's first material with an albedo is its stones. It is - and that is what the better-looking spirit is wearing.");
			KeyStow = config.Bind<KeyboardShortcut>("Keys", "KeyStow", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Optional. Empties your pack into the chests around you from wherever you stand, skipping the post entirely. Unbound by default.");
			KeyConfigure = config.Bind<KeyboardShortcut>("Keys", "KeyConfigure", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Optional. Look at a chest and press this to say what it holds. Unbound by default because the chest window has a button for it.");
			KeepHotbar = config.Bind<bool>("Keys", "KeepHotbar", true, "For KeyStow only: leave the hotbar row alone. Your axe and your food live there on purpose. A post takes whatever you put in it, hotbar or not, because putting it in was already the decision.");
			NeverStow = config.Bind<string>("Keys", "NeverStow", "Hammer,Hoe,Cultivator", "For KeyStow only: prefab names that never leave your pack. Comma-separated.");
			Verbose = GroveConfig.Verbose;
		}
	}
	internal class StowPost : MonoBehaviour, Hoverable
	{
		public const string Name = "stow_post";

		private static readonly List<StowPost> All = new List<StowPost>();

		private static GameObject _prefab;

		private static GameObject _holder;

		private Piece _piece;

		private Container _container;

		private CarryRun _run;

		private SpiritView _view;

		public static bool Ready
		{
			get
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab("stow_post") != (Object)null;
				}
				return false;
			}
		}

		public Container Container => _container;

		private void Awake()
		{
			_piece = ((Component)this).GetComponent<Piece>();
			_container = ((Component)this).GetComponent<Container>();
			_run = new CarryRun(this);
			_view = new SpiritView(this);
			All.Add(this);
		}

		private void OnDestroy()
		{
			if (_view != null)
			{
				_view.Clear();
			}
			if (_run != null)
			{
				_run.Abandon();
			}
			All.Remove(this);
		}

		private void Update()
		{
			if ((Object)(object)_container == (Object)null)
			{
				return;
			}
			if (!StowConfig.CarrierEnabled.Value)
			{
				if (_run != null)
				{
					_run.Abandon();
				}
				if (_view != null)
				{
					_view.Clear();
				}
			}
			else
			{
				if (_run != null)
				{
					_run.Tick();
				}
				if (_view != null)
				{
					_view.Tick();
				}
			}
		}

		public static bool Is(Container container)
		{
			if ((Object)(object)container != (Object)null)
			{
				return (Object)(object)((Component)container).GetComponent<StowPost>() != (Object)null;
			}
			return false;
		}

		public string GetHoverName()
		{
			if (!((Object)(object)_piece != (Object)null))
			{
				return StowConfig.PostName.Value;
			}
			return _piece.m_name;
		}

		public string GetHoverText()
		{
			string hoverName = GetHoverName();
			int num = (((Object)(object)_container != (Object)null && _container.GetInventory() != null) ? _container.GetInventory().NrOfItems() : 0);
			string text = ((_run != null && _run.Working) ? (hoverName + " ( carrying " + num + " )") : ((num != 0) ? (hoverName + " ( " + num + " with nowhere to go )") : hoverName));
			return Localization.instance.Localize(text + "\n[<color=yellow><b>$KEY_Use</b></color>] $piece_container_open");
		}

		public void Empty()
		{
			if ((Object)(object)_container == (Object)null)
			{
				return;
			}
			Inventory inventory = _container.GetInventory();
			if (inventory == null || inventory.NrOfItems() == 0)
			{
				return;
			}
			ZNetView component = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return;
			}
			component.ClaimOwnership();
			if (_run != null)
			{
				if (StowConfig.CarrierEnabled.Value)
				{
					_run.Wake();
				}
				else
				{
					_run.Instant(inventory);
				}
			}
		}

		public static bool Register()
		{
			if (!StowConfig.PostEnabled.Value)
			{
				return true;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			if (Ready && InHammer())
			{
				return true;
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = Build();
				if ((Object)(object)_prefab == (Object)null)
				{
					return false;
				}
			}
			AddToScene();
			AddToHammer();
			return Ready;
		}

		private static GameObject Donor()
		{
			ZNetScene instance = ZNetScene.instance;
			string[] array = new string[2]
			{
				StowConfig.PostDonor.Value,
				"piece_chest_wood"
			};
			foreach (string text in array)
			{
				if (!string.IsNullOrEmpty(text))
				{
					GameObject prefab = instance.GetPrefab(text);
					if ((Object)(object)prefab != (Object)null)
					{
						return prefab;
					}
					StowRuntime.Log.LogWarning((object)("Post donor '" + text + "' does not exist."));
				}
			}
			return null;
		}

		private static GameObject Build()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0079: 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_0127: 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)
			GameObject val = Donor();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_holder == (Object)null)
			{
				_holder = new GameObject("StowPostHolder");
				_holder.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_holder);
			}
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			ZNetView.m_forceDisableInit = true;
			GameObject val2;
			try
			{
				val2 = Object.Instantiate<GameObject>(val, _holder.transform);
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			((Object)val2).name = "stow_post";
			val2.transform.localRotation = Quaternion.identity;
			Container component = val2.GetComponent<Container>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = StowConfig.PostName.Value;
				component.m_width = Mathf.Clamp(StowConfig.PostWidth.Value, 1, 8);
				component.m_height = Mathf.Clamp(StowConfig.PostHeight.Value, 1, 4);
				component.m_autoDestroyEmpty = false;
				component.m_privacy = (PrivacySetting)2;
			}
			Piece component2 = val2.GetComponent<Piece>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_name = StowConfig.PostName.Value;
				component2.m_description = "Drop things in and close it. They go to the chests that asked for them.";
				component2.m_resources = Requirements(StowConfig.PostCost.Value);
				component2.m_category = (PieceCategory)4;
				Sprite val3 = Icons.Load(Icons.For(StowConfig.PostModelFile.Value), "stow_post");
				if ((Object)(object)val3 != (Object)null)
				{
					component2.m_icon = val3;
				}
			}
			if (!PostModel.Apply(val2))
			{
				StowRuntime.Log.LogWarning((object)"Stowing post is wearing the donor chest's own body - the model file was not found beside the dll.");
			}
			float value = StowConfig.PostScale.Value;
			val2.transform.localScale = new Vector3(value, value, value);
			if ((Object)(object)val2.GetComponent<StowPost>() == (Object)null)
			{
				val2.AddComponent<StowPost>();
			}
			StowRuntime.Log.LogInfo((object)("Built stow_post from " + ((Object)val).name + "."));
			return val2;
		}

		private static Requirement[] Requirements(string spec)
		{
			//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_00ca: 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: Expected O, but got Unknown
			List<Requirement> list = new List<Requirement>();
			string[] array = (spec ?? "").Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ':' });
				if (array2.Length != 2)
				{
					continue;
				}
				string text = array2[0].Trim();
				if (text.Length != 0 && int.TryParse(array2[1].Trim(), out var result) && result > 0)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
					ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
					if ((Object)(object)val == (Object)null)
					{
						StowRuntime.Log.LogWarning((object)("Post cost mentions unknown item '" + text + "'."));
						continue;
					}
					list.Add(new Requirement
					{
						m_resItem = val,
						m_amount = result,
						m_recover = true
					});
				}
			}
			return list.ToArray();
		}

		private static void AddToScene()
		{
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)_prefab == (Object)null || (Object)(object)instance.GetPrefab("stow_post") != (Object)null)
			{
				return;
			}
			if (!instance.m_prefabs.Contains(_prefab))
			{
				instance.m_prefabs.Add(_prefab);
			}
			try
			{
				((Dictionary<int, GameObject>)AccessTools.Field(typeof(ZNetScene), "m_namedPrefabs").GetValue(instance))[StringExtensionMethods.GetStableHashCode("stow_post")] = _prefab;
			}
			catch (Exception ex)
			{
				StowRuntime.Log.LogError((object)("Could not register stow_post: " + ex.Message));
			}
		}

		private static bool InHammer()
		{
			PieceTable val = HammerPieces();
			if ((Object)(object)val != (Object)null && (Object)(object)_prefab != (Object)null)
			{
				return val.m_pieces.Contains(_prefab);
			}
			return false;
		}

		private static PieceTable HammerPieces()
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Hammer");
			ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null || val.m_itemData == null || val.m_itemData.m_shared == null)
			{
				return null;
			}
			PieceTable buildPieces = val.m_itemData.m_shared.m_buildPieces;
			if (!((Object)(object)buildPieces != (Object)null) || buildPieces.m_pieces == null)
			{
				return null;
			}
			return buildPieces;
		}

		private static void AddToHammer()
		{
			if (!((Object)(object)_prefab == (Object)null))
			{
				PieceTable val = HammerPieces();
				if (!((Object)(object)val == (Object)null) && !val.m_pieces.Contains(_prefab))
				{
					val.m_pieces.Add(_prefab);
					StowRuntime.Log.LogInfo((object)"Stowing post added to the hammer.");
				}
			}
		}
	}
	internal static class StowRuntime
	{
		internal static ManualLogSource Log;

		private static bool _stowHeld;

		private static bool _configureHeld;

		private static bool _propsReported;

		internal static void Tick()
		{
			StowPost.Register();
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				if (!_propsReported && StowConfig.LookForProps.Value.Length > 0)
				{
					_propsReported = true;
					PropIndex.Search(StowConfig.LookForProps.Value);
				}
				HandleStow(localPlayer);
				HandleConfigure(localPlayer);
			}
		}

		private static void HandleStow(Player player)
		{
			//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)
			KeyboardShortcut value = StowConfig.KeyStow.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				_stowHeld = false;
			}
			else if (!_stowHeld)
			{
				_stowHeld = true;
				if (!Busy())
				{
					Depositor.Run(player);
				}
			}
		}

		private static void HandleConfigure(Player player)
		{
			//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)
			KeyboardShortcut value = StowConfig.KeyConfigure.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				_configureHeld = false;
			}
			else
			{
				if (_configureHeld)
				{
					return;
				}
				_configureHeld = true;
				if (FilterPanel.IsOpen)
				{
					FilterPanel.Close();
				}
				else
				{
					if (Busy())
					{
						return;
					}
					GameObject val = StowPatches.Hovering(player);
					if (!((Object)(object)val == (Object)null))
					{
						Container componentInParent = val.GetComponentInParent<Container>();
						if (!((Object)(object)componentInParent == (Object)null) && !StowPost.Is(componentInParent))
						{
							FilterPanel.Open(componentInParent);
						}
					}
				}
			}
		}

		private static bool Busy()
		{
			if (!InventoryGui.IsVisible())
			{
				return Menu.IsVisible();
			}
			return true;
		}
	}
	internal static class StowPatches
	{
		private static readonly FieldInfo PlayerHovering = AccessTools.Field(typeof(Player), "m_hovering");

		private static readonly FieldInfo GuiContainer = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");

		public static GameObject Hovering(Player player)
		{
			if (!(PlayerHovering == null))
			{
				object? value = PlayerHovering.GetValue(player);
				return (GameObject)((value is GameObject) ? value : null);
			}
			return null;
		}

		public static Container CurrentContainer(InventoryGui gui)
		{
			if (!(GuiContainer == null) && !((Object)(object)gui == (Object)null))
			{
				object? value = GuiContainer.GetValue(gui);
				return (Container)((value is Container) ? value : null);
			}
			return null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InventoryGui), "CloseContainer")]
		private static void EmptyOnClose(InventoryGui __instance)
		{
			EmptyPost(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		private static void EmptyOnHide(InventoryGui __instance)
		{
			EmptyPost(__instance);
		}

		private static void EmptyPost(InventoryGui gui)
		{
			Container val = CurrentContainer(gui);
			if (!((Object)(object)val == (Object)null))
			{
				RulesButton.Hide();
				if (FilterPanel.IsOpen)
				{
					FilterPanel.Close();
				}
				StowPost component = ((Component)val).GetComponent<StowPost>();
				if ((Object)(object)component != (Object)null)
				{
					component.Empty();
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InventoryGui), "Show")]
		private static void ShowRulesButton(InventoryGui __instance, Container container)
		{
			RulesButton.Sync(__instance, container);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Container), "GetHoverText")]
		private static void ShowFilter(Container __instance, ref string __result)
		{
			if (!string.IsNullOrEmpty(__result) && !StowPost.Is(__instance))
			{
				string text = ChestFilter.Summary(__instance);
				if (text != null)
				{
					__result = __result + "\n<color=#D9A441>" + text + "</color>";
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "TakeInput")]
		private static void BlockInput(ref bool __result)
		{
			if (FilterPanel.IsOpen)
			{
				__result = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerController), "TakeInput")]
		private static void BlockController(ref bool __result)
		{
			if (FilterPanel.IsOpen)
			{
				__result = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerController), "InInventoryEtc")]
		private static void HoldLookStill(ref bool __result)
		{
			if (FilterPanel.IsOpen)
			{
				__result = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
		private static void FreeCursor()
		{
			if (FilterPanel.IsOpen)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Menu), "Show")]
		private static bool EscapeClosesPanel()
		{
			if (!FilterPanel.IsOpen)
			{
				return true;
			}
			FilterPanel.Close();
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static void RebuildCatalogue()
		{
			Forget();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static void RebuildCatalogueFromServer()
		{
			Forget();
		}

		private static void Forget()
		{
			ItemGroups.Invalidate();
			PostModel.Invalidate();
			CarrierModel.Invalidate();
			Flare.Invalidate();
			CarriedItem.Invalidate();
		}
	}
	internal static class Theme
	{
		public static readonly Color Bg = Hex(2238510);

		public static readonly Color Panel = Hex(2896956);

		public static readonly Color Row = Hex(3357765);

		public static readonly Color Ink = Hex(14212836);

		public static readonly Color Dim = Hex(9082787);

		public static readonly Color Gold = Hex(14263361);

		public static readonly Color Rule = Hex(4279382);

		public static readonly Color Hair = new Color(1f, 1f, 1f, 0.04f);

		private static Font _font;

		public static Font Mono
		{
			get
			{
				if ((Object)(object)_font == (Object)null)
				{
					_font = Font.CreateDynamicFontFromOSFont(new string[4] { "Consolas", "Cascadia Mono", "Courier New", "Lucida Console" }, 12);
					if ((Object)(object)_font != (Object)null)
					{
						((Object)_font).hideFlags = (HideFlags)61;
					}
				}
				return _font;
			}
		}

		public static Texture2D Solid(Color colour)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Texture2D obj = Make(1, 1);
			obj.SetPixel(0, 0, colour);
			obj.Apply();
			return obj;
		}

		public static Texture2D Bordered(Color fill, Color border)
		{
			//IL_001b: 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)
			Texture2D val = Make(3, 3);
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					val.SetPixel(i, j, (i == 1 && j == 1) ? fill : border);
				}
			}
			val.Apply();
			return val;
		}

		public static Texture2D Underline(Color line)
		{
			//IL_001d: 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)
			Texture2D val = Make(3, 3);
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					val.SetPixel(i, j, (j == 0) ? line : Color.clear);
				}
			}
			val.Apply();
			return val;
		}

		public static Texture2D Clear()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Texture2D obj = Make(1, 1);
			obj.SetPixel(0, 0, Color.clear);
			obj.Apply();
			return obj;
		}

		private static Texture2D Make(int width, int height)
		{
			//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_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_0020: Expected O, but got Unknown
			return new Texture2D(width, height, (TextureFormat)5, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
		}

		private static Color Hex(int rgb)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f);
		}
	}
}
namespace Grove
{
	internal static class BloodFeed
	{
		private static Dictionary<string, float> _weights;

		private static string _weightsRaw;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "OnDeath")]
		private static void Feed(Character __instance)
		{
			//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_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)
			if ((Object)(object)__instance == (Object)null || Sapling.All.Count == 0)
			{
				return;
			}
			float num = WeightOf(Utils.GetPrefabName(((Component)__instance).gameObject));
			if (num <= 0f)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			float value = GroveConfig.FeedRange.Value;
			Sapling sapling = null;
			float num2 = float.MaxValue;
			foreach (Sapling item in Sapling.All)
			{
				if (!((Object)(object)item == (Object)null))
				{
					float num3 = Vector3.Distance(((Component)item).transform.position, position);
					if (!(num3 > value) && !(num3 >= num2))
					{
						sapling = item;
						num2 = num3;
					}
				}
			}
			if (!((Object)(object)sapling == (Object)null))
			{
				sapling.Feed(num);
				if (GroveConfig.Messages.Value && (Object)(object)Player.m_localPlayer != (Object)null && sapling.Progress < 1f)
				{
					((Character)Player.m_localPlayer).Message((MessageType)1, Localization.instance.Localize($"{sapling.GetHoverName()}  ( {Mathf.FloorToInt(sapling.Blood)} / {Mathf.FloorToInt(sapling.Needed)} )"), 0, (Sprite)null);
				}
			}
		}

		private static float WeightOf(string prefab)
		{
			if (string.IsNullOrEmpty(prefab))
			{
				return 0f;
			}
			string text = GroveConfig.FeedWeights.Value ?? "";
			if (_weights == null || text != _weightsRaw)
			{
				_weightsRaw = text;
				_weights = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);
				string[] array = text.Split(new char[1] { ',' });
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split(new char[1] { ':' });
					if (array2.Length == 2)
					{
						string text2 = array2[0].Trim();
						if (text2.Length != 0 && float.TryParse(array2[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
						{
							_weights[text2] = result;
						}
					}
				}
			}
			if (!_weights.TryGetValue(prefab, out var value))
			{
				return 0f;
			}
			return value;
		}
	}
	internal class ForestSpirit : MonoBehaviour, Hoverable, Interactable
	{
		public static float SpinIdle = 6f;

		public static float SpinAwake = 19f;

		public static float BobHeight = 0.07f;

		public static float BobPeriod = 4.3f;

		public static float PulseDepth = 0.35f;

		public static float PulsePeriod = 5.7f;

		public static float LightRange = 7f;

		public static Color LightColour = new Color(1f, 0.74f, 0.3f);

		public static float DriftRate = 8f;

		public static float NearRange = 4f;

		public static float FarRange = 16f;

		public static float Orbit = 0.34f;

		public Transform Hoop;

		public Transform Heart;

		private readonly List<Transform> _rings = new List<Transform>();

		private Light _light;

		private Renderer[] _renderers;

		private MaterialPropertyBlock _block;

		private Vector3 _spin;

		private Vector3 _rest;

		private float _bobPhase;

		private float _pulsePhase;

		private float _wake;

		private static readonly int EmissionColour = Shader.PropertyToID("_EmissionColor");

		private void Start()
		{
			//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_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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			ZNetView componentInParent = ((Component)this).GetComponentInParent<ZNetView>();
			Random random = new Random(((Object)(object)componentInParent != (Object)null && componentInParent.IsValid()) ? ((object)Unsafe.As<ZDOID, ZDOID>(ref componentInParent.GetZDO().m_uid)/*cast due to .constrained prefix*/).GetHashCode() : ((Object)this).GetInstanceID());
			_spin = new Vector3(Signed(random), Signed(random), Signed(random));
			_bobPhase = (float)random.NextDouble() * (float)Math.PI * 2f;
			_pulsePhase = (float)random.NextDouble() * (float)Math.PI * 2f;
			_rest = ((Component)this).transform.localPosition;
			CollectRings();
			MakeLight();
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			_block = new MaterialPropertyBlock();
		}

		private float Signed(Random random)
		{
			float num = 1f + (float)random.NextDouble();
			if (random.Next(2) != 0)
			{
				return num;
			}
			return 0f - num;
		}

		private void CollectRings()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if ((Object)(object)Hoop == (Object)null)
			{
				return;
			}
			foreach (Transform item in Hoop)
			{
				Transform val = item;
				if (((Object)val).name.StartsWith("ring"))
				{
					_rings.Add(val);
				}
			}
		}

		private void MakeLight()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			_light = ((Component)this).GetComponentInChildren<Light>();
			if (!((Object)(object)_light != (Object)null))
			{
				GameObject val = new GameObject("spirit_light");
				val.transform.SetParent(((Component)this).transform, false);
				_light = val.AddComponent<Light>();
				_light.type = (LightType)2;
				_light.range = LightRange;
				_light.color = LightColour;
				_light.intensity = 1f;
				_light.shadows = (LightShadows)0;
			}
		}

		private void Update()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			float deltaTime = Time.deltaTime;
			float time = Time.time;
			Wake(deltaTime);
			float num = Mathf.Lerp(SpinIdle, SpinAwake, _wake);
			if ((Object)(object)Hoop != (Object)null)
			{
				Hoop.Rotate(_spin * num * deltaTime, (Space)1);
			}
			Bob(time);
			Drift(deltaTime, num / SpinAwake);
			Pulse(time);
		}

		private void Wake(float delta)
		{
			//IL_001b: 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)
			Player localPlayer = Player.m_localPlayer;
			float num = 0f;
			if ((Object)(object)localPlayer != (Object)null)
			{
				float num2 = Vector3.Distance(((Component)localPlayer).transform.position, ((Component)this).transform.position);
				num = 1f - Mathf.InverseLerp(NearRange, FarRange, num2);
			}
			_wake = Mathf.MoveTowards(_wake, num, delta * 0.6f);
		}

		private void Bob(float time)
		{
			//IL_003d: 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)
			float num = Mathf.Sin(time * ((float)Math.PI * 2f / BobPeriod) + _bobPhase);
			float num2 = BobHeight * Mathf.Lerp(0.33f, 1f, _wake);
			((Component)this).transform.localPosition = _rest + new Vector3(0f, num * num2, 0f);
		}

		private void Drift(float delta, float liveliness)
		{
			float num = DriftRate * liveliness * delta;
			for (int i = 0; i < _rings.Count; i++)
			{
				if (!((Object)(object)_rings[i] == (Object)null))
				{
					_rings[i].Rotate(0f, 0f, num, (Space)1);
				}
			}
		}

		private void Pulse(float time)
		{
			//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_008a: 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)
			float num = Mathf.Sin(time * ((float)Math.PI * 2f / PulsePeriod) + _pulsePhase);
			float num2 = 1f + num * PulseDepth * Mathf.Lerp(0.4f, 1f, _wake);
			if ((Object)(object)_light != (Object)null)
			{
				_light.intensity = Mathf.Lerp(0.5f, 1.6f, _wake) * num2;
			}
			if (_renderers == null || _block == null)
			{
				return;
			}
			Color val = LightColour * num2;
			Renderer[] renderers = _renderers;
			foreach (Renderer val2 in renderers)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Material sharedMaterial = val2.sharedMaterial;
					if (!((Object)(object)sharedMaterial == (Object)null) && sharedMaterial.HasProperty(EmissionColour))
					{
						val2.GetPropertyBlock(_block);
						_block.SetColor(EmissionColour, val);
						val2.SetPropertyBlock(_block);
					}
				}
			}
		}

		public string GetHoverName()
		{
			return GroveConfig.SpiritName.Value;
		}

		public string GetHoverText()
		{
			return Localization.instance.Localize(GetHoverName() + "\n[<color=yellow><b>$KEY_Use</b></color>] commune");
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold)
			{
				return false;
			}
			Player val = (Player)(object)((user is Player) ? user : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			ZNetView componentInParent = ((Component)this).GetComponentInParent<ZNetView>();
			if ((Object)(object)componentInParent == (Object)null || !componentInParent.IsValid())
			{
				return false;
			}
			int num = Mathf.Max(1, GroveConfig.HeartwoodGiven.Value);
			Inventory inventory = ((Humanoid)val).GetInventory();
			GameObject val2 = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("GroveHeartwood") : null);
			if ((Object)(object)val2 == (Object)null)
			{
				GrovePlugin.LogOnce("GroveHeartwood is not registered - the spirit has nothing to give.");
				return true;
			}
			ItemDrop component = val2.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (!inventory.CanAddItem(component.m_itemData, num))
			{
				((Character)user).Message((MessageType)2, "$inventory_full", 0, (Sprite)null);
				return true;
			}
			inventory.AddItem("GroveHeartwood", num, 1, 0, 0L, "", false);
			((Character)user).Message((MessageType)2, Localization.instance.Localize("The " + GetHoverName().ToLowerInvariant() + " folds itself into the heartwood."), 0, (Sprite)null);
			Part(componentInParent);
			return true;
		}

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

		private void Part(ZNetView nview)
		{
			//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)
			string value = GroveConfig.PartingEffect.Value;
			if (!string.IsNullOrEmpty(value) && (Object)(object)ZNetScene.instance != (Object)null)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(value);
				if ((Object)(object)prefab != (Object)null)
				{
					Object.Instantiate<GameObject>(prefab, ((Component)this).transform.position, Quaternion.identity);
				}
				else
				{
					GrovePlugin.LogOnce("Parting effect '" + value + "' does not exist.");
				}
			}
			nview.ClaimOwnership();
			nview.Destroy();
		}
	}
	internal static class GroveConfig
	{
		public static ConfigEntry<bool> TestMode;

		public static ConfigEntry<string> SpiritName;

		public static ConfigEntry<float> SpiritScale;

		public static ConfigEntry<int> MoteCount;

		public static ConfigEntry<int> RingCount;

		public static ConfigEntry<bool> ShowHoop;

		public static ConfigEntry<float> SpiritRise;

		public static ConfigEntry<string> PartingEffect;

		public static ConfigEntry<string> HeartwoodName;

		public static ConfigEntry<string> HeartwoodDonor;

		public static ConfigEntry<int> HeartwoodStack;

		public static ConfigEntry<int> HeartwoodGiven;

		public static ConfigEntry<string> SaplingName;

		public static ConfigEntry<string> SaplingCost;

		public static ConfigEntry<string> SaplingDonor;

		public static ConfigEntry<float> SaplingScale;

		public static ConfigEntry<float> SaplingHealth;

		public static ConfigEntry<string> SaplingIcon;

		public static ConfigEntry<bool> NeedsCultivated;

		public static ConfigEntry<float> BloodNeeded;

		public static ConfigEntry<float> FeedRange;

		public static ConfigEntry<string> FeedWeights;

		public static ConfigEntry<bool> Messages;

		public static ConfigEntry<bool> Verbose;

		public static ConfigEntry<bool> CoupleToStow;

		public static ConfigEntry<string> StowPostCost;

		public static ConfigEntry<string> GlowDonors;

		public static ConfigEntry<bool> DumpMaterials;

		public static ConfigEntry<string> LookForPrefabs;

		private const float TestBlood = 3f;

		public static float BloodNeededNow()
		{
			if (!TestMode.Value)
			{
				return Mathf.Max(1f, BloodNeeded.Value);
			}
			return 3f;
		}

		public static void Bind(ConfigFile config)
		{
			TestMode = config.Bind<bool>("Diagnostics", "TestMode", false, "Drops what a sapling needs to three greydwarfs, so the whole chain - stages, spirit, commune, heartwood - can be walked in a minute instead of an hour. Announced in the log on startup so it is hard to leave on.");
			SpiritName = config.Bind<string>("Spirit", "SpiritName", "Forest spirit", "What it is called when you look at it.");
			SpiritScale = config.Bind<float>("Spirit", "SpiritScale", 1f, "Scale of the whole thing. The mesh is built knee-to-chest height.");
			MoteCount = config.Bind<int>("Spirit", "MoteCount", 6, "How many beads ride each ring. Six rather than the original seven: seven was chosen so no two beads sat opposite each other on a single circle, and with several circles crossing that buys nothing while an even count divides more cleanly.");
			RingCount = config.Bind<int>("Spirit", "RingCount", 2, "How many circles of beads. One is the original single hoop. Two crossed circles is the default: it reads as an orbit rather than a swarm and keeps both rings separable, which three only just manages and four does not - at four the beads stop reading as being on circles at all and become a cloud.");
			ShowHoop = config.Bind<bool>("Spirit", "ShowHoop", false, "Draw the torus the beads sit on. Off: the circle is implied by where the beads are and by their moving together, which is a lighter and stranger thing than a visible ring - and with several rings crossing, the torus meshes turn the whole shape into a ball of wire.");
			SpiritRise = config.Bind<float>("Spirit", "SpiritRise", 0.4f, "How far above the sapling the spirit appears.");
			PartingEffect = config.Bind<string>("Spirit", "PartingEffect", "", "A vanilla effect played once, where the spirit stood, at the moment it folds into the heartwood and goes. Blank for none.\nNot the glow: the spirit's breathing is a light and an emission colour driven in code, always on, and nothing to do with this setting. This was called FadeEffect and that name cost a conversation, because the spirit visibly fades in and out on its own and the two are unrelated.\nNamed rather than built, because a particle system authored here would look like a mod and the game's own does not - but which effect is right is a question for the game rather than a guess made here, so a name that does not resolve costs the moment its flourish and does not break it. Empty by default until a name is confirmed loaded: vfx_prayer was the guess and it does not exist, which is a warning in the log on every commune and nothing on screen.");
			HeartwoodName = config.Bind<string>("Heartwood", "HeartwoodName", "Heartwood", "What the material is called.");
			HeartwoodDonor = config.Bind<string>("Heartwood", "HeartwoodDonor", "SurtlingCore", "The vanilla item it is cloned from, for its ItemDrop, Rigidbody, colliders and float-in-water behaviour. Only the mesh, the name and the icon change.");
			HeartwoodStack = config.Bind<int>("Heartwood", "HeartwoodStack", 10, "How many fit in a slot.");
			HeartwoodGiven = config.Bind<int>("Heartwood", "HeartwoodGiven", 1, "How many a spirit folds itself into. One, and really only one: the heartwood is where the spirit lives, so a spirit that produced five of them would have five homes and be in none of them. It is also the economy - the whole chain exists to make a single stowing post cost something real, and five would make the rest free - but the story is the harder constraint of the two.");
			SaplingName = config.Bind<string>("Sapling", "SaplingName", "Ancient sapling", "What the planted seed is called.");
			SaplingCost = config.Bind<string>("Sapling", "SaplingCost", "AncientSeed:1", "What planting one costs. Not refunded when you take it back up - a seed put into the ground is spent.");
			SaplingDonor = config.Bind<string>("Sapling", "SaplingDonor", "sapling_carrot", "The vanilla piece it is cloned from, for its placement rules and its Piece and WearNTear. The donor's own Plant component is torn out: it grows on a timer, which is exactly what must not happen here.");
			SaplingScale = config.Bind<float>("Sapling", "SaplingScale", 1f, "Scale of the planted piece.");
			SaplingIcon = config.Bind<string>("Sapling", "SaplingIcon", "grove_sapling_icon.png", "The picture on the cultivator, read from beside the dll. Without one the piece keeps the donor's icon and the cultivator offers you a carrot. Rendered from stage one - the seed you actually place - because the grown stages are two metres of mostly trunk and at inventory size they come out as a brown stick. tools/sapling_icon.py renders the alternatives if you want a different one.");
			SaplingHealth = config.Bind<float>("Sapling", "SaplingHealth", 500f, "How much punishment it takes before it is destroyed. The donor is a carrot and carries a carrot's health, which is a few points - so a single greydwarf swinging near it ended the whole ritual, and the seed is not refunded. Five hundred is roughly ten hits from a brute: it survives a fight happening around it and does not survive a mob left to work on it, which is the point. Defending it is meant to be the hard part of the hour, not a formality and not a coin flip.");
			NeedsCultivated = config.Bind<bool>("Sapling", "NeedsCultivated", false, "Whether it must go in tilled soil. Off by default: an ancient seed answering to a forest is a stranger idea than a crop, and making it want a vegetable patch shrinks it.");
			BloodNeeded = config.Bind<float>("Sapling", "BloodNeeded", 30f, "How much death it takes. With the default weights that is about thirty greydwarfs, or rather fewer if you go and find a nest - elites are worth four and shamans three.\nThirty, so that one greydwarf raid arriving on a planted sapling is enough to finish it on its own. Sixty was two or three evenings of going out to look for kills, which made the sapling a chore you topped up. A raid turning up at a grove you planted is the best thing that happens in this whole chain - the forest coming to you instead - and it should be the payoff rather than a fifth of one.");
			FeedRange = config.Bind<float>("Sapling", "FeedRange", 24f, "How close a kill must be to count. Only the nearest sapling is fed - otherwise a heap of saplings planted together would all grow at once off the same work.");
			FeedWeights = config.Bind<string>("Sapling", "FeedWeights", "Greydwarf:1,Greydwarf_Elite:4,Greydwarf_Shaman:3,Greyling:0", "What each death is worth, as Prefab:Amount. Anything not listed is worth nothing. A list rather than a faction check, because ForestMonsters would also catch trolls, boars and the Elder, and 'kill anything in the forest' is a duller quest than 'clear out the greydwarfs'. Greylings are listed at zero so it is visible that they were considered and refused.");
			Messages = config.Bind<bool>("Sapling", "Messages", true, "Corner counter each time a kill feeds a sapling.");
			Verbose = config.Bind<bool>("Diagnostics", "Verbose", false, "Log every feed.");
			CoupleToStow = config.Bind<bool>("Post", "CoupleToStow", true, "Make the stowing post cost heartwood - which is to say, make the post the place the spirit ends up living. That is where the sorting comes from, and it is why the post is worth an hour of greydwarfs when a chest is worth ten wood. Off puts the post back to plain wood and nails, for anyone who wants the sorting without the ritual.");
			StowPostCost = config.Bind<string>("Post", "StowPostCost", "GroveHeartwood:1", "What is *added* to the stowing post's cost, as Item:Amount. Added rather than replacing, because the rest of that recipe is Post/PostCost and someone may have changed it deliberately. An ingredient already there is raised to whichever amount is higher rather than counted twice.");
			GlowDonors = config.Bind<string>("Spirit", "GlowDonors", "fire_pit,piece_walltorch,bonfire,Ember,piece_groundtorch_green,guard_stone", "Prefabs to try to lift the glowing material from, best first. The first one that resolves and has an albedo wins.");
			DumpMaterials = config.Bind<bool>("Diagnostics", "DumpMaterials", false, "On startup, log every material on each donor with its shader and whether it exposes an emission property. This is how to find a donor worth naming rather than guessing at one.");
			LookForPrefabs = config.Bind<string>("Diagnostics", "LookForPrefabs", "", "Comma-separated words. Logs every loaded prefab whose name contains one. The asset manifest lists what exists on disk, most of which is never loaded; this lists what is genuinely there.");
		}
	}
	[BepInPlugin("ezomic.valheim.vaettir", "Vaettir", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class GrovePlugin : BaseUnityPlugin
	{
		private sealed class Step
		{
			public string Name;

			public Func<bool> Run;

			public bool Abandoned;
		}

		public const string PluginGuid = "ezomic.valheim.vaettir";

		public const string PluginName = "Vaettir";

		public const string PluginVersion = "1.0.0";

		public const string PluginAuthor = "Robbin Thijssen";

		private const string CoreGuid = "ezomic.valheim.core";

		internal static ManualLogSource Log;

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

		private Harmony _harmony;

		private bool _diagnosticsDone;

		private Step[] _steps;

		private static bool StowApply()
		{
			StowCoupling.Apply();
			return false;
		}

		internal static void RegisterNow()
		{
			if (Log == null)
			{
				return;
			}
			try
			{
				HeartwoodPrefab.Register();
				SpiritPrefab.Register();
				SaplingPrefab.Register();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Early registration failed; Update will retry. " + ex));
			}
		}

		private void Run(Step step)
		{
			if (step.Abandoned)
			{
				return;
			}
			try
			{
				step.Run();
			}
			catch (Exception ex)
			{
				step.Abandoned = true;
				Log.LogError((object)(step.Name + " could not be registered and will not be retried again this session. " + ex));
			}
		}

		internal static void LogOnce(string message)
		{
			if (Log != null && Said.Add(message))
			{
				Log.LogWarning((object)message);
			}
		}

		private void Awake()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			GroveConfig.Bind(((BaseUnityPlugin)this).Config);
			StowConfig.Bind(((BaseUnityPlugin)this).Config);
			StowRuntime.Log = ((BaseUnityPlugin)this).Logger;
			TryRegisterWithCore();
			_harmony = new Harmony("ezomic.valheim.vaettir");
			_harmony.PatchAll(typeof(BloodFeed));
			_harmony.PatchAll(typeof(GrovePatches));
			_harmony.PatchAll(typeof(StowPatches));
			_steps = new Step[4]
			{
				new Step
				{
					Name = "Heartwood",
					Run = HeartwoodPrefab.Register
				},
				new Step
				{
					Name = "Forest spirit",
					Run = SpiritPrefab.Register
				},
				new Step
				{
					Name = "Ancient sapling",
					Run = SaplingPrefab.Register
				},
				new Step
				{
					Name = "Stow coupling",
					Run = StowApply
				}
			};
			Log.LogInfo((object)"Vaettir 1.0.0 by Robbin Thijssen - ready.");
			if (GroveConfig.TestMode.Value)
			{
				Log.LogWarning((object)"TEST MODE: a sapling needs three greydwarfs, not sixty. Turn TestMode off in the config before playing for real.");
			}
		}

		private void TryRegisterWithCore()
		{
			if (!Chainloader.PluginInfos.ContainsKey("ezomic.valheim.core"))
			{
				Log.LogInfo((object)"Core not installed - running standalone, without the version gate.");
			}
			else
			{
				RegisterWithCore();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void RegisterWithCore()
		{
			Suite.Register("ezomic.valheim.vaettir", "Vaettir", "1.0.0", ((BaseUnityPlugin)this).Config, (Requirement)0, (Assembly)null);
		}

		private void OnDestroy()
		{
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
			Step[] steps = _steps;
			foreach (Step step in steps)
			{
				Run(step);
			}
			StowRuntime.Tick();
			if (!_diagnosticsDone && !((Object)(object)ZNetScene.instance == (Object)null))
			{
				_diagnosticsDone = true;
				if (GroveConfig.LookForPrefabs.Value.Length > 0)
				{
					PropIndex.Search(GroveConfig.LookForPrefabs.Value);
				}
				if (GroveConfig.DumpMaterials.Value)
				{
					SpiritPrefab.DumpMaterials();
				}
			}
		}

		private void OnGUI()
		{
			FilterPanel.Draw();
		}
	}
	internal static class GrovePatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static void ForgetSkins()
		{
			Skins.Invalidate();
			StowCoupling.Invalidate();
			GrovePlugin.RegisterNow();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static void SceneReady()
		{
			GrovePlugin.RegisterNow();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static void ForgetSkinsFromServer()
		{
			Skins.Invalidate();
			StowCoupling.Invalidate();
			GrovePlugin.RegisterNow();
		}
	}
	internal static class HeartwoodPrefab
	{
		public const string Name = "GroveHeartwood";

		private const string Mesh = "grove_heartwood.obj";

		private const string Icon = "grove_heartwood_icon.png";

		private static GameObject _prefab;

		private static GameObject _holder;

		public static bool Ready
		{
			get
			{
				if ((Object)(object)ObjectDB.instance != (Object)null)
				{
					return (Object)(object)ObjectDB.instance.GetItemPrefab("GroveHeartwood") != (Object)null;
				}
				return false;
			}
		}

		public static bool Register()
		{
			if (Ready)
			{
				return true;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = Build();
				if ((Object)(object)_prefab == (Object)null)
				{
					return false;
				}
			}
			AddToObjectDB();
			AddToScene();
			return Ready;
		}

		private static GameObject Build()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_00b6: 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)
			ModelData modelData = ObjMesh.Load(Path.Combine(Path.GetDirectoryName(typeof(HeartwoodPrefab).Assembly.Location), "grove_heartwood.obj"));
			if (modelData == null)
			{
				GrovePlugin.Log.LogError((object)"No grove_heartwood.obj beside the dll - cannot build GroveHeartwood.");
				return null;
			}
			GameObject val = Donor();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_holder == (Object)null)
			{
				_holder = new GameObject("GroveHeartwoodHolder");
				_holder.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_holder);
			}
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			ZNetView.m_forceDisableInit = true;
			GameObject val2;
			try
			{
				val2 = Object.Instantiate<GameObject>(val, _holder.transform);
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			((Object)val2).name = "GroveHeartwood";
			val2.transform.localRotation = Quaternion.identity;
			Visual(val2, modelData);
			ItemDrop component = val2.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
			{
				GrovePlugin.Log.LogError((object)("Donor " + ((Object)val).name + " has no usable ItemDrop."));
				return null;
			}
			SharedData shared = component.m_itemData.m_shared;
			shared.m_name = GroveConfig.HeartwoodName.Value;
			shared.m_description = "Warm, and heavier than wood should be. The spirit is folded up inside, waiting to be put somewhere.";
			shared.m_itemType = (ItemType)1;
			shared.m_maxStackSize = Mathf.Max(1, GroveConfig.HeartwoodStack.Value);
			shared.m_weight = 0.5f;
			shared.m_teleportable = true;
			shared.m_questItem = false;
			Sprite val3 = Icons.Load("grove_heartwood_icon.png", "GroveHeartwood");
			if ((Object)(object)val3 != (Object)null)
			{
				shared.m_icons = (Sprite[])(object)new Sprite[1] { val3 };
			}
			component.m_itemData.m_stack = 1;
			component.m_itemData.m_dropPrefab = val2;
			GrovePlugin.Log.LogInfo((object)("Built GroveHeartwood from " + ((Object)val).name + "."));
			return val2;
		}

		private static GameObject Donor()
		{
			ZNetScene instance = ZNetScene.instance;
			string[] array = new string[3]
			{
				GroveConfig.HeartwoodDonor.Value,
				"SurtlingCore",
				"Wood"
			};
			foreach (string text in array)
			{
				if (!string.IsNullOrEmpty(text))
				{
					GameObject prefab = instance.GetPrefab(text);
					if ((Object)(object)prefab != (Object)null)
					{
						return prefab;
					}
					GrovePlugin.LogOnce("Heartwood donor '" + text + "' does not exist.");
				}
			}
			return null;
		}

		private static void Visual(GameObject clone, ModelData model)
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			MeshRenderer[] componentsInChildren = clone.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)component != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)component);
					}
					Object.DestroyImmediate((Object)(object)val);
				}
			}
			GameObject val2 = new GameObject("heartwood_visual");
			val2.transform.SetParent(clone.transform, false);
			val2.AddComponent<MeshFilter>().sharedMesh = model.Mesh;
			((Renderer)val2.AddComponent<MeshRenderer>()).sharedMaterials = Skins.Skin(model.Groups);
			Skins.Remap(model.Mesh, model.Groups);
			Ground(clone, model);
		}

		private static void Ground(GameObject clone, ModelData model)
		{
			//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_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)
			if (!((Object)(object)clone.GetComponentInChildren<Collider>(true) != (Object)null) && !((Object)(object)model.Mesh == (Object)null))
			{
				Bounds bounds = model.Mesh.bounds;
				BoxCollider obj = clone.AddComponent<BoxCollider>();
				obj.center = ((Bounds)(ref bounds)).center;
				obj.size = ((Bounds)(ref bounds)).size;
				GrovePlugin.LogOnce("Donor " + GroveConfig.HeartwoodDonor.Value + " left no collider on GroveHeartwood - added one from the mesh bounds so it does not fall through the world.");
			}
		}

		private static void AddToObjectDB()
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)_prefab == (Object)null || (Object)(object)instance == (Object)null || (Object)(object)instance.GetItemPrefab("GroveHeartwood") != (Object)null)
			{
				return;
			}
			if (!instance.m_items.Contains(_prefab))
			{
				instance.m_items.Add(_prefab);
			}
			try
			{
				AccessTools.Method(typeof(ObjectDB), "UpdateRegisters", (Type[])null, (Type[])null).Invoke(instance, null);
			}
			catch (Exception ex)
			{
				GrovePlugin.Log.LogError((object)("Could not refresh ObjectDB for GroveHeartwood: " + ex.Message));
			}
		}

		private static void AddToScene()
		{
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)_prefab == (Object)null || (Object)(object)instance.GetPrefab("GroveHeartwood") != (Object)null)
			{
				return;
			}
			if (!instance.m_prefabs.Contains(_prefab))
			{
				instance.m_prefabs.Add(_prefab);
			}
			try
			{
				((Dictionary<int, GameObject>)AccessTools.Field(typeof(ZNetScene), "m_namedPrefabs").GetValue(instance))[StringExtensionMethods.GetStableHashCode("GroveHeartwood")] = _prefab;
			}
			catch (Exception ex)
			{
				GrovePlugin.Log.LogError((object)("Could not register GroveHeartwood: " + ex.Message));
			}
		}
	}
	internal static class Icons
	{
		public static Sprite Load(string fileName, string label)
		{
			//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_007d: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(fileName))
			{
				return null;
			}
			string path = Path.Combine(Path.GetDirectoryName(typeof(Icons).Assembly.Location), fileName);
			if (!File.Exists(path))
			{
				GrovePlugin.LogOnce("No " + fileName + " beside the dll - " + label + " will use the donor's icon, which is someone else's picture.");
				return null;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				if (!LoadPng(val, File.ReadAllBytes(path)))
				{
					return null;
				}
				((Object)val).name = label + "_icon";
				((Object)val).hideFlags = (HideFlags)61;
				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)
			{
				GrovePlugin.Log.LogError((object)("Could not read " + fileName + ": " + ex.Message));
				return null;
			}
		}

		public static string For(string modelFile)
		{
			if (string.IsNullOrEmpty(modelFile))
			{
				return null;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(modelFile);
			if (!string.IsNullOrEmpty(fileNameWithoutExtension))
			{
				return fileNameWithoutExtension + "_icon.png";
			}
			return null;
		}

		private static bool LoadPng(Texture2D texture, byte[] data)
		{
			Type type = AccessTools.TypeByName("UnityEngine.ImageConversion");
			if (type == null)
			{
				GrovePlugin.LogOnce("UnityEngine.ImageConversion is missing - cannot read icons.");
				return false;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "LoadImage", new Type[2]
			{
				typeof(Texture2D),
				typeof(byte[])
			}, (Type[])null) ?? AccessTools.Method(type, "LoadImage", new Type[3]
			{
				typeof(Texture2D),
				typeof(byte[]),
				typeof(bool)
			}, (Type[])null);
			if (methodInfo == null)
			{
				GrovePlugin.LogOnce("No LoadImage overload found on UnityEngine.ImageConversion.");
				return false;
			}
			object[] parameters = ((methodInfo.GetParameters().Length != 3) ? new object[2] { texture, data } : new object[3] { texture, data, false });
			return (bool)methodInfo.Invoke(null, parameters);
		}
	}
	internal sealed class ModelData
	{
		public Mesh Mesh;

		public string[] Groups;
	}
	internal static class ObjMesh
	{
		public static ModelData Load(string path)
		{
			if (!File.Exists(path))
			{
				GrovePlugin.Log.LogWarning((object)("No model at " + path));
				return null;
			}
			try
			{
				return Parse(File.ReadAllLines(path), Path.GetFileNameWithoutExtension(path));
			}
			catch (Exception ex)
			{
				GrovePlugin.Log.LogError((object)("Could not read " + path + ": " + ex.Message));
				return null;
			}
		}

		private static ModelData Parse(string[] lines, string name)
		{
			//IL_029c: 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_02aa: Expected O, but got Unknown
			//IL_0148: 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_01b3: 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_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			List<Vector2> list2 = new List<Vector2>();
			List<Vector3> list3 = new List<Vector3>();
			List<Color> list4 = new List<Color>();
			List<string> list5 = new List<string>();
			List<List<int>> list6 = new List<List<int>>();
			Dictionary<string, int> index = new Dictionary<string, int>();
			Dictionary<string, int> lookup = new Dictionary<string, int>();
			List<Vector3> list7 = new List<Vector3>();
			List<Vector2> list8 = new List<Vector2>();
			List<Vector3> list9 = new List<Vector3>();
			List<Color> outShades = new List<Color>();
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			List<int> triangles = Bucket("", list5, list6, index);
			for (int i = 0; i < lines.Length; i++)
			{
				string text = lines[i].Trim();
				if (text.Length == 0 || text[0] == '#')
				{
					continue;
				}
				string[] array = text.Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
				if (array.Length < 2)
				{
					continue;
				}
				switch (array[0])
				{
				case "v":
					if (array.Length >= 4)
					{
						list.Add(new Vector3(float.Parse(array[1], invariantCulture), float.Parse(array[2], invariantCulture), float.Parse(array[3], invariantCulture)));
						if (array.Length >= 7)
						{
							list4.Add(new Color(float.Parse(array[4], invariantCulture), float.Parse(array[5], invariantCulture), float.Parse(array[6], invariantCulture), 1f));
						}
					}
					break;
				case "vt":
					if (array.Length >= 3)
					{
						list2.Add(new Vector2(float.Parse(array[1], invariantCulture), float.Parse(array[2], invariantCulture)));
					}
					break;
				case "vn":
					if (array.Length >= 4)
					{
						list3.Add(new Vector3(float.Parse(array[1], invariantCulture), float.Parse(array[2], invariantCulture), float.Parse(array[3], invariantCulture)));
					}
					break;
				case "usemtl":
					triangles = Bucket(array[1].Trim(), list5, list6, index);
					break;
				case "f":
					AddFace(array, list, list2, list3, list4, lookup, list7, list8, list9, outShades, triangles);
					break;
				}
			}
			for (int num = list6.Count - 1; num >= 0; num--)
			{
				if (list6[num].Count == 0)
				{
					list6.RemoveAt(num);
					list5.RemoveAt(num);
				}
			}
			if (list7.Count == 0 || list6.Count == 0)
			{
				GrovePlugin.Log.LogError((object)("Model " + name + " has no geometry."));
				return null;
			}
			Mesh val = new Mesh
			{
				name = name
			};
			if (list7.Count > 65535)
			{
				val.indexFormat = (IndexFormat)1;
				GrovePlugin.Log.LogInfo((object)(name + " needs 32 bit indices (" + list7.Count + " verts)."));
			}
			val.SetVertices(list7);
			if (list8.Count == list7.Count)
			{
				val.SetUVs(0, list8);
			}
			val.subMeshCount = list6.Count;
			for (int j = 0; j < list6.Count; j++)
			{
				val.SetTriangles(list6[j], j);
			}
			if (list9.Count == list7.Count)
			{
				val.SetNormals(list9);
			}
			else
			{
				val.RecalculateNormals();
			}
			Color[] array2 = (Color[])(object)new Color[list7.Count];
			for (int k = 0; k < array2.Length; k++)
			{
				array2[k] = Color.white;
			}
			val.colors = array2;
			val.RecalculateBounds();
			val.RecalculateTangents();
			int num2 = 0;
			for (int l = 0; l < list6.Count; l++)
			{
				num2 += list6[l].Count;
			}
			GrovePlugin.Log.LogInfo((object)string.Format("Loaded {0}: {1} verts, {2} tris, parts [{3}]", name, list7.Count, num2 / 3, string.Join(", ", list5.ToArray())));
			return new ModelData
			{
				Mesh = val,
				Groups = list5.ToArray()
			};
		}

		private static List<int> Bucket(string material, List<string> names, List<List<int>> buckets, Dictionary<string, int> index)
		{
			if (index.TryGetValue(material, out var value))
			{
				return buckets[value];
			}
			index[material] = buckets.Count;
			names.Add(material);
			buckets.Add(new List<int>());
			return buckets[buckets.Count - 1];
		}

		private static void AddFace(string[] parts, List<Vector3> positions, List<Vector2> uvs, List<Vector3> normals, List<Color> shades, Dictionary<string, int> lookup, List<Vector3> outPositions, List<Vector2> outUvs, List<Vector3> outNormals, List<Color> outShades, List<int> triangles)
		{
			//IL_0055: 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_006c: 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_0098: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>(parts.Length - 1);
			for (int i = 1; i < parts.Length; i++)
			{
				string text = parts[i];
				if (!lookup.TryGetValue(text, out var value))
				{
					string[] fields = text.Split(new char[1] { '/' });
					int num = Index(fields, 0, positions.Count);
					if (num < 0)
					{
						continue;
					}
					outPositions.Add(positions[num]);
					outShades.Add((num < shades.Count) ? shades[num] : Color.white);
					int num2 = Index(fields, 1, uvs.Count);
					outUvs.Add((num2 >= 0) ? uvs[num2] : Vector2.zero);
					int num3 = Index(fields, 2, normals.Count);
					outNormals.Add((num3 >= 0) ? normals[num3] : Vector3.up);
					value = (lookup[text] = outPositions.Count - 1);
				}
				list.Add(value);
			}
			for (int j = 2; j < list.Count; j++)
			{
				triangles.Add(list[0]);
				triangles.Add(list[j - 1]);
				triangles.Add(list[j]);
			}
		}

		private static int Index(string[] fields, int slot, int count)
		{
			if (slot >= fields.Length)
			{
				return -1;
			}
			string text = fields[slot];
			if (string.IsNullOrEmpty(text))
			{
				return -1;
			}
			if (!int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return -1;
			}
			if (result > 0)
			{
				result--;
			}
			else if (result < 0)
			{
				result = count + result;
			}
			if (result < 0 || result >= count)
			{
				return -1;
			}
			return result;
		}
	}
	internal static class PropIndex
	{
		private static Dictionary<string, GameObject> _index;

		private static readonly string[] Chaff = new string[5] { "destruction", "broken", "lod", "vfx", "sfx" };

		public static GameObject Find(string name)
		{
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(name);
				if ((Object)(object)prefab != (Object)null)
				{
					return prefab;
				}
			}
			if (_index == null)
			{
				BuildIndex();
			}
			if (!_index.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		private static void BuildIndex()
		{
			//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_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)
			_index = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.transform.parent != (Object)null || (Object)(object)val.GetComponentInChildren<MeshRenderer>(true) == (Object)null)
				{
					continue;
				}
				Scene scene = val.scene;
				bool flag = ((Scene)(ref scene)).IsValid();
				if (_index.TryGetValue(((Object)val).name, out var value))
				{
					if (flag)
					{
						continue;
					}
					scene = value.scene;
					if (!((Scene)(ref scene)).IsValid())
					{
						continue;
					}
				}
				_index[((Object)val).name] = val;
			}
			GrovePlugin.Log.LogInfo((object)("Prop index built: " + _index.Count + " candidates with meshes."));
		}

		public static void Search(string keywords)
		{
			if (string.IsNullOrEmpty(keywords))
			{
				return;
			}
			if (_index == null)
			{
				BuildIndex();
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string key in _index.Keys)
			{
				hashSet.Add(key);
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
				{
					if ((Object)(object)prefab != (Object)null)
					{
						hashSet.Add(((Object)prefab).name);
					}
				}
			}
			string[] array = keywords.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				List<string> list = new List<string>();
				foreach (string item in hashSet)
				{
					if (item.IndexOf(text, StringComparison.OrdinalIgnoreCase) < 0)
					{
						continue;
					}
					string text2 = item.ToLowerInvariant();
					string text3 = text.ToLowerInvariant();
					bool flag = false;
					string[] chaff = Chaff;
					foreach (string value in chaff)
					{
						if (text2.Contains(value) && !text3.Contains(value))
						{
							flag = true;
						}
					}
					if (!flag)
					{
						list.Add(item);
					}
				}
				list.Sort();
				GrovePlugin.Log.LogInfo((object)("Prefabs matching '" + text + "' (" + list.Count + "): " + string.Join(", ", list.GetRange(0, Math.Min(40, list.Count)).ToArray())));
			}
		}
	}
	internal class Sapling : MonoBehaviour, Hoverable
	{
		private const string ZBlood = "groveBlood";

		public static float SwayDegrees = 3.2f;

		public static float SwayPeriod = 5.6f;

		public static float BreathPeriod = 3.7f;

		public static float BreathDepth = 0.035f;

		private float _stirPhase;

		public static readonly List<Sapling> All = new List<Sapling>();

		private static readonly string[] StageNames = new string[4] { "newly planted", "rooting", "swelling", "ready to open" };

		public Transform[] Stages = (Transform[])(object)new Transform[0];

		private ZNetView _nview;

		private Piece _piece;

		private int _shown = -1;

		private WearNTear _wear;

		private Destructible _destructible;

		private float _lastCry = -99f;

		private Quaternion[] _restRotation;

		private Vector3[] _restScale;

		private float Condition
		{
			get
			{
				if ((Object)(object)_wear != (Object)null)
				{
					return Mathf.Clamp01(_wear.GetHealthPercentage());
				}
				if ((Object)(object)_destructible == (Object)null)
				{
					return 1f;
				}
				ZNetView component = ((Component)_destructible).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					return 1f;
				}
				float num = Mathf.Max(1f, _destructible.m_health);
				return Mathf.Clamp01(component.GetZDO().GetFloat(ZDOVars.s_health, num) / num);
			}
		}

		public float Blood
		{
			get
			{
				if (!((Object)(object)_nview != (Object)null) || !_nview.IsValid())
				{
					return 0f;
				}
				return _nview.GetZDO().GetFloat("groveBlood", 0f);
			}
		}

		public float Needed => GroveConfig.BloodNeededNow();

		public float Progress => Mathf.Clamp01(Blood / Needed);

		private void Awake()
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
			_piece = ((Component)this).GetComponent<Piece>();
			All.Add(this);
			WatchForHarm();
		}

		private void WatchForHarm()
		{
			_wear = ((Component)this).GetComponentInChildren<WearNTear>(true);
			if ((Object)(object)_wear != (Object)null)
			{
				_wear.m_onDamaged = (Action)Delegate.Combine(_wear.m_onDamaged, new Action(Hurt));
				_wear.m_onDestroyed = (Action)Delegate.Combine(_wear.m_onDestroyed, new Action(Lost));
			}
			_destructible = ((Component)this).GetComponentInChildren<Destructible>(true);
			if (!((Object)(object)_destructible == (Object)null))
			{
				_destructible.m_onDamaged = (Action)Delegate.Combine(_destructible.m_onDamaged, new Action(Hurt));
				_destructible.m_onDestroyed = (Action)Delegate.Combine(_destructible.m_onDestroyed, new Action(Lost));
			}
		}

		private void Hurt()
		{
			if (GroveConfig.Messages.Value && !((Object)(object)Player.m_localPlayer == (Object)null) && !(Time.time - _lastCry < 5f))
			{
				_lastCry = Time.time;
				((Character)Player.m_localPlayer).Message((MessageType)1, Localization.instance.Localize(GetHoverName() + " is being torn at."), 0, (Sprite)null);
			}
		}

		private void Lost()
		{
			GrovePlugin.Log.LogInfo((object)(GetHoverName() + " was destroyed at " + Mathf.FloorToInt(Blood) + "/" + Mathf.FloorToInt(Needed) + "."));
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize(GetHoverName() + " was destroyed."), 0, (Sprite)null);
			}
		}

		private void OnDestroy()
		{
			All.Remove(this);
		}

		private void Start()
		{
			Show();
		}

		public void Feed(float amount)
		{
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid() && !(amount <= 0f))
			{
				_nview.ClaimOwnership();
				float blood = Blood;
				float num = Mathf.Min(Needed, blood + amount);
				_nview.GetZDO().Set("groveBlood", num);
				if (GroveConfig.Verbose.Value)
				{
					GrovePlugin.Log.LogInfo((object)("sapling fed " + amount + " -> " + num + "/" + Needed));
				}
				Show();
				if (num >= Needed)
				{
					Open();
				}
			}
		}

		private void Show()
		{
			if (Stages == null || Stages.Length == 0)
			{
				return;
			}
			int num = Mathf.Clamp(Mathf.FloorToInt(Progress * (float)Stages.Length), 0, Stages.Length - 1);
			if (num == _shown)
			{
				return;
			}
			_shown = num;
			for (int i = 0; i < Stages.Length; i++)
			{
				if ((Object)(object)Stages[i] != (Object)null)
				{
					((Component)Stages[i]).gameObject.SetActive(i == num);
				}
			}
		}

		private void Update()
		{
			Show();
			Stir();
		}

		private void Stir()
		{
			//IL_00bd: 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_00cf: 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)
			if (Stages != null && Stages.Length != 0 && _shown >= 0 && _shown < Stages.Length)
			{
				Transform val = Stages[_shown];
				if (!((Object)(object)val == (Object)null))
				{
					Capture();
					float num = Mathf.Lerp(0.25f, 1f, Progress);
					float num2 = Time.time + _stirPhase;
					float num3 = Mathf.Sin(num2 * ((float)Math.PI * 2f / SwayPeriod)) * SwayDegrees * num;
					float num4 = Mathf.Cos(num2 * ((float)Math.PI * 2f / (SwayPeriod * 1.37f))) * SwayDegrees * 0.6f * num;
					val.localRotation = _restRotation[_shown] * Quaternion.Euler(num3, 0f, num4);
					float num5 = 1f + Mathf.Sin(num2 * ((float)Math.PI * 2f / BreathPeriod)) * BreathDepth * num;
					val.localScale = _restScale[_shown] * num5;
				}
			}
		}

		private void Capture()
		{
			//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_00c1: 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_006b: 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_0070: 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_008c: 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)
			if (_restRotation == null || _restRotation.Length != Stages.Length)
			{
				_restRotation = (Quaternion[])(object)new Quaternion[Stages.Length];
				_restScale = (Vector3[])(object)new Vector3[Stages.Length];
				for (int i = 0; i < Stages.Length; i++)
				{
					_restRotation[i] = (((Object)(object)Stages[i] != (Object)null) ? Stages[i].localRotation : Quaternion.identity);
					_restScale[i] = (((Object)(object)Stages[i] != (Object)null) ? Stages[i].localScale : Vector3.one);
				}
				Vector3 position = ((Component)this).transform.position;
				_stirPhase = Mathf.Abs(position.x * 12.9898f + position.z * 78.233f) % ((float)Math.PI * 2f);
			}
		}

		private unsafe void Open()
		{
			//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_0077: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid() && _nview.IsOwner())
			{
				GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab("ForestSpirit") : null);
				if ((Object)(object)val == (Object)null)
				{
					GrovePlugin.LogOnce("Sapling is ready but ForestSpirit is not registered - it will stay ready.");
					return;
				}
				Vector3 val2 = ((Component)this).transform.position + Vector3.up * GroveConfig.SpiritRise.Value;
				Object.Instantiate<GameObject>(val, val2, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f));
				ManualLogSource log = GrovePlugin.Log;
				Vector3 val3 = val2;
				log.LogInfo((object)("A forest spirit answered at " + ((object)(*(Vector3*)(&val3))/*cast due to .constrained prefix*/).ToString() + "."));
				_nview.Destroy();
			}
		}

		public string GetHoverName()
		{
			if (!((Object)(object)_piece != (Object)null))
			{
				return GroveConfig.SaplingName.Value;
			}
			return _piece.m_name;
		}

		public string GetHoverText()
		{
			int num = Mathf.Clamp(Mathf.FloorToInt(Progress * (float)StageNames.Length), 0, StageNames.Length - 1);
			float condition = Condition;
			string text = ((condition < 0.999f) ? $"\n<color=#dd6666>damaged</color>  ( {Mathf.CeilToInt(condition * 100f)}% )" : "");
			return Localization.instance.Localize($"{GetHoverName()}\n{StageNames[num]}  ( {Mathf.FloorToInt(Blood)} / {Mathf.FloorToInt(Needed)} ){text}");
		}
	}
	internal static class SaplingPrefab
	{
		public const string Name = "grove_ancient_sapling";

		private const string StageMesh = "grove_sapling_{0}.obj";

		private const int Stages = 1;

		private static GameObject _prefab;

		private static GameObject _holder;

		public static bool Ready
		{
			get
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab("grove_ancient_sapling") != (Object)null;
				}
				return false;
			}
		}

		public static bool Register()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			if (Ready && InCultivator())
			{
				return true;
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = Build();
				if ((Object)(object)_prefab == (Object)null)
				{
					return false;
				}
			}
			AddToScene();
			AddToCultivator();
			if (Ready)
			{
				return InCultivator();
			}
			return false;
		}

		private static GameObject Donor()
		{
			ZNetScene instance = ZNetScene.instance;
			string[] array = new string[2]
			{
				GroveConfig.SaplingDonor.Value,
				"sapling_carrot"
			};
			foreach (string text in array)
			{
				if (!string.IsNullOrEmpty(text))
				{
					GameObject prefab = instance.GetPrefab(text);
					if ((Object)(object)prefab != (Object)null)
					{
						return prefab;
					}
					GrovePlugin.LogOnce("Sapling donor '" + text + "' does not exist.");
				}
			}
			return null;
		}

		private static GameObject Build()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00fd: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Donor();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			string directoryName = Path.GetDirectoryName(typeof(SaplingPrefab).Assembly.Location);
			ModelData[] array = new ModelData[1];
			for (int i = 0; i < 1; i++)
			{
				array[i] = ObjMesh.Load(Path.Combine(directoryName, $"grove_sapling_{i + 1}.obj"));
				if (array[i] == null)
				{
					GrovePlugin.Log.LogError((object)("Sapling stage mesh " + (i + 1) + " is missing from beside the dll."));
					return null;
				}
			}
			if ((Object)(object)_holder == (Object)null)
			{
				_holder = new GameObject("GroveSaplingHolder");
				_holder.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_holder);
			}
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			ZNetView.m_forceDisableInit = true;
			GameObject val2;
			try
			{
				val2 = Object.Instantiate<GameObject>(val, _holder.transform);
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			((Object)val2).name = "grove_ancient_sapling";
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one * GroveConfig.SaplingScale.Value;
			Strip(val2);
			Dress(val2);
			Fortify(val2);
			Transform[] stages = Visuals(val2, array);
			Sapling sapling = val2.GetComponent<Sapling>();
			if ((Object)(object)sapling == (Object)null)
			{
				sapling = val2.AddComponent<Sapling>();
			}
			sapling.Stages = stages;
			GrovePlugin.Log.LogInfo((object)("Built grove_ancient_sapling from " + ((Object)val).name + "."));
			return val2;
		}

		private static void Strip(GameObject clone)
		{
			Plant[] componentsInChildren = clone.GetComponentsInChildren<Plant>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
			}
			Pickable[] componentsInChildren2 = clone.GetComponentsInChildren<Pickable>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren2[i]);
			}
			MeshRenderer[] componentsInChildren3 = clone.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val in componentsInChildren3)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static void Dress(GameObject clone)
		{
			Piece component = clone.GetComponent<Piece>();
			if (!((Object)(object)component == (Object)null))
			{
				component.m_name = GroveConfig.SaplingName.Value;
				component.m_description = "It grows on what dies near it.";
				component.m_resources = Requirements(GroveConfig.SaplingCost.Value);
				Sprite val = Icons.Load(GroveConfig.SaplingIcon.Value, "grove_ancient_sapling");
				if ((Object)(object)val != (Object)null)
				{
					component.m_icon = val;
				}
				component.m_groundPiece = true;
				component.m_groundOnly = true;
				component.m_cultivatedGroundOnly = GroveConfig.NeedsCultivated.Value;
				component.m_targetNonPlayerBuilt = false;
			}
		}

		private static void Fortify(GameObject clone)
		{
			float health = Mathf.Max(1f, GroveConfig.SaplingHealth.Value);
			List<string> list = new List<string>();
			WearNTear[] componentsInChildren = clone.GetComponentsInChildren<WearNTear>(true);
			foreach (WearNTear val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.m_health = health;
					val.m_noSupportWear = true;
					val.m_noRoofWear = true;
					list.Add("WearNTear");
				}
			}
			Destructible[] componentsInChildren2 = clone.GetComponentsInChildren<Destructible>(true);
			foreach (Destructible val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					val2.m_health = health;
					val2.m_ttl = 0f;
					val2.m_minToolTier = 0;
					list.Add("Destructible");
				}
			}
			if (list.Count == 0)
			{
				GrovePlugin.LogOnce("The sapling donor carries neither WearNTear nor Destructible, so it cannot be damaged and cannot be given health either.");
				return;
			}
			GrovePlugin.Log.LogInfo((object)("Sapling health set to " + health + " on " + string.Join(" + ", list.ToArray()) + "."));
		}

		private static Transform[] Visuals(GameObject clone, ModelData[] models)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Transform[] array = (Transform[])(object)new Transform[models.Length];
			for (int i = 0; i < models.Length; i++)
			{
				GameObject val = new GameObject("stage" + (i + 1));
				val.transform.SetParent(clone.transform, false);
				val.AddComponent<MeshFilter>().sharedMesh = models[i].Mesh;
				((Renderer)val.AddComponent<MeshRenderer>()).sharedMaterials = Skins.Skin(models[i].Groups);
				Skins.Remap(models[i].Mesh, models[i].Groups);
				val.SetActive(false);
				array[i] = val.transform;
			}
			return array;
		}

		private static Requirement[] Requirements(string spec)
		{
			//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_00c2: 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_00d6: Expected O, but got Unknown
			List<Requirement> list = new List<Requirement>();
			string[] array = (spec ?? "").Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ':' });
				if (array2.Length != 2)
				{
					continue;
				}
				string text = array2[0].Trim();
				if (text.Length != 0 && int.TryParse(array2[1].Trim(), out var result) && result > 0)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
					ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
					if ((Object)(object)val == (Object)null)
					{
						GrovePlugin.LogOnce("Sapling cost mentions unknown item '" + text + "'.");
						continue;
					}
					list.Add(new Requirement
					{
						m_resItem = val,
						m_amount = result,
						m_recover = false
					});
				}
			}
			return list.ToArray();
		}

		private static void AddToScene()
		{
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)_prefab == (Object)null || (Object)(object)instance.GetPrefab("grove_ancient_sapling") != (Object)null)
			{
				return;
			}
			if (!instance.m_prefabs.Contains(_prefab))
			{
				instance.m_prefabs.Add(_prefab);
			}
			try
			{
				((Dictionary<int, GameObject>)AccessTools.Field(typeof(ZNetScene), "m_namedPrefabs").GetValue(instance))[StringExtensionMethods.GetStableHashCode("grove_ancient_sapling")] = _prefab;
			}
			catch (Exception ex)
			{
				GrovePlugin.Log.LogError((object)("Could not register grove_ancient_sapling: " + ex.Message));
			}
		}

		private static bool InCultivator()
		{
			PieceTable val = CultivatorPieces();
			if ((Object)(object)val != (Object)null && (Object)(object)_prefab != (Object)null)
			{
				return val.m_pieces.Contains(_prefab);
			}
			return false;
		}

		private static PieceTable CultivatorPieces()
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Cultivator");
			ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null || val.m_itemData == null || val.m_itemData.m_shared == null)
			{
				return null;
			}
			PieceTable buildPieces = val.m_itemData.m_shared.m_buildPieces;
			if (!((Object)(object)buildPieces != (Object)null) || buildPieces.m_pieces == null)
			{
				return null;
			}
			return buildPieces;
		}

		private static void AddToCultivator()
		{
			if (!((Object)(object)_prefab == (Object)null))
			{
				PieceTable val = CultivatorPieces();
				if (!((Object)(object)val == (Object)null) && !val.m_pieces.Contains(_prefab))
				{
					val.m_pieces.Add(_prefab);
					GrovePlugin.Log.LogInfo((object)"Ancient sapling added to the cultivator.");
				}
			}
		}
	}
	internal static class Skins
	{
		private const string GlowGroup = "core";

		private const string Emission = "_EmissionColor";

		private static readonly Dictionary<string, string[]> Donors = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"bark",
				new string[3] { "wood_wall", "wood_beam", "piece_chest_wood" }
			},
			{
				"wood",
				new string[3] { "wood_wall", "wood_beam", "piece_chest_wood" }
			},
			{
				"seed",
				new string[2] { "wood_beam", "wood_wall" }
			},
			{
				"stone",
				new string[3] { "stone_wall_2x1", "piece_stonecutter", "smelter" }
			},
			{
				"moss",
				new string[5] { "sapling_carrot", "sapling_turnip", "Bush01", "shrub_2", "piece_beehive" }
			}
		};

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

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

		public static void Invalidate()
		{
			Cache.Clear();
			Atlas.Clear();
		}

		public static Material For(string group)
		{
			if (Cache.TryGetValue(group, out var value))
			{
				return value;
			}
			if (group == "core")
			{
				Material val = Pick(group, mustEmit: true);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return Pick(group, mustEmit: false);
		}

		private static Material Pick(string group, bool mustEmit)
		{
			//IL_00b6: 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)
			string[] array = DonorsFor(group);
			foreach (string text in array)
			{
				GameObject val = PropIndex.Find(text);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				MeshRenderer[] componentsInChildren = val.GetComponentsInChildren<MeshRenderer>(true);
				foreach (MeshRenderer val2 in componentsInChildren)
				{
					Material sharedMaterial = ((Renderer)val2).sharedMaterial;
					if (!((Object)(object)sharedMaterial == (Object)null) && !((Object)(object)sharedMaterial.shader == (Object)null) && sharedMaterial.HasProperty("_MainTex") && !((Object)(object)sharedMaterial.GetTexture("_MainTex") == (Object)null) && (!mustEmit || sharedMaterial.HasProperty("_EmissionColor")))
					{
						Cache[group] = sharedMaterial;
						Atlas[group] = UvRegion((Renderer)(object)val2);
						GrovePlugin.Log.LogInfo((object)string.Format("'{0}' skinned with {1} from {2} (shader {3}){4}, atlas {5}.", group, ((Object)sharedMaterial).name, text, ((Object)sharedMaterial.shader).name, mustEmit ? " [emissive]" : "", Atlas[group]));
						return sharedMaterial;
					}
				}
			}
			if (mustEmit)
			{
				return null;
			}
			GrovePlugin.Log.LogWarning((object)("No material found for group '" + group + "'."));
			Cache[group] = null;
			return null;
		}

		private static string[] DonorsFor(string group)
		{
			if (string.Equals(group, "core", StringComparison.OrdinalIgnoreCase))
			{
				return (GroveConfig.GlowDonors.Value ?? "").Split(new char[1] { ',' });
			}
			if (!Donors.TryGetValue(group, out var value))
			{
				return Donors["wood"];
			}
			return value;
		}

		public static Material[] Skin(string[] groups)
		{
			Material[] array = (Material[])(object)new Material[groups.Length];
			for (int i = 0; i < groups.Length; i++)
			{
				array[i] = For(groups[i]);
			}
			return array;
		}

		private static Rect UvRegion(Renderer renderer)
		{
			//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_020f: 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_0055: 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_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_0093: 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_020a: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(0f, 0f, 1f, 1f);
			MeshFilter val2 = (((Object)(object)renderer != (Object)null) ? ((Component)renderer).GetComponent<MeshFilter>() : null);
			Mesh val3 = (((Object)(object)val2 != (Object)null) ? val2.sharedMesh : null);
			if ((Object)(object)val3 == (Object)null)
			{
				return val;
			}
			Vector2[] uv;
			int[] triangles;
			try
			{
				if (!val3.isReadable)
				{
					return val;
				}
				uv = val3.uv;
				triangles = val3.triangles;
			}
			catch
			{
				return val;
			}
			if (uv == null || uv.Length == 0 || triangles == null || triangles.Length < 3)
			{
				return val;
			}
			float num = 0f;
			Rect result = val;
			for (int i = 0; i + 2 < triangles.Length; i += 3)
			{
				int num2 = triangles[i];
				int num3 = triangles[i + 1];
				int num4 = triangles[i + 2];
				if (num2 >= uv.Length || num3 >= uv.Length || num4 >= uv.Length)
				{
					continue;
				}
				float num5 = Mathf.Min(uv[num2].x, Mathf.Min(uv[num3].x, uv[num4].x));
				float num6 = Mathf.Max(uv[num2].x, Mathf.Max(uv[num3].x, uv[num4].x));
				float num7 = Mathf.Min(uv[num2].y, Mathf.Min(uv[num3].y, uv[num4].y));
				float num8 = Mathf.Max(uv[num2].y, Mathf.Max(uv[num3].y, uv[num4].y));
				float num9 = num6 - num5;
				float num10 = num8 - num7;
				if (!(num9 <= 0.005f) && !(num10 <= 0.005f) && !(num9 > 1f) && !(num10 > 1f))
				{
					float num11 = num9 * num10;
					if (!(num11 <= num))
					{
						num = num11;
						((Rect)(ref result))..ctor(num5, num7, num9, num10);
					}
				}
			}
			if (!(num > 0f))
			{
				return val;
			}
			return result;
		}

		public static void Remap(Mesh mesh, string[] groups)
		{
			//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)
			if ((Object)(object)mesh == (Object)null || groups == null)
			{
				return;
			}
			Vector2[] uv = mesh.uv;
			if (uv == null || uv.Length == 0)
			{
				return;
			}
			int num = Mathf.Min(groups.Length, mesh.subMeshCount);
			bool[] array = new bool[uv.Length];
			for (int i = 0; i < num; i++)
			{
				if (!Atlas.TryGetValue(groups[i], out var value) || (((Rect)(ref value)).width >= 0.999f && ((Rect)(ref value)).height >= 0.999f))
				{
					continue;
				}
				int[] triangles = mesh.GetTriangles(i);
				foreach (int num2 in triangles)
				{
					if (num2 >= 0 && num2 < uv.Length && !array[num2])
					{
						array[num2] = true;
						uv[num2] = new Vector2(((Rect)(ref value)).x + Mathf.Clamp01(uv[num2].x) * ((Rect)(ref value)).width, ((Rect)(ref value)).y + Mathf.Clamp01(uv[num2].y) * ((Rect)(ref value)).height);
					}
				}
			}
			mesh.uv = uv;
		}
	}
	internal static class SpiritPrefab
	{
		public const string Name = "ForestSpirit";

		private const string HeartMesh = "grove_spirit_heart.obj";

		private const string HoopMesh = "grove_spirit_hoop.obj";

		private const string MoteMesh = "grove_spirit_mote.obj";

		private static GameObject _prefab;

		private static GameObject _holder;

		private static Material _glow;

		public static bool Ready
		{
			get
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab("ForestSpirit") != (Object)null;
				}
				return false;
			}
		}

		public static bool Register()
		{
			if (Ready)
			{
				return true;
			}
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = Build();
				if ((Object)(object)_prefab == (Object)null)
				{
					return false;
				}
			}
			AddToScene(instance);
			return Ready;
		}

		private static GameObject Build()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00de: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			string? directoryName = Path.GetDirectoryName(typeof(SpiritPrefab).Assembly.Location);
			ModelData modelData = ObjMesh.Load(Path.Combine(directoryName, "grove_spirit_heart.obj"));
			ModelData modelData2 = ObjMesh.Load(Path.Combine(directoryName, "grove_spirit_hoop.obj"));
			ModelData modelData3 = ObjMesh.Load(Path.Combine(directoryName, "grove_spirit_mote.obj"));
			if (modelData == null || modelData2 == null || modelData3 == null)
			{
				GrovePlugin.Log.LogError((object)"Spirit meshes are missing from beside the dll - cannot build ForestSpirit. Expected grove_spirit_heart.obj, grove_spirit_hoop.obj and grove_spirit_mote.obj.");
				return null;
			}
			if ((Object)(object)_holder == (Object)null)
			{
				_holder = new GameObject("GroveSpiritHolder");
				_holder.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_holder);
			}
			bool forceDisableInit = ZNetView.m_forceDisableInit;
			ZNetView.m_forceDisableInit = true;
			GameObject val;
			try
			{
				val = new GameObject("ForestSpirit");
				val.transform.SetParent(_holder.transform, false);
				float value = GroveConfig.SpiritScale.Value;
				val.transform.localScale = new Vector3(value, value, value);
				ZNetView obj = val.AddComponent<ZNetView>();
				obj.m_persistent = true;
				obj.m_type = (ObjectType)0;
				obj.m_distant = false;
				Material val2 = Glow();
				GameObject val3 = Part(val.transform, "heart", modelData, val2);
				GameObject val4 = new GameObject("rings");
				val4.transform.SetParent(val.transform, false);
				Rings(val4.transform, modelData2, modelData3, val2);
				Reach(val);
				ForestSpirit forestSpirit = val.AddComponent<ForestSpirit>();
				forestSpirit.Heart = val3.transform;
				forestSpirit.Hoop = val4.transform;
			}
			finally
			{
				ZNetView.m_forceDisableInit = forceDisableInit;
			}
			int num = Mathf.Max(1, GroveConfig.RingCount.Value);
			int num2 = Mathf.Max(0, GroveConfig.MoteCount.Value);
			GrovePlugin.Log.LogInfo((object)("Built ForestSpirit: heart " + modelData.Mesh.vertexCount + " verts, " + num + " ring(s) of " + num2 + " = " + num * num2 + " beads, " + (GroveConfig.ShowHoop.Value ? "hoop drawn" : "hoop hidden") + "."));
			return val;
		}

		private static void Rings(Transform parent, ModelData hoop, ModelData mote, Material glow)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_006e: 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)
			int num = Mathf.Max(1, GroveConfig.RingCount.Value);
			int num2 = Mathf.Max(0, GroveConfig.MoteCount.Value);
			for (int i = 0; i < num; i++)
			{
				GameObject val = new GameObject("ring" + i);
				val.transform.SetParent(parent, false);
				val.transform.localRotation = Quaternion.Euler(90f + 180f / (float)num * (float)i, 0f, 0f);
				if (GroveConfig.ShowHoop.Value)
				{
					Part(val.transform, "hoop", hoop, glow);
				}
				for (int j = 0; j < num2; j++)
				{
					float num3 = (360f / (float)num2 * (float)j + 12f * (float)i) * ((float)Math.PI / 180f);
					Part(val.transform, "mote" + i + "_" + j, mote, glow).transform.localPosition = new Vector3(Mathf.Cos(num3) * ForestSpirit.Orbit, Mathf.Sin(num3) * ForestSpirit.Orbit, 0f);
				}
			}
		}

		private static void Reach(GameObject root)
		{
			SphereCollider obj = root.AddComponent<SphereCollider>();
			obj.radius = ForestSpirit.Orbit + 0.16f;
			((Collider)obj).isTrigger = false;
			Rigidbody obj2 = root.AddComponent<Rigidbody>();
			obj2.isKinematic = true;
			obj2.useGravity = false;
			root.layer = LayerMask.NameToLayer("Default");
		}

		private static GameObject Part(Transform parent, string name, ModelData model, Material skin)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<MeshFilter>().sharedMesh = model.Mesh;
			MeshRenderer val2 = val.AddComponent<MeshRenderer>();
			Material[] array = (Material[])(object)new Material[model.Groups.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = skin;
			}
			((Renderer)val2).sharedMaterials = array;
			Skins.Remap(model.Mesh, model.Groups);
			((Renderer)val2).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)val2).receiveShadows = false;
			return val;
		}

		private static Material Glow()
		{
			if ((Object)(object)_glow != (Object)null)
			{
				return _glow;
			}
			_glow = Skins.For("core");
			if ((Object)(object)_glow != (Object)null)
			{
				return _glow;
			}
			GrovePlugin.Log.LogWarning((object)"No GlowDonor resolved - falling back to any material. The spirit will be visible but will not glow. Turn on DumpMaterials to find a donor worth naming.");
			MeshRenderer[] array = Resources.FindObjectsOfTypeAll<MeshRenderer>();
			foreach (MeshRenderer val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Renderer)val).sharedMaterial == (Object)null))
				{
					_glow = ((Renderer)val).sharedMaterial;
					break;
				}
			}
			return _glow;
		}

		public static void DumpMaterials()
		{
			string[] array = (GroveConfig.GlowDonors.Value ?? "").Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				GameObject val = PropIndex.Find(text);
				if ((Object)(object)val == (Object)null)
				{
					GrovePlugin.Log.LogInfo((object)("donor " + text + ": not loaded"));
					continue;
				}
				Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					Material[] sharedMaterials = componentsInChildren[j].sharedMaterials;
					foreach (Material val2 in sharedMaterials)
					{
						if (!((Object)(object)val2 == (Object)null))
						{
							GrovePlugin.Log.LogInfo((object)string.Format("donor {0}: {1} shader={2} emission={3} albedo={4}", text, ((Object)val2).name, ((Object)(object)val2.shader != (Object)null) ? ((Object)val2.shader).name : "none", val2.HasProperty("_EmissionColor"), val2.HasProperty("_MainTex") && (Object)(object)val2.GetTexture("_MainTex") != (Object)null));
						}
					}
				}
			}
		}

		private static void AddToScene(ZNetScene scene)
		{
			if (!((Object)(object)_prefab == (Object)null) && !((Object)(object)scene.GetPrefab("ForestSpirit") != (Object)null))
			{
				if (!scene.m_prefabs.Contains(_prefab))
				{
					scene.m_prefabs.Add(_prefab);
				}
				try
				{
					((Dictionary<int, GameObject>)AccessTools.Field(typeof(ZNetScene), "m_namedPrefabs").GetValue(scene))[StringExtensionMethods.GetStableHashCode("ForestSpirit")] = _prefab;
				}
				catch (Exception ex)
				{
					GrovePlugin.Log.LogError((object)("Could not register ForestSpirit: " + ex.Message));
					return;
				}
				GrovePlugin.Log.LogInfo((object)"Registered ForestSpirit with ZNetScene. Try: spawn ForestSpirit");
			}
		}
	}
	internal static class StowCoupling
	{
		private const string PostPrefab = "stow_post";

		private static bool _done;

		public static void Invalidate()
		{
			_done = false;
		}

		public static void Apply()
		{
			if (_done || !GroveConfig.CoupleToStow.Value || (Object)(object)ZNetScene.instance == (Object)null || (Object)(object)ObjectDB.instance == (Object)null || !HeartwoodPrefab.Ready)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("stow_post");
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				GrovePlugin.LogOnce("Found stow_post but it has no Piece - not touching its recipe.");
				_done = true;
				return;
			}
			List<Requirement> list = Requirements(GroveConfig.StowPostCost.Value);
			if (list.Count == 0)
			{
				_done = true;
				return;
			}
			component.m_resources = Merge(component.m_resources, list);
			_done = true;
			GrovePlugin.Log.LogInfo((object)"The stowing post now costs heartwood.");
		}

		private static Requirement[] Merge(Requirement[] existing, List<Requirement> extra)
		{
			List<Requirement> list = new List<Requirement>((IEnumerable<Requirement>)(((object)existing) ?? ((object)new Requirement[0])));
			foreach (Requirement item in extra)
			{
				bool flag = false;
				foreach (Requirement item2 in list)
				{
					if (!((Object)(object)item2.m_resItem == (Object)null) && !((Object)(object)item.m_resItem == (Object)null) && !(((Object)item2.m_resItem).name != ((Object)item.m_resItem).name))
					{
						item2.m_amount = Mathf.Max(item2.m_amount, item.m_amount);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(item);
				}
			}
			return list.ToArray();
		}

		private static List<Requirement> Requirements(string spec)
		{
			//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_00c2: 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_00d6: Expected O, but got Unknown
			List<Requirement> list = new List<Requirement>();
			string[] array = (spec ?? "").Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ':' });
				if (array2.Length != 2)
				{
					continue;
				}
				string text = array2[0].Trim();
				if (text.Length != 0 && int.TryParse(array2[1].Trim(), out var result) && result > 0)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
					ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
					if ((Object)(object)val == (Object)null)
					{
						GrovePlugin.LogOnce("Stow post cost mentions unknown item '" + text + "'.");
						continue;
					}
					list.Add(new Requirement
					{
						m_resItem = val,
						m_amount = result,
						m_recover = true
					});
				}
			}
			return list;
		}
	}
}