using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MutagenicWilds
{
	public static class AllblackItems
	{
		private class Def
		{
			public string name;

			public string title;

			public string description;

			public string[] donors;

			public int craftAmount;

			public Func<string> ingredients;

			public GameObject go;

			public Recipe recipe;
		}

		public const string BloodName = "pm_AllblackBlood";

		public const string BarName = "pm_Allblack";

		public const string ArrowName = "pm_ArrowAllblack";

		public const string BoltName = "pm_BoltAllblack";

		public const string SwordName = "pm_SwordAllblack";

		public const string SpearName = "pm_SpearAllblack";

		public static readonly string BloodTitle = Loc.Token("item_allblack_blood");

		public static readonly string BarTitle = Loc.Token("item_allblack");

		public static readonly string ArrowTitle = Loc.Token("item_allblack_arrow");

		public static readonly string BoltTitle = Loc.Token("item_allblack_bolt");

		public static readonly string SwordTitle = Loc.Token("item_allblack_sword");

		public static readonly string SpearTitle = Loc.Token("item_allblack_spear");

		private static readonly Color Black = new Color(0.16f, 0.16f, 0.2f);

		private static readonly List<Def> Defs = new List<Def>
		{
			new Def
			{
				name = "pm_AllblackBlood",
				title = BloodTitle,
				donors = new string[1] { "SilverOre" },
				description = Loc.Token("item_allblack_blood_desc")
			},
			new Def
			{
				name = "pm_Allblack",
				title = BarTitle,
				donors = new string[1] { "Silver" },
				description = Loc.Token("item_allblack_desc")
			},
			new Def
			{
				name = "pm_ArrowAllblack",
				title = ArrowTitle,
				donors = new string[3] { "ArrowSilver", "ArrowFrost", "ArrowObsidian" },
				craftAmount = 10,
				ingredients = () => Cfg(Plugin.AllblackArrowIngredients, "Allblack:1,Coins:50,Feathers:6"),
				description = Loc.Token("item_allblack_weapon_desc")
			},
			new Def
			{
				name = "pm_BoltAllblack",
				title = BoltTitle,
				donors = new string[4] { "BoltBlackmetal", "BoltCarapace", "BoltIron", "BoltBone" },
				craftAmount = 10,
				ingredients = () => Cfg(Plugin.AllblackBoltIngredients, "Allblack:1,Coins:50,Feathers:6"),
				description = Loc.Token("item_allblack_weapon_desc")
			},
			new Def
			{
				name = "pm_SwordAllblack",
				title = SwordTitle,
				donors = new string[1] { "SwordSilver" },
				craftAmount = 1,
				ingredients = () => Cfg(Plugin.AllblackSwordIngredients, "Allblack:20,Coins:300,ElderBark:20"),
				description = Loc.Token("item_allblack_weapon_desc")
			},
			new Def
			{
				name = "pm_SpearAllblack",
				title = SpearTitle,
				donors = new string[2] { "SpearWolfFang", "SpearCarapace" },
				craftAmount = 1,
				ingredients = () => Cfg(Plugin.AllblackSpearIngredients, "Allblack:15,Coins:250,ElderBark:15"),
				description = Loc.Token("item_allblack_spear_desc")
			}
		};

		private static bool _warned;

		public static GameObject Blood => Get("pm_AllblackBlood");

		private static string Cfg(ConfigEntry<string> e, string fallback)
		{
			if (e == null)
			{
				return fallback;
			}
			return e.Value;
		}

		private static GameObject Get(string name)
		{
			return Defs.FirstOrDefault((Def x) => x.name == name)?.go;
		}

		public static bool IsAllblackWeapon(string sharedName)
		{
			if (!(sharedName == ArrowTitle) && !(sharedName == BoltTitle) && !(sharedName == SwordTitle))
			{
				return sharedName == SpearTitle;
			}
			return true;
		}

		public static void Ensure(ObjectDB db)
		{
			if ((Object)(object)db == (Object)null || db.m_items == null || db.m_items.Count == 0)
			{
				return;
			}
			try
			{
				foreach (Def def in Defs)
				{
					if ((Object)(object)def.go == (Object)null)
					{
						Build(db, def);
					}
				}
				foreach (Def def2 in Defs)
				{
					if (!((Object)(object)def2.go == (Object)null))
					{
						if (!db.m_items.Contains(def2.go))
						{
							db.m_items.Add(def2.go);
						}
						EnsureRecipe(db, def2);
					}
				}
				MethodInfo methodInfo = AccessTools.Method(typeof(ObjectDB), "UpdateRegisters", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					methodInfo.Invoke(db, null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Allblack items could not be set up: " + ex));
			}
		}

		private static void Build(ObjectDB db, Def d)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			string[] donors = d.donors;
			foreach (string name in donors)
			{
				val = PregnancyItems.Find(db, name);
				if ((Object)(object)val != (Object)null)
				{
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				if (!_warned)
				{
					_warned = true;
					Plugin.Log.LogWarning((object)("Allblack: the vanilla item to copy for " + Loc.Plain(d.title) + " (" + string.Join("/", d.donors) + ") was not found, so it is not added"));
				}
				return;
			}
			GameObject val2 = PregnancyItems.Clone(val, d.name);
			ItemDrop component = val2.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return;
			}
			component.m_itemData.m_shared.m_name = d.title;
			component.m_itemData.m_shared.m_description = d.description;
			SharedData shared = component.m_itemData.m_shared;
			if (shared.m_icons != null && shared.m_icons.Length != 0 && (Object)(object)shared.m_icons[0] != (Object)null)
			{
				try
				{
					Sprite[] array = (Sprite[])(object)new Sprite[shared.m_icons.Length];
					for (int j = 0; j < array.Length; j++)
					{
						array[j] = (((Object)(object)shared.m_icons[j] != (Object)null) ? PregnancyItems.Tinted(shared.m_icons[j], Black, silverEdge: true) : null);
					}
					shared.m_icons = array;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogInfo((object)("Allblack icon recolour skipped (" + ex.Message + "), the copied icon is used"));
				}
			}
			if (IsAllblackWeapon(d.title))
			{
				ToAllblackDamage(shared);
			}
			Blacken(val2);
			d.go = val2;
		}

		private static void ToAllblackDamage(SharedData sh)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DamageTypes damages = sh.m_damages;
				damages.m_damage += AllblackRules.FromDonor(damages.m_spirit, ((DamageTypes)(ref damages)).GetTotalDamage() - damages.m_spirit - damages.m_damage);
				damages.m_spirit = 0f;
				sh.m_damages = damages;
				DamageTypes damagesPerLevel = sh.m_damagesPerLevel;
				damagesPerLevel.m_damage += AllblackRules.FromDonor(damagesPerLevel.m_spirit, ((DamageTypes)(ref damagesPerLevel)).GetTotalDamage() - damagesPerLevel.m_spirit - damagesPerLevel.m_damage);
				damagesPerLevel.m_spirit = 0f;
				sh.m_damagesPerLevel = damagesPerLevel;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogInfo((object)("Allblack damage type skipped (" + ex.Message + ")"));
			}
		}

		internal static void Blacken(GameObject go, float amount = 0.85f)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val in componentsInChildren)
				{
					Material[] sharedMaterials = val.sharedMaterials;
					for (int j = 0; j < sharedMaterials.Length; j++)
					{
						if (!((Object)(object)sharedMaterials[j] == (Object)null))
						{
							Material val2 = new Material(sharedMaterials[j]);
							if (val2.HasProperty("_Color"))
							{
								val2.SetColor("_Color", Color.Lerp(val2.GetColor("_Color"), Black, amount));
							}
							if (amount > 0.5f && val2.HasProperty("_EmissionColor"))
							{
								val2.SetColor("_EmissionColor", Color.black);
							}
							if (amount > 0.5f && val2.HasProperty("_MetalGlossColor"))
							{
								val2.SetColor("_MetalGlossColor", Black);
							}
							sharedMaterials[j] = val2;
						}
					}
					val.sharedMaterials = sharedMaterials;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogInfo((object)("Allblack model recolour skipped (" + ex.Message + ")"));
			}
		}

		private static void EnsureRecipe(ObjectDB db, Def d)
		{
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			if (db.m_recipes == null || d.ingredients == null)
			{
				return;
			}
			if ((Object)(object)d.recipe == (Object)null)
			{
				ItemDrop component = d.go.GetComponent<ItemDrop>();
				string donorName = null;
				string[] donors = d.donors;
				foreach (string text in donors)
				{
					if ((Object)(object)PregnancyItems.Find(db, text) != (Object)null)
					{
						donorName = text;
						break;
					}
				}
				Recipe val = ((IEnumerable<Recipe>)db.m_recipes).FirstOrDefault((Func<Recipe, bool>)((Recipe r) => (Object)(object)r != (Object)null && (Object)(object)r.m_item != (Object)null && ((Object)r.m_item).name == donorName));
				if ((Object)(object)val == (Object)null || (Object)(object)val.m_craftingStation == (Object)null)
				{
					Plugin.Log.LogWarning((object)("Allblack: no recipe to copy the crafting station from for " + Loc.Plain(d.title) + ", so it can't be crafted"));
					return;
				}
				List<Requirement> list = new List<Requirement>();
				donors = d.ingredients().Split(',');
				for (int i = 0; i < donors.Length; i++)
				{
					string[] array = donors[i].Split(':');
					string text2 = array[0].Trim();
					if (text2.Length != 0)
					{
						if (array.Length < 2 || !int.TryParse(array[1].Trim(), out var result) || result <= 0)
						{
							result = 1;
						}
						GameObject val2 = ((text2 == "pm_Allblack" || text2 == "Allblack") ? Get("pm_Allblack") : PregnancyItems.Find(db, text2));
						ItemDrop val3 = (((Object)(object)val2 != (Object)null) ? val2.GetComponent<ItemDrop>() : null);
						if ((Object)(object)val3 == (Object)null)
						{
							Plugin.Log.LogWarning((object)(Loc.Plain(d.title) + ": ingredient '" + text2 + "' is not an item in this game, skipped"));
							continue;
						}
						list.Add(new Requirement
						{
							m_resItem = val3,
							m_amount = result,
							m_recover = true
						});
					}
				}
				if (list.Count == 0)
				{
					Plugin.Log.LogWarning((object)(Loc.Plain(d.title) + ": no valid ingredients, so it can't be crafted"));
					return;
				}
				Recipe val4 = ScriptableObject.CreateInstance<Recipe>();
				((Object)val4).name = "Recipe_" + d.name;
				val4.m_item = component;
				val4.m_amount = d.craftAmount;
				val4.m_enabled = true;
				val4.m_craftingStation = val.m_craftingStation;
				val4.m_minStationLevel = val.m_minStationLevel;
				val4.m_resources = list.ToArray();
				d.recipe = val4;
			}
			if (!db.m_recipes.Contains(d.recipe))
			{
				db.m_recipes.Add(d.recipe);
			}
		}

		public static void RegisterPrefabs(ZNetScene scene)
		{
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			if (Defs.Any((Def d) => (Object)(object)d.go == (Object)null) && (Object)(object)ObjectDB.instance != (Object)null)
			{
				Ensure(ObjectDB.instance);
			}
			Dictionary<int, GameObject> dictionary = ((AccessTools.Field(typeof(ZNetScene), "m_namedPrefabs") != null) ? (AccessTools.Field(typeof(ZNetScene), "m_namedPrefabs").GetValue(scene) as Dictionary<int, GameObject>) : null);
			foreach (Def def in Defs)
			{
				if ((Object)(object)def.go == (Object)null)
				{
					continue;
				}
				if (!scene.m_prefabs.Contains(def.go))
				{
					scene.m_prefabs.Add(def.go);
				}
				if (dictionary != null && dictionary.Count > 0)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)def.go).name);
					if (!dictionary.ContainsKey(stableHashCode))
					{
						dictionary[stableHashCode] = def.go;
					}
				}
			}
			GameObject val = Get("pm_AllblackBlood");
			GameObject val2 = Get("pm_Allblack");
			ItemDrop from = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			ItemDrop val3 = (((Object)(object)val2 != (Object)null) ? val2.GetComponent<ItemDrop>() : null);
			if ((Object)(object)from == (Object)null || (Object)(object)val3 == (Object)null)
			{
				return;
			}
			int num = 0;
			foreach (GameObject prefab in scene.m_prefabs)
			{
				Smelter val4 = (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<Smelter>() : null);
				if (!((Object)(object)val4 == (Object)null) && val4.m_conversion != null && !val4.m_conversion.Any((ItemConversion c) => c != null && (Object)(object)c.m_from == (Object)(object)from) && val4.m_conversion.Any((ItemConversion c) => c != null && (Object)(object)c.m_from != (Object)null && ((Object)c.m_from).name == "SilverOre"))
				{
					val4.m_conversion.Add(new ItemConversion
					{
						m_from = from,
						m_to = val3
					});
					num++;
				}
			}
			Plugin.Log.LogInfo((object)("Allblack: items registered, " + num + " smelter(s) taught Allblack Blood -> Allblack"));
		}

		public static void AddDrop(List<KeyValuePair<GameObject, int>> drops)
		{
			GameObject blood = Blood;
			AllblackCfg allblack = Plugin.Cfg.allblack;
			if (!((Object)(object)blood == (Object)null) && allblack.dropAmount > 0 && !(Random.value >= allblack.dropChance))
			{
				drops.Add(new KeyValuePair<GameObject, int>(blood, allblack.dropAmount));
			}
		}
	}
	[HarmonyPatch]
	internal static class AllblackTooltipPatch
	{
		private static MethodBase TargetMethod()
		{
			return PatchUtil.Overload(typeof(ItemData), "GetTooltip", 6, isStatic: true);
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static void Postfix(ItemData __0, ref string __result)
		{
			try
			{
				if (__0 != null && __0.m_shared != null && __result != null && AllblackItems.IsAllblackWeapon(__0.m_shared.m_name))
				{
					__result = __result.Replace("$inventory_damage:", Loc.T("allblack_damage"));
				}
			}
			catch (Exception e)
			{
				Safe.Err("AllblackItems:261", e);
			}
		}
	}
	public static class ConfigBinder
	{
		private sealed class Binder
		{
			private readonly ConfigFile _f;

			public readonly List<Action<MutationConfig>> Apply = new List<Action<MutationConfig>>();

			private readonly Dictionary<ConfigDefinition, string> _orphans;

			public Binder(ConfigFile f)
			{
				_f = f;
				try
				{
					PropertyInfo property = typeof(ConfigFile).GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					_orphans = ((property != null) ? (property.GetValue(f, null) as Dictionary<ConfigDefinition, string>) : null);
				}
				catch (Exception)
				{
					_orphans = null;
				}
			}

			public void Add<T>(string section, string key, T def, ConfigDescription desc, Action<MutationConfig, T> set)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				if (typeof(T) == typeof(bool) && _orphans != null)
				{
					ConfigDefinition key2 = new ConfigDefinition(section, key);
					string value2;
					if (_orphans.TryGetValue(key2, out var value) && (value2 = ConfigRules.TolerantBool(value)) != value)
					{
						_orphans[key2] = value2;
					}
				}
				ConfigEntry<T> e = _f.Bind<T>(section, key, def, Wrapped(desc));
				Apply.Add(delegate(MutationConfig m)
				{
					set(m, e.Value);
				});
			}
		}

		private static readonly Dictionary<string, string[]> Tunable = new Dictionary<string, string[]>
		{
			{
				"giant",
				new string[5] { "scale", "health", "damage", "moveSpeed", "attackSpeed" }
			},
			{
				"tiny",
				new string[5] { "scale", "health", "damage", "moveSpeed", "attackSpeed" }
			},
			{
				"small",
				new string[5] { "scale", "health", "damage", "moveSpeed", "attackSpeed" }
			},
			{
				"large",
				new string[5] { "scale", "health", "damage", "moveSpeed", "attackSpeed" }
			},
			{
				"diplomat",
				new string[1] { "noticeRadius" }
			},
			{
				"mannequin",
				new string[2] { "comfort", "allowSleep" }
			},
			{
				"immortal",
				new string[6] { "scale", "health", "damage", "moveSpeed", "ambientLook", "ambientColour" }
			},
			{
				"vampiric",
				new string[9] { "lifesteal", "elderLifesteal", "ancientLifesteal", "daylightBurnPctMaxHpPerSec", "seekShelter", "shelterRadius", "elderChance", "ambientLook", "ambientColour" }
			},
			{
				"friendly",
				new string[2] { "ambientLook", "ambientColour" }
			},
			{
				"relentless",
				new string[3] { "moveSpeed", "ambientLook", "ambientColour" }
			},
			{
				"undying",
				new string[10] { "oozerHpPctOfBase", "oozerStartHpPct", "oozerMinHp", "oozerGraceSec", "oozerSizeFit", "regenPctPerSec", "regenDelaySec", "tint", "ambientLook", "ambientColour" }
			},
			{
				"moronic",
				new string[4] { "searchRadius", "excludeTamed", "ambientLook", "ambientColour" }
			},
			{
				"all_consuming",
				new string[10] { "maxConsumed", "lootPerMeal", "gainHpRatio", "gainDamageRatio", "mealCap", "excludeTamed", "eatOwnFaction", "digestSeconds", "preyRadius", "maxPursuitDistance" }
			},
			{
				"impregnator",
				new string[7] { "gestationSec", "maxStacks", "friendlyOffspringChance", "sicknessAtStacks", "sicknessChance", "childfreeDurationSec", "frenzyDurationSec" }
			},
			{
				"mother",
				new string[8] { "calves", "twinChance", "pregnancyChance", "maxCalves", "maxNearby", "ambientLook", "ambientColour", "exodiaColour" }
			},
			{
				"golden",
				new string[28]
				{
					"coins", "coinsMeadows", "coinsBlackForest", "coinsSwamp", "coinsMountain", "coinsPlains", "coinsMistlands", "coinsAshLands", "coinsDeepNorth", "gemsMeadows",
					"gemsBlackForest", "gemsSwamp", "gemsMountain", "gemsPlains", "gemsMistlands", "gemsAshLands", "gemsDeepNorth", "gemMin", "gemMax", "vanishSeconds",
					"spotDistance", "spotConeDegrees", "wallsBlock", "startleSeconds", "driftAfterSeconds", "revealDistance", "vanishMessage", "bodyGlow"
				}
			},
			{
				"shedding",
				new string[3] { "intervalSec", "amount", "drops" }
			},
			{
				"alpha",
				new string[8] { "herdRadius", "herdMax", "callCooldown", "rallySeconds", "leash", "rallyBiteBonus", "ambientLook", "ambientColour" }
			},
			{
				"drenching",
				new string[8] { "auraRadius", "sizeScaling", "wetSeconds", "poisonDamage", "auraVisual", "auraOpacity", "tint", "ambientLook" }
			},
			{
				"elemental",
				new string[9] { "fireScale", "fireScares", "fireWarms", "fireSound", "healShare", "freezeSeconds", "slowHoldSeconds", "debuffSeconds", "burnDamage" }
			},
			{
				"radiating",
				new string[8] { "auraRadius", "sizeScaling", "attackScalingMultiplier", "edgeDamage", "tickSeconds", "auraVisual", "auraBrightness", "tint" }
			},
			{
				"volatile",
				new string[13]
				{
					"periodSec", "chargeSparks", "chargeSound", "blastSound", "damageRatio", "maxHealthShare", "blastRadius", "sizeScaling", "vfxScale", "vfxOpacity",
					"tint", "ambientLook", "chargeColour"
				}
			},
			{
				"glass_cannon",
				new string[8] { "health", "oneShotBosses", "spareFullHealth", "blowMeadows", "blowBlackForest", "blowSwamp", "glowIntensity", "tint" }
			},
			{
				"rabid",
				new string[10] { "chaseRadius", "windupSeconds", "parryStunSeconds", "chargeSeconds", "restSeconds", "loseSeconds", "biteHealthShare", "biteMin", "biteMax", "companionAggroRange" }
			}
		};

		private static readonly Dictionary<string, string> Help = new Dictionary<string, string>
		{
			{ "scale", "Size multiplier (2 = twice as big)." },
			{ "health", "Health multiplier. For Glass Cannon this is its absolute hit points instead." },
			{ "damage", "Damage multiplier." },
			{ "moveSpeed", "Walk/run/swim speed multiplier (0.6 = 40% slower)." },
			{ "attackSpeed", "Animation speed multiplier, so also attack speed (0.6 = 40% slower)." },
			{ "lifesteal", "Fraction of damage dealt that a plain Vampiric heals back (0.75 = 75%). Healing never goes over max health." },
			{ "elderLifesteal", "The same for an Elder Vampiric (immune to the sun). Should be higher than the plain one." },
			{ "ancientLifesteal", "The same for an Ancient Vampire. The highest of the three." },
			{ "seekShelter", "A plain Vampiric mob that the sun burns looks for shade by day: it walks to the nearest roof, cave or overhang (what counts as shelter for the burn), fights what comes near it, and rests there until dusk. Elders and Ancient Vampires never do. Only creatures with a fighting AI (not a vampiric deer); a tame one is left alone." },
			{ "shelterRadius", "How far (metres, 4 to 34) a plain Vampiric mob looks for shade." },
			{ "daylightBurnPctMaxHpPerSec", "Fraction of max health lost per second in daylight when not sheltered (0.01 = 1%, so about 100 s to die in full sun). Elders and Ancient Vampires are immune." },
			{ "oozerSizeFit", "How much of the dead mob's hitbox its Oozer may fill (0.9 = 90%, at most 1): the Oozer is scaled to fit inside the creature it came from, small for a hen and larger for a Troll. 0 = the Oozer is always the same size." },
			{ "oozerHpPctOfBase", "Oozer form's max health as a fraction of the mob's normal max health (its level counted, mutations not)." },
			{ "oozerStartHpPct", "How much of that the Oozer starts with (0.4 = 40%). It must regrow the rest to bring the mob back." },
			{ "oozerMinHp", "The least max health an Oozer has, so a small creature's Oozer is not gone at the first touch." },
			{ "oozerGraceSec", "For this many seconds after it appears the Oozer takes no damage, so the blow, the burning or the crowd that killed the mob can't finish the Oozer in the same moment. 0 = none." },
			{ "regenPctPerSec", "Fraction of the Oozer's max health it regains per second once regeneration starts." },
			{ "regenDelaySec", "Seconds without being hit before the Oozer starts regenerating." },
			{ "poisonDamage", "A Poison Drenching aura drips poison instead of leaving you Wet: this much poison damage in total, renewed while you stand in it." },
			{ "wetSeconds", "How many seconds the Wet status lasts after the aura last touched you (the game's own lasts minutes). 0 = the game's duration." },
			{ "debuffSeconds", "How long an element's damage over time or debuff lasts, from its hits, auras and blasts: Burning (fire), Poison (poison), Shock (lightning), Frost, and spirit's Cold. Each pays out the damage the game itself would have dealt, spread over exactly this many seconds. Never more than 5." },
			{ "tint", "The colour of this mutation's look, as hex (#RRGGBB). Elemental mobs use their element's colour instead." },
			{ "ambientLook", "On: this mutation has a small ambient look on every player's screen (see \"Ambient looks\" in the Display settings, which switches all of them). Off: this one is not drawn. Looks only: nothing about how the mob behaves changes." },
			{ "ambientColour", "The colour of this mutation's ambient look, as hex (#RRGGBB). The default was chosen to differ from every element's colour and from the other mutations' looks, so a mutation can be told apart by its colour as well as its shape." },
			{ "chargeColour", "The colour of a plain Volatile mob: its glow, embers, pulses and blast. Hot magenta by default: the one colour no element and no other mutation uses. An Elemental Volatile mob uses its element's colour instead, and the pulses of a blast that would kill you still turn red." },
			{ "exodiaColour", "The colour of the glow when a Mother that is an Exodia (five mutations) is about to give birth. Red by default; a plain Mother's glow is pink (Look colour)." },
			{ "fireScares", "1 = other creatures keep away from a fire Elemental the way they do from any fire (a Greydwarf from a campfire); a fire Elemental itself is never afraid of fire. 0 = it is not a fire to them." },
			{ "fireWarms", "1 = a player standing near a fire Elemental is warmed by it, as by a campfire: the game's Warm status, and the cold of the weather goes. It cancels with an Elemental's own Frost or Cold: the two take each other away. 0 = off." },
			{ "fireSound", "How loud the burning sound of a fire Elemental is (a campfire, a hearth or a bonfire by the creature's size), as a share of the game's own. 0 = silent." },
			{ "healShare", "An Elemental is not hurt by its own element: that part of a hit is taken out and it is healed for this share of it (0.5 = half), however it was dealt. It is weak to the opposing element (fire to frost, lightning to frost, poison to fire, spirit to lightning). Only mobs that are Elementals by mutation. 0 = it just takes no damage from its own element." },
			{ "fireScale", "Size of a fire Elemental's flames compared with the game's own Burning effect on a creature of its size (1 = as the game shows it)." },
			{ "burnDamage", "The fire damage a Fire Drenching aura's smoke (the game's Smoked status, kept for its full time) deals in all while it lasts, renewed each time it touches you. Radiating and Volatile don't use it: they burn with their own damage." },
			{ "freezeSeconds", "How many seconds the Frost debuff from a frost Elemental lasts (every frost debuff of this mod: hits, auras, Drenching). Every hit or aura tick renews it, so it wears off quickly once you are clear. 0 = no Frost at all, just the frost damage." },
			{ "slowHoldSeconds", "How many of those seconds the Frost slows at full strength. After that the slow eases off in a straight line to nothing at the end of the Frost. 2 of 5 by default." },
			{ "sizeScaling", "How much the aura or blast follows the creature's actual body size (the same rule for Drenching, Radiating and Volatile): 1 = in proportion, 0 = every creature has the same reach. At 0.6 a creature three times a Boar's size reaches about 2x as far (never less than half or more than 3x). The log lists each kind's size and reach the first time it is seen." },
			{ "edgeDamage", "How much of the damage is left at the very rim of the aura, as a fraction (0.3 = 30%). It falls off in a straight line from the full amount at the centre." },
			{ "tickSeconds", "Seconds between the aura's damage ticks." },
			{ "attackScalingMultiplier", "Multiplier on the aura's centre damage, which follows the creature's own attack damage (flattened, so a strong creature does more but not proportionally more: an attack of 5 gives about 2.6, 20 about 6, 60 about 11.7). 1 = as designed. Anything of another faction inside the aura takes it: half piercing, half blunt (the blunt half is the element for an Elemental one)." },
			{ "vfxScale", "Size of the explosion picture (not the damage area) for an average-sized creature. It grows and shrinks in proportion to the creature's own size, so a Giant's is bigger and a calf's smaller. 1 = the effect at full size." },
			{ "chargeSound", "How loud the crackle of a charging Volatile mob is at its loudest, as a share of full volume. One crackle with each pulse, louder each time (and louder the more of your health the blast would take). 0 = silent; the pulses still show." },
			{ "blastSound", "How loud a Volatile mob's blast is, as a share of full volume (a Giant's a little louder, a Tiny's a little quieter). 0 = silent." },
			{ "chargeSparks", "Show the countdown of a Volatile mob: from its first hit, once a second, a smaller copy of its blast plays at the middle of its body, bigger each time, and the last beat is the blast itself at full size and in the same colour. The pulses turn red once the blast would kill you. 0 = no pulses (the crackle and the blast still happen)." },
			{ "vfxOpacity", "How solid the explosion picture is, 0 (invisible) to 1 (full). The damage is unchanged." },
			{ "searchRadius", "How far (metres) it looks for another creature of its own faction to fight." },
			{ "excludeTamed", "Leave tamed creatures alone (a tamed creature is not attacked or eaten)." },
			{ "maxConsumed", "How many creatures it can eat." },
			{ "lootPerMeal", "Extra loot for each creature it has eaten, added to its loot multiplier (0.3 = +30% a meal, so three meals add 90%): the more it ate, the stronger it is, and the more it drops." },
			{ "eatOwnFaction", "On: meadow and Black Forest creatures (the ForestMonsters faction: Boars, Greylings, Greydwarfs...) also hunt each other. Every other faction only hunts creatures of other factions." },
			{ "gainHpRatio", "How much of an eaten creature's health it keeps. 0.5 = half of it, 1 = all of it." },
			{ "gainDamageRatio", "How much of an eaten creature's damage it keeps. 0.5 = half of it, 1 = all of it. Both are held back by the meal cap below." },
			{ "spareFullHealth", "On: a Glass Cannon can't kill a player on full health in one hit; it leaves them on 1 hp, and then burning, poison, cold, auras and blasts ignore them until they heal. Only a real hit can finish them. Off: its hits are always lethal." },
			{ "blowMeadows", "How much of a player's max health one Glass Cannon blow takes in the Meadows, so a new player can learn to dodge it (0.5 = half: two blows kill). 1 = the usual lethal blow. Counted before armour, where the player is standing." },
			{ "blowBlackForest", "The same for the Black Forest (0.75 = three quarters). 1 = the usual lethal blow." },
			{ "glowIntensity", "How strong the faint crimson glow around a Glass Cannon is (1 = the default, a small dim light, a fraction of a Golden's). 0 = no glow. Looks only." },
			{ "blowSwamp", "The same for the Swamp (1 = the usual lethal blow, the default). Every later biome is always lethal." },
			{ "digestSeconds", "How long (seconds) it digests after a meal: it does not hunt and its blows are ordinary until that has passed, so a crowd cannot fill it in a moment. 0 = it can eat again at once." },
			{ "mealCap", "Stops one meal from making it too strong: a single meal can never add more than this share of the eater's own normal health or damage. 1 = at most double its own (3 meals = 4x at most). 0 = no cap." },
			{ "preyRadius", "How far (metres) it looks for something to eat when it has no target. Once it has picked a meal it keeps chasing it, up to the pursuit distance below." },
			{ "maxPursuitDistance", "How far (metres) its meal can get from it before it gives up the chase and goes back to what it was doing. 0 = it never gives up." },
			{ "gestationSec", "Seconds per pregnancy cycle (one offspring is born each cycle)." },
			{ "maxStacks", "Most pregnancies that can stack on one victim." },
			{ "friendlyOffspringChance", "Chance (0 to 1) that an offspring is born Friendly (hostile mobs only)." },
			{ "companionAggroRange", "Hostile creatures within this distance (metres) of a Loyal companion turn on it at once when it is closer to them than whatever they are targeting now (or they have no target). A creature that hits a Loyal also switches to it. 0 = leave it to the game." },
			{ "sicknessAtStacks", "Pregnancy stacks at which Nausea starts (it ends when stacks drop below this). Max stacks is a separate setting, so set this at or below it." },
			{ "sicknessChance", "Chance (0 to 1) on each roll of Nausea that the victim throws up one of the foods they are eating (picked at random)." },
			{ "childfreeDurationSec", "How long a Childfree Potion lasts, in seconds." },
			{ "frenzyDurationSec", "How long Freyja's Frenzy (the aphrodisiac mead) lasts, in seconds." },
			{ "comfort", "Comfort a Mannequin adds to a player resting (sheltered) within its range, like a piece of furniture: counted once however many there are. 0 turns it off." },
			{ "allowSleep", "On: you can sleep in a bed even when enemies are nearby, as long as a Mannequin is within the comfort distance of you. Off: the usual \"can't sleep with enemies nearby\" rule applies." },
			{ "calves", "How many calves a Mother spawns with, every time (each is a copy of the Mother's other mutations)." },
			{ "twinChance", "Chance (0 to 1) that a Mother spawns with one extra Young mob." },
			{ "pregnancyChance", "Chance (0 to 1), rolled once per check, that a Mother becomes pregnant (gains a stack)." },
			{ "maxNearby", "A pregnancy waits while this many of her calves are already close by. 0 = no limit. The calves she spawns with don't wait." },
			{ "maxCalves", "The most calves one Mother can ever have, counting the ones she spawned with. 0 = no limit." },
			{ "windupSeconds", "How long (seconds) a Rabid or called animal stops and faces you before a bite lands. If you have moved out of its reach (or rolled) by then, the bite misses. 0 = bites at once." },
			{ "chargeSeconds", "How long (seconds) it can run at you before it is winded and can only walk. 0 = it never tires." },
			{ "restSeconds", "How long (seconds) it is winded (walking pace) once its charge runs out." },
			{ "parryStunSeconds", "How long (seconds) a Rabid or called animal is stunned when you parry its bite (a shield or buckler raised just before the bite lands): it stops, cannot bite, and is pushed back a step. 0 = a parry does nothing to it." },
			{ "loseSeconds", "Seconds without a clear line to you (behind a wall, a rock, a building) before it gives up the hunt. A Relentless animal never gives up. 0 = it never does." },
			{ "herdRadius", "How far (metres) around a hurt Alpha its herd (animals of the same kind) can hear the call. Only the nearest few inside it answer (see Herd max)." },
			{ "herdMax", "Most herd mates that answer one call (the nearest ones). The rest of the herd carries on as normal." },
			{ "callCooldown", "Seconds before the same Alpha can call its herd again. 0 = it calls on every hit. A killing blow never calls the herd." },
			{ "rallySeconds", "Longest (seconds) a called animal hunts you. It stops sooner if its Alpha dies or you get out of reach (see Leash)." },
			{ "leash", "A called animal gives up the hunt when you are further than this (metres) from it. 0 = it never gives up while the call lasts." },
			{ "rallyBiteBonus", "Extra bite damage for the enraged herd (0.5 = 50% harder)." },
			{ "coins", "Coins a Golden creature drops in a biome with no entry of its own (the ocean), on top of its normal loot." },
			{ "gemMin", "A Golden creature drops at least this many gems or treasures from the list of the biome it spawned in." },
			{ "gemMax", "...and at most this many." },
			{ "coinsMeadows", "Coins a Golden creature spawned in the Meadows drops." },
			{ "gemsMeadows", "Gems and treasures a Golden creature spawned in the Meadows can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsBlackForest", "Coins a Golden creature spawned in the BlackForest drops." },
			{ "gemsBlackForest", "Gems and treasures a Golden creature spawned in the BlackForest can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsSwamp", "Coins a Golden creature spawned in the Swamp drops." },
			{ "gemsSwamp", "Gems and treasures a Golden creature spawned in the Swamp can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsMountain", "Coins a Golden creature spawned in the Mountain drops." },
			{ "gemsMountain", "Gems and treasures a Golden creature spawned in the Mountain can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsPlains", "Coins a Golden creature spawned in the Plains drops." },
			{ "gemsPlains", "Gems and treasures a Golden creature spawned in the Plains can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsMistlands", "Coins a Golden creature spawned in the Mistlands drops." },
			{ "gemsMistlands", "Gems and treasures a Golden creature spawned in the Mistlands can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsAshLands", "Coins a Golden creature spawned in the AshLands drops." },
			{ "gemsAshLands", "Gems and treasures a Golden creature spawned in the AshLands can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "coinsDeepNorth", "Coins a Golden creature spawned in the DeepNorth drops." },
			{ "gemsDeepNorth", "Gems and treasures a Golden creature spawned in the DeepNorth can drop, separated by | (game item names). They are the kind found in that biome's dungeon and structure chests." },
			{ "vanishSeconds", "A Golden creature vanishes (no drops) this many seconds after a player first comes near. 0 = never." },
			{ "spotDistance", "A Golden creature counts as seen when a player is within this many metres of it (and looking its way, see Spot cone degrees). Until then it behaves like any creature of its kind and never fights." },
			{ "spotConeDegrees", "How far to either side of where a player is looking a Golden creature counts as seen (45 = a 90 degree view in front of them)." },
			{ "wallsBlock", "A wall, rock or tree between the player and the Golden creature means it is not seen." },
			{ "startleSeconds", "When it is seen, a Golden creature gives a startled cry and holds still this many seconds before it runs. 0 = it runs at once." },
			{ "driftAfterSeconds", "If a player has been within Spot distance of a Golden creature for this many seconds without seeing it, it slowly walks towards them (not closer than Reveal distance) until they notice it. 0 = it never does, so a Golden can be missed." },
			{ "revealDistance", "The closest (metres) an unnoticed Golden creature walks to a player while it drifts towards them (see Drift after seconds)." },
			{ "vanishMessage", "Show \"<name> Vanished\" in the middle of the screen when a Golden creature near you vanishes." },
			{ "bodyGlow", "How much a Golden creature's body shines from inside, on top of its gold colour. 0 = none: the body shows its normal texture and shading in gold, like an Elemental. Higher is brighter in the dark but flattens the texture (at 1 the body is a plain gold shape). Looks only." },
			{ "intervalSec", "A Shedding animal drops an item about this often (seconds)." },
			{ "amount", "How many of the item it drops each time." },
			{ "drops", "What each animal sheds, as Animal=Item pairs separated by commas. \"default\" is used for any animal not listed. Use the game's item names, e.g. Hen=ChickenEgg,Deer=DeerHide,default=LeatherScraps." },
			{ "auraRadius", "How close (metres) a player has to be to be soaked (Wet, or the element's debuff) or hurt, for a creature about the size of a Boar. Bigger creatures reach a little further and smaller ones a little less (see Size scaling)." },
			{ "auraOpacity", "How see-through the mist is (0 = invisible, 1 = solid). Lower it if several Drenching mobs make the screen too busy." },
			{ "auraBrightness", "How bright the Radiating ring and wave are (0 = black, 1 = the element's full colour). Lower it for a dimmer ring." },
			{ "auraVisual", "Show the effect's picture (the look only; the gameplay works either way)." },
			{ "periodSec", "A Volatile mob explodes this many seconds after it was first hit. If it is killed first, nothing happens." },
			{ "damageRatio", "Fraction of the damage stored since the first hit that the blast deals (0.5 = half)." },
			{ "maxHealthShare", "The most one blast can take from one creature, as a share of that creature's FULL health, armour counted (0.5 = half). So a blast is never a one-hit kill on someone at full health. 0 turns the limit off." },
			{ "blastRadius", "Reach (metres) of the blast at full effect size. The real reach is this times the explosion picture's scale (Vfx scale x the creature's size), so the damage area always matches what is drawn. It hurts anything of another faction, never the mob or its own faction." },
			{ "noticeRadius", "How far (metres) from a creature that takes damage a Diplomat notices it." },
			{ "elderChance", "Chance (0 to 1) that a Vampiric mob is an Elder, which is immune to sunlight." },
			{ "oneShotBosses", "Let Glass Cannon one-shot bosses too (off by default)." },
			{ "chaseRadius", "How far (metres) it notices a player to chase." },
			{ "biteHealthShare", "How hard a bite hits, as a share of the animal's own health. 0.25 = a quarter, so a 20 hp boar bites for 5 and a big animal bites harder." },
			{ "biteMin", "A bite never hits softer than this." },
			{ "biteMax", "A bite never hits harder than this. 0 = no limit." }
		};

		private static readonly Dictionary<string, string> HelpFor = new Dictionary<string, string>
		{
			{ "drenching.auraRadius", "How close (metres) a player has to be to be soaked by the mist (Wet, or the element's debuff, or poison for a Poison Drenching), for a creature about the size of a Boar. Bigger creatures reach a little further and smaller ones a little less (see Size scaling)." },
			{ "radiating.auraRadius", "How far out (metres) the damaging wave reaches from the creature, for a creature about the size of a Boar. Bigger creatures reach a little further and smaller ones a little less (see Size scaling). Anything of another faction inside it is hurt." },
			{ "drenching.auraVisual", "On: show the blue mist around a Drenching mob. Off: no mist is drawn (the look only; the soaking works either way)." },
			{ "radiating.auraVisual", "On: draw the ring and wave of a Radiating mob. Off: nothing is drawn (the look only; the damage works either way, so players cannot see its reach)." },
			{ "moronic.excludeTamed", "On: a Moronic creature never attacks tamed creatures (it keeps to wild ones and players)." },
			{ "all_consuming.excludeTamed", "On: an All-consuming creature never eats tamed creatures." },
			{ "glass_cannon.health", "Its absolute hit points (not a multiplier): 1 by default, so almost anything kills it." },
			{ "friendly.ambientLook", "On: a few soft hearts rise from a Friendly mob when you are within about 14 m (see \"Ambient looks\" in the Display settings). Looks only." },
			{ "vampiric.ambientLook", "On: when a Vampiric mob heals from a bite, a short stream of dark-red motes runs from the victim to it. Nothing is drawn while it is idle. Looks only." },
			{ "relentless.ambientLook", "On: a Relentless mob kicks up a little dust behind it while it runs. Looks only." },
			{ "immortal.ambientLook", "On: a low, thin violet mist round an Ancient Vampire's feet. Looks only." },
			{ "volatile.ambientLook", "On: a Volatile mob has a few embers and a faint glow before it is hit, brightening as the charge runs down (the wind-up itself is \"Charging sparks\"). Looks only." },
			{ "drenching.ambientLook", "On: water drips from a Drenching mob (the mist round it is \"Aura visual\"). Looks only." },
			{ "undying.ambientLook", "On: a faint pale wisp drifts off an Undying mob. Looks only." },
			{ "moronic.ambientLook", "On: a few small stars circle over a Moronic mob's head. Looks only." },
			{ "alpha.ambientLook", "On: a ring spreads over the ground out to the herd's reach when an Alpha calls its herd. Nothing is drawn otherwise. Looks only." },
			{ "mother.ambientLook", "On: a Mother glows for the last 5 seconds before a calf is born (a warning you can act on), and hearts rise when one is. Looks only." },
			{ "immortal.health", "Health multiplier for an Ancient Vampire (the Immortal mutation)." }
		};

		private static readonly Dictionary<string, float[]> FloatRanges = new Dictionary<string, float[]>
		{
			{
				"vfxScale",
				new float[2] { 0.05f, 5f }
			},
			{
				"sizeScaling",
				new float[2] { 0f, 1f }
			},
			{
				"vfxOpacity",
				new float[2] { 0f, 1f }
			},
			{
				"elderChance",
				new float[2] { 0f, 1f }
			},
			{
				"shelterRadius",
				new float[2] { 4f, 34f }
			},
			{
				"oozerStartHpPct",
				new float[2] { 0.01f, 0.95f }
			},
			{
				"oozerMinHp",
				new float[2] { 1f, 1000f }
			},
			{
				"oozerGraceSec",
				new float[2] { 0f, 5f }
			},
			{
				"lootPerMeal",
				new float[2] { 0f, 2f }
			},
			{
				"wetSeconds",
				new float[2] { 0f, 3600f }
			},
			{
				"fireScale",
				new float[2] { 0.1f, 3f }
			},
			{
				"healShare",
				new float[2] { 0f, 1f }
			},
			{
				"fireScares",
				new float[2] { 0f, 1f }
			},
			{
				"fireWarms",
				new float[2] { 0f, 1f }
			},
			{
				"fireSound",
				new float[2] { 0f, 1f }
			},
			{
				"chargeSound",
				new float[2] { 0f, 1f }
			},
			{
				"blastSound",
				new float[2] { 0f, 1f }
			},
			{
				"auraOpacity",
				new float[2] { 0f, 1f }
			},
			{
				"auraBrightness",
				new float[2] { 0f, 1f }
			},
			{
				"freezeSeconds",
				new float[2] { 0f, 5f }
			},
			{
				"slowHoldSeconds",
				new float[2] { 0f, 5f }
			},
			{
				"debuffSeconds",
				new float[2] { 0.5f, 5f }
			},
			{
				"parryStunSeconds",
				new float[2] { 0f, 5f }
			},
			{
				"vanishSeconds",
				new float[2] { 0f, 3600f }
			},
			{
				"daylightBurnPctMaxHpPerSec",
				new float[2] { 0f, 1f }
			},
			{
				"mealCap",
				new float[2] { 0f, 10f }
			},
			{
				"biteHealthShare",
				new float[2] { 0f, 5f }
			},
			{
				"biteMin",
				new float[2] { 0f, 100f }
			},
			{
				"biteMax",
				new float[2] { 0f, 1000f }
			},
			{
				"sicknessChance",
				new float[2] { 0f, 1f }
			},
			{
				"friendlyOffspringChance",
				new float[2] { 0f, 1f }
			},
			{
				"blowMeadows",
				new float[2] { 0.05f, 1f }
			},
			{
				"blowBlackForest",
				new float[2] { 0.05f, 1f }
			},
			{
				"blowSwamp",
				new float[2] { 0.05f, 1f }
			},
			{
				"glowIntensity",
				new float[2] { 0f, 3f }
			},
			{
				"twinChance",
				new float[2] { 0f, 1f }
			},
			{
				"damageRatio",
				new float[2] { 0f, 20f }
			},
			{
				"maxHealthShare",
				new float[2] { 0f, 1f }
			},
			{
				"spotDistance",
				new float[2] { 1f, 100f }
			},
			{
				"oozerSizeFit",
				new float[2] { 0f, 1f }
			},
			{
				"bodyGlow",
				new float[2] { 0f, 1f }
			},
			{
				"spotConeDegrees",
				new float[2] { 5f, 180f }
			},
			{
				"startleSeconds",
				new float[2] { 0f, 3f }
			},
			{
				"driftAfterSeconds",
				new float[2] { 0f, 600f }
			},
			{
				"pregnancyChance",
				new float[2] { 0f, 1f }
			},
			{
				"regenPctPerSec",
				new float[2] { 0f, 1f }
			},
			{
				"scale",
				new float[2] { 0.1f, 10f }
			},
			{
				"moveSpeed",
				new float[2] { 0.1f, 10f }
			},
			{
				"attackSpeed",
				new float[2] { 0.1f, 10f }
			},
			{
				"health",
				new float[2] { 0.05f, 100f }
			},
			{
				"damage",
				new float[2] { 0.05f, 100f }
			}
		};

		private static string HelpText(string mid, string key)
		{
			if (HelpFor.TryGetValue(mid + "." + key, out var value))
			{
				return value;
			}
			if (Help.TryGetValue(key, out value))
			{
				return value;
			}
			return "Tuning value.";
		}

		private static ConfigDescription D(string text)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			return new ConfigDescription(text, (AcceptableValueBase)null, Array.Empty<object>());
		}

		private static ConfigDescription FloatDesc(string key, string help)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			if (FloatRanges.TryGetValue(key, out var value))
			{
				return new ConfigDescription(help, (AcceptableValueBase)(object)new AcceptableValueRange<float>(value[0], value[1]), Array.Empty<object>());
			}
			string text = key.ToLowerInvariant();
			if (text.EndsWith("sec") || text.EndsWith("seconds"))
			{
				return new ConfigDescription(help, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 3600f), Array.Empty<object>());
			}
			if (text.EndsWith("radius") || text.EndsWith("range") || text.EndsWith("distance"))
			{
				return new ConfigDescription(help, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 500f), Array.Empty<object>());
			}
			return D(help);
		}

		private static string BiomeLabel(string biome)
		{
			return biome switch
			{
				"DeepNorth" => "Deep North", 
				"AshLands" => "Ash Lands", 
				"BlackForest" => "Black Forest", 
				_ => biome, 
			};
		}

		public static string Wrap(string text, int width = 100)
		{
			if (string.IsNullOrEmpty(text) || text.Length <= width)
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string[] array = text.Split('\n');
			foreach (string obj in array)
			{
				int num = 0;
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append('\n');
				}
				string[] array2 = obj.Split(' ');
				foreach (string text2 in array2)
				{
					if (num > 0 && num + 1 + text2.Length > width)
					{
						stringBuilder.Append('\n');
						num = 0;
					}
					else if (num > 0)
					{
						stringBuilder.Append(' ');
						num++;
					}
					stringBuilder.Append(text2);
					num += text2.Length;
				}
			}
			return stringBuilder.ToString();
		}

		public static ConfigDescription Wrapped(ConfigDescription d)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (d != null)
			{
				return new ConfigDescription(Wrap(d.Description), d.AcceptableValues, d.Tags);
			}
			return null;
		}

		private static ConfigDescription Adv(string text)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(text, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = true
				}
			});
		}

		private static ConfigDescription Range01(string text)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			return new ConfigDescription(text, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>());
		}

		public static List<Action<MutationConfig>> Bind(ConfigFile f, MutationConfig d)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Expected O, but got Unknown
			//IL_06a2: Expected O, but got Unknown
			//IL_0af4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1d: Expected O, but got Unknown
			//IL_0b51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b7a: Expected O, but got Unknown
			//IL_0def: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e18: Expected O, but got Unknown
			//IL_0ede: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f07: Expected O, but got Unknown
			//IL_0f84: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fad: Expected O, but got Unknown
			//IL_0fe1: Unknown result type (might be due to invalid IL or missing references)
			//IL_100a: Expected O, but got Unknown
			//IL_103e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1067: Expected O, but got Unknown
			//IL_1094: Unknown result type (might be due to invalid IL or missing references)
			//IL_10bd: Expected O, but got Unknown
			//IL_10f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_111a: Expected O, but got Unknown
			//IL_126b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1294: Expected O, but got Unknown
			//IL_1473: Unknown result type (might be due to invalid IL or missing references)
			//IL_148a: Expected O, but got Unknown
			//IL_13e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_13fa: Expected O, but got Unknown
			Binder binder = new Binder(f);
			binder.Add("01 - Spawn chance", "Chance multiplier", d.spawnChance.chanceMultiplier, new ConfigDescription("A big dial for how many mobs mutate. 1 = normal, 0.5 = half as many, 2 = twice as many. It only changes the first mutation, not extra mutations or Ancient Vampires.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.spawnChance.chanceMultiplier = v;
			});
			binder.Add("01 - Spawn chance", "Immortal chance", d.spawnChance.immortalChance, Range01("How likely any mob is to be an Ancient Vampire. 0.001 = 1 in 1000, 0 = never. It can still pick up other mutations after."), delegate(MutationConfig m, float v)
			{
				m.spawnChance.immortalChance = v;
			});
			binder.Add("01 - Spawn chance", "Golden chance", d.spawnChance.goldenChance, Range01("How likely any normal mob is to be Golden (a rare gold creature that runs away and drops coins). 0.002 = 1 in 500, 0 = never. It never counts toward the mutation limit and is not rolled for raid or summoned mobs."), delegate(MutationConfig m, float v)
			{
				m.spawnChance.goldenChance = v;
			});
			binder.Add("01 - Spawn chance", "Size chance", d.spawnChance.sizeChance, Range01("When a mob's first mutation is not a size, how likely it is to also get a size (Giant, Large, Small or Tiny) on top. 0.5 = half the time. A size can also be the first mutation itself. A size counts as a mutation toward the limit."), delegate(MutationConfig m, float v)
			{
				m.spawnChance.sizeChance = v;
			});
			binder.Add("01 - Spawn chance", "Ancient Vampire - appears after", d.spawnChance.immortalAfterKey, D("Ancient Vampires wait until this world event has happened. defeated_bonemass = after Bonemass is beaten (when you can make Allblack). Leave empty to let them appear from the start."), delegate(MutationConfig m, string v)
			{
				m.spawnChance.immortalAfterKey = v;
			});
			ExtraCfg ex = d.spawnChance.extraMutation;
			binder.Add("01 - Spawn chance", "Extra mutations - max total", ex.maxTotal, new ConfigDescription("The most mutations one mob can ever have, sizes (Giant, Large, Small, Tiny) included: a size takes one of these slots. Each biome's own \"Most mutations\" does not count sizes, so a size comes on top of that limit but never past this total. Bigger = more chances of wild stacks.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()), delegate(MutationConfig m, int v)
			{
				m.spawnChance.extraMutation.maxTotal = v;
			});
			CapCfg mutationCap = d.spawnChance.mutationCap;
			binder.Add("01 - Spawn chance", "Mutation limit - by biome", mutationCap.byBiome, D("On: a natural roll can give at most the number set under each biome's \"Most mutations\" (1 in the Meadows, one more per biome up, 5 from the Plains). A size (Giant, Large, Small, Tiny) does not count toward this limit, so a Meadows mob can still be a Giant Vampiric. Off: only \"Extra mutations - max total\" limits. Creatures that already have more (bred, spawned with mm_spawn) keep them."), delegate(MutationConfig m, bool v)
			{
				m.spawnChance.mutationCap.byBiome = v;
			});
			binder.Add("01 - Spawn chance", "Mutation limit - follow boss progress", mutationCap.followProgress, D("On: a biome's limit only applies once the world has got that far: 1 mutation with no boss down, one more for each boss in the list below that has been defeated (by anyone in the world). So a Mountain mob stays at 3 until Bonemass is down. Off: the biome limit alone."), delegate(MutationConfig m, bool v)
			{
				m.spawnChance.mutationCap.followProgress = v;
			});
			binder.Add("01 - Spawn chance", "Mutation limit - boss keys", Csv(mutationCap.bossKeys), D("The world events that raise the progress limit by one each, in order. Comma separated. Default: Eikthyr, the Elder, Bonemass and Moder (defeated_eikthyr, defeated_gdking, defeated_bonemass, defeated_dragon)."), delegate(MutationConfig m, string v)
			{
				m.spawnChance.mutationCap.bossKeys = Split(v);
			});
			binder.Add("01 - Spawn chance", "Raid and summoned mobs - chance multiplier", d.spawnChance.eventChanceMultiplier, new ConfigDescription("Like the big dial above, but only for raid mobs and mobs that other creatures summon. 1 = same as everyone, 0 = never, 2 = twice as likely. Does nothing if they are switched off in 02 - Who can mutate.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.spawnChance.eventChanceMultiplier = v;
			});
			string[] order = new string[9] { "Meadows", "BlackForest", "Swamp", "Mountain", "Plains", "Mistlands", "AshLands", "DeepNorth", "Ocean" };
			List<string> list = order.Where((string x) => d.spawnChance.biomeChance.ContainsKey(x) || ex.biomeChance.ContainsKey(x)).ToList();
			list.AddRange(from x in d.spawnChance.biomeChance.Keys.Concat(ex.biomeChance.Keys).Distinct()
				where !order.Contains(x)
				select x);
			for (int num = 0; num < list.Count; num++)
			{
				string name = list[num];
				string section = "01" + "bcdefghijklmnop"[num] + " - Biome: " + BiomeLabel(name);
				if (d.spawnChance.biomeChance.ContainsKey(name))
				{
					binder.Add(section, "Chance of a mutation", d.spawnChance.biomeChance[name], Range01("How likely a mob is to spawn mutated here. 0.3 = 3 in 10, 1 = always, 0 = never."), delegate(MutationConfig m, float v)
					{
						m.spawnChance.biomeChance[name] = v;
					});
				}
				if (ex.biomeChance.ContainsKey(name))
				{
					binder.Add(section, "Chance of extra mutations", ex.biomeChance[name], Range01("After a mob mutates, how likely it is to get another one (and another...). 0.1 = 1 in 10."), delegate(MutationConfig m, float v)
					{
						m.spawnChance.extraMutation.biomeChance[name] = v;
					});
				}
				if (mutationCap.maxByBiome.ContainsKey(name))
				{
					binder.Add(section, "Most mutations", mutationCap.maxByBiome[name], new ConfigDescription("The most mutations a natural roll can give here, sizes not counted (see \"Mutation limit\" in 01 - Spawn chance; a boss that is still alive can hold it lower).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()), delegate(MutationConfig m, int v)
					{
						m.spawnChance.mutationCap.maxByBiome[name] = v;
					});
				}
				if (!d.spawnChance.mobKillersAllowed.TryGetValue(name, out var value))
				{
					value = d.spawnChance.mobKillersAllowedElsewhere;
				}
				binder.Add(section, "Creature-killing mutations allowed", value, D("Off: the mutations that make mobs kill other creatures (All-consuming, Moronic; see \"Creature-killing mutations\" in 01 - Spawn chance) are never rolled here, so the animals you hunt are not thinned out. On: they roll like any other mutation. Off by default in the Meadows."), delegate(MutationConfig m, bool v)
				{
					m.spawnChance.mobKillersAllowed[name] = v;
				});
			}
			string section2 = "01" + "bcdefghijklmnop"[list.Count] + " - Biome: Any other";
			binder.Add(section2, "Chance of a mutation", d.spawnChance.defaultChance, Range01("How likely a mob is to spawn mutated in any biome not listed above. 0.3 = 3 in 10."), delegate(MutationConfig m, float v)
			{
				m.spawnChance.defaultChance = v;
			});
			binder.Add(section2, "Chance of extra mutations", ex.chance, Range01("How likely a mutated mob is to get another mutation in any biome not listed above."), delegate(MutationConfig m, float v)
			{
				m.spawnChance.extraMutation.chance = v;
			});
			binder.Add(section2, "Most mutations", mutationCap.maxElsewhere, new ConfigDescription("The most mutations a natural roll can give in any biome not listed above.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()), delegate(MutationConfig m, int v)
			{
				m.spawnChance.mutationCap.maxElsewhere = v;
			});
			binder.Add(section2, "Creature-killing mutations allowed", d.spawnChance.mobKillersAllowedElsewhere, D("Whether the mutations that make mobs kill other creatures (All-consuming, Moronic) can be rolled in any biome not listed above."), delegate(MutationConfig m, bool v)
			{
				m.spawnChance.mobKillersAllowedElsewhere = v;
			});
			binder.Add("02 - Who can mutate", "Exclude bosses", d.eligibility.excludeBosses, D("Bosses never mutate."), delegate(MutationConfig m, bool v)
			{
				m.eligibility.excludeBosses = v;
			});
			binder.Add("02 - Who can mutate", "Exclude tamed", d.eligibility.excludeTamed, D("Tamed creatures never mutate."), delegate(MutationConfig m, bool v)
			{
				m.eligibility.excludeTamed = v;
			});
			binder.Add("02 - Who can mutate", "Exclude raid and summoned mobs", d.eligibility.excludeSummonedAndEventMobs, D("On: mobs from raids/events and mobs summoned by other creatures never mutate. Off: they roll like any other mob, or at their own rate (see \"Raid and summoned mobs\" in 01 - Spawn chance)."), delegate(MutationConfig m, bool v)
			{
				m.eligibility.excludeSummonedAndEventMobs = v;
			});
			binder.Add("02 - Who can mutate", "Exclude passive creatures", d.eligibility.excludePassive, D("On: passive animals (deer, hens, boars... see \"Passive creatures\" below) never mutate. Off: they roll like any other mob. Rabid only rolls on passive animals, so with this on it can only come from breeding."), delegate(MutationConfig m, bool v)
			{
				m.eligibility.excludePassive = v;
			});
			binder.Add("02 - Who can mutate", "Exclude minibosses", d.eligibility.excludeMinibosses, D("On (default): the creatures listed under \"Minibosses\" below never mutate. Off: they roll like any other mob."), delegate(MutationConfig m, bool v)
			{
				m.eligibility.excludeMinibosses = v;
			});
			binder.Add("02 - Who can mutate", "Exclude Epic Loot bounty creatures", d.eligibility.excludeEpicLootBounties, D("On (default): the targets and escorts of Epic Loot bounties never mutate, so a bounty is the fight Epic Loot designed. Off: they roll like any other mob. Does nothing without Epic Loot."), delegate(MutationConfig m, bool v)
			{
				m.eligibility.excludeEpicLootBounties = v;
			});
			binder.Add("02 - Who can mutate", "Minibosses", Csv(d.mobOverrides.miniboss), D("Prefab names counted as minibosses (Hildir's and Bogwitch's challenge creatures...). They never mutate while \"Exclude minibosses\" is on. Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.miniboss = Split(v);
			});
			binder.Add("02 - Who can mutate", "Creatures that split on death", Csv(d.mobOverrides.splitsInto), D("Parent:Piece prefab pairs (BlobElite:Blob). The pieces a creature splits into keep its mutations, except Mimic, Mother, Friendly, Rabid, Undying, Impregnator and the Ancient Vampire. Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.splitsInto = Split(v);
			});
			binder.Add("02 - Who can mutate", "Passive creatures", Csv(d.mobOverrides.passive), D("Prefab names treated as passive (can roll Rabid). Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.passive = Split(v);
			});
			binder.Add("02 - Who can mutate", "Hostile creatures", Csv(d.mobOverrides.hostile), D("Prefab names forced to count as hostile. Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.hostile = Split(v);
			});
			binder.Add("02 - Who can mutate", "Creatures with a base element", Csv(d.mobOverrides.elemental), D("Prefab:element pairs for creatures that already have an element (Surtling:fire, Hatchling:frost, Ghost:spirit...). With the Elemental mutation they take one of the other four elements; any other creature takes any of the five. Elements: fire, frost, lightning, poison, spirit. Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.elemental = Split(v);
			});
			binder.Add("02 - Who can mutate", "Ranged creatures", Csv(d.mobOverrides.ranged), D("Prefab names forced to count as ranged (can't roll Glass Cannon). Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.ranged = Split(v);
			});
			binder.Add("02 - Who can mutate", "Never mutate", Csv(d.mobOverrides.neverMutate), D("Prefab names that never mutate. Comma separated."), delegate(MutationConfig m, string v)
			{
				m.mobOverrides.neverMutate = Split(v);
			});
			binder.Add("03 - Loot", "Passive variant multiplier", d.loot.passiveVariantMultiplier, new ConfigDescription("A Friendly or Mannequin mob (the passive variants) drops this fraction of its loot (0.5 = half; applies once). Each mutation's own loot multiplier is in its \"Mutation - ...\" section.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.loot.passiveVariantMultiplier = v;
			});
			binder.Add("03 - Loot", "Young loot multiplier", d.loot.youngMultiplier, new ConfigDescription("How much loot young creatures drop (calves from Mothers, Impregnator babies, Young group members). 0.5 = half, 1 = full, 0 = none.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.loot.youngMultiplier = v;
			});
			binder.Add("03 - Loot", "Scale trophies and fixed drops", d.loot.scaleFixedDrops, D("Off (default): like the game's own stars, the loot multipliers only scale the drops the game itself multiplies for a starred creature; trophies and other fixed drops stay as the game rolled them (a Giant drops more meat, not more trophies). On: every drop is scaled, trophies included."), delegate(MutationConfig m, bool v)
			{
				m.loot.scaleFixedDrops = v;
			});
			binder.Add("03 - Loot", "Apply loot multipliers to Epic Loot", d.loot.scaleEpicLoot, D("On (default): with Epic Loot installed, its drops follow the same multiplier as the vanilla drops: a mob that drops 2x loot gets an extra Epic Loot roll, 1.25x gives a 25% chance of one, and a Young or Friendly mob (below 1x) skips that share of its Epic Loot rolls. Off: Epic Loot's drops are not touched (an Undying mob's Oozer body still never rolls them)."), delegate(MutationConfig m, bool v)
			{
				m.loot.scaleEpicLoot = v;
			});
			binder.Add("04 - Offspring", "Pass on Ancient Vampire", d.offspring.passOnAncientVampire, D("Off (default): the Ancient Vampire is a rare title won at spawn and young are never born with it (they keep the other mutations), so a Mother or Impregnator can't breed a cluster of mobs that only Allblack can kill. On: it can be inherited."), delegate(MutationConfig m, bool v)
			{
				m.offspring.passOnAncientVampire = v;
			});
			binder.Add("04 - Offspring", "Pass on Elder", d.offspring.passOnElder, D("Off (default): young of an Elder Vampiric are Vampiric but roll Elder like any other mob, so breeding Elders (a Mother, an Impregnator, a tame pair) can't farm Allblack Blood. On: Elder parents give Elder young."), delegate(MutationConfig m, bool v)
			{
				m.offspring.passOnElder = v;
			});
			binder.Add("04 - Offspring", "Use vanilla calves", d.offspring.useVanillaCalves, D("Where the game has a young form of the mob (Boar piglet, Wolf cub, Lox calf), Impregnator births are born as that and grow up with the game's own timer. Off: every birth uses the newborn fraction above."), delegate(MutationConfig m, bool v)
			{
				m.offspring.useVanillaCalves = v;
			});
			binder.Add("04 - Offspring", "Grow-up time (seconds)", d.offspring.growUpSec, D("How long a Young mob takes to climb from Tiny to its grown-up size and stats, passing through every size step (Small, normal, Large...) on the way."), delegate(MutationConfig m, float v)
			{
				m.offspring.growUpSec = v;
			});
			binder.Add("04 - Offspring", "Bonus mutation roll", d.offspring.bonusMutationRoll, D("Offspring can roll extra mutations on top of the ones they inherit."), delegate(MutationConfig m, bool v)
			{
				m.offspring.bonusMutationRoll = v;
			});
			binder.Add("11 - Young and Aged", "Groups can have a calf or an Aged one", d.ageGroups.enabled, D("When this many creatures of one kind spawn close together (a camp, a herd), one of them can be Young (small and weak, grows up) or an Aged one (smaller and weaker)."), delegate(MutationConfig m, bool v)
			{
				m.ageGroups.enabled = v;
			});
			binder.Add("11 - Young and Aged", "Group size", d.ageGroups.groupSize, new ConfigDescription("How many of one kind close together make a group.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 20), Array.Empty<object>()), delegate(MutationConfig m, int v)
			{
				m.ageGroups.groupSize = v;
			});
			binder.Add("11 - Young and Aged", "Calf chance", d.ageGroups.calfChance, Range01("Chance (0 to 1), per group, that one of them is Young. It grows up over the grow-up time (see 04 - Offspring)."), delegate(MutationConfig m, float v)
			{
				m.ageGroups.calfChance = v;
			});
			binder.Add("11 - Young and Aged", "Aged chance", d.ageGroups.ancientChance, Range01("Chance (0 to 1), per group, that one of them is Aged. A Vampiric is never Aged (it stays regular). Not the same as the Ancient Vampire mutation: see \"Immortal chance\" in 01 - Spawn chance."), delegate(MutationConfig m, float v)
			{
				m.ageGroups.ancientChance = v;
			});
			binder.Add("11 - Young and Aged", "Aged size, health and damage", d.ageGroups.ancientMultiplier, new ConfigDescription("An Aged mob's size, health and damage as a fraction of normal (0.8 = 80%).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.ageGroups.ancientMultiplier = v;
			});
			binder.Add("10 - Loyal breeding", "Loyal companions can breed", d.loyalBreeding.enabled, D("Feed a Loyal companion its breeding food (see the README) and two of the same kind that are both in the mood make a baby that is Loyal too."), delegate(MutationConfig m, bool v)
			{
				m.loyalBreeding.enabled = v;
			});
			binder.Add("10 - Loyal breeding", "In the mood for (seconds)", d.loyalBreeding.loveSeconds, new ConfigDescription("How long a fed companion waits for a partner.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 3600f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.loyalBreeding.loveSeconds = v;
			});
			binder.Add("10 - Loyal breeding", "Pregnancy time (seconds)", d.loyalBreeding.gestationSeconds, new ConfigDescription("From the two meeting to the baby being born.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 86400f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.loyalBreeding.gestationSeconds = v;
			});
			binder.Add("10 - Loyal breeding", "Cooldown (seconds)", d.loyalBreeding.cooldownSeconds, new ConfigDescription("After the birth, before either parent can breed again.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 86400f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.loyalBreeding.cooldownSeconds = v;
			});
			binder.Add("10 - Loyal breeding", "Most companions of a kind nearby", d.loyalBreeding.maxNearby, new ConfigDescription("Breeding stops while this many of your companions of the same kind (young ones and ones expecting a baby included) are within the radius below, and starts again when there is room. Nothing is removed. 0 = no limit.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()), delegate(MutationConfig m, int v)
			{
				m.loyalBreeding.maxNearby = v;
			});
			binder.Add("10 - Loyal breeding", "Population radius (metres)", d.loyalBreeding.populationRadius, new ConfigDescription("How far around a breeding companion the companions above are counted.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 500f), Array.Empty<object>()), delegate(MutationConfig m, float v)
			{
				m.loyalBreeding.populationRadius = v;
			});
			binder.Add("13 - First finds", "First finds", d.firstFinds.enabled, D("On: the server remembers who first met each mutation, combination and unique creature on this world, and every player's Compendium shows \"First found by ...\" beside it. Kept in a small file next to the server's settings (BepInEx/config/MutagenicWilds/firstfinds), one per world. Off: nothing is recorded or shown."), delegate(MutationConfig m, bool v)
			{
				m.firstFinds.enabled = v;
			});
			binder.Add("13 - First finds", "Announce first finds", d.firstFinds.announce, D("On: when someone meets a combination or a unique creature nobody on this world has met before, everyone online gets a short message (at most one every few seconds; several at once become \"... and 2 more\"). Each player can hide these messages for themselves in 12 - Compendium."), delegate(MutationConfig m, bool v)
			{
				m.firstFinds.announce = v;
			});
			binder.Add("13 - First finds", "Announce single mutations too", d.firstFinds.announceMutations, D("On: a single mutation met for the first time on the world is announced as well. Off (default): only combinations and unique creatures, since a new world turns up many single mutations in its first hours."), delegate(MutationConfig m, bool v)
			{
				m.firstFinds.announceMutations = v;
			});
			binder.Add("09 - Allblack", "Elder Vampiric drop chance", d.allblack.dropChance, Range01("Chance (0 to 1) that an Elder Vampiric drops Allblack Blood when it dies."), delegate(MutationConfig m, float v)
			{
				m.allblack.dropChance = v;
			});
			binder.Add("09 - Allblack", "Allblack Blood dropped", d.allblack.dropAmount, new ConfigDescription("How many Allblack Blood an Elder Vampiric drops.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), Array.Empty<object>()), delegate(MutationConfig m, int v)
			{
				m.allblack.dropAmount = v;
			});
			binder.Add("09 - Allblack", "Harmless Elders drop Blood", d.allblack.harmlessElderDrops, D("Off: a Friendly, Mannequin or Moronic Elder Vampiric drops no Allblack Blood, so the Blood has to be won from a dangerous Elder. On: any Elder drops it."), delegate(MutationConfig m, bool v)
			{
				m.allblack.harmlessElderDrops = v;
			});
			binder.Add("09 - Allblack", "Kin Slayer: owner only", d.allblack.kinSlayerOwnerOnly, D("On: only a Loyal companion's owner can kill it with the Kin Slayer. Off: anyone holding one can (in multiplayer, that includes other players' companions)."), delegate(MutationConfig m, bool v)
			{
				m.allblack.kinSlayerOwnerOnly = v;
			});
			string[] orderedIds = d.OrderedIds;
			foreach (string text in orderedIds)
			{
				string mid = text;
				MutationDef mutationDef = d.mutations[mid];
				string text2 = "Mutation - " + mutationDef.label;
				binder.Add(text2, "Enabled", mutationDef.enabled, D("Off: this mutation does not exist. It is never rolled, bred, or given by mm_spawn, and creatures that already have it lose its effects within a second or so (some looks, such as an aura already drawn, may last until the creature is seen again). Turn it back on and they get them back."), delegate(MutationConfig m, bool v)
				{
					m.mutations[mid].enabled = v;
				});
				if (mid != "immortal")
				{
					binder.Add(text2, "Weight", mutationDef.weight, new ConfigDescription("How often it is picked compared with the others. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000), Array.Empty<object>()), delegate(MutationConfig m, int v)
					{
						m.mutations[mid].weight = v;
					});
					if (mid == "friendly" || mid == "mannequin")
					{
						binder.Add(text2, "Passive variant (reduced loot)", mutationDef.passiveVariant, D("On: a mob with this mutation drops reduced loot (see 03 - Loot)."), delegate(MutationConfig m, bool v)
						{
							m.mutations[mid].passiveVariant = v;
						});
					}
				}
				binder.Add(text2, "Loot multiplier", mutationDef.lootMultiplier, new ConfigDescription("Loot from a mob with this mutation: 1 = vanilla, 1.5 = half as much again. A mob's mutations add up: each adds its multiplier minus 1 to a base of 1 (two at 1.5 give 2.0), so 0 means this mutation adds no loot of its own (a mob with only this one drops nothing).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()), delegate(MutationConfig m, float v)
				{
					m.mutations[mid].lootMultiplier = v;
				});
				if (mutationDef.wildLootOnly)
				{
					binder.Add(text2, "Loot bonus only when wild", def: true, D("On: the loot multiplier above only applies to wild creatures. A tamed or Loyal one drops without it, so a bonus that pays for a fight can't be farmed from animals a player keeps."), delegate(MutationConfig m, bool v)
					{
						m.mutations[mid].wildLootOnly = v;
					});
				}
				if (!Tunable.TryGetValue(mid, out var value2))
				{
					continue;
				}
				string[] array = value2;
				foreach (string text3 in array)
				{
					string k = text3;
					if (k == "tint" || k.EndsWith("Colour", StringComparison.Ordinal))
					{
						AddTint(binder, text2, mid, mutationDef, k);
					}
					else
					{
						if (!mutationDef.effects.TryGetValue(k, out var value3) || value3 == null)
						{
							continue;
						}
						string text4 = HelpText(mid, k);
						if (value3 is bool)
						{
							binder.Add(text2, Nice(k), (bool)value3, D(text4), delegate(MutationConfig m, bool v)
							{
								m.mutations[mid].effects[k] = v;
							});
						}
						else if (value3 is string)
						{
							binder.Add(text2, Nice(k), (string)value3, D(text4), delegate(MutationConfig m, string v)
							{
								m.mutations[mid].effects[k] = v;
							});
						}
						else if (value3 is long || value3 is int)
						{
							binder.Add(text2, Nice(k), Convert.ToInt32(value3), D(text4), delegate(MutationConfig m, int v)
							{
								m.mutations[mid].effects[k] = (long)v;
							});
						}
						else
						{
							binder.Add(text2, Nice(k), Convert.ToSingle(value3, CultureInfo.InvariantCulture), FloatDesc(k, text4), delegate(MutationConfig m, float v)
							{
								m.mutations[mid].effects[k] = (double)v;
							});
						}
					}
				}
			}
			foreach (KeyValuePair<string, object[]> item in d.pairs.OrderBy<KeyValuePair<string, object[]>, string>((KeyValuePair<string, object[]> p) => p.Key, StringComparer.Ordinal))
			{
				string key = item.Key;
				binder.Add("05 - Combo names", key, (string)item.Value[0], Adv("Name when a mob has exactly these two mutations (also used as part of the name for bigger combinations)."), delegate(MutationConfig m, string v)
				{
					m.pairs[key][0] = v;
				});
			}
			if (d.elementalPairs != null)
			{
				foreach (KeyValuePair<string, Dictionary<string, object[]>> item2 in d.elementalPairs.OrderBy<KeyValuePair<string, Dictionary<string, object[]>>, string>((KeyValuePair<string, Dictionary<string, object[]>> x) => x.Key, StringComparer.Ordinal))
				{
					foreach (KeyValuePair<string, object[]> item3 in item2.Value.OrderBy<KeyValuePair<string, object[]>, string>((KeyValuePair<string, object[]> x) => x.Key, StringComparer.Ordinal))
					{
						string element = item2.Key;
						string other = item3.Key;
						binder.Add("06 - Elemental combo names", element + "+" + other, (string)item3.Value[0], Adv("Name of an Elemental creature of this element with this one other mutation (also part of bigger combinations)."), delegate(MutationConfig m, string v)
						{
							m.elementalPairs[element][other][0] = v;
						});
					}
				}
			}
			return binder.Apply;
		}

		private static void AddTint(Binder b, string sec, string mid, MutationDef def, string key = "tint")
		{
			string prefix = ((key == "tint") ? "tint" : key.Substring(0, key.Length - "Colour".Length));
			string key2 = key switch
			{
				"exodiaColour" => "Exodia glow colour", 
				"chargeColour" => "Charge colour", 
				"ambientColour" => "Look colour", 
				"tint" => "Tint colour", 
				_ => "Colour", 
			};
			if (!def.effects.TryGetValue(prefix + "R", out var value) || !def.effects.TryGetValue(prefix + "G", out var value2) || !def.effects.TryGetValue(prefix + "B", out var value3))
			{
				return;
			}
			string defHex = ToHex(Convert.ToSingle(value, CultureInfo.InvariantCulture), Convert.ToSingle(value2, CultureInfo.InvariantCulture), Convert.ToSingle(value3, CultureInfo.InvariantCulture));
			b.Add(sec, key2, defHex, D(Help[key]), delegate(MutationConfig m, string v)
			{
				if (!string.Equals((v ?? "").Trim().TrimStart('#'), defHex.TrimStart('#'), StringComparison.OrdinalIgnoreCase) && FromHex(v, out var r, out var g, out var b2))
				{
					Dictionary<string, object> effects = m.mutations[mid].effects;
					effects[prefix + "R"] = (double)r;
					effects[prefix + "G"] = (double)g;
					effects[prefix + "B"] = (double)b2;
				}
			});
		}

		private static string ToHex(float r, float g, float b)
		{
			Func<float, int> func = (float x) => Math.Max(0, Math.Min(255, (int)Math.Round(x * 255f)));
			return "#" + func(r).ToString("X2") + func(g).ToString("X2") + func(b).ToString("X2");
		}

		private static bool FromHex(string v, out float r, out float g, out float b)
		{
			r = (g = (b = 0f));
			v = (v ?? "").Trim().TrimStart('#');
			if (v.Length != 6)
			{
				return false;
			}
			if (!int.TryParse(v, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			r = (float)((result >> 16) & 0xFF) / 255f;
			g = (float)((result >> 8) & 0xFF) / 255f;
			b = (float)(result & 0xFF) / 255f;
			return true;
		}

		public static MutationConfig Build(string defaultText, List<Action<MutationConfig>> apply)
		{
			MutationConfig mutationConfig = MutationConfig.FromText(defaultText);
			foreach (Action<MutationConfig> item in apply)
			{
				item(mutationConfig);
			}
			return mutationConfig.Rebuild();
		}

		private static string Nice(string key)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < key.Length; i++)
			{
				char c = key[i];
				if (i == 0)
				{
					stringBuilder.Append(char.ToUpperInvariant(c));
				}
				else if (char.IsUpper(c))
				{
					stringBuilder.Append(' ').Append(char.ToLowerInvariant(c));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		private static string Csv(List<string> l)
		{
			if (l != null)
			{
				return string.Join(", ", l.ToArray());
			}
			return "";
		}

		private static List<string> Split(string s)
		{
			return (from x in (s ?? "").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select x.Trim() into x
				where x.Length > 0
				select x).ToList();
		}
	}
	internal sealed class ConfigurationManagerAttributes
	{
		public bool? IsAdvanced;
	}
	public static class ConfigMigrate
	{
		private static readonly Regex NewName = new Regex("^0([1-9] - .+)$");

		public static void Run(ConfigFile f)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			try
			{
				PropertyInfo property = typeof(ConfigFile).GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				Dictionary<ConfigDefinition, string> dictionary = ((property != null) ? (property.GetValue(f, null) as Dictionary<ConfigDefinition, string>) : null);
				if (dictionary == null || dictionary.Count == 0)
				{
					return;
				}
				int num = 0;
				foreach (ConfigDefinition item in f.Keys.ToList())
				{
					Match match = NewName.Match(item.Section);
					if (!match.Success)
					{
						continue;
					}
					ConfigDefinition key = new ConfigDefinition(match.Groups[1].Value, item.Key);
					if (dictionary.TryGetValue(key, out var value))
					{
						ConfigEntryBase val = f[item];
						if (object.Equals(val.BoxedValue, val.DefaultValue))
						{
							val.SetSerializedValue(value);
							num++;
						}
						dictionary.Remove(key);
					}
				}
				if (num > 0)
				{
					f.Save();
					Plugin.Log.LogInfo((object)("Settings: moved " + num + " value(s) from the old section names to the new ones (01 - ... 09 - ...)"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Settings from before the section rename could not be carried over: " + ex.Message));
			}
		}
	}
	public static class ConfigUpgrade
	{
		public static void Run(ConfigFile f, bool fileExisted)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			try
			{
				ConfigEntry<int> val = f.Bind<int>("00 - Mod", "Settings version", 0, new ConfigDescription("Used by the mod to carry your settings across updates. Leave it alone.", (AcceptableValueBase)null, Array.Empty<object>()));
				if (!fileExisted)
				{
					val.Value = 4;
					return;
				}
				int value = val.Value;
				if (value >= 4)
				{
					return;
				}
				List<ConfigVersionRules.Change> list = ConfigVersionRules.Plan(ConfigVersionRules.Steps, value, 4, delegate(string section, string key)
				{
					foreach (ConfigDefinition key in f.Keys)
					{
						if (key.Section == section && key.Key == key)
						{
							return f[key].GetSerializedValue();
						}
					}
					return (string)null;
				});
				if (ConfigVersionRules.AnyReplaced(list))
				{
					try
					{
						string text = f.ConfigFilePath + ".bak-v" + value;
						if (File.Exists(f.ConfigFilePath) && !File.Exists(text))
						{
							File.Copy(f.ConfigFilePath, text);
							Plugin.Log.LogInfo((object)("Settings: the old settings file was kept as " + Path.GetFileName(text)));
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Settings: could not copy the old settings file (" + ex.Message + "); the update is not applied"));
						return;
					}
				}
				foreach (ConfigVersionRules.Change item in list)
				{
					string text2 = item.Step.Section + " / " + item.Step.Key;
					if (item.Outcome == ConfigVersionRules.Outcome.Replaced)
					{
						foreach (ConfigDefinition key2 in f.Keys)
						{
							if (key2.Section == item.Step.Section && key2.Key == item.Step.Key)
							{
								f[key2].SetSerializedValue(item.Step.NewDefault);
								break;
							}
						}
						Plugin.Log.LogInfo((object)("Settings: " + text2 + " " + item.Was + " -> " + item.Step.NewDefault + " (the new default; yours was the old one). " + item.Step.Note));
					}
					else if (item.Outcome == ConfigVersionRules.Outcome.KeptCustom)
					{
						Plugin.Log.LogInfo((object)("Settings: " + text2 + " stays " + item.Was + " (you changed it; the new default is " + item.Step.NewDefault + "). " + item.Step.Note));
					}
				}
				val.Value = ConfigVersionRules.After(value, 4);
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("Settings: the update of an older settings file did not run (" + ex2.Message + ")"));
			}
		}
	}
	public static class ConfigSync
	{
		public const string Rpc = "pm_config";

		public const string VersionRpc = "pm_version";

		public const string HelloRpc = "pm_hello";

		public const int Protocol = 1;

		private static string _mine;

		private static string _lastSent;

		public static bool Greeted;

		private static float _readySince = -1f;

		private static bool _missingHandled;

		public const float HandshakeWait = 12f;

		public const float ClientWait = 30f;

		private const float KickGrace = 1.5f;

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

		private static readonly Dictionary<long, float> _seen = new Dictionary<long, float>();

		private static readonly Dictionary<long, float> _closeAt = new Dictionary<long, float>();

		private static float _nextCheck;

		public static string Mine
		{
			get
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected O, but got Unknown
				if (_mine == null)
				{
					string text = "?";
					try
					{
						BepInPlugin val = (BepInPlugin)Attribute.GetCustomAttribute(typeof(Plugin), typeof(BepInPlugin));
						if (val != null)
						{
							text = val.Version.ToString();
						}
					}
					catch (Exception e)
					{
						Safe.Err("ConfigSync:29", e);
					}
					_mine = text + "/p" + 1;
				}
				return _mine;
			}
		}

		public static void OnVersion(ZRpc rpc, string server)
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				Greeted = true;
				try
				{
					rpc.Invoke("pm_hello", new object[1] { Mine });
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("Config sync could not answer the server: " + ex.Message));
				}
				if (!(server == Mine))
				{
					Reject(Loc.T("msg_version_mismatch", server, Mine));
				}
			}
		}

		public static HandshakeRules.State Handshake()
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return HandshakeRules.State.NotApplicable;
			}
			bool flag = false;
			float seconds = 0f;
			if (!instance.IsServer())
			{
				ZNetPeer serverPeer = instance.GetServerPeer();
				flag = serverPeer != null && serverPeer.IsReady();
				if (flag)
				{
					if (_readySince < 0f)
					{
						_readySince = Time.realtimeSinceStartup;
					}
					seconds = Time.realtimeSinceStartup - _readySince;
				}
			}
			return HandshakeRules.Of(instance.IsServer(), flag, Greeted, seconds, 12f);
		}

		public static void ResetHandshake()
		{
			Greeted = false;
			_readySince = -1f;
			_missingHandled = false;
		}

		public static void ResetServer()
		{
			_hellos.Clear();
			_seen.Clear();
			_closeAt.Clear();
			_nextCheck = 0f;
		}

		public static bool MayRoll()
		{
			return HandshakeRules.MayRoll(Handshake());
		}

		public static void Watch()
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance != (Object)null && instance.IsServer())
			{
				ServerWatch();
			}
			else if (!_missingHandled && Handshake() == HandshakeRules.State.Missing)
			{
				_missingHandled = true;
				Reject(Loc.T("msg_no_server_mod"));
			}
		}

		public static void OnHello(ZRpc rpc, string theirs)
		{
			try
			{
				ZNet instance = ZNet.instance;
				if ((Object)(object)instance == (Object)null || !instance.IsServer())
				{
					return;
				}
				foreach (ZNetPeer peer in instance.GetPeers())
				{
					if (peer != null && peer.m_rpc == rpc)
					{
						_hellos[peer.m_uid] = theirs ?? "";
						break;
					}
				}
			}
			catch (Exception e)
			{
				Safe.Err("ConfigSync.OnHello", e);
			}
		}

		public static void ServerWatch()
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer() || (Plugin.RequireClientMod != null && !Plugin.RequireClientMod.Value))
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextCheck)
			{
				return;
			}
			_nextCheck = realtimeSinceStartup + 0.5f;
			HashSet<long> hashSet = new HashSet<long>();
			ZNetPeer[] array = instance.GetPeers().ToArray();
			foreach (ZNetPeer val in array)
			{
				if (val == null || val.m_rpc == null || !val.IsReady())
				{
					continue;
				}
				long uid = val.m_uid;
				hashSet.Add(uid);
				if (_closeAt.TryGetValue(uid, out var value))
				{
					if (realtimeSinceStartup >= value)
					{
						_closeAt.Remove(uid);
						Close(instance, val);
					}
					continue;
				}
				if (!_seen.TryGetValue(uid, out var value2))
				{
					value2 = realtimeSinceStartup;
					_seen[uid] = realtimeSinceStartup;
				}
				_hellos.TryGetValue(uid, out var value3);
				HandshakeRules.Verdict verdict = HandshakeRules.Client(value3, Mine, realtimeSinceStartup - value2, 30f);
				if (HandshakeRules.Kick(verdict))
				{
					Plugin.Log.LogWarning((object)(Loc.T("msg_prefix") + ((verdict == HandshakeRules.Verdict.KickMismatch) ? ("Turned away " + Describe(val) + ": it runs Mutagenic Wilds " + value3 + " and this server runs " + Mine + ".") : ("Turned away " + Describe(val) + ": it does not run Mutagenic Wilds (nothing answered in " + 30f + " s). Set \"Require Mutagenic Wilds on players\" off to let such players in."))));
					try
					{
						val.m_rpc.Invoke("Error", new object[1] { 3 });
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Could not tell " + Describe(val) + " why: " + ex.Message));
					}
					_closeAt[uid] = realtimeSinceStartup + 1.5f;
				}
			}
			Prune(_hellos, hashSet);
			Prune(_seen, hashSet);
			Prune(_closeAt, hashSet);
		}

		private static void Close(ZNet net, ZNetPeer peer)
		{
			try
			{
				net.Disconnect(peer);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not disconnect " + Describe(peer) + ": " + ex.Message));
			}
		}

		private static string Describe(ZNetPeer peer)
		{
			try
			{
				return string.IsNullOrEmpty(peer.m_playerName) ? "a player" : ("\"" + peer.m_playerName + "\"");
			}
			catch (Exception e)
			{
				Safe.Err("ConfigSync.Describe", e);
				return "a player";
			}
		}

		private static void Prune<T>(Dictionary<long, T> d, HashSet<long> live)
		{
			if (d.Count == 0)
			{
				return;
			}
			List<long> list = new List<long>();
			foreach (long key in d.Keys)
			{
				if (!live.Contains(key))
				{
					list.Add(key);
				}
			}
			foreach (long item in list)
			{
				d.Remove(item);
			}
		}

		public static void Reject(string why)
		{
			Plugin.Log.LogError((object)(Loc.T("msg_prefix") + why));
			try
			{
				if (Plugin.LeaveOnMismatch != null && !Plugin.LeaveOnMismatch.Value)
				{
					Plugin.Log.LogWarning((object)"Staying connected anyway (\"Leave on mismatch\" is off): creatures may behave differently for different players.");
					return;
				}
				ZNet instance = ZNet.instance;
				if (!((Object)(object)instance == (Object)null) && !instance.IsServer())
				{
					ZNetPeer serverPeer = instance.GetServerPeer();
					if (serverPeer != null)
					{
						instance.Disconnect(serverPeer);
					}
					if ((Object)(object)MessageHud.instance != (Object)null)
					{
						MessageHud.instance.ShowMessage((MessageType)2, "Mutagenic Wilds: " + why, 0, (Sprite)null, false, true);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not leave the server: " + ex.Message));
			}
		}

		public static void Broadcast()
		{
			try
			{
				ZNet instance = ZNet.instance;
				if ((Object)(object)instance == (Object)null || !instance.IsServer() || Plugin.LocalCfg == null || Plugin.LocalCfg.Hash == _lastSent)
				{
					return;
				}
				_lastSent = Plugin.LocalCfg.Hash;
				foreach (ZNetPeer peer in instance.GetPeers())
				{
					if (peer != null && peer.m_rpc != null && peer.IsReady())
					{
						peer.m_rpc.Invoke("pm_config", new object[1] { Plugin.LocalCfg.RawText });
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Config sync could not broadcast the changed settings: " + ex.Message));
			}
		}

		public static void OnConfig(ZRpc rpc, string json)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				MutationConfig mutationConfig = MutationConfig.FromText(json);
				Plugin.OnServerCfg = true;
				if (Plugin.Cfg == null || !(mutationConfig.Hash == Plugin.Cfg.Hash))
				{
					Plugin.Cfg = mutationConfig;
					Plugin.CfgEpoch++;
					Plugin.Log.LogInfo((object)("Using the server's mutation config (hash " + mutationConfig.Hash.Substring(0, 8) + ")"));
				}
			}
			catch (Exception ex)
			{
				Reject(Loc.T("msg_config_unreadable", ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Awake")]
	internal static class ConfigSyncResetPatch
	{
		private static void Prefix()
		{
			Plugin.UseLocalConfig();
			ConfigSync.ResetHandshake();
			ConfigSync.ResetServer();
		}
	}
	[HarmonyPatch]
	internal static class ConfigSyncWatchPatch
	{
		private static MethodBase TargetMethod()
		{
			return PatchUtil.FirstMethod(typeof(ZNet), "Update");
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static void Postfix()
		{
			try
			{
				ConfigSync.Watch();
			}
			catch (Exception e)
			{
				Safe.Err("ConfigSync.Watch", e);
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal static class ConfigSyncListenPatch
	{
		private static void Postfix(ZNetPeer peer)
		{
			try
			{
				peer.m_rpc.Register<string>("pm_config", (Action<ZRpc, string>)ConfigSync.OnConfig);
				peer.m_rpc.Register<string>("pm_version", (Action<ZRpc, string>)ConfigSync.OnVersion);
				peer.m_rpc.Register<string>("pm_hello", (Action<ZRpc, string>)ConfigSync.OnHello);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Config sync could not listen: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	internal static class ConfigSyncSendPatch
	{
		private static void Postfix(ZNet __instance, ZRpc rpc)
		{
			if ((Object)(object)__instance == (Object)null || !__instance.IsServer() || rpc == null || Plugin.LocalCfg == null)
			{
				return;
			}
			try
			{
				rpc.Invoke("pm_version", new object[1] { ConfigSync.Mine });
				rpc.Invoke("pm_config", new object[1] { Plugin.LocalCfg.RawText });
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Config sync could not send: " + ex.Message));
			}
		}
	}
	public class PairDef
	{
		public string key;

		public string name;

		public bool isTitle;

		public int priority;
	}
	public class MutationDef
	{
		public string label;

		public string adjective;

		public int weight;

		public bool enabled = true;

		public bool firstOnly;

		public string requiresBase;

		public string passiveNeeds;

		public bool passiveNeedsUnlessArmed;

		public string passiveBlockedBy;

		public bool passiveVariant;

		public float lootMultiplier = 1f;

		public bool wildLootOnly;

		public Dictionary<string, object> effects = new Dictionary<string, object>();
	}
	public class EligibilityCfg
	{
		public bool excludeBosses = true;

		public bool excludeTamed = true;

		public bool excludeSummonedAndEventMobs;

		public bool excludePassive;

		public bool excludeMinibosses = true;

		public bool excludeEpicLootBounties = true;
	}
	public class MobOverrides
	{
		public List<string> passive = new List<string>();

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

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

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

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

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

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

		[JsonIgnore]
		public HashSet<string> PassiveSet;

		[JsonIgnore]
		pub