using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using ExtraPotions.Meadworks.Contracts;
using ExtraPotions.Meadworks.Crucible;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtraPotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.21.0")]
[assembly: AssemblyInformationalVersion("0.1.21+fatal: not a git repository (or any of the parent directories): .git")]
[assembly: AssemblyProduct("Wildroot.Core")]
[assembly: AssemblyTitle("Wildroot.Core")]
[assembly: AssemblyVersion("0.1.21.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 ExtraPotions.Wildroot
{
	public enum ExtraResourceOrigin
	{
		None,
		LocalFile,
		Server
	}
	public enum CatalogMatch
	{
		Unknown,
		Same,
		Different
	}
	public sealed class CatalogMismatchGate
	{
		public const double SettleSeconds = 10.0;

		private string pending = "";

		private string warned = "";

		private double since;

		public bool Pending
		{
			get
			{
				if (pending.Length > 0)
				{
					return !string.Equals(pending, warned, StringComparison.Ordinal);
				}
				return false;
			}
		}

		public double Since => since;

		public string? Observe(CatalogMatch match, string? server, string? local, double now)
		{
			if (match != CatalogMatch.Different)
			{
				pending = "";
				warned = "";
				return null;
			}
			string text = server + "/" + local;
			if (!string.Equals(text, pending, StringComparison.Ordinal))
			{
				pending = text;
				since = now;
				return null;
			}
			if (now - since < 10.0 || string.Equals(text, warned, StringComparison.Ordinal))
			{
				return null;
			}
			warned = text;
			return text;
		}
	}
	public static class CatalogDistribution
	{
		public const int MaxSharedLength = 65536;

		public static ExtraResourceOrigin Origin(SessionRole role, bool enabled)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			if (enabled)
			{
				if ((int)role != 3)
				{
					return ExtraResourceOrigin.LocalFile;
				}
				return ExtraResourceOrigin.Server;
			}
			return ExtraResourceOrigin.None;
		}

		public static bool Publishes(SessionRole role)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)role != 2)
			{
				return (int)role == 4;
			}
			return true;
		}

		public static string? Shareable(string? text)
		{
			if (text == null)
			{
				text = "";
			}
			if (text.Length <= 65536)
			{
				return text;
			}
			return null;
		}

		public static string Fingerprint(IEnumerable<PlantDefinition> definitions)
		{
			if (definitions == null)
			{
				throw new ArgumentNullException("definitions");
			}
			IOrderedEnumerable<string> values = definitions.Select(Line).OrderBy<string, string>((string l) => l, StringComparer.Ordinal);
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(string.Join("\n", values)));
			StringBuilder stringBuilder = new StringBuilder(16);
			for (int num = 0; num < 8; num++)
			{
				stringBuilder.Append(array[num].ToString("x2", CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		public static CatalogMatch Compare(string? server, string? local)
		{
			if (!string.IsNullOrEmpty(server) && !string.IsNullOrEmpty(local))
			{
				if (!string.Equals(server, local, StringComparison.Ordinal))
				{
					return CatalogMatch.Different;
				}
				return CatalogMatch.Same;
			}
			return CatalogMatch.Unknown;
		}

		private static string Line(PlantDefinition d)
		{
			return string.Join("|", d.Id, d.Prefab, d.GrownPrefab, d.Kind.ToString(), string.Join(",", d.Costs.Select((ResourceCost c) => c.ItemId + ":" + c.Amount.ToString(CultureInfo.InvariantCulture))), d.HarvestItem, d.Yield.ToString(CultureInfo.InvariantCulture), N(d.GrowMin), N(d.GrowMax), N(d.RespawnSeconds), N(d.Radius), N(d.ScaleMin), N(d.ScaleMax), d.Enabled ? "1" : "0", d.Free ? "1" : "0");
			static string N(double v)
			{
				return v.ToString("R", CultureInfo.InvariantCulture);
			}
		}
	}
	public sealed class RecordedValue
	{
		public object Handle { get; }

		public string Member { get; }

		public object? Original { get; }

		internal RecordedValue(object handle, string member, object? original)
		{
			Handle = handle;
			Member = member;
			Original = original;
		}
	}
	public sealed class MutationLedger
	{
		private sealed class Key : IEquatable<Key>
		{
			private readonly object handle;

			private readonly string member;

			public Key(object handle, string member)
			{
				this.handle = handle;
				this.member = member;
			}

			public bool Equals(Key? other)
			{
				if (other != null && handle == other.handle)
				{
					return string.Equals(member, other.member, StringComparison.Ordinal);
				}
				return false;
			}

			public override bool Equals(object? obj)
			{
				return Equals(obj as Key);
			}

			public override int GetHashCode()
			{
				return RuntimeHelpers.GetHashCode(handle) * 31 + StringComparer.Ordinal.GetHashCode(member);
			}
		}

		private readonly Dictionary<Key, RecordedValue> index = new Dictionary<Key, RecordedValue>();

		private readonly List<RecordedValue> order = new List<RecordedValue>();

		public int Count => order.Count;

		public bool Capture(object handle, string member, object? original)
		{
			if (handle == null)
			{
				throw new ArgumentNullException("handle");
			}
			if (string.IsNullOrEmpty(member))
			{
				throw new ArgumentException("Expected a member name.", "member");
			}
			Key key = new Key(handle, member);
			if (index.ContainsKey(key))
			{
				return false;
			}
			RecordedValue recordedValue = new RecordedValue(handle, member, original);
			index.Add(key, recordedValue);
			order.Add(recordedValue);
			return true;
		}

		public RecordedValue? Original(object handle, string member)
		{
			if (handle == null || member == null || !index.TryGetValue(new Key(handle, member), out RecordedValue value))
			{
				return null;
			}
			return value;
		}

		public IReadOnlyList<RecordedValue> Restore()
		{
			List<RecordedValue> list = order.AsEnumerable().Reverse().ToList();
			order.Clear();
			index.Clear();
			return list.AsReadOnly();
		}
	}
	public static class CultivatorMembership
	{
		public static IReadOnlyList<string> Restore(IEnumerable<string> current, IEnumerable<string> native, IEnumerable<string> managed)
		{
			HashSet<string> hashSet = new HashSet<string>(native ?? throw new ArgumentNullException("native"), StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(managed ?? throw new ArgumentNullException("managed"), StringComparer.Ordinal);
			List<string> list = new List<string>();
			foreach (string item in current ?? throw new ArgumentNullException("current"))
			{
				if ((!hashSet2.Contains(item) || hashSet.Contains(item)) && !list.Contains(item))
				{
					list.Add(item);
				}
			}
			foreach (string item2 in native)
			{
				if (!list.Contains(item2))
				{
					list.Add(item2);
				}
			}
			return list.AsReadOnly();
		}
	}
	public static class CatalogLoader
	{
		private static string Text(JObject value, string key, string fallback = "")
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			JToken val = value[key];
			if (val == null)
			{
				return fallback;
			}
			if ((int)val.Type != 8)
			{
				throw new ArgumentException("Expected text for " + key);
			}
			return Extensions.Value<string>((IEnumerable<JToken>)val) ?? fallback;
		}

		private static double Number(JObject value, string key, double fallback)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			JToken val = value[key];
			if (val == null)
			{
				return fallback;
			}
			if ((int)val.Type != 7 && (int)val.Type != 6)
			{
				throw new ArgumentException("Expected number for " + key);
			}
			double num = Extensions.Value<double>((IEnumerable<JToken>)val);
			if (double.IsNaN(num) || double.IsInfinity(num))
			{
				throw new ArgumentException("Nonfinite " + key);
			}
			return num;
		}

		private static int Integer(JObject value, string key, int fallback)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			JToken val = value[key];
			if (val == null)
			{
				return fallback;
			}
			if ((int)val.Type != 6)
			{
				throw new ArgumentException("Expected integer for " + key);
			}
			return Extensions.Value<int>((IEnumerable<JToken>)val);
		}

		private static bool Flag(JObject value, string key, bool fallback)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			JToken val = value[key];
			if (val == null)
			{
				return fallback;
			}
			if ((int)val.Type != 9)
			{
				throw new ArgumentException("Expected boolean for " + key);
			}
			return Extensions.Value<bool>((IEnumerable<JToken>)val);
		}

		public static CatalogLoadResult Load(string json, IPrefabCatalog prefabs)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			if (prefabs == null)
			{
				throw new ArgumentNullException("prefabs");
			}
			List<string> list = new List<string>();
			List<PlantDefinition> list2 = new List<PlantDefinition>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			try
			{
				if (json == null || json.Length > 1048576)
				{
					throw new ArgumentException("Catalog size exceeded");
				}
				JObject val2;
				using (StringReader stringReader = new StringReader(json))
				{
					JsonTextReader val = new JsonTextReader((TextReader)stringReader)
					{
						MaxDepth = 32,
						FloatParseHandling = (FloatParseHandling)1
					};
					try
					{
						val2 = JObject.Load((JsonReader)(object)val, new JsonLoadSettings
						{
							DuplicatePropertyNameHandling = (DuplicatePropertyNameHandling)2
						});
						if (((JsonReader)val).Read())
						{
							throw new ArgumentException("Trailing catalog content");
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				if (Integer(val2, "schema", -1) != 1)
				{
					throw new ArgumentException("Unsupported catalog schema");
				}
				JToken obj = val2["entries"];
				JArray val3 = (JArray)(object)((obj is JArray) ? obj : null);
				if (val3 == null || ((JContainer)val3).Count > 4096)
				{
					throw new ArgumentException("Invalid catalog entry count");
				}
				foreach (JToken item in val3)
				{
					try
					{
						JObject val4 = (JObject)(object)((item is JObject) ? item : null);
						if (val4 == null)
						{
							throw new ArgumentException("Entry must be an object");
						}
						string text = Text(val4, "id");
						string prefab = Text(val4, "prefab");
						string text2 = Text(val4, "grownPrefab");
						string text3 = Text(val4, "harvestItem");
						if (string.IsNullOrWhiteSpace(text) || text.Length > 128 || !hashSet.Add(text))
						{
							throw new ArgumentException("Missing, oversized or duplicate id");
						}
						if (!prefabs.HasPrefab(prefab) || (!string.IsNullOrEmpty(text2) && !prefabs.HasPrefab(text2)))
						{
							throw new ArgumentException("Unknown prefab");
						}
						if (!Enum.TryParse<PlantKind>(Text(val4, "kind"), ignoreCase: false, out var result) || !Enum.IsDefined(typeof(PlantKind), result))
						{
							throw new ArgumentException("Unknown plant kind");
						}
						bool flag = Flag(val4, "enabled", fallback: true);
						bool flag2 = Flag(val4, "free", fallback: false);
						List<ResourceCost> list3 = new List<ResourceCost>();
						JToken obj2 = val4["costs"];
						foreach (JToken item2 in (JArray)(((obj2 is JArray) ? obj2 : null) ?? throw new ArgumentException("Costs must be explicit")))
						{
							JObject val5 = (JObject)(object)((item2 is JObject) ? item2 : null);
							if (val5 == null)
							{
								throw new ArgumentException("Invalid cost");
							}
							string text4 = Text(val5, "item");
							if (!prefabs.HasItem(text4))
							{
								throw new ArgumentException("Unknown material");
							}
							list3.Add(new ResourceCost(text4, Integer(val5, "amount", 0)));
						}
						if (flag && list3.Count == 0 && !flag2)
						{
							throw new ArgumentException("No implicit free planting");
						}
						int num = Integer(val4, "yield", 0);
						if (num < 0 || (!string.IsNullOrEmpty(text3) && !prefabs.HasItem(text3)) || (num > 0 && string.IsNullOrEmpty(text3)))
						{
							throw new ArgumentException("Invalid harvest");
						}
						double num2 = Number(val4, "growMin", 0.0);
						double num3 = Number(val4, "growMax", num2);
						double num4 = Number(val4, "respawnSeconds", 0.0);
						double num5 = Number(val4, "radius", 1.0);
						double num6 = Number(val4, "scaleMin", 1.0);
						double num7 = Number(val4, "scaleMax", num6);
						if (num2 < 0.0 || num3 < num2 || num4 < 0.0 || num5 < 0.0 || num6 <= 0.0 || num7 < num6)
						{
							throw new ArgumentException("Invalid growth, scale or spacing range");
						}
						list2.Add(new PlantDefinition(text, prefab, text2, result, list3, text3, num, num2, num3, num4, num5, num6, num7, flag, flag2));
					}
					catch (Exception ex) when (ex is ArgumentException || ex is OverflowException || ex is FormatException)
					{
						list.Add("Entry " + list2.Count + ": " + ex.Message);
					}
				}
			}
			catch (Exception ex2) when (ex2 is JsonException || ex2 is ArgumentException || ex2 is OverflowException || ex2 is FormatException)
			{
				list.Add(ex2.Message);
			}
			return new CatalogLoadResult((list.Count == 0) ? new CatalogSnapshot(list2) : null, list);
		}
	}
	public enum PlantKind
	{
		Crop,
		Sapling,
		Pickable,
		Decorative,
		Vine
	}
	public sealed class PlantDefinition
	{
		public string Id { get; }

		public string Prefab { get; }

		public string GrownPrefab { get; }

		public PlantKind Kind { get; }

		public IReadOnlyList<ResourceCost> Costs { get; }

		public string HarvestItem { get; }

		public int Yield { get; }

		public double GrowMin { get; }

		public double GrowMax { get; }

		public double RespawnSeconds { get; }

		public double Radius { get; }

		public double ScaleMin { get; }

		public double ScaleMax { get; }

		public bool Enabled { get; }

		public bool Free { get; }

		public PlantDefinition(string id, string prefab, string grownPrefab, PlantKind kind, IReadOnlyList<ResourceCost> costs, string harvestItem, int yield, double growMin, double growMax, double respawnSeconds, double radius, double scaleMin, double scaleMax, bool enabled, bool free)
		{
			Id = id;
			Prefab = prefab;
			GrownPrefab = grownPrefab;
			Kind = kind;
			Costs = new List<ResourceCost>(costs).AsReadOnly();
			HarvestItem = harvestItem;
			Yield = yield;
			GrowMin = growMin;
			GrowMax = growMax;
			RespawnSeconds = respawnSeconds;
			Radius = radius;
			ScaleMin = scaleMin;
			ScaleMax = scaleMax;
			Enabled = enabled;
			Free = free;
		}
	}
	public interface IPrefabCatalog
	{
		bool HasPrefab(string prefab);

		bool HasItem(string item);
	}
	public sealed class CatalogSnapshot
	{
		public IReadOnlyList<PlantDefinition> Entries { get; }

		public CatalogSnapshot(IReadOnlyList<PlantDefinition> entries)
		{
			Entries = new List<PlantDefinition>(entries).AsReadOnly();
		}
	}
	public sealed class CatalogLoadResult
	{
		public CatalogSnapshot? Snapshot { get; }

		public IReadOnlyList<string> Errors { get; }

		public bool Valid
		{
			get
			{
				if (Snapshot != null)
				{
					return Errors.Count == 0;
				}
				return false;
			}
		}

		public CatalogLoadResult(CatalogSnapshot? snapshot, IReadOnlyList<string> errors)
		{
			Snapshot = snapshot;
			Errors = new List<string>(errors).AsReadOnly();
		}
	}
	public sealed class CatalogStore
	{
		public CatalogSnapshot Current { get; private set; }

		public CatalogStore(CatalogSnapshot initial)
		{
			Current = initial ?? throw new ArgumentNullException("initial");
		}

		public bool TryReplace(CatalogLoadResult candidate)
		{
			if (candidate == null || !candidate.Valid)
			{
				return false;
			}
			Current = candidate.Snapshot;
			return true;
		}
	}
	public readonly struct PlantState
	{
		public double Started { get; }

		public double Duration { get; }

		public bool Picked { get; }

		public bool Blocked { get; }

		public PlantState(double started, double duration, bool picked, bool blocked)
		{
			Started = started;
			Duration = duration;
			Picked = picked;
			Blocked = blocked;
		}
	}
	public enum GrowthPhase
	{
		Growing,
		Ready,
		Regrowing,
		Blocked,
		Exhausted
	}
	public readonly struct GrowthResult
	{
		public GrowthPhase Phase { get; }

		public double Fraction { get; }

		public double Remaining { get; }

		public GrowthResult(GrowthPhase phase, double fraction, double remaining)
		{
			Phase = phase;
			Fraction = fraction;
			Remaining = remaining;
		}
	}
	public interface ICatalogSettings
	{
		bool TryGet<T>(string id, out T value);
	}
	public sealed class CatalogSettings : ICatalogSettings
	{
		private readonly Dictionary<string, object> values;

		public CatalogSettings(IDictionary<string, object>? values = null)
		{
			this.values = new Dictionary<string, object>(values ?? new Dictionary<string, object>(), StringComparer.Ordinal);
		}

		public CatalogSettings With(string id, object value)
		{
			CatalogSettings catalogSettings = new CatalogSettings(values);
			catalogSettings.values[id] = value;
			return catalogSettings;
		}

		public bool TryGet<T>(string id, out T value)
		{
			if (values.TryGetValue(id, out object value2) && value2 is T val)
			{
				value = val;
				return true;
			}
			value = default(T);
			return false;
		}
	}
	public enum CatalogSection
	{
		None,
		Berries,
		Mushrooms,
		Flowers,
		Debris,
		Crops,
		Saplings,
		Vines,
		MiscFlora
	}
	public readonly struct GrowthOverride
	{
		public double GrowMin { get; }

		public double GrowMax { get; }

		public double Radius { get; }

		public double ScaleMin { get; }

		public double ScaleMax { get; }

		public GrowthOverride(double growMin, double growMax, double radius, double scaleMin, double scaleMax)
		{
			GrowMin = growMin;
			GrowMax = growMax;
			Radius = radius;
			ScaleMin = scaleMin;
			ScaleMax = scaleMax;
		}
	}
	public static class CatalogPolicy
	{
		public const double MinimumSaplingGrowth = 10.0;

		private static readonly Dictionary<string, (CatalogSection section, string stem)> Stems = new Dictionary<string, (CatalogSection, string)>(StringComparer.Ordinal)
		{
			{
				"RaspberryBush",
				(CatalogSection.Berries, "Raspberry")
			},
			{
				"BlueberryBush",
				(CatalogSection.Berries, "Blueberry")
			},
			{
				"CloudberryBush",
				(CatalogSection.Berries, "Cloudberry")
			},
			{
				"LingonberryBush",
				(CatalogSection.Berries, "Lingonberry")
			},
			{
				"Pickable_Mushroom",
				(CatalogSection.Mushrooms, "Mushroom")
			},
			{
				"Pickable_Mushroom_yellow",
				(CatalogSection.Mushrooms, "YellowMushroom")
			},
			{
				"Pickable_Mushroom_blue",
				(CatalogSection.Mushrooms, "BlueMushroom")
			},
			{
				"Pickable_SmokePuff",
				(CatalogSection.Mushrooms, "Smokepuff")
			},
			{
				"Pickable_Thistle",
				(CatalogSection.Flowers, "Thistle")
			},
			{
				"Pickable_Dandelion",
				(CatalogSection.Flowers, "Dandelion")
			},
			{
				"Pickable_Fiddlehead",
				(CatalogSection.Flowers, "Fiddlehead")
			},
			{
				"Pickable_Branch",
				(CatalogSection.Debris, "PickableBranch")
			},
			{
				"Pickable_Stone",
				(CatalogSection.Debris, "PickableStone")
			},
			{
				"Pickable_Flint",
				(CatalogSection.Debris, "PickableFlint")
			},
			{
				"sapling_barley",
				(CatalogSection.Crops, "Barley")
			},
			{
				"sapling_carrot",
				(CatalogSection.Crops, "Carrot")
			},
			{
				"sapling_flax",
				(CatalogSection.Crops, "Flax")
			},
			{
				"sapling_onion",
				(CatalogSection.Crops, "Onion")
			},
			{
				"sapling_seedcarrot",
				(CatalogSection.Crops, "SeedCarrot")
			},
			{
				"sapling_seedonion",
				(CatalogSection.Crops, "SeedOnion")
			},
			{
				"sapling_seedturnip",
				(CatalogSection.Crops, "SeedTurnip")
			},
			{
				"sapling_turnip",
				(CatalogSection.Crops, "Turnip")
			},
			{
				"sapling_magecap",
				(CatalogSection.Crops, "Magecap")
			},
			{
				"sapling_jotunpuffs",
				(CatalogSection.Crops, "JotunPuffs")
			},
			{
				"sapling_oat",
				(CatalogSection.Crops, "Oat")
			},
			{
				"sapling_poteitr",
				(CatalogSection.Crops, "Poteitr")
			},
			{
				"sapling_Kale",
				(CatalogSection.Crops, "Kale")
			},
			{
				"sapling_seedkale",
				(CatalogSection.Crops, "SeedKale")
			},
			{
				"Beech_Sapling",
				(CatalogSection.Saplings, "Beech")
			},
			{
				"Birch_Sapling",
				(CatalogSection.Saplings, "Birch")
			},
			{
				"Autumn_Birch_Sapling",
				(CatalogSection.Saplings, "AutumnBirch")
			},
			{
				"Ancient_Sapling",
				(CatalogSection.Saplings, "Ancient")
			},
			{
				"Ygga_Sapling",
				(CatalogSection.Saplings, "Ygga")
			},
			{
				"Ashwood_Sapling",
				(CatalogSection.Saplings, "Ashwood")
			},
			{
				"Oak_Sapling",
				(CatalogSection.Saplings, "Oak")
			},
			{
				"FirTree_Sapling",
				(CatalogSection.Saplings, "Fir")
			},
			{
				"FirTree_big_Sapling",
				(CatalogSection.Saplings, "Timberwood")
			},
			{
				"PineTree_Sapling",
				(CatalogSection.Saplings, "Pine")
			}
		};

		public const string AshlandsCropsId = "Restrictions.AshlandsCrops";

		private static readonly Point3[] VineSnaps = new Point3[4]
		{
			new Point3(1.0, -0.5, 0.0),
			new Point3(-1.0, -0.5, 0.0),
			new Point3(1.0, -2.0, 0.0),
			new Point3(-1.0, -2.0, 0.0)
		};

		public static readonly IReadOnlyCollection<string> PickedSpawners = new HashSet<string>(StringComparer.Ordinal) { "Pickable_Mushroom", "Pickable_Mushroom_yellow", "Pickable_Mushroom_blue", "Pickable_SmokePuff", "Pickable_Thistle", "Pickable_Dandelion", "Pickable_Fiddlehead" };

		public static CatalogSection Section(PlantDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (Stems.TryGetValue(definition.Id, out (CatalogSection, string) value))
			{
				return value.Item1;
			}
			return definition.Kind switch
			{
				PlantKind.Vine => CatalogSection.Vines, 
				PlantKind.Decorative => CatalogSection.MiscFlora, 
				PlantKind.Sapling => CatalogSection.Saplings, 
				PlantKind.Crop => CatalogSection.Crops, 
				_ => CatalogSection.None, 
			};
		}

		public static string Stem(PlantDefinition definition)
		{
			if (definition == null || !Stems.TryGetValue(definition.Id, out (CatalogSection, string) value))
			{
				return "";
			}
			return value.Item2;
		}

		private static bool Flag(ICatalogSettings s, string id, bool fallback)
		{
			if (!s.TryGet<bool>(id, out var value))
			{
				return fallback;
			}
			return value;
		}

		private static double Number(ICatalogSettings s, string id, double fallback, IList<string>? warnings, double min = 0.0)
		{
			double num;
			int value2;
			if (s.TryGet<float>(id, out var value))
			{
				num = value;
			}
			else if (s.TryGet<int>(id, out value2))
			{
				num = value2;
			}
			else
			{
				if (!s.TryGet<double>(id, out var value3))
				{
					return fallback;
				}
				num = value3;
			}
			if (double.IsNaN(num) || double.IsInfinity(num) || num < min)
			{
				warnings?.Add(id + " out of range; kept " + fallback.ToString(CultureInfo.InvariantCulture));
				return fallback;
			}
			return num;
		}

		public static ISet<string> DisabledNames(ICatalogSettings s)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			if (!s.TryGet<string>("Catalog.DisabledResourceNames", out var value) || string.IsNullOrWhiteSpace(value))
			{
				return hashSet;
			}
			string[] array = value.Split(',');
			foreach (string text in array)
			{
				if (text.Trim().Length > 0)
				{
					hashSet.Add(text.Trim());
				}
			}
			return hashSet;
		}

		public static bool CropOverrides(ICatalogSettings s)
		{
			return Flag(s, "Growth.Crops.EnableCropOverrides", fallback: false);
		}

		public static bool VineOverrides(ICatalogSettings s)
		{
			return Flag(s, "Growth.Vines.EnableVineOverrides", fallback: false);
		}

		public static double? VineAttachDistance(ICatalogSettings s)
		{
			if (!VineOverrides(s))
			{
				return null;
			}
			return Number(s, "Growth.Vines.VineAttachDistance", 1.8, null);
		}

		public static GrowthOverride? ModdedCrop(ICatalogSettings s)
		{
			if (!CropOverrides(s) || !Flag(s, "Growth.Crops.OverrideModdedCrops", fallback: true))
			{
				return null;
			}
			return CropGrowth(s, new GrowthOverride(4000.0, 5000.0, 0.5, 0.9, 1.1), null);
		}

		public static GrowthOverride? ModdedSapling(ICatalogSettings s)
		{
			if (!Flag(s, "Growth.Saplings.OverrideModdedSaplings", fallback: false))
			{
				return null;
			}
			double num = Math.Max(10.0, Number(s, "Growth.Saplings.ModdedSaplingGrowthTime", 3000.0, null));
			double num2 = Number(s, "Growth.Saplings.ModdedSaplingMinScale", 0.5, null, 1E-06);
			return new GrowthOverride(scaleMax: Math.Max(num2, Number(s, "Growth.Saplings.ModdedSaplingMaxScale", 2.0, null, 1E-06)), growMin: num, growMax: num, radius: Number(s, "Growth.Saplings.ModdedSaplingGrowRadius", 2.0, null), scaleMin: num2);
		}

		private static GrowthOverride CropGrowth(ICatalogSettings s, GrowthOverride current, IList<string>? warnings)
		{
			double num = Number(s, "Growth.Crops.CropGrowTimeMin", current.GrowMin, warnings);
			double growMax = Math.Max(num, Number(s, "Growth.Crops.CropGrowTimeMax", current.GrowMax, warnings));
			double num2 = Number(s, "Growth.Crops.CropMinScale", current.ScaleMin, warnings, 1E-06);
			return new GrowthOverride(scaleMax: Math.Max(num2, Number(s, "Growth.Crops.CropMaxScale", current.ScaleMax, warnings, 1E-06)), growMin: num, growMax: growMax, radius: Number(s, "Growth.Crops.CropGrowRadius", current.Radius, warnings), scaleMin: num2);
		}

		public static CatalogSnapshot Apply(CatalogSnapshot baseline, ICatalogSettings settings, IList<string>? warnings = null)
		{
			if (baseline == null || settings == null)
			{
				throw new ArgumentNullException("baseline");
			}
			ISet<string> disabled = DisabledNames(settings);
			bool misc = Flag(settings, "Catalog.EnableMiscFlora", fallback: true);
			bool debris = Flag(settings, "Catalog.EnableDebris", fallback: true);
			bool crops = CropOverrides(settings);
			bool vines = VineOverrides(settings);
			return new CatalogSnapshot(baseline.Entries.Select((PlantDefinition d) => Effective(d, settings, disabled, misc, debris, crops, vines, warnings)).ToList());
		}

		private static PlantDefinition Effective(PlantDefinition d, ICatalogSettings s, ISet<string> disabled, bool misc, bool debris, bool crops, bool vines, IList<string>? warnings)
		{
			CatalogSection catalogSection = Section(d);
			string text = Stem(d);
			IReadOnlyList<ResourceCost> costs = d.Costs;
			int num = d.Yield;
			double num2 = d.RespawnSeconds;
			double num3 = d.GrowMin;
			double growMax = d.GrowMax;
			double num4 = d.Radius;
			double num5 = d.ScaleMin;
			double num6 = d.ScaleMax;
			bool enabled = d.Enabled;
			object obj;
			string text2;
			switch (catalogSection)
			{
			case CatalogSection.Berries:
			case CatalogSection.Mushrooms:
			case CatalogSection.Flowers:
				obj = "Catalog.Vanilla." + catalogSection.ToString() + ".";
				goto IL_00a8;
			case CatalogSection.Debris:
				obj = "Catalog.Vanilla.Debris.";
				goto IL_00a8;
			case CatalogSection.Crops:
				if (crops && text.Length > 0)
				{
					costs = Cost(costs, Number(s, "Catalog.Vanilla.Crops." + text + "Cost", FirstAmount(costs), warnings), ref enabled);
					num = (int)Number(s, "Catalog.Vanilla.Crops." + text + "Return", num, warnings);
					GrowthOverride growthOverride = CropGrowth(s, new GrowthOverride(num3, growMax, num4, num5, num6), warnings);
					num3 = growthOverride.GrowMin;
					growMax = growthOverride.GrowMax;
					num4 = growthOverride.Radius;
					num5 = growthOverride.ScaleMin;
					num6 = growthOverride.ScaleMax;
				}
				break;
			case CatalogSection.Saplings:
				if (text.Length > 0)
				{
					num3 = (growMax = Math.Max(10.0, Number(s, "Growth.Saplings." + text + "GrowthTime", num3, warnings)));
					num4 = Number(s, "Growth.Saplings." + text + "GrowRadius", num4, warnings);
					num5 = Number(s, "Growth.Saplings." + text + "MinScale", num5, warnings, 1E-06);
					num6 = Math.Max(num5, Number(s, "Growth.Saplings." + text + "MaxScale", num6, warnings, 1E-06));
				}
				break;
			case CatalogSection.Vines:
				if (vines)
				{
					num3 = (growMax = Number(s, "Growth.Vines.VineGrowthTime", num3, warnings));
					num4 = Number(s, "Growth.Vines.VineGrowRadius", num4, warnings);
					num2 = Number(s, "Growth.Vines.VineBerryRespawnTime", num2 / 60.0, warnings) * 60.0;
					num = (int)Number(s, "Growth.Vines.VineBerryReturn", num, warnings);
				}
				break;
			case CatalogSection.MiscFlora:
				{
					if (!misc)
					{
						enabled = false;
					}
					break;
				}
				IL_00a8:
				text2 = (string)obj;
				costs = Cost(costs, Number(s, text2 + text + "Cost", FirstAmount(costs), warnings), ref enabled);
				num = (int)Number(s, text2 + text + "Return", num, warnings);
				num2 = Number(s, text2 + text + "RespawnTime", num2 / 60.0, warnings) * 60.0;
				if (catalogSection == CatalogSection.Debris && !debris)
				{
					enabled = false;
				}
				break;
			}
			if (disabled.Contains(d.Prefab))
			{
				enabled = false;
			}
			return new PlantDefinition(d.Id, d.Prefab, d.GrownPrefab, d.Kind, costs, d.HarvestItem, num, num3, growMax, num2, num4, num5, num6, enabled, d.Free);
		}

		public static bool EnforcesBiome(PlantDefinition definition, bool nativePrefab, ICatalogSettings s)
		{
			if (definition == null || s == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (definition.Kind != PlantKind.Crop && definition.Kind != PlantKind.Sapling && definition.Kind != PlantKind.Vine)
			{
				return false;
			}
			if (!nativePrefab)
			{
				return Flag(s, "Restrictions.EnforceBiomes", fallback: false);
			}
			return Flag(s, "Restrictions.EnforceBiomesVanilla", fallback: true);
		}

		public static bool AshlandsCrops(ICatalogSettings s)
		{
			return Flag(s ?? throw new ArgumentNullException("s"), "Restrictions.AshlandsCrops", fallback: true);
		}

		public static int? ReferenceBiome(string prefab, ICatalogSettings s)
		{
			return ReferenceTraits.Biome(prefab, AshlandsCrops(s));
		}

		public static CatalogSnapshot WithExtras(CatalogSnapshot effective, IReadOnlyList<ExtraResourceDefinition> extras, ICatalogSettings s, IList<string>? warnings = null)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			if (effective == null || extras == null || s == null)
			{
				throw new ArgumentNullException("effective");
			}
			ISet<string> set = DisabledNames(s);
			List<PlantDefinition> list = effective.Entries.ToList();
			HashSet<string> hashSet = new HashSet<string>(list.Select((PlantDefinition e) => e.Prefab), StringComparer.Ordinal);
			foreach (ExtraResourceDefinition extra in extras)
			{
				if (extra != null)
				{
					if (!hashSet.Add(extra.Prefab))
					{
						warnings?.Add("Extra resource " + extra.Prefab + " is already a catalog entry; skipped");
						continue;
					}
					list.Add(new PlantDefinition(extra.Prefab, extra.Prefab, "", PlantKind.Decorative, (IReadOnlyList<ResourceCost>)(object)new ResourceCost[1]
					{
						new ResourceCost(extra.Material, extra.Cost)
					}, "", 0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, !set.Contains(extra.Prefab), free: false));
				}
			}
			return new CatalogSnapshot(list);
		}

		public static IReadOnlyList<Point3> VineSnapPoints(PlantDefinition definition, ICatalogSettings s)
		{
			if (definition == null || s == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (!(definition.Id == "vines") || !Flag(s, "Catalog.SnappableVines", fallback: true))
			{
				return Array.Empty<Point3>();
			}
			return VineSnaps;
		}

		public static bool ShowsPickedSpawner(string prefab, ICatalogSettings s)
		{
			if (s != null && prefab != null && PickedSpawners.Contains(prefab))
			{
				return Flag(s, "Catalog.ShowPickableSpawners", fallback: true);
			}
			return false;
		}

		private static double FirstAmount(IReadOnlyList<ResourceCost> costs)
		{
			return (costs.Count > 0) ? costs[0].Amount : 0;
		}

		private static IReadOnlyList<ResourceCost> Cost(IReadOnlyList<ResourceCost> costs, double amount, ref bool enabled)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if (costs.Count == 0)
			{
				return costs;
			}
			int num = (int)Math.Min(2147483647.0, Math.Round(amount));
			if (num <= 0)
			{
				enabled = false;
				return costs;
			}
			List<ResourceCost> list = costs.ToList();
			list[0] = new ResourceCost(costs[0].ItemId, num);
			return list;
		}
	}
	public readonly struct PiecePolicy
	{
		public bool Targetable { get; }

		public bool Removable { get; }

		public bool RecoverResources { get; }

		public bool ToleratesEnvironment { get; }

		public bool GroundOnly { get; }

		public bool RequiresCultivation { get; }

		public bool RequiresSunlight { get; }

		public bool RequiresGrowthSpace { get; }

		public PiecePolicy(bool targetable, bool removable, bool recover, bool tolerates, bool groundOnly, bool cultivation, bool sunlight, bool growthSpace)
		{
			Targetable = targetable;
			Removable = removable;
			RecoverResources = recover;
			ToleratesEnvironment = tolerates;
			GroundOnly = groundOnly;
			RequiresCultivation = cultivation;
			RequiresSunlight = sunlight;
			RequiresGrowthSpace = growthSpace;
		}
	}
	public static class PiecePolicies
	{
		private static bool Flag(ICatalogSettings s, string id, bool fallback)
		{
			if (!s.TryGet<bool>(id, out var value))
			{
				return fallback;
			}
			return value;
		}

		public static PiecePolicy For(PlantDefinition definition, ICatalogSettings s)
		{
			if (definition == null || s == null)
			{
				throw new ArgumentNullException("definition");
			}
			CatalogSection catalogSection = CatalogPolicy.Section(definition);
			bool flag = CatalogPolicy.CropOverrides(s);
			bool flag2 = catalogSection == CatalogSection.Crops;
			bool flag3 = definition.Kind == PlantKind.Pickable;
			bool targetable = ((!flag2) ? Flag(s, "Restrictions.EnemiesTargetPieces", fallback: true) : (!flag || Flag(s, "Growth.Crops.EnemiesTargetCrops", fallback: true)));
			bool removable = catalogSection != CatalogSection.MiscFlora || Flag(s, "Restrictions.CanRemoveFlora", fallback: false);
			bool recover = (catalogSection == CatalogSection.Berries || catalogSection == CatalogSection.Mushrooms || catalogSection == CatalogSection.Flowers) && Flag(s, "Restrictions.RecoverResources", fallback: false);
			bool tolerates = !Flag(s, "Restrictions.PlantsRequireShielding", fallback: true);
			bool num = Flag(s, "Restrictions.PlaceAnywhere", fallback: false) && catalogSection != CatalogSection.Mushrooms && catalogSection != CatalogSection.Flowers && !flag2;
			bool flag4 = definition.Prefab == "FernAshlands" || definition.Prefab == "Pickable_Branch" || definition.Prefab == "Pickable_Stone" || definition.Prefab == "Pickable_Flint";
			bool groundOnly = !num || flag4;
			bool cultivation = ((!flag2) ? (flag3 && Flag(s, "Restrictions.RequireCultivation", fallback: false)) : (!flag || Flag(s, "Growth.Crops.CropsRequireCultivation", fallback: true)));
			bool sunlight = !num && (!flag2 || !flag || Flag(s, "Growth.Crops.CropsRequireSunlight", fallback: true));
			bool growthSpace = !num && (!flag2 || !flag || Flag(s, "Growth.Crops.CropsRequireGrowthSpace", fallback: true));
			return new PiecePolicy(targetable, removable, recover, tolerates, groundOnly, cultivation, sunlight, growthSpace);
		}

		public static bool SpawnsEmpty(PlantDefinition definition, ICatalogSettings s)
		{
			CatalogSection catalogSection = CatalogPolicy.Section(definition);
			if (catalogSection == CatalogSection.Berries || catalogSection == CatalogSection.Mushrooms || catalogSection == CatalogSection.Flowers || catalogSection == CatalogSection.Debris)
			{
				return Flag(s, "Restrictions.ResourcesSpawnEmpty", fallback: false);
			}
			return false;
		}
	}
	public readonly struct DropEntry
	{
		public string Item { get; }

		public int StackMin { get; }

		public int StackMax { get; }

		public DropEntry(string item, int stackMin, int stackMax)
		{
			Item = item;
			StackMin = stackMin;
			StackMax = stackMax;
		}
	}
	public sealed class DropTableValues
	{
		public int Min { get; }

		public int Max { get; }

		public double Chance { get; }

		public bool OneOfEach { get; }

		public IReadOnlyList<DropEntry> Entries { get; }

		public DropTableValues(int min, int max, double chance, bool oneOfEach, IReadOnlyList<DropEntry> entries)
		{
			Min = min;
			Max = max;
			Chance = chance;
			OneOfEach = oneOfEach;
			Entries = new List<DropEntry>(entries).AsReadOnly();
		}
	}
	public static class TreeDropPolicy
	{
		public static readonly IReadOnlyCollection<string> SeedItems = new HashSet<string>(StringComparer.Ordinal) { "BeechSeeds", "BirchSeeds", "Acorn", "PineCone", "FirCone", "FirConeFrost", "AncientSeed", "Sap" };

		public static DropTableValues Apply(DropTableValues original, ICatalogSettings s)
		{
			if (original == null || s == null)
			{
				throw new ArgumentNullException("original");
			}
			if (!(s.TryGet<bool>("Drops.EnableSeedOverrides", out var value) && value))
			{
				return original;
			}
			int num = Math.Max(0, Int("Drops.treeDropMin", 1));
			int max = Math.Max(num, Int("Drops.treeDropMax", 3));
			int seedMin = Math.Max(0, Int("Drops.seedDropMin", 1));
			int seedMax = Math.Max(seedMin, Int("Drops.seedDropMax", 2));
			float value2;
			double num2 = (s.TryGet<float>("Drops.dropChance", out value2) ? ((double)value2) : 0.5);
			if (double.IsNaN(num2))
			{
				num2 = 0.5;
			}
			bool value3;
			return new DropTableValues(chance: Math.Min(1.0, Math.Max(0.0, num2)), entries: original.Entries.Select((DropEntry e) => (!SeedItems.Contains(e.Item)) ? e : new DropEntry(e.Item, seedMin, seedMax)).ToList(), min: num, max: max, oneOfEach: s.TryGet<bool>("Drops.oneOfEach", out value3) && value3);
			int Int(string id, int fallback)
			{
				if (!s.TryGet<int>(id, out var value4))
				{
					return fallback;
				}
				return value4;
			}
		}
	}
	public static class HoverTimer
	{
		public static string Format(double remainingSeconds, double fraction, bool asPercentage)
		{
			if (double.IsNaN(remainingSeconds) || double.IsNaN(fraction))
			{
				throw new ArgumentException("Invalid growth timer");
			}
			if (remainingSeconds <= 0.0)
			{
				return "";
			}
			if (asPercentage)
			{
				return Math.Floor(Math.Min(1.0, Math.Max(0.0, fraction)) * 100.0).ToString(CultureInfo.InvariantCulture) + "%";
			}
			long num = (long)Math.Ceiling(remainingSeconds);
			long num2 = num / 3600;
			long num3 = num % 3600 / 60;
			long num4 = num % 60;
			if (num2 <= 0)
			{
				if (num3 <= 0)
				{
					return num4 + "s";
				}
				return num3 + "m " + num4 + "s";
			}
			return num2 + "h " + num3 + "m " + num4 + "s";
		}
	}
	public sealed class ExtraResourceDefinition
	{
		public string Prefab { get; }

		public string Material { get; }

		public int Cost { get; }

		public bool GroundOnly { get; }

		public string Name { get; }

		public string Description { get; }

		public ExtraResourceDefinition(string prefab, string material, int cost, bool groundOnly, string name, string description)
		{
			Prefab = prefab;
			Material = material;
			Cost = cost;
			GroundOnly = groundOnly;
			Name = name;
			Description = description;
		}
	}
	public sealed class ExtraResourceImportResult
	{
		public bool Valid { get; }

		public IReadOnlyList<ExtraResourceDefinition> Entries { get; }

		public IReadOnlyList<string> Warnings { get; }

		public ExtraResourceImportResult(bool valid, IReadOnlyList<ExtraResourceDefinition> entries, IReadOnlyList<string> warnings)
		{
			Valid = valid;
			Entries = new List<ExtraResourceDefinition>(entries).AsReadOnly();
			Warnings = new List<string>(warnings).AsReadOnly();
		}
	}
	public static class ExtraResourceImporter
	{
		public static ExtraResourceImportResult Parse(string text, IPrefabCatalog prefabs)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Invalid comparison between Unknown and I4
			if (prefabs == null)
			{
				throw new ArgumentNullException("prefabs");
			}
			List<ExtraResourceDefinition> list = new List<ExtraResourceDefinition>();
			List<string> list2 = new List<string>();
			try
			{
				if (text == null || text.Length > 1048576)
				{
					throw new ArgumentException("Extra resource size exceeded");
				}
				using (IEnumerator<string> enumerator = Blocks(text).GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						JsonTextReader val = new JsonTextReader((TextReader)new StringReader(enumerator.Current))
						{
							MaxDepth = 32
						};
						JObject val2;
						try
						{
							val2 = JObject.Load((JsonReader)(object)val, new JsonLoadSettings
							{
								DuplicatePropertyNameHandling = (DuplicatePropertyNameHandling)2
							});
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
						try
						{
							string text2 = ReadText(val2, "prefabName");
							if (!text2.StartsWith("PE_Fake", StringComparison.Ordinal))
							{
								string text3 = ReadText(val2, "resourceName");
								JToken obj = val2["resourceCost"];
								if (obj == null || (int)obj.Type != 6)
								{
									throw new ArgumentException("Cost must be an integer");
								}
								int num = Extensions.Value<int>((IEnumerable<JToken>)val2["resourceCost"]);
								if (num <= 0 || !prefabs.HasPrefab(text2) || !prefabs.HasItem(text3))
								{
									throw new ArgumentException("Unresolved prefab/material or nonpositive cost");
								}
								JToken obj2 = val2["groundOnly"];
								if (obj2 == null || (int)obj2.Type != 9)
								{
									throw new ArgumentException("groundOnly must be boolean");
								}
								list.Add(new ExtraResourceDefinition(text2, text3, num, Extensions.Value<bool>((IEnumerable<JToken>)val2["groundOnly"]), ReadText(val2, "pieceName"), ReadText(val2, "pieceDescription")));
							}
						}
						catch (Exception ex) when (ex is ArgumentException || ex is OverflowException || ex is FormatException)
						{
							list2.Add("Skipped extra resource: " + ex.Message);
						}
					}
				}
				return new ExtraResourceImportResult(valid: true, list, list2);
			}
			catch (Exception ex2) when (ex2 is JsonException || ex2 is ArgumentException)
			{
				list2.Add(ex2.Message);
				return new ExtraResourceImportResult(valid: false, Array.Empty<ExtraResourceDefinition>(), list2);
			}
		}

		private static string ReadText(JObject obj, string name)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			JToken obj2 = obj[name];
			if (obj2 == null || (int)obj2.Type != 8)
			{
				throw new ArgumentException(name + " must be text");
			}
			return Extensions.Value<string>((IEnumerable<JToken>)obj[name]) ?? "";
		}

		private static IEnumerable<string> Blocks(string text)
		{
			int index = 0;
			int count = 0;
			while (index < text.Length)
			{
				for (; index < text.Length && (char.IsWhiteSpace(text[index]) || text[index] == ';'); index++)
				{
				}
				if (index == text.Length)
				{
					break;
				}
				if (text[index] == '{')
				{
					int num = count + 1;
					count = num;
					if (num <= 4096)
					{
						int num2 = index;
						int num3 = 0;
						bool flag = false;
						bool flag2 = false;
						for (; index < text.Length; index++)
						{
							char c = text[index];
							if (flag)
							{
								if (flag2)
								{
									flag2 = false;
									continue;
								}
								switch (c)
								{
								case '\\':
									flag2 = true;
									break;
								case '"':
									flag = false;
									break;
								}
								continue;
							}
							switch (c)
							{
							case '"':
								flag = true;
								continue;
							case '{':
								num3++;
								continue;
							case '}':
								break;
							default:
								continue;
							}
							if (--num3 != 0)
							{
								continue;
							}
							index++;
							break;
						}
						if (num3 != 0 || flag)
						{
							throw new ArgumentException("Truncated extra-resource object");
						}
						yield return text.Substring(num2, index - num2);
						continue;
					}
				}
				throw new ArgumentException("Invalid extra-resource object boundary");
			}
		}
	}
	public static class GrowthRules
	{
		private static bool Finite(double n)
		{
			if (!double.IsNaN(n))
			{
				return !double.IsInfinity(n);
			}
			return false;
		}

		public static GrowthResult Evaluate(PlantState state, double worldTime, PlantDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (!Finite(worldTime) || !Finite(state.Started) || !Finite(state.Duration) || state.Duration < 0.0)
			{
				throw new ArgumentException("Invalid growth clock");
			}
			if (state.Picked && definition.RespawnSeconds == 0.0)
			{
				return new GrowthResult(GrowthPhase.Exhausted, 1.0, 0.0);
			}
			double num = (state.Picked ? definition.RespawnSeconds : state.Duration);
			double num2 = Math.Max(0.0, worldTime - state.Started);
			double fraction = ((num == 0.0) ? 1.0 : Math.Min(1.0, num2 / num));
			double num3 = Math.Max(0.0, num - num2);
			return new GrowthResult(state.Blocked ? GrowthPhase.Blocked : ((num3 == 0.0) ? GrowthPhase.Ready : (state.Picked ? GrowthPhase.Regrowing : GrowthPhase.Growing)), fraction, num3);
		}
	}
	public sealed class LiveCatalogValues
	{
		private sealed class Value
		{
			internal object? Original;

			internal object? Applied;

			internal bool Owned;

			internal Func<object?, object?> Snapshot = Identity;
		}

		private ConditionalWeakTable<object, Dictionary<string, Value>> values = new ConditionalWeakTable<object, Dictionary<string, Value>>();

		private readonly List<WeakReference<object>> targets = new List<WeakReference<object>>();

		private static object? Identity(object? value)
		{
			return value;
		}

		public bool Apply(object target, string member, object? current, object? original, object? effective, Func<object?, object?>? snapshot = null)
		{
			snapshot = snapshot ?? new Func<object, object>(Identity);
			object obj = snapshot(current);
			if (!values.TryGetValue(target, out Dictionary<string, Value> value))
			{
				value = new Dictionary<string, Value>(StringComparer.Ordinal);
				values.Add(target, value);
				targets.Add(new WeakReference<object>(target));
			}
			if (!value.TryGetValue(member, out var value2))
			{
				bool flag = object.Equals(obj, snapshot(effective));
				bool owned = object.Equals(obj, snapshot(original)) || flag;
				Dictionary<string, Value> dictionary = value;
				Value obj2 = new Value
				{
					Original = (flag ? original : current),
					Applied = obj,
					Owned = owned,
					Snapshot = snapshot
				};
				value2 = obj2;
				dictionary[member] = obj2;
			}
			if (!value2.Owned)
			{
				return false;
			}
			if (!object.Equals(obj, value2.Applied))
			{
				value2.Owned = false;
				return false;
			}
			value2.Applied = snapshot(effective);
			return true;
		}

		public void Restore(Func<object, bool> alive, Func<object, string, object?> read, Action<object, string, object?> write)
		{
			foreach (WeakReference<object> target2 in targets)
			{
				if (!target2.TryGetTarget(out var target) || !alive(target) || !values.TryGetValue(target, out Dictionary<string, Value> value))
				{
					continue;
				}
				foreach (KeyValuePair<string, Value> item in value)
				{
					Value value2 = item.Value;
					if (value2.Owned && object.Equals(value2.Snapshot(read(target, item.Key)), value2.Applied))
					{
						write(target, item.Key, value2.Original);
					}
				}
			}
			targets.Clear();
			values = new ConditionalWeakTable<object, Dictionary<string, Value>>();
		}
	}
	public static class ReferenceTraits
	{
		private const int Meadows = 1;

		private const int Swamp = 2;

		private const int BlackForest = 8;

		private const int Plains = 16;

		private const int AshLands = 32;

		private const int Mistlands = 512;

		private const int Farmland = 25;

		private static readonly Dictionary<string, int> biomes = new Dictionary<string, int>
		{
			{ "sapling_turnip", 539 },
			{ "sapling_seedturnip", 539 },
			{ "sapling_carrot", 25 },
			{ "sapling_seedcarrot", 25 },
			{ "sapling_onion", 25 },
			{ "sapling_seedonion", 25 },
			{ "sapling_oat", 25 },
			{ "sapling_poteitr", 25 },
			{ "sapling_Kale", 25 },
			{ "sapling_seedkale", 25 },
			{ "sapling_barley", 16 },
			{ "sapling_flax", 16 },
			{ "sapling_magecap", 512 },
			{ "sapling_jotunpuffs", 512 }
		};

		private static readonly HashSet<string> ashlandsSet = new HashSet<string> { "sapling_turnip", "sapling_seedturnip", "sapling_carrot", "sapling_seedcarrot", "sapling_onion", "sapling_seedonion", "sapling_oat", "sapling_poteitr", "sapling_Kale", "sapling_seedkale" };

		private static readonly Dictionary<string, bool> heat = new Dictionary<string, bool> { { "Ashwood_Sapling", true } };

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

		public static IReadOnlyCollection<string> AshlandsCrops => ashlandsSet;

		public static int? Biome(string? prefab, bool ashlandsCrops = true)
		{
			if (prefab == null || !biomes.TryGetValue(prefab, out var value))
			{
				return null;
			}
			return (ashlandsCrops && ashlandsSet.Contains(prefab)) ? (value | 0x20) : value;
		}

		public static bool? Heat(string? prefab)
		{
			if (prefab == null || !heat.TryGetValue(prefab, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool? Cold(string? prefab)
		{
			if (prefab == null || !cold.TryGetValue(prefab, out var value))
			{
				return null;
			}
			return value;
		}
	}
	public sealed class ReferenceMod
	{
		public SourceMod Mod { get; }

		public string ConfigFile { get; }

		public string Prefix { get; }

		public ReferenceMod(string guid, string name, string configFile, string prefix)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			Mod = new SourceMod(guid, name);
			ConfigFile = configFile;
			Prefix = prefix;
		}
	}
	public enum ImportStatus
	{
		Refused,
		NothingFound,
		Blocked,
		Applied
	}
	public sealed class ImportOutcome
	{
		public ImportStatus Status { get; }

		public int Written { get; }

		public IReadOnlyList<string> Report { get; }

		internal ImportOutcome(ImportStatus status, int written, List<string> report)
		{
			Status = status;
			Written = written;
			Report = report.AsReadOnly();
		}
	}
	public static class ReferenceImport
	{
		public static IReadOnlyList<ReferenceMod> Sources { get; } = new ReferenceMod[2]
		{
			new ReferenceMod("advize.PlantEasily", "PlantEasily", "advize.PlantEasily.cfg", "PlantEasily"),
			new ReferenceMod("advize.PlantEverything", "PlantEverything", "advize.PlantEverything.cfg", "PlantEverything")
		};

		public static ConfigConverter Converter(string mappingJson)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			ConversionMapping val = ConversionMapping.Parse(mappingJson);
			return new ConfigConverter(new ConversionMapping(val.Schema, string.IsNullOrEmpty(val.SourceMod) ? "PlantEasily+PlantEverything" : val.SourceMod, 2, (IEnumerable<ConversionRule>)val.Rules));
		}

		public static bool Allowed(SessionRole role)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			return (int)role != 3;
		}

		public static IReadOnlyDictionary<string, string>? ParsePairs(string? text)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			string[] array = (text ?? "").Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					int num = text2.IndexOf('=');
					if (num <= 0 || num == text2.Length - 1)
					{
						return null;
					}
					string text3 = text2.Substring(0, num).Trim();
					string text4 = text2.Substring(num + 1).Trim();
					if (text3.Length == 0 || text4.Length == 0 || dictionary.ContainsKey(text3))
					{
						return null;
					}
					dictionary.Add(text3, text4);
				}
			}
			return dictionary;
		}

		public static ImportOutcome Run(SessionRole role, ConfigConverter converter, IEnumerable<KeyValuePair<string, string>> settings, IConversionTarget target, string? choices, string? bindingOverrides)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (converter == null)
			{
				throw new ArgumentNullException("converter");
			}
			if (settings == null)
			{
				throw new ArgumentNullException("settings");
			}
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			List<string> list = new List<string>();
			if (!Allowed(role))
			{
				list.Add("refused: connected to a server; the server owns Wildroot's world settings. Import in single player or on the server.");
				return new ImportOutcome(ImportStatus.Refused, 0, list);
			}
			List<KeyValuePair<string, string>> list2 = settings.ToList();
			Dictionary<string, ConversionRule> dictionary = converter.Mapping.Rules.ToDictionary<ConversionRule, string>((ConversionRule r) => r.Source, StringComparer.Ordinal);
			List<KeyValuePair<string, string>> list3 = new List<KeyValuePair<string, string>>();
			List<string> list4 = new List<string>();
			List<string> list5 = new List<string>();
			foreach (KeyValuePair<string, string> item in list2)
			{
				ConversionRule value3;
				if (item.Key != null && dictionary.TryGetValue(item.Key, out var value) && !value.MetadataOnly && WildrootSettings.Superseded.TryGetValue(value.Target, out string value2))
				{
					list4.Add("superseded " + item.Key + " -> " + value.Target + ": " + value2);
				}
				else if (item.Key != null && dictionary.TryGetValue(item.Key, out value3) && !value3.MetadataOnly && WildrootSettings.UnboundByDefault.Contains(value3.Target))
				{
					list5.Add("kept unbound " + item.Key + " -> " + value3.Target + ": opens from the MeadWorks menu; bind it in Wildroot's settings if wanted.");
				}
				else
				{
					list3.Add(item);
				}
			}
			if (list2.Count == 0)
			{
				list.Add("nothing found: no PlantEasily or PlantEverything settings to import.");
				return new ImportOutcome(ImportStatus.NothingFound, 0, list);
			}
			ConversionPreview val = converter.Preview((IEnumerable<KeyValuePair<string, string>>)list3);
			list.Add("Wildroot import: " + val.Values.Count + " values, " + val.Conflicts.Count + " conflicts, " + val.BindingConflicts.Count + " shortcut collisions, " + val.Errors.Count + " errors, " + val.Unknown.Count + " unknown, " + val.Metadata.Count + " metadata, " + list4.Count + " superseded, " + list5.Count + " kept unbound.");
			foreach (ConversionValue value4 in val.Values)
			{
				list.Add("value " + value4.SourceId + " -> " + value4.TargetId + " = " + Convert.ToString(value4.Value, CultureInfo.InvariantCulture));
			}
			foreach (ConversionConflict conflict in val.Conflicts)
			{
				list.Add("conflict " + conflict.TargetId + ": " + string.Join(" | ", conflict.Choices.Select((ConversionValue c) => c.SourceId + "=" + Convert.ToString(c.Value, CultureInfo.InvariantCulture))) + " (choose with Import.ConflictChoices: " + conflict.TargetId + "=<source>)");
			}
			foreach (ConversionConflict bindingConflict in val.BindingConflicts)
			{
				list.Add("collision " + bindingConflict.TargetId + ": " + string.Join(", ", bindingConflict.Choices.Select((ConversionValue c) => c.TargetId)) + " (set another key with Import.BindingOverrides: <target>=<key>)");
			}
			foreach (string error in val.Errors)
			{
				list.Add("error " + error);
			}
			foreach (string item2 in val.Unknown)
			{
				list.Add("unknown " + item2 + ": skipped (newer reference version?)");
			}
			foreach (string metadatum in val.Metadata)
			{
				list.Add("metadata " + metadatum);
			}
			list.AddRange(list4);
			list.AddRange(list5);
			IReadOnlyDictionary<string, string> readOnlyDictionary = ParsePairs(choices);
			IReadOnlyDictionary<string, string> readOnlyDictionary2 = ParsePairs(bindingOverrides);
			if (readOnlyDictionary == null || readOnlyDictionary2 == null)
			{
				list.Add("blocked: Import.ConflictChoices and Import.BindingOverrides take Target=Value pairs separated by semicolons.");
				return new ImportOutcome(ImportStatus.Blocked, 0, list);
			}
			if (val.Values.Count == 0 && val.Errors.Count == 0)
			{
				list.Add("nothing to import: no reference value maps to a Wildroot setting.");
				return new ImportOutcome(ImportStatus.NothingFound, 0, list);
			}
			try
			{
				ConversionResult val2 = converter.Apply(val, target, readOnlyDictionary, (readOnlyDictionary2.Count == 0) ? null : readOnlyDictionary2);
				list.Add("applied " + val2.Written + " values; the previous Wildroot config was backed up first.");
				return new ImportOutcome((val2.Written == 0) ? ImportStatus.NothingFound : ImportStatus.Applied, val2.Written, list);
			}
			catch (Exception ex) when (ex is ArgumentException || ex is NotSupportedException || ex is InvalidOperationException || ex is FormatException)
			{
				list.Add("blocked: " + ex.Message + " Nothing was written.");
				return new ImportOutcome(ImportStatus.Blocked, 0, list);
			}
		}
	}
	public static class WildrootImportedHelp
	{
		private static readonly Dictionary<string, string> descriptions = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["General.ToggleKey"] = "Shortcut to turn Wildroot on or off while gameplay input is available. It is unbound by default because F8 opens the shared MeadWorks menu. The server controls the master setting in multiplayer.",
			["Grid.SnapKey"] = "Shortcut to turn snapping to nearby plants on or off. Grid size is unchanged. Unbound by default: use the Grid: SnappingEnabled setting, or hold the controller modifier and click the right stick.",
			["Harvest.ReplantToggleKey"] = "Shortcut to turn replanting after bulk harvest on or off. Replanting still requires the replacement materials and placement permission. Unbound by default: use the Harvest: Replant setting.",
			["Input.IncreaseXKey"] = "While holding the grid modifier, add one column to the planting grid, up to 10.",
			["Input.IncreaseYKey"] = "While holding the grid modifier, add one row to the planting grid, up to 10.",
			["Input.DecreaseXKey"] = "While holding the grid modifier, remove one column from the planting grid, down to 1.",
			["Input.DecreaseYKey"] = "While holding the grid modifier, remove one row from the planting grid, down to 1.",
			["Input.KeyboardModifierKey"] = "Hold this keyboard shortcut to use the grid resize controls while planting.",
			["Input.GamepadModifierKey"] = "Hold this controller button for gardening controls: resize with the directional pad, toggle snapping with the right stick, or bulk-harvest with Use.",
			["Input.KeyboardHarvestModifierKey"] = "Hold this keyboard shortcut while using a ripe resource to harvest nearby resources within Harvest Radius.",
			["Planting.PreventPartialPlanting"] = "On: refuse the entire grid if any cell cannot be planted. Off: plant the cells allowed by Prevent Invalid Planting. Placement permissions still apply to every cell.",
			["Planting.PreventInvalidPlanting"] = "On: skip extra grid cells that fail growth or placement checks. Off: allow extra cells with biological or target failures; the root cell must still be valid and permission failures are never bypassed.",
			["Planting.UseStamina"] = "On: planting with the cultivator uses the native stamina cost. Off: cultivator placement costs no stamina.",
			["Planting.UseDurability"] = "On: cultivator placement uses its native durability cost. Off: planting does not reduce cultivator durability.",
			["General.Enabled"] = "On: enable Wildroot gardening when session permissions allow it. Off: cancel pending gardening work and release Wildroot changes. In multiplayer, the server owns this switch; installed source-mod step-aside still applies.",
			["Grid.SnappingEnabled"] = "On: align the planting grid with nearby plants or pickable resources. Off: place the grid at the unsnapped ghost position.",
			["Grid.Rows"] = "Number of rows in the planting grid, from 1 to 10. With grid planting off, the layout is 1 by 1; Farming row perks can still affect eligible single-crop planting.",
			["Grid.Columns"] = "Number of columns in the planting grid, from 1 to 10. The concurrent placement limit also caps the number of cells.",
			["Planting.RandomizeRotation"] = "On: choose a random heading in 22.5-degree steps for each placement. Off: keep the placement ghost heading. This is independent of position and tilt scatter.",
			["Planting.EnableScatter"] = "On: apply configured position and tilt scatter to new placements. Off: keep grid positions without scatter. Randomize Rotation is a separate switch.",
			["Planting.PositionScatterRadius"] = "Maximum position offset in meters along each horizontal axis when scatter is enabled. Zero keeps the planned grid positions.",
			["Planting.RotationScatterAngle"] = "Maximum pitch and roll offset in degrees when scatter is enabled. Zero adds no tilt; the heading is controlled separately.",
			["Planting.EnableDebugMessages"] = "Legacy import value retained for compatibility. Wildroot does not read this value to enable planting logs.",
			["Grid.GloballyAlignGridDirections"] = "On: use the world-forward direction, rotated by the ghost heading, for unsnapped rows. Off: start with the player-to-ghost direction before applying that heading.",
			["Grid.MinimizeGridSpacing"] = "On: crop spacing uses 1.1 times the grow radius plus the largest relevant capsule radius. Off: use twice the grow radius. Extra Crop Spacing is added in either mode; sapling spacing is separate.",
			["Grid.GridSnappingStyle"] = "Choose Intelligent snapping to orient grid axes around nearby valid space, or Legacy snapping to keep the selected snap axes.",
			["Grid.ForceAltPlacement"] = "On: always use alternate placement when choosing snap candidates and single-crop row perks. Off: use the native alternate-placement input.",
			["Grid.PreferCardinalSnapping"] = "On: prefer forward, back, left or right snap positions when any valid cardinal candidate exists. Off: keep valid diagonal candidates too.",
			["Grid.ExtraCropSpacing"] = "Additional grid spacing in meters for crops, added to their calculated spacing. Saplings use Extra Sapling Spacing instead.",
			["Grid.ExtraSaplingSpacing"] = "Additional grid spacing in meters for saplings, added to 2.2 times their grow radius.",
			["Harvest.Enabled"] = "On: using a ripe resource with the harvest modifier starts a nearby bulk harvest. Off: disable bulk harvest; separate Farming auto-replant perks are not this switch.",
			["Harvest.HarvestStyle"] = "LikeResources harvests nearby ready resources that yield the same item as the target. AllResources includes other ready resources in range. Ward and loaded-area checks still apply.",
			["Harvest.Radius"] = "Bulk-harvest radius in meters around the resource you use. Only ready resources with placement-area and ward access are selected.",
			["Harvest.Replant"] = "On: after confirmed harvest, try to plant a replacement crop at the original position and pay its materials. Off: bulk harvest does not request this replant; eligible Farming auto-replant perks remain separate.",
			["Performance.MaxConcurrentPlacements"] = "Maximum cells and queued or in-flight placements Wildroot accepts at once. The value is at least 1 in use; larger values permit more work, while grid dimensions remain capped at 10 by 10.",
			["Performance.GhostUpdateBatchSize"] = "Maximum extra preview ghosts updated per frame, with at least 1 in use. Larger values refresh a large preview sooner but do more work each frame.",
			["Performance.BulkPlantingBatchSize"] = "Maximum queued placement jobs processed per update, clamped to 1 through 10000 in use. Larger values complete batches sooner but can increase work per frame.",
			["Spacing.Pickables.PreventOverlappingPlacements"] = "On: reject overlapping pickable-resource preview cells. Off: remove this extra overlap check. Terrain and placement permissions still apply.",
			["Spacing.Pickables.DefaultGridSpacing"] = "Fallback grid spacing in meters for pickable resources without a per-prefab spacing or a native harvest radius.",
			["Spacing.Pickables.BlueberryBush GridSpacing"] = "Grid spacing in meters between placements of prefab BlueberryBush. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.CloudberryBush GridSpacing"] = "Grid spacing in meters between placements of prefab CloudberryBush. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.LingonberryBush GridSpacing"] = "Grid spacing in meters between placements of prefab LingonberryBush. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Branch GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Branch. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Dandelion GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Dandelion. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Fiddlehead GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Fiddlehead. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Flint GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Flint. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Mushroom GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Mushroom. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Mushroom_blue GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Mushroom_blue. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Mushroom_yellow GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Mushroom_yellow. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_SmokePuff GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_SmokePuff. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Stone GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Stone. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Pickable_Thistle GridSpacing"] = "Grid spacing in meters between placements of prefab Pickable_Thistle. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.Placeable_Stone GridSpacing"] = "Grid spacing in meters between placements of prefab Placeable_Stone. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["Spacing.Pickables.RaspberryBush GridSpacing"] = "Grid spacing in meters between placements of prefab RaspberryBush. This changes placement spacing; it does not change the item's yield or respawn timer.",
			["UI.ShowCost"] = "On: add the grid count or full batch material cost to native requirement text when more than one cell is planned. Off: keep the native requirement display.",
			["Preview.CostDisplayStyle"] = "TotalCount adds the number of planned cells; FullCost shows each requirement amount multiplied by that cell count. Requires Show Cost and a grid larger than one cell.",
			["Preview.CostDisplayLocation"] = "Place the extra grid-count or material-cost text to the left or right of the native requirement text.",
			["Preview.ShowHUDKeyHints"] = "On: show grid modifier and resize keys beside the grid size in the build hints. Off: retain the grid size without those key boxes.",
			["Preview.ShowHoverKeyHints"] = "On: add one hint line to ripe-resource hover text with the bulk-harvest modifier and Use key, plus the replacement crop while Harvest Replant is enabled. Off: omit that line.",
			["Preview.ShowHoverReplantHint"] = "On: include the configured replacement crop in the harvest hint line while Harvest Replant is enabled. Off: leave the crop out. Preview: ShowHoverKeyHints shows or hides the whole line. Actual planting still checks and charges materials.",
			["Preview.ShowGhostsDuringPlacement"] = "On: keep unplaced preview silhouettes visible while a batch is being placed. Off: hide those silhouettes during placement.",
			["Preview.ShowGridDirections"] = "On: draw row and column guide lines for the planting grid. Off: hide the direction-line objects, including the snap line.",
			["Preview.ShowSnapDirection"] = "On: show the guide line from the snapped grid toward its snap source. Off: hide that line. Show Grid Directions must also be enabled.",
			["Preview.HighlightRootGhost"] = "On: tint the healthy root ghost when the grid contains more than one cell. Off: keep its normal ghost appearance.",
			["Preview.RootGhostHighlightColor"] = "Color used for the healthy root ghost highlight. Requires Highlight Root Ghost and more than one grid cell.",
			["Preview.RowStartColor"] = "Color at the start of the row-direction guide line. Requires Show Grid Directions.",
			["Preview.RowEndColor"] = "Color at the end of the row-direction guide line. Requires Show Grid Directions.",
			["Preview.ColumnStartColor"] = "Color at the start of the column-direction guide line. Requires Show Grid Directions.",
			["Preview.ColumnEndColor"] = "Color at the end of the column-direction guide line. Requires Show Grid Directions.",
			["Preview.SnapStartColor"] = "Color at the start of the snap-direction guide line. Requires Show Grid Directions and Show Snap Direction.",
			["Preview.SnapEndColor"] = "Color at the end of the snap-direction guide line. Requires Show Grid Directions and Show Snap Direction.",
			["Catalog.Vanilla.Berries.RaspberryCost"] = "Amount of the first planting material required for Raspberry. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Berries.BlueberryCost"] = "Amount of the first planting material required for Blueberry. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Berries.CloudberryCost"] = "Amount of the first planting material required for Cloudberry. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Berries.LingonberryCost"] = "Amount of the first planting material required for Lingonberry. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Berries.RaspberryRespawnTime"] = "Minutes for Raspberry to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Berries.BlueberryRespawnTime"] = "Minutes for Blueberry to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Berries.CloudberryRespawnTime"] = "Minutes for Cloudberry to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Berries.LingonberryRespawnTime"] = "Minutes for Lingonberry to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Berries.RaspberryReturn"] = "Number of the resource's own item received when harvesting Raspberry.",
			["Catalog.Vanilla.Berries.BlueberryReturn"] = "Number of the resource's own item received when harvesting Blueberry.",
			["Catalog.Vanilla.Berries.CloudberryReturn"] = "Number of the resource's own item received when harvesting Cloudberry.",
			["Catalog.Vanilla.Berries.LingonberryReturn"] = "Number of the resource's own item received when harvesting Lingonberry.",
			["Growth.Crops.EnableCropOverrides"] = "On: apply Wildroot crop cost, yield, scale, growth-time and growing-condition overrides. Off: keep the captured native crop values. Other gardening features remain controlled separately.",
			["Growth.Crops.OverrideModdedCrops"] = "On: apply the crop growth and condition overrides to third-party crops too. Off: leave those crops unchanged. Requires Enable Crop Overrides.",
			["Growth.Crops.CropMinScale"] = "Minimum crop scale multiplier when crop overrides are enabled. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Crops.CropMaxScale"] = "Maximum crop scale multiplier when crop overrides are enabled. Effective maximum cannot be lower than Crop Min Scale.",
			["Growth.Crops.CropGrowTimeMin"] = "Minimum crop growth time in seconds when crop overrides are enabled. Invalid or negative values keep the captured baseline.",
			["Growth.Crops.CropGrowTimeMax"] = "Maximum crop growth time in seconds when crop overrides are enabled. Effective maximum is raised to at least Crop Grow Time Min.",
			["Growth.Crops.CropGrowRadius"] = "Crop growth-clearance radius in meters when crop overrides are enabled. Grid spacing is calculated from this radius too.",
			["Growth.Crops.CropsRequireCultivation"] = "On: crops require cultivated ground. Off: remove that requirement. Requires Enable Crop Overrides; other placement restrictions still apply.",
			["Growth.Crops.CropsRequireSunlight"] = "On: crops need open sky. Off: allow growth under a roof. Requires Enable Crop Overrides.",
			["Growth.Crops.CropsRequireGrowthSpace"] = "On: crops need clear space within their growth radius. Off: remove that growth-space check. Requires Enable Crop Overrides.",
			["Growth.Crops.EnemiesTargetCrops"] = "On: enemies may target the configured crops. Off: remove their normal target flag. Requires Enable Crop Overrides.",
			["Catalog.Vanilla.Crops.BarleyCost"] = "Amount of the first planting material required for Barley. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.BarleyReturn"] = "Number of the resource's own item received when harvesting Barley. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.CarrotCost"] = "Amount of the first planting material required for Carrot. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.CarrotReturn"] = "Number of the resource's own item received when harvesting Carrot. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.FlaxCost"] = "Amount of the first planting material required for Flax. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.FlaxReturn"] = "Number of the resource's own item received when harvesting Flax. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.OnionCost"] = "Amount of the first planting material required for Onion. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.OnionReturn"] = "Number of the resource's own item received when harvesting Onion. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedCarrotCost"] = "Amount of the first planting material required for Seed Carrot. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedCarrotReturn"] = "Number of the resource's own item received when harvesting Seed Carrot. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedOnionCost"] = "Amount of the first planting material required for Seed Onion. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedOnionReturn"] = "Number of the resource's own item received when harvesting Seed Onion. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedTurnipCost"] = "Amount of the first planting material required for Seed Turnip. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedTurnipReturn"] = "Number of the resource's own item received when harvesting Seed Turnip. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.TurnipCost"] = "Amount of the first planting material required for Turnip. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.TurnipReturn"] = "Number of the resource's own item received when harvesting Turnip. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.MagecapCost"] = "Amount of the first planting material required for Magecap. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.MagecapReturn"] = "Number of the resource's own item received when harvesting Magecap. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.JotunPuffsCost"] = "Amount of the first planting material required for Jotun Puffs. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.JotunPuffsReturn"] = "Number of the resource's own item received when harvesting Jotun Puffs. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.OatCost"] = "Amount of the first planting material required for Oat. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.OatReturn"] = "Number of the resource's own item received when harvesting Oat. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.PoteitrCost"] = "Amount of the first planting material required for Poteitr. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.PoteitrReturn"] = "Number of the resource's own item received when harvesting Poteitr. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.KaleCost"] = "Amount of the first planting material required for Kale. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.KaleReturn"] = "Number of the resource's own item received when harvesting Kale. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedKaleCost"] = "Amount of the first planting material required for Seed Kale. Zero disables this catalog entry instead of making planting free. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Crops.SeedKaleReturn"] = "Number of the resource's own item received when harvesting Seed Kale. Applies only while Enable Crop Overrides is on.",
			["Catalog.Vanilla.Debris.PickableBranchCost"] = "Amount of the first planting material required for Pickable Branch. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Debris.PickableBranchReturn"] = "Number of the resource's own item received when harvesting Pickable Branch.",
			["Catalog.Vanilla.Debris.PickableBranchRespawnTime"] = "Minutes for Pickable Branch to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Debris.PickableStoneCost"] = "Amount of the first planting material required for Pickable Stone. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Debris.PickableStoneReturn"] = "Number of the resource's own item received when harvesting Pickable Stone.",
			["Catalog.Vanilla.Debris.PickableStoneRespawnTime"] = "Minutes for Pickable Stone to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Debris.PickableFlintCost"] = "Amount of the first planting material required for Pickable Flint. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Debris.PickableFlintReturn"] = "Number of the resource's own item received when harvesting Pickable Flint.",
			["Catalog.Vanilla.Debris.PickableFlintRespawnTime"] = "Minutes for Pickable Flint to replenish after picking. Zero means it does not replenish.",
			["Restrictions.RequireCultivation"] = "On: added pickable resources require cultivated ground. Off: they can be placed on ordinary ground. Crop cultivation has its own override setting.",
			["Restrictions.PlaceAnywhere"] = "On: eligible saplings, bushes and decorative plants can leave the ground and ignore roof and growth-space checks. Off: keep those restrictions. Crops, mushrooms, flowers and fixed-ground debris do not gain this behavior; permissions still apply.",
			["Restrictions.EnforceBiomes"] = "On: added cloned saplings and vines use their configured growth biome mask. Off: permit all biomes for those plants. Native plants use Enforce Biomes Vanilla.",
			["Restrictions.EnforceBiomesVanilla"] = "On: native crops and saplings retain their growth biome restrictions. Off: use all biomes. Other growth and shielding checks remain separate.",
			["Restrictions.PlantsRequireShielding"] = "On: plants retain their normal heat and cold tolerances and may need a shield in harsh biomes. Off: configured plants tolerate those environmental conditions.",
			["Restrictions.CanRemoveFlora"] = "On: added decorative flora can be removed. Off: keep that decorative flora non-removable. Other piece kinds follow their existing rules.",
			["Restrictions.RecoverResources"] = "On: recover placement materials when removing added berry bushes, mushrooms or flowers. Off: removing them does not refund those materials.",
			["Restrictions.ResourcesSpawnEmpty"] = "On: added berries, mushrooms, flowers and debris start picked and wait for their respawn timer. Off: they start ready to pick. A zero respawn time does not replenish them.",
			["Restrictions.EnemiesTargetPieces"] = "On: enemies may target added non-crop pieces. Off: remove their normal target flags. Crop overrides have a separate Enemies Target Crops switch.",
			["Catalog.Vanilla.Flowers.ThistleCost"] = "Amount of the first planting material required for Thistle. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Flowers.DandelionCost"] = "Amount of the first planting material required for Dandelion. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Flowers.FiddleheadCost"] = "Amount of the first planting material required for Fiddlehead. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Flowers.ThistleRespawnTime"] = "Minutes for Thistle to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Flowers.DandelionRespawnTime"] = "Minutes for Dandelion to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Flowers.FiddleheadRespawnTime"] = "Minutes for Fiddlehead to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Flowers.ThistleReturn"] = "Number of the resource's own item received when harvesting Thistle.",
			["Catalog.Vanilla.Flowers.DandelionReturn"] = "Number of the resource's own item received when harvesting Dandelion.",
			["Catalog.Vanilla.Flowers.FiddleheadReturn"] = "Number of the resource's own item received when harvesting Fiddlehead.",
			["Catalog.EnableDebugMessages"] = "Legacy import value retained for compatibility. Wildroot does not read this value to enable catalog logs.",
			["Catalog.ShowPickableSpawners"] = "On: retain a visible picked spawner for configured mushrooms, thistle, dandelion and fiddlehead. Off: hide their picked spawner representation.",
			["Catalog.EnableMiscFlora"] = "On: make decorative flora entries available in the cultivator catalog. Off: disable those entries without changing their identities.",
			["Catalog.EnableDebris"] = "On: include branch, stone and flint resource entries in the cultivator catalog. Off: disable those debris entries.",
			["Catalog.EnableExtraResources"] = "On: load extra-resource definitions from the authority file and synchronize them to clients. Off: omit those extra definitions; ordinary catalog entries are unchanged.",
			["Catalog.SnappableVines"] = "On: add Wildroot snap points to the decorative vines piece. Off: remove only those added snap points; native snap points remain intact.",
			["Catalog.EnableLocalization"] = "Legacy import value retained for compatibility. Wildroot uses its shared translation support and Presentation Language instead.",
			["Catalog.Language"] = "Legacy import value retained for compatibility. Select the active interface language with Presentation Language.",
			["Catalog.DisabledResourceNames"] = "Comma-separated prefab names to disable in the cultivator catalog. Names are trimmed and case-sensitive; an empty list disables no entries. Applies to extra resources too.",
			["Catalog.Vanilla.Mushrooms.MushroomCost"] = "Amount of the first planting material required for Mushroom. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Mushrooms.YellowMushroomCost"] = "Amount of the first planting material required for Yellow Mushroom. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Mushrooms.BlueMushroomCost"] = "Amount of the first planting material required for Blue Mushroom. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Mushrooms.SmokepuffCost"] = "Amount of the first planting material required for Smokepuff. Zero disables this catalog entry instead of making planting free.",
			["Catalog.Vanilla.Mushrooms.MushroomRespawnTime"] = "Minutes for Mushroom to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Mushrooms.YellowMushroomRespawnTime"] = "Minutes for Yellow Mushroom to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Mushrooms.BlueMushroomRespawnTime"] = "Minutes for Blue Mushroom to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Mushrooms.SmokepuffRespawnTime"] = "Minutes for Smokepuff to replenish after picking. Zero means it does not replenish.",
			["Catalog.Vanilla.Mushrooms.MushroomReturn"] = "Number of the resource's own item received when harvesting Mushroom.",
			["Catalog.Vanilla.Mushrooms.YellowMushroomReturn"] = "Number of the resource's own item received when harvesting Yellow Mushroom.",
			["Catalog.Vanilla.Mushrooms.BlueMushroomReturn"] = "Number of the resource's own item received when harvesting Blue Mushroom.",
			["Catalog.Vanilla.Mushrooms.SmokepuffReturn"] = "Number of the resource's own item received when harvesting Smokepuff.",
			["Growth.Saplings.OverrideModdedSaplings"] = "On: apply the Modded Sapling growth time, scale and radius to third-party saplings. Off: keep their native growth settings.",
			["Growth.Saplings.ModdedSaplingMinScale"] = "Minimum grown scale multiplier for third-party saplings. Must be positive; the effective maximum is raised to at least this value. Requires Override Modded Saplings.",
			["Growth.Saplings.ModdedSaplingMaxScale"] = "Maximum grown scale multiplier for third-party saplings. Effective maximum cannot be below its minimum scale. Requires Override Modded Saplings.",
			["Growth.Saplings.ModdedSaplingGrowthTime"] = "Growth time in seconds for third-party saplings. The effective minimum is 10 seconds. Requires Override Modded Saplings.",
			["Growth.Saplings.ModdedSaplingGrowRadius"] = "Growth-clearance radius in meters for third-party saplings. This also contributes to grid spacing. Requires Override Modded Saplings.",
			["Growth.Saplings.BirchMinScale"] = "Minimum grown scale multiplier for Birch saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.BirchMaxScale"] = "Maximum grown scale multiplier for Birch saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.OakMinScale"] = "Minimum grown scale multiplier for Oak saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.OakMaxScale"] = "Maximum grown scale multiplier for Oak saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.AncientMinScale"] = "Minimum grown scale multiplier for Ancient saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.AncientMaxScale"] = "Maximum grown scale multiplier for Ancient saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.BirchGrowthTime"] = "Growth time in seconds for Birch saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.OakGrowthTime"] = "Growth time in seconds for Oak saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.AncientGrowthTime"] = "Growth time in seconds for Ancient saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.BirchGrowRadius"] = "Growth-clearance radius in meters for Birch saplings. This also contributes to grid spacing.",
			["Growth.Saplings.OakGrowRadius"] = "Growth-clearance radius in meters for Oak saplings. This also contributes to grid spacing.",
			["Growth.Saplings.AncientGrowRadius"] = "Growth-clearance radius in meters for Ancient saplings. This also contributes to grid spacing.",
			["Growth.Saplings.BeechGrowthTime"] = "Growth time in seconds for Beech saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.PineGrowthTime"] = "Growth time in seconds for Pine saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.FirGrowthTime"] = "Growth time in seconds for Fir saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.BeechMinScale"] = "Minimum grown scale multiplier for Beech saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.BeechMaxScale"] = "Maximum grown scale multiplier for Beech saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.PineMinScale"] = "Minimum grown scale multiplier for Pine saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.PineMaxScale"] = "Maximum grown scale multiplier for Pine saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.FirMinScale"] = "Minimum grown scale multiplier for Fir saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.FirMaxScale"] = "Maximum grown scale multiplier for Fir saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.BeechGrowRadius"] = "Growth-clearance radius in meters for Beech saplings. This also contributes to grid spacing.",
			["Growth.Saplings.PineGrowRadius"] = "Growth-clearance radius in meters for Pine saplings. This also contributes to grid spacing.",
			["Growth.Saplings.FirGrowRadius"] = "Growth-clearance radius in meters for Fir saplings. This also contributes to grid spacing.",
			["Growth.Saplings.YggaMinScale"] = "Minimum grown scale multiplier for Ygga saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.YggaMaxScale"] = "Maximum grown scale multiplier for Ygga saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.YggaGrowthTime"] = "Growth time in seconds for Ygga saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.YggaGrowRadius"] = "Growth-clearance radius in meters for Ygga saplings. This also contributes to grid spacing.",
			["Growth.Saplings.AutumnBirchMinScale"] = "Minimum grown scale multiplier for Autumn Birch saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.AutumnBirchMaxScale"] = "Maximum grown scale multiplier for Autumn Birch saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.AutumnBirchGrowthTime"] = "Growth time in seconds for Autumn Birch saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.AutumnBirchGrowRadius"] = "Growth-clearance radius in meters for Autumn Birch saplings. This also contributes to grid spacing.",
			["Growth.Saplings.AshwoodMinScale"] = "Minimum grown scale multiplier for Ashwood saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.AshwoodMaxScale"] = "Maximum grown scale multiplier for Ashwood saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.AshwoodGrowthTime"] = "Growth time in seconds for Ashwood saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.AshwoodGrowRadius"] = "Growth-clearance radius in meters for Ashwood saplings. This also contributes to grid spacing.",
			["Growth.Saplings.TimberwoodMinScale"] = "Minimum grown scale multiplier for Timberwood saplings. Must be positive; the effective maximum is raised to at least this value.",
			["Growth.Saplings.TimberwoodMaxScale"] = "Maximum grown scale multiplier for Timberwood saplings. Effective maximum cannot be below its minimum scale.",
			["Growth.Saplings.TimberwoodGrowthTime"] = "Growth time in seconds for Timberwood saplings. The effective minimum is 10 seconds.",
			["Growth.Saplings.TimberwoodGrowRadius"] = "Growth-clearance radius in meters for Timberwood saplings. This also contributes to grid spacing.",
			["Drops.EnableSeedOverrides"] = "On: replace tree drop-roll counts and chances and the stack range for seeds, cones, acorns and sap. Off: restore the captured native drop tables.",
			["Drops.seedDropMin"] = "Minimum stack amount for seeds, cones, acorns and sap in tree destruction drops. Requires Enable Seed Overrides; negative values become 0.",
			["Drops.seedDropMax"] = "Maximum stack amount for those planting materials in tree destruction drops. Requires Enable Seed Overrides; effective maximum is at least Seed Drop Min.",
			["Drops.treeDropMin"] = "Minimum number of tree drop rolls when Enable Seed Overrides is on. Negative values become 0; this is not the number of logs or wood in each stack.",
			["Drops.treeDropMax"] = "Maximum number of tree drop rolls when Enable Seed Overrides is on. Effective maximum is at least Tree Drop Min.",
			["Drops.dropChance"] = "Chance of a successful tree drop roll, from 0 to 1, when Enable Seed Overrides is on. 0.5 means 50%; values outside the range are clamped.",
			["Drops.oneOfEach"] = "On: the overridden tree drop table selects each item type at most once. Off: repeated selections are allowed. Requires Enable Seed Overrides.",
			["Hover.EnablePickableTimers"] = "On: append remaining respawn time to hover text for picked, replenishing resources. Off: omit that timer. Resources with no respawn time have no countdown.",
			["Hover.EnablePlantTimers"] = "On: append remaining growth time to a plant's hover text. Off: omit that timer.",
			["Hover.GrowthAsPercentage"] = "On: show completed growth or respawn progress as a whole percentage. Off: show remaining time in hours, minutes and seconds. Requires the matching hover timer.",
			["Growth.Vines.EnableVineOverrides"] = "On: apply vine attachment, growth time, growth radius and berry yield/respawn overrides. Off: keep the captured vine values.",
			["Growth.Vines.VineAttachDistance"] = "Maximum native vine attachment distance in meters when vine overrides are enabled.",
			["Growth.Vines.VineGrowRadius"] = "Growth-clearance radius in meters for vines when vine overrides are enabled.",
			["Growth.Vines.VineGrowthTime"] = "Time in seconds for a planted vine to grow when vine overrides are enabled.",
			["Growth.Vines.VineBerryRespawnTime"] = "Minutes before berries on a grown vine replenish when vine overrides are enabled. Zero gives no replenishment.",
			["Growth.Vines.VineBerryReturn"] = "Number of berry items harvested from a grown vine when vine overrides are enabled."
		};

		public static IEnumerable<string> Keys => descriptions.Keys;

		public static string? Description(string id)
		{
			if (!descriptions.TryGetValue(id, out string value))
			{
				return null;
			}
			return value;
		}

		public static bool IsInternal(string id)
		{
			switch (id)
			{
			case "Planting.EnableDebugMessages":
			case "Catalog.EnableDebugMessages":
			case "Catalog.EnableLocalization":
			case "Catalog.Language":
			case "Farm.ToggleKey":
				return true;
			default:
				return false;
			}
		}
	}
	public enum WildrootPreset
	{
		Vanilla,
		MeadWorksDefault,
		Relaxed,
		Custom
	}
	public sealed class WildrootPresetGroup
	{
		private readonly Dictionary<WildrootPreset, IReadOnlyDictionary<string, object>> choices;

		public string Selector { get; }

		public string[] Members { get; }

		public WildrootPresetGroup(string selector, string[] members, object[] vanilla, object[] defaults, object[] relaxed)
		{
			Selector = selector;
			Members = members;
			choices = new Dictionary<WildrootPreset, IReadOnlyDictionary<string, object>>
			{
				[WildrootPreset.Vanilla] = Values(vanilla),
				[WildrootPreset.MeadWorksDefault] = Values(defaults),
				[WildrootPreset.Relaxed] = Val