using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using CompanionKit.Core;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Beastwhispering.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.18.0")]
[assembly: AssemblyInformationalVersion("0.2.18+de8ede7c1cc4e525b56eb73ca1c0bdd9555d1cc3")]
[assembly: AssemblyProduct("Beastwhispering.Core")]
[assembly: AssemblyTitle("Beastwhispering.Core")]
[assembly: AssemblyMetadata("BuildStamp", "de8ede7c 2026-09-05")]
[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]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Beastwhispering.Core
{
	public static class ArrowAdoption
	{
		public const double ArmToleranceSeconds = 0.05;

		public static bool FlightStartUnknown(double projectileShootTime)
		{
			return projectileShootTime <= 0.0;
		}

		public static bool ShouldAdopt(bool ownerMatch, double armTime, double projectileShootTime, double toleranceSeconds = 0.05)
		{
			if (!ownerMatch)
			{
				return false;
			}
			if (FlightStartUnknown(projectileShootTime))
			{
				return true;
			}
			return projectileShootTime + toleranceSeconds >= armTime;
		}
	}
	public enum CounterVerdict
	{
		Inactive,
		Expired,
		AlreadyCountered,
		WindowSpent,
		Counter
	}
	public enum BraceHitVerdict
	{
		Counter,
		NoDealer,
		SelfHit,
		StatusTick,
		NotHostile
	}
	public struct BraceHitInputs
	{
		public string DealerUid;

		public string SelfUid;

		public bool SourceIsStatus;

		public bool DealerHostile;
	}
	public sealed class BraceState
	{
		private readonly HashSet<string> _countered = new HashSet<string>(StringComparer.Ordinal);

		public bool Open { get; private set; }

		public double ExpireAt { get; private set; }

		public IReadOnlyCollection<string> CounteredUids => _countered;

		public int CounterCount { get; private set; }

		public int MaxCounters { get; private set; }

		public void Begin(double now, double windowSeconds, int maxCounters = 0)
		{
			Open = true;
			ExpireAt = now + ((windowSeconds > 0.0) ? windowSeconds : 0.0);
			_countered.Clear();
			CounterCount = 0;
			MaxCounters = ((maxCounters > 0) ? maxCounters : 0);
		}

		public bool Active(double now)
		{
			if (Open)
			{
				return now < ExpireAt;
			}
			return false;
		}

		public double RemainingSeconds(double now)
		{
			if (!Active(now))
			{
				return 0.0;
			}
			return ExpireAt - now;
		}

		public void End()
		{
			Open = false;
			_countered.Clear();
			CounterCount = 0;
			MaxCounters = 0;
		}

		public CounterVerdict TryCounter(string attackerUid, double now, bool perAttackerOnce)
		{
			if (!Open)
			{
				return CounterVerdict.Inactive;
			}
			if (now >= ExpireAt)
			{
				return CounterVerdict.Expired;
			}
			if (MaxCounters > 0 && CounterCount >= MaxCounters)
			{
				return CounterVerdict.WindowSpent;
			}
			if (perAttackerOnce && !string.IsNullOrEmpty(attackerUid) && _countered.Contains(attackerUid))
			{
				return CounterVerdict.AlreadyCountered;
			}
			if (perAttackerOnce && !string.IsNullOrEmpty(attackerUid))
			{
				_countered.Add(attackerUid);
			}
			CounterCount++;
			return CounterVerdict.Counter;
		}
	}
	public static class BraceRules
	{
		public static BraceHitVerdict Eligible(in BraceHitInputs hit)
		{
			if (string.IsNullOrEmpty(hit.DealerUid))
			{
				return BraceHitVerdict.NoDealer;
			}
			if (!string.IsNullOrEmpty(hit.SelfUid) && string.Equals(hit.DealerUid, hit.SelfUid, StringComparison.Ordinal))
			{
				return BraceHitVerdict.SelfHit;
			}
			if (hit.SourceIsStatus)
			{
				return BraceHitVerdict.StatusTick;
			}
			if (!hit.DealerHostile)
			{
				return BraceHitVerdict.NotHostile;
			}
			return BraceHitVerdict.Counter;
		}
	}
	public enum BuffFoodKind
	{
		Damage,
		DecayRider
	}
	public sealed class BuffFoodDef
	{
		public string Key = "";

		public int? ItemId;

		public BuffFoodKind Kind;

		public double PercentPerLevel;

		public double? DurationSeconds;

		public string Toast = "";
	}
	public sealed class BuffFoodEntry
	{
		public string Species = "";

		public List<BuffFoodDef> Foods = new List<BuffFoodDef>();
	}
	public static class BuffFoods
	{
		public static Dictionary<string, BuffFoodEntry> Parse(string json, Action<string> warn = null)
		{
			return JsonTable.Read(json, warn, "species", "an object of species → buff-food arrays", ParseEntry);
		}

		private static BuffFoodEntry ParseEntry(string species, object value, Action<string> warn)
		{
			if (!(value is List<object> list))
			{
				new FieldReader("'" + species + "'", warn).Say("value must be an ARRAY of buff-food objects — species skipped.");
				return null;
			}
			List<BuffFoodDef> list2 = new List<BuffFoodDef>();
			for (int i = 0; i < list.Count; i++)
			{
				BuffFoodDef buffFoodDef = ParseRow(species, i, list[i], warn);
				if (buffFoodDef != null)
				{
					list2.Add(buffFoodDef);
				}
			}
			return new BuffFoodEntry
			{
				Species = species,
				Foods = list2
			};
		}

		private static BuffFoodDef ParseRow(string species, int index, object value, Action<string> warn)
		{
			FieldReader fieldReader = new FieldReader($"'{species}' buff food #{index + 1}", warn);
			if (!(value is Dictionary<string, object> dictionary))
			{
				fieldReader.Say("must be an object — entry skipped.");
				return null;
			}
			BuffFoodDef buffFoodDef = new BuffFoodDef
			{
				Kind = BuffFoodKind.Damage
			};
			bool flag = false;
			double? num = null;
			ItemKey val = default(ItemKey);
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "item":
					if (ItemKey.TryRead(item.Value, ref val))
					{
						buffFoodDef.Key = ((ItemKey)(ref val)).Key;
						buffFoodDef.ItemId = ((ItemKey)(ref val)).ItemId;
						flag = true;
					}
					else
					{
						fieldReader.Wrong("item", "a number (ItemID) or non-empty string (display name)");
					}
					break;
				case "kind":
				{
					if (item.Value is string name && TryParseKind(name, out var kind))
					{
						buffFoodDef.Kind = kind;
						break;
					}
					fieldReader.Say($"unknown kind '{item.Value}' (valid: damage, decayRider) — entry skipped.");
					return null;
				}
				case "percentperlevel":
				{
					if (!fieldReader.Num("percentPerLevel", item.Value, out var result, "a number > 0", "entry skipped"))
					{
						return null;
					}
					if (!(result > 0.0))
					{
						fieldReader.Wrong("percentPerLevel", "a number > 0", "entry skipped");
						return null;
					}
					num = result;
					break;
				}
				case "durationseconds":
				{
					if (!fieldReader.Num("durationSeconds", item.Value, out var result2, "a number > 0 (seconds)", "entry skipped"))
					{
						return null;
					}
					if (!(result2 > 0.0))
					{
						fieldReader.Wrong("durationSeconds", "a number > 0 (seconds)", "entry skipped");
						return null;
					}
					buffFoodDef.DurationSeconds = result2;
					break;
				}
				case "toast":
					if (item.Value is string toast)
					{
						buffFoodDef.Toast = toast;
					}
					else
					{
						fieldReader.Wrong("toast", "a string", "ignored");
					}
					break;
				default:
					fieldReader.Unknown(item.Key, "item, kind, percentPerLevel, durationSeconds, toast");
					break;
				}
			}
			if (!flag)
			{
				fieldReader.Say("missing/invalid required 'item' — entry skipped.");
				return null;
			}
			if (!num.HasValue)
			{
				fieldReader.Say("missing required 'percentPerLevel' (> 0) — entry skipped.");
				return null;
			}
			buffFoodDef.PercentPerLevel = num.Value;
			return buffFoodDef;
		}

		private static bool TryParseKind(string name, out BuffFoodKind kind)
		{
			if (string.Equals(name, "damage", StringComparison.OrdinalIgnoreCase))
			{
				kind = BuffFoodKind.Damage;
				return true;
			}
			if (string.Equals(name, "decayRider", StringComparison.OrdinalIgnoreCase))
			{
				kind = BuffFoodKind.DecayRider;
				return true;
			}
			kind = BuffFoodKind.Damage;
			return false;
		}

		public static Dictionary<string, BuffFoodEntry> Merge(Dictionary<string, BuffFoodEntry> builtIn, Dictionary<string, BuffFoodEntry> overrides)
		{
			return SpeciesTable.Merge<BuffFoodEntry>(builtIn, overrides);
		}

		public static BuffFoodEntry Resolve(Dictionary<string, BuffFoodEntry> table, string speciesId)
		{
			BuffFoodEntry result = default(BuffFoodEntry);
			if (!SpeciesTable.TryResolve<BuffFoodEntry>(table, speciesId, ref result, (string)null))
			{
				return null;
			}
			return result;
		}

		public static BuffFoodDef Match(BuffFoodEntry entry, int itemId, string itemName)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (entry?.Foods == null)
			{
				return null;
			}
			foreach (BuffFoodDef food in entry.Foods)
			{
				ItemKey val = new ItemKey(food.Key, food.ItemId);
				if (((ItemKey)(ref val)).Matches(itemId, itemName))
				{
					return food;
				}
			}
			return null;
		}

		public static BuffFoodDef DefFor(BuffFoodEntry entry, string slotKey)
		{
			if (entry?.Foods == null || string.IsNullOrEmpty(slotKey))
			{
				return null;
			}
			foreach (BuffFoodDef food in entry.Foods)
			{
				if (string.Equals(food.Key, slotKey, StringComparison.OrdinalIgnoreCase))
				{
					return food;
				}
			}
			return null;
		}

		public static double Percent(BuffFoodDef def, LoyaltyTier tier)
		{
			if (def != null)
			{
				return def.PercentPerLevel * (double)PetBuffs.Level(tier) * 0.5;
			}
			return 0.0;
		}

		public static float DamageFactor(BuffFoodDef def, LoyaltyTier tier, double secondsLeft)
		{
			if (def == null || def.Kind != BuffFoodKind.Damage || !(secondsLeft > 0.0))
			{
				return 1f;
			}
			return (float)(1.0 + Percent(def, tier) / 100.0);
		}

		public static float DecayFraction(BuffFoodDef def, LoyaltyTier tier, double secondsLeft)
		{
			if (def == null || def.Kind != BuffFoodKind.DecayRider || !(secondsLeft > 0.0))
			{
				return 0f;
			}
			return (float)(Percent(def, tier) / 100.0);
		}

		public static double ResolveDuration(BuffFoodDef def, double hungerSecondsPerDay)
		{
			return def?.DurationSeconds ?? hungerSecondsPerDay;
		}

		public static string Describe(BuffFoodDef def, LoyaltyTier tier, double secondsLeft)
		{
			if (def == null)
			{
				return "no buff food";
			}
			double num = Percent(def, tier);
			string text = ((def.Kind == BuffFoodKind.DecayRider) ? string.Format(CultureInfo.InvariantCulture, "+{0:F1}% of total damage as Decay", num) : string.Format(CultureInfo.InvariantCulture, "+{0:F1}% pet damage", num));
			return string.Format(CultureInfo.InvariantCulture, "{0}: {1} ({2} lvl {3}, {4:F0}s left)", def.Key, text, tier, PetBuffs.Level(tier), secondsLeft);
		}
	}
	public enum BwIdRegistry
	{
		ItemId,
		EffectPreset
	}
	public readonly struct BwIdRange
	{
		public int Start { get; }

		public int End { get; }

		public BwIdRange(int start, int end)
		{
			Start = start;
			End = end;
		}

		public bool Contains(int id)
		{
			if (id >= Start)
			{
				return id <= End;
			}
			return false;
		}

		public override string ToString()
		{
			return $"{Start}-{End}";
		}
	}
	public readonly struct BwIdEntry
	{
		public int Id { get; }

		public string Key { get; }

		public string Family { get; }

		public BwIdRegistry Registry { get; }

		public string Name { get; }

		public BwIdEntry(int id, string key, string family, BwIdRegistry registry, string name)
		{
			Id = id;
			Key = key;
			Family = family;
			Registry = registry;
			Name = name;
		}

		public override string ToString()
		{
			return $"{Id} {Key} ({Family}, {Registry})";
		}
	}
	public static class BwIds
	{
		public const int SkillHealPet = 87000;

		public const int SkillHuntAsOne = 87001;

		public const int SkillPetCommand = 87002;

		public const int SkillReleasePet = 87003;

		public const int SkillPetGift = 87004;

		public const int SkillForTheKill = 87005;

		public const int SkillScatology = 87006;

		public const int SkillBeastOfBurden = 87007;

		public const int SkillWildUnknown = 87008;

		public const int SkillCommunion = 87009;

		public const int StatusPetHungry = 87050;

		public const int StatusPetStarving = 87051;

		public const int StatusBondFraying = 87052;

		public const int StatusBondBroken = 87053;

		public const int StatusBondSteady = 87054;

		public const int StatusBondDevoted = 87055;

		public const int StatusPetCold = 87056;

		public const int StatusPetFreezing = 87057;

		public const int StatusPetHot = 87058;

		public const int StatusPetOverheating = 87059;

		public const int StatusPetScent = 87060;

		public const int StatusSynergy = 87061;

		public const int StatusKillFavor = 87062;

		public const int StatusCommunionBroken = 87063;

		public const int StatusCommunionFraying = 87064;

		public const int StatusCommunionSteady = 87065;

		public const int StatusCommunionDevoted = 87066;

		public const int StatusBuffCrystalPowder = 87067;

		public const int StatusBuffAmbraine = 87068;

		public const int StatusBuffGaberryWine = 87069;

		public const int StatusBuffDarkStone = 87070;

		public const int StatusPetThirsty = 87071;

		public const int StatusPetDehydrated = 87072;

		public const int BlanketHeatingBlanket = 87100;

		public const int BlanketCoolingBlanket = 87101;

		public const int BlanketHeatingBlanketScroll = 87102;

		public const int BlanketCoolingBlanketScroll = 87103;

		public const int SigilFire = 87150;

		public const int SigilFrost = 87151;

		public const int SigilAir = 87152;

		public const int SigilBlood = 87153;

		public const int FeatherTattered = 87200;

		public const int FeatherRuffled = 87201;

		public const int FeatherSleek = 87202;

		public const int FeatherResplendent = 87203;

		public const int FletchTatteredPhysical = 87220;

		public const int FletchRuffledPhysical = 87221;

		public const int FletchSleekPhysical = 87222;

		public const int FletchResplendentRaw = 87223;

		public const int FletchTatteredEthereal = 87224;

		public const int FletchTatteredDecay = 87225;

		public const int FletchTatteredElectric = 87226;

		public const int FletchTatteredFrost = 87227;

		public const int FletchTatteredFire = 87228;

		public const int FletchRuffledEthereal = 87229;

		public const int FletchRuffledDecay = 87230;

		public const int FletchRuffledElectric = 87231;

		public const int FletchRuffledFrost = 87232;

		public const int FletchRuffledFire = 87233;

		public const int FletchSleekEthereal = 87234;

		public const int FletchSleekDecay = 87235;

		public const int FletchSleekElectric = 87236;

		public const int FletchSleekFrost = 87237;

		public const int FletchSleekFire = 87238;

		public const int ArmorLeather = 87250;

		public const int TamingHyenaChow = 87300;

		public const int TamingHyenaScroll = 87301;

		public const int TamingPearlbirdChow = 87302;

		public const int TamingPearlbirdScroll = 87303;

		public const int TamingVeaberChow = 87304;

		public const int TamingVeaberScroll = 87305;

		public static readonly BwIdEntry[] All = new BwIdEntry[71]
		{
			new BwIdEntry(87000, "skill.heal-pet", "skills", BwIdRegistry.ItemId, "Heal Pet"),
			new BwIdEntry(87001, "skill.hunt-as-one", "skills", BwIdRegistry.ItemId, "Hunt as One"),
			new BwIdEntry(87002, "skill.pet-command", "skills", BwIdRegistry.ItemId, "Command Pet"),
			new BwIdEntry(87003, "skill.release-pet", "skills", BwIdRegistry.ItemId, "Release Pet"),
			new BwIdEntry(87004, "skill.pet-gift", "skills", BwIdRegistry.ItemId, "Gift of the Wild"),
			new BwIdEntry(87005, "skill.for-the-kill", "skills", BwIdRegistry.ItemId, "For the Kill"),
			new BwIdEntry(87006, "skill.scatology", "skills", BwIdRegistry.ItemId, "Scatology"),
			new BwIdEntry(87007, "skill.beast-of-burden", "skills", BwIdRegistry.ItemId, "Beast of Burden"),
			new BwIdEntry(87008, "skill.wild-unknown", "skills", BwIdRegistry.ItemId, "Wild Unknown"),
			new BwIdEntry(87009, "skill.communion", "skills", BwIdRegistry.ItemId, "Communion"),
			new BwIdEntry(87050, "status.pet-hungry", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87051, "status.pet-starving", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87052, "status.bond-fraying", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87053, "status.bond-broken", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87054, "status.bond-steady", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87055, "status.bond-devoted", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87056, "status.pet-cold", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87057, "status.pet-freezing", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87058, "status.pet-hot", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87059, "status.pet-overheating", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87060, "status.pet-scent", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87061, "status.synergy", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87062, "status.kill-favor", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87063, "status.communion-broken", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87064, "status.communion-fraying", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87065, "status.communion-steady", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87066, "status.communion-devoted", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87067, "status.buff-crystal-powder", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87068, "status.buff-ambraine", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87069, "status.buff-gaberry-wine", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87070, "status.buff-dark-stone", "statusPresets", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87071, "status.pet-thirsty", "statusPresets", BwIdRegistry.EffectPreset, "Thirsty Companion"),
			new BwIdEntry(87072, "status.pet-dehydrated", "statusPresets", BwIdRegistry.EffectPreset, "Dehydrated Companion"),
			new BwIdEntry(87100, "blanket.heating-blanket", "blankets", BwIdRegistry.ItemId, "Heating Blanket"),
			new BwIdEntry(87101, "blanket.cooling-blanket", "blankets", BwIdRegistry.ItemId, "Cooling Blanket"),
			new BwIdEntry(87102, "blanket.heating-blanket-scroll", "blankets", BwIdRegistry.ItemId, "Recipe: Heating Blanket"),
			new BwIdEntry(87103, "blanket.cooling-blanket-scroll", "blankets", BwIdRegistry.ItemId, "Recipe: Cooling Blanket"),
			new BwIdEntry(87150, "sigil.fire", "sigils", BwIdRegistry.ItemId, "Pet Fire Sigil"),
			new BwIdEntry(87151, "sigil.frost", "sigils", BwIdRegistry.ItemId, "Pet Frost Sigil"),
			new BwIdEntry(87152, "sigil.air", "sigils", BwIdRegistry.ItemId, "Pet Wind Sigil"),
			new BwIdEntry(87153, "sigil.blood", "sigils", BwIdRegistry.ItemId, "Pet Blood Sigil"),
			new BwIdEntry(87200, "feather.tattered", "feathers", BwIdRegistry.ItemId, "Tattered Pearlbird Feather"),
			new BwIdEntry(87201, "feather.ruffled", "feathers", BwIdRegistry.ItemId, "Ruffled Pearlbird Feather"),
			new BwIdEntry(87202, "feather.sleek", "feathers", BwIdRegistry.ItemId, "Sleek Pearlbird Feather"),
			new BwIdEntry(87203, "feather.resplendent", "feathers", BwIdRegistry.ItemId, "Resplendent Pearlbird Feather"),
			new BwIdEntry(87220, "fletch.tattered-physical", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87221, "fletch.ruffled-physical", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87222, "fletch.sleek-physical", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87223, "fletch.resplendent-raw", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87224, "fletch.tattered-ethereal", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87225, "fletch.tattered-decay", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87226, "fletch.tattered-electric", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87227, "fletch.tattered-frost", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87228, "fletch.tattered-fire", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87229, "fletch.ruffled-ethereal", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87230, "fletch.ruffled-decay", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87231, "fletch.ruffled-electric", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87232, "fletch.ruffled-frost", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87233, "fletch.ruffled-fire", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87234, "fletch.sleek-ethereal", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87235, "fletch.sleek-decay", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87236, "fletch.sleek-electric", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87237, "fletch.sleek-frost", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87238, "fletch.sleek-fire", "fletchEnchantments", BwIdRegistry.EffectPreset, null),
			new BwIdEntry(87250, "armor.leather", "petArmor", BwIdRegistry.ItemId, "Pet Leather Armor"),
			new BwIdEntry(87300, "taming.hyena.chow", "taming", BwIdRegistry.ItemId, "Hyena Chow"),
			new BwIdEntry(87301, "taming.hyena.scroll", "taming", BwIdRegistry.ItemId, "Recipe: Hyena Chow"),
			new BwIdEntry(87302, "taming.pearlbird.chow", "taming", BwIdRegistry.ItemId, "Pearlbird Chow"),
			new BwIdEntry(87303, "taming.pearlbird.scroll", "taming", BwIdRegistry.ItemId, "Recipe: Pearlbird Chow"),
			new BwIdEntry(87304, "taming.veaber.chow", "taming", BwIdRegistry.ItemId, "Veaber Chow"),
			new BwIdEntry(87305, "taming.veaber.scroll", "taming", BwIdRegistry.ItemId, "Recipe: Veaber Chow")
		};

		public static readonly BwIdRange[] Pool = new BwIdRange[1]
		{
			new BwIdRange(87000, 87999)
		};

		public static bool TryGet(string key, out int id)
		{
			BwIdEntry[] all = All;
			for (int i = 0; i < all.Length; i++)
			{
				BwIdEntry bwIdEntry = all[i];
				if (bwIdEntry.Key == key)
				{
					id = bwIdEntry.Id;
					return true;
				}
			}
			id = 0;
			return false;
		}

		public static bool TryFind(int id, out BwIdEntry entry)
		{
			BwIdEntry[] all = All;
			for (int i = 0; i < all.Length; i++)
			{
				BwIdEntry bwIdEntry = all[i];
				if (bwIdEntry.Id == id)
				{
					entry = bwIdEntry;
					return true;
				}
			}
			entry = default(BwIdEntry);
			return false;
		}

		public static bool InPool(int id)
		{
			BwIdRange[] pool = Pool;
			foreach (BwIdRange bwIdRange in pool)
			{
				if (bwIdRange.Contains(id))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsOurs(int id)
		{
			BwIdEntry entry;
			return TryFind(id, out entry);
		}

		public static IEnumerable<string> Lines()
		{
			BwIdRange[] pool = Pool;
			foreach (BwIdRange bwIdRange in pool)
			{
				yield return $"pool {bwIdRange}";
			}
			BwIdEntry[] all = All;
			for (int i = 0; i < all.Length; i++)
			{
				BwIdEntry bwIdEntry = all[i];
				yield return bwIdEntry.ToString();
			}
		}
	}
	public enum ComfortGate
	{
		NeverSampled,
		Ok,
		SystemOff,
		NoPetState,
		NoPlayer,
		NoPetSim,
		GameplayPaused,
		NoEnvironment,
		NoSampleTransform
	}
	public enum AmbientSource
	{
		None,
		Environment,
		Rediscovered
	}
	public static class ComfortGates
	{
		public static ComfortGate Evaluate(bool systemEnabled, bool hasPetState, bool hasEnvironment, bool hasSampleTransform)
		{
			if (!systemEnabled)
			{
				return ComfortGate.SystemOff;
			}
			if (!hasPetState)
			{
				return ComfortGate.NoPetState;
			}
			if (!hasEnvironment)
			{
				return ComfortGate.NoEnvironment;
			}
			if (!hasSampleTransform)
			{
				return ComfortGate.NoSampleTransform;
			}
			return ComfortGate.Ok;
		}

		public static string Code(ComfortGate gate)
		{
			return gate switch
			{
				ComfortGate.Ok => "ok", 
				ComfortGate.SystemOff => "system-off", 
				ComfortGate.NoPetState => "no-pet-state", 
				ComfortGate.NoPlayer => "no-player", 
				ComfortGate.NoPetSim => "no-pet-sim", 
				ComfortGate.GameplayPaused => "gameplay-paused", 
				ComfortGate.NoEnvironment => "no-env", 
				ComfortGate.NoSampleTransform => "no-transform", 
				_ => "never-sampled", 
			};
		}

		public static bool IsFault(ComfortGate gate)
		{
			if (gate != ComfortGate.Ok && gate != ComfortGate.SystemOff)
			{
				return gate != ComfortGate.GameplayPaused;
			}
			return false;
		}

		public static AmbientSource PreferredAmbientSource(bool envAvailable, bool rediscoveredAvailable)
		{
			if (envAvailable)
			{
				return AmbientSource.Environment;
			}
			if (rediscoveredAvailable)
			{
				return AmbientSource.Rediscovered;
			}
			return AmbientSource.None;
		}

		public static string SourceLabel(AmbientSource source)
		{
			return source switch
			{
				AmbientSource.Environment => "environment", 
				AmbientSource.Rediscovered => "rediscovered-environment", 
				_ => "none", 
			};
		}
	}
	public static class CommunionBadge
	{
		public const string NoBenefit = "no benefit yet — deepen the bond";

		public static string Describe(IReadOnlyList<ResolvedBuff> benefits)
		{
			if (benefits == null || benefits.Count == 0)
			{
				return "no benefit yet — deepen the bond";
			}
			return string.Join(", ", from b in benefits
				orderby (int)b.Stat
				select "+" + b.Amount.ToString("0.##", CultureInfo.InvariantCulture) + (PetBuffs.IsFlat(b.Stat) ? " " : "% ") + StatName(b.Stat));
		}

		public static string Description(LoyaltyTier tier, string benefits)
		{
			object obj = tier switch
			{
				LoyaltyTier.Gone => "The communion is severed.", 
				LoyaltyTier.Broken => "The communion is broken.", 
				LoyaltyTier.Fraying => "The communion is fraying.", 
				LoyaltyTier.Guarded => "The communion is guarded.", 
				LoyaltyTier.Cautious => "The communion is cautious.", 
				LoyaltyTier.Steady => "The communion is steady.", 
				LoyaltyTier.Trusting => "The communion is trusting.", 
				LoyaltyTier.Devoted => "The communion is devoted.", 
				LoyaltyTier.Unshaken => "The communion is unshaken.", 
				LoyaltyTier.Boundless => "The communion is boundless.", 
				LoyaltyTier.Sworn => "The communion is sworn.", 
				LoyaltyTier.Fierce => "The communion is fierce.", 
				LoyaltyTier.Mythic => "The communion is mythic.", 
				LoyaltyTier.Eternal => "The communion is eternal.", 
				_ => "The communion endures.", 
			};
			string text = ((string.IsNullOrEmpty(benefits) || benefits == "no benefit yet — deepen the bond") ? "No benefit yet — deepen the bond." : ("The bond grants you " + benefits + "."));
			return (string?)obj + " " + text;
		}

		private static string StatName(PetBuffStat stat)
		{
			return PetBuffs.DisplayName(stat);
		}
	}
	public enum ConvergePinMode
	{
		None,
		Planted,
		Converge
	}
	public struct ConvergePinInputs
	{
		public bool PinEnabled;

		public bool ConvergeEnabled;

		public bool HasPetBody;

		public bool StyleOpposite;

		public string? StyleName;

		public bool HasStation;

		public bool Planted;

		public bool TauntEnabled;

		public bool HasLiveTarget;

		public string? EnemyName;

		public float Dist;

		public float AttackRange;

		public float ConvergeReachMultiplier;

		public bool Guest;

		public bool HasLiveAnchor;

		public bool LockedOnAnchor;

		public string? LockedName;

		public float Now;

		public float LastPinAt;

		public float LastConvergePinAt;

		public float PlantedSeconds;

		public float PlantedCooldown;

		public float ConvergeSeconds;

		public float ConvergeCooldown;
	}
	public struct ConvergePinVerdict
	{
		public ConvergePinMode Mode;

		public string Why;

		public float Seconds;

		public float Reach;

		public string LockedOn;

		public bool Armed => Mode != ConvergePinMode.None;
	}
	public static class ConvergePin
	{
		public const float DefaultReachMultiplier = 3f;

		public const float DefaultConvergeSeconds = 1.5f;

		public const float DefaultConvergeCooldown = 5f;

		public const string GuestLockWording = "unknown (guest: lock state is master-side)";

		public const string MovingToStation = "moving to station";

		public static ConvergePinVerdict Should(in ConvergePinInputs i)
		{
			if (!i.PinEnabled)
			{
				return Held("off ([Combat] StationPin=false)");
			}
			if (!i.HasPetBody)
			{
				return Held("no pet body");
			}
			if (!i.StyleOpposite)
			{
				return Held("style " + i.StyleName + " (pin is Opposite-only)");
			}
			if (!i.HasStation)
			{
				return Held("no station yet");
			}
			if (!i.Planted)
			{
				if (!i.ConvergeEnabled)
				{
					return Held("moving to station");
				}
				ConvergePinVerdict result = Tail(in i, ConvergePinMode.Converge, i.AttackRange * i.ConvergeReachMultiplier, i.ConvergeSeconds, i.ConvergeCooldown);
				if (result.Armed)
				{
					return result;
				}
				return Held("moving to station (converge: " + result.Why + ")");
			}
			return Tail(in i, ConvergePinMode.Planted, i.AttackRange + 1f, i.PlantedSeconds, i.PlantedCooldown);
		}

		private static ConvergePinVerdict Tail(in ConvergePinInputs i, ConvergePinMode mode, float reach, float seconds, float cooldown)
		{
			if (!i.TauntEnabled)
			{
				return Held("[Brace] EnableTaunt is off");
			}
			if (!i.HasLiveTarget)
			{
				return Held("no live target");
			}
			if (i.Dist > reach)
			{
				return Held("target " + F1(i.Dist) + "m > reach " + F1(reach) + "m");
			}
			if (!i.Guest && !i.HasLiveAnchor)
			{
				return Held("no live anchor");
			}
			if (!i.Guest && i.LockedOnAnchor)
			{
				return Held("mob already locked on the bird");
			}
			float num = cooldown - (i.Now - ((mode == ConvergePinMode.Converge) ? i.LastConvergePinAt : i.LastPinAt));
			if (num > 0f)
			{
				return Held("cooldown (" + F1(num) + "s left)");
			}
			string text = (i.Guest ? "unknown (guest: lock state is master-side)" : ((i.LockedName == null) ? "nothing" : ("'" + i.LockedName + "'")));
			return new ConvergePinVerdict
			{
				Mode = mode,
				Why = "armed: '" + i.EnemyName + "' " + F1(i.Dist) + "m, locked on " + text,
				Seconds = seconds,
				Reach = reach,
				LockedOn = text
			};
		}

		private static ConvergePinVerdict Held(string why)
		{
			return new ConvergePinVerdict
			{
				Mode = ConvergePinMode.None,
				Why = why
			};
		}

		private static string F1(float v)
		{
			return v.ToString("F1", CultureInfo.InvariantCulture);
		}
	}
	public enum DevTameKeyPress
	{
		Tame,
		RefuseAndExplain,
		RefuseSilently
	}
	public static class DevTameKeyGate
	{
		public const string RefusalMessage = "The tame key is a DEV tool and is disabled: set [Taming] EnableDevTameKey = true in cobalt.beastwhispering.cfg to use it. Taming foods are unaffected, and the 'tame' dev verb still works.";

		public static DevTameKeyPress Decide(bool enabled, bool alreadyExplained)
		{
			if (enabled)
			{
				return DevTameKeyPress.Tame;
			}
			if (!alreadyExplained)
			{
				return DevTameKeyPress.RefuseAndExplain;
			}
			return DevTameKeyPress.RefuseSilently;
		}

		public static bool Explained(DevTameKeyPress press)
		{
			return press != DevTameKeyPress.Tame;
		}
	}
	public sealed class DotAuraSpec
	{
		public string Key;

		public int Slot;

		public string FxStatusName;

		public string Label;

		public string[] Statuses;

		public bool Matches(string statusName)
		{
			if (string.IsNullOrEmpty(statusName) || Statuses == null)
			{
				return false;
			}
			for (int i = 0; i < Statuses.Length; i++)
			{
				if (string.Equals(Statuses[i], statusName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class DotAuras
	{
		public const string BurningKey = "aura.dotburning";

		public const string PoisonKey = "aura.dotpoison";

		public const string BleedKey = "aura.dotbleed";

		public const string PlagueKey = "aura.dotplague";

		public static readonly DotAuraSpec[] Roster = new DotAuraSpec[4]
		{
			new DotAuraSpec
			{
				Key = "aura.dotburning",
				Slot = 102,
				FxStatusName = "Burning",
				Label = "burning",
				Statuses = new string[3] { "Burning", "Burn", "Immolate" }
			},
			new DotAuraSpec
			{
				Key = "aura.dotpoison",
				Slot = 103,
				FxStatusName = "Poisoned",
				Label = "poisoned",
				Statuses = new string[7] { "Poisoned", "Poisoned +", "Hallowed Marsh Poison Lvl1", "Hallowed Marsh Poison Lvl2", "SulphurPoison", "Food Poisoned", "Food Poisoned +" }
			},
			new DotAuraSpec
			{
				Key = "aura.dotbleed",
				Slot = 104,
				FxStatusName = "Bleeding",
				Label = "bleeding",
				Statuses = new string[2] { "Bleeding", "Bleeding +" }
			},
			new DotAuraSpec
			{
				Key = "aura.dotplague",
				Slot = 105,
				FxStatusName = "Plague",
				Label = "plagued",
				Statuses = new string[1] { "Plague" }
			}
		};

		public static DotAuraSpec Find(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			for (int i = 0; i < Roster.Length; i++)
			{
				if (string.Equals(Roster[i].Key, key, StringComparison.OrdinalIgnoreCase))
				{
					return Roster[i];
				}
			}
			return null;
		}

		public static List<string> ActiveKeys(IEnumerable<string> liveStatusNames, bool enabled)
		{
			List<string> list = new List<string>();
			if (!enabled || liveStatusNames == null)
			{
				return list;
			}
			for (int i = 0; i < Roster.Length; i++)
			{
				DotAuraSpec dotAuraSpec = Roster[i];
				foreach (string liveStatusName in liveStatusNames)
				{
					if (dotAuraSpec.Matches(liveStatusName))
					{
						list.Add(dotAuraSpec.Key);
						break;
					}
				}
			}
			return list;
		}

		public static string Explain(IEnumerable<string> liveStatusNames, bool enabled, bool hasAnchor, bool proxied = false)
		{
			if (!enabled)
			{
				return "off: [DotAuras] Enable is false";
			}
			if (!hasAnchor && !proxied)
			{
				return "idle: no live anchor to read statuses from and no proxied status set (bodiless bond, or a GUEST whose master streams no ck.proxy.status — old master build or no announced row)";
			}
			string text = (proxied ? "proxied status set (ck.proxy.status)" : "anchor");
			List<string> list = ActiveKeys(liveStatusNames, enabled: true);
			if (list.Count == 0)
			{
				return "clear: the " + text + " carries no covered DoT status";
			}
			return "active: " + string.Join(", ", list.ToArray()) + (proxied ? " (proxied)" : "");
		}
	}
	internal static class EnumRead
	{
		public static bool TryName<T>(string s, out T value) where T : struct
		{
			value = default(T);
			if (string.IsNullOrEmpty(s))
			{
				return false;
			}
			if (!Enum.TryParse<T>(s, ignoreCase: true, out var result))
			{
				return false;
			}
			if (!Enum.IsDefined(typeof(T), result))
			{
				return false;
			}
			value = result;
			return true;
		}
	}
	public sealed class ExecuteCreditWindow
	{
		private struct Entry
		{
			public double At;

			public int Stacks;
		}

		public const double DefaultWindowSeconds = 12.0;

		private const int PruneAtCount = 16;

		private readonly Dictionary<string, Entry> _armed = new Dictionary<string, Entry>(StringComparer.Ordinal);

		private readonly double _window;

		public double WindowSeconds => _window;

		public int Count => _armed.Count;

		public ExecuteCreditWindow(double windowSeconds = 12.0)
		{
			_window = ((windowSeconds > 0.0) ? windowSeconds : 12.0);
		}

		public void Arm(string uid, double now)
		{
			Arm(uid, now, 0);
		}

		public void Arm(string uid, double now, int stacks)
		{
			if (!string.IsNullOrEmpty(uid))
			{
				if (_armed.Count >= 16)
				{
					Prune(now);
				}
				if (stacks < 0)
				{
					stacks = 0;
				}
				if (TryGetArmed(uid, now, out var stacks2) && stacks2 > stacks)
				{
					stacks = stacks2;
				}
				_armed[uid] = new Entry
				{
					At = now,
					Stacks = stacks
				};
			}
		}

		public bool IsArmed(string uid, double now)
		{
			int stacks;
			return TryGetArmed(uid, now, out stacks);
		}

		public bool TryGetArmed(string uid, double now, out int stacks)
		{
			stacks = 0;
			if (string.IsNullOrEmpty(uid))
			{
				return false;
			}
			if (!_armed.TryGetValue(uid, out var value))
			{
				return false;
			}
			double num = now - value.At;
			if (num < 0.0 || num > _window)
			{
				return false;
			}
			stacks = value.Stacks;
			return true;
		}

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

		private void Prune(double now)
		{
			List<string> list = null;
			foreach (KeyValuePair<string, Entry> item in _armed)
			{
				double num = now - item.Value.At;
				if (num < 0.0 || num > _window)
				{
					(list ?? (list = new List<string>())).Add(item.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					_armed.Remove(list[i]);
				}
			}
		}
	}
	public sealed class TemperatureExposure
	{
		private double _timer;

		private int _dir;

		public double EscalateSeconds { get; }

		public double RecoverSeconds { get; }

		public ComfortStage Stage { get; private set; }

		public TemperatureExposure(double escalateSeconds = 30.0, double recoverSeconds = 15.0, ComfortStage startStage = ComfortStage.Comfortable)
		{
			EscalateSeconds = escalateSeconds;
			RecoverSeconds = recoverSeconds;
			Stage = startStage;
		}

		public ComfortStage Tick(int stepsOutside, double dt, double escalateMult = 1.0)
		{
			ComfortStage comfortStage = Temperature.Stage(stepsOutside);
			int num = comfortStage.CompareTo(Stage);
			if (num == 0)
			{
				_timer = 0.0;
				_dir = 0;
				return Stage;
			}
			if (num != _dir)
			{
				_timer = 0.0;
				_dir = num;
			}
			if (dt > 0.0)
			{
				_timer += dt;
			}
			double num2 = ((num > 0) ? (EscalateSeconds * Math.Max(1.0, escalateMult)) : RecoverSeconds);
			while (_timer >= num2 && comfortStage.CompareTo(Stage) == num)
			{
				_timer -= num2;
				Stage += num;
			}
			if (Stage == comfortStage)
			{
				_timer = 0.0;
				_dir = 0;
			}
			return Stage;
		}

		public ComfortStage Tick(TempStep temp, ComfortBand band, double dt)
		{
			return Tick(Temperature.StepsOutside(temp, band), dt);
		}
	}
	public sealed class HungerTimer
	{
		private int _daysApplied;

		public double SecondsPerDay { get; }

		public double SecondsSinceFed { get; private set; }

		public double Stretch { get; private set; } = 1.0;

		public double EffectiveSecondsPerDay => SecondsPerDay * Stretch;

		public HungerTimer(double secondsPerDay, double secondsSinceFed = 0.0, double stretch = 1.0)
		{
			Stretch = ((!(stretch > 0.0)) ? 1.0 : stretch);
			SecondsPerDay = secondsPerDay;
			SecondsSinceFed = ((!(secondsSinceFed > 0.0)) ? 0.0 : secondsSinceFed);
			_daysApplied = ((SecondsPerDay > 0.0) ? ((int)(SecondsSinceFed / EffectiveSecondsPerDay)) : 0);
		}

		public void Feed(double stretch = 1.0)
		{
			Stretch = ((!(stretch > 0.0)) ? 1.0 : stretch);
			SecondsSinceFed = 0.0;
			_daysApplied = 0;
		}

		public void Seed(double secondsSinceFed)
		{
			SecondsSinceFed = ((!(secondsSinceFed > 0.0)) ? 0.0 : secondsSinceFed);
			_daysApplied = ((SecondsPerDay > 0.0) ? ((int)(SecondsSinceFed / EffectiveSecondsPerDay)) : 0);
		}

		public int Tick(double dt)
		{
			if (dt <= 0.0)
			{
				return 0;
			}
			SecondsSinceFed += dt;
			if (SecondsPerDay <= 0.0)
			{
				return 0;
			}
			int num = (int)(SecondsSinceFed / EffectiveSecondsPerDay);
			int result = num - _daysApplied;
			_daysApplied = num;
			return result;
		}
	}
	public sealed class FletchEntry
	{
		public string Key;

		public string ArrowKey;

		public int? ArrowId;
	}
	public sealed class FeatherQuality
	{
		public string Quality;

		public LoyaltyTier Tier;

		public int Percent;

		public int FlatX;

		public int ItemId;

		public int EnchantmentId;

		public string ItemName => Quality + " Pearlbird Feather";
	}
	public static class FeatherFletching
	{
		public struct StackSlot
		{
			public string Key;

			public int FreeSpace;

			public StackSlot(string key, int freeSpace)
			{
				Key = key ?? string.Empty;
				FreeSpace = freeSpace;
			}
		}

		public const int PhysicalDamageType = 0;

		public const int RawDamageType = 8;

		public const int ElementalVariantBase = 87224;

		private const int ElementalVariantCount = 15;

		public static readonly FeatherQuality[] Qualities = new FeatherQuality[4]
		{
			new FeatherQuality
			{
				Quality = "Tattered",
				Tier = LoyaltyTier.Broken,
				Percent = 10,
				FlatX = 2,
				ItemId = 87200,
				EnchantmentId = 87220
			},
			new FeatherQuality
			{
				Quality = "Ruffled",
				Tier = LoyaltyTier.Fraying,
				Percent = 20,
				FlatX = 3,
				ItemId = 87201,
				EnchantmentId = 87221
			},
			new FeatherQuality
			{
				Quality = "Sleek",
				Tier = LoyaltyTier.Guarded,
				Percent = 30,
				FlatX = 5,
				ItemId = 87202,
				EnchantmentId = 87222
			},
			new FeatherQuality
			{
				Quality = "Resplendent",
				Tier = LoyaltyTier.Steady,
				Percent = 40,
				FlatX = 7,
				ItemId = 87203,
				EnchantmentId = 87223
			}
		};

		public static FeatherQuality QualityFor(int loyalty)
		{
			LoyaltyTier loyaltyTier = Loyalty.Tier(loyalty);
			for (int num = Qualities.Length - 1; num > 0; num--)
			{
				if (loyaltyTier >= Qualities[num].Tier)
				{
					return Qualities[num];
				}
			}
			return Qualities[0];
		}

		public static int? PercentForItemId(int itemId)
		{
			FeatherQuality[] qualities = Qualities;
			foreach (FeatherQuality featherQuality in qualities)
			{
				if (featherQuality.ItemId == itemId)
				{
					return featherQuality.Percent;
				}
			}
			return null;
		}

		public static FeatherQuality QualityForItemId(int itemId)
		{
			FeatherQuality[] qualities = Qualities;
			foreach (FeatherQuality featherQuality in qualities)
			{
				if (featherQuality.ItemId == itemId)
				{
					return featherQuality;
				}
			}
			return null;
		}

		private static int IndexOf(FeatherQuality q)
		{
			if (q == null)
			{
				return -1;
			}
			for (int i = 0; i < Qualities.Length; i++)
			{
				if (Qualities[i] == q || Qualities[i].EnchantmentId == q.EnchantmentId)
				{
					return i;
				}
			}
			return -1;
		}

		public static int EnchantmentIdFor(FeatherQuality q, int damageType)
		{
			int num = IndexOf(q);
			if (num < 0)
			{
				return 0;
			}
			if (num == Qualities.Length - 1)
			{
				return q.EnchantmentId;
			}
			if (damageType <= 0 || damageType > 5)
			{
				return q.EnchantmentId;
			}
			return 87224 + num * 5 + (damageType - 1);
		}

		public static FeatherQuality QualityForEnchantmentId(int enchantmentId)
		{
			FeatherQuality[] qualities = Qualities;
			foreach (FeatherQuality featherQuality in qualities)
			{
				if (featherQuality.EnchantmentId == enchantmentId)
				{
					return featherQuality;
				}
			}
			if (enchantmentId >= 87224 && enchantmentId < 87239)
			{
				int num = (enchantmentId - 87224) / 5;
				if (num >= 0 && num < Qualities.Length)
				{
					return Qualities[num];
				}
			}
			return null;
		}

		public static int? FlatTypeForEnchantmentId(int enchantmentId)
		{
			FeatherQuality featherQuality = Qualities[Qualities.Length - 1];
			if (enchantmentId == featherQuality.EnchantmentId)
			{
				return 8;
			}
			for (int i = 0; i < Qualities.Length - 1; i++)
			{
				if (Qualities[i].EnchantmentId == enchantmentId)
				{
					return 0;
				}
			}
			if (enchantmentId >= 87224 && enchantmentId < 87239)
			{
				return (enchantmentId - 87224) % 5 + 1;
			}
			return null;
		}

		public static int PickFlatType(IList<int> presentTypes, double roll)
		{
			if (presentTypes == null || presentTypes.Count == 0)
			{
				return 0;
			}
			List<int> list = new List<int>(presentTypes.Count);
			foreach (int presentType in presentTypes)
			{
				if (presentType >= 0 && presentType <= 5)
				{
					list.Add(presentType);
				}
			}
			if (list.Count == 0)
			{
				return 0;
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			int num = (int)(roll * (double)list.Count);
			if (num < 0)
			{
				num = 0;
			}
			if (num >= list.Count)
			{
				num = list.Count - 1;
			}
			return list[num];
		}

		public static bool IsFletchEnchantment(int enchantmentId)
		{
			return QualityForEnchantmentId(enchantmentId) != null;
		}

		public static bool CanUpgradeFletch(int? existingPercent, int newPercent)
		{
			if (existingPercent.HasValue)
			{
				return newPercent > existingPercent.Value;
			}
			return true;
		}

		public static string DisplayNameFor(string baseName, int percent)
		{
			if (percent > 0)
			{
				return $"{baseName} (+{ClampPercent(percent)}%)";
			}
			return baseName;
		}

		public static Dictionary<string, FletchEntry> Parse(string json, Action<string> warn = null)
		{
			return JsonTable.Read(json, warn, "arrow", "an object of arrow → fletch objects", ParseEntry);
		}

		private static FletchEntry ParseEntry(string key, object value, Action<string> warn)
		{
			FieldReader fieldReader = new FieldReader("'" + key + "'", warn);
			if (!(value is Dictionary<string, object> dictionary))
			{
				fieldReader.Say("value must be an object — arrow skipped.");
				return null;
			}
			FletchEntry fletchEntry = new FletchEntry
			{
				Key = key
			};
			ItemKey val = default(ItemKey);
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				if (item.Key.ToLowerInvariant() == "arrow")
				{
					if (ItemKey.TryRead(item.Value, ref val))
					{
						fletchEntry.ArrowKey = ((ItemKey)(ref val)).Key;
						fletchEntry.ArrowId = ((ItemKey)(ref val)).ItemId;
					}
					else
					{
						fieldReader.Wrong("arrow", "a number (ItemID) or non-empty string (display name)");
					}
				}
				else
				{
					fieldReader.Unknown(item.Key, "arrow");
				}
			}
			if (fletchEntry.ArrowKey == null)
			{
				fieldReader.Say("missing required 'arrow' — arrow skipped.");
				return null;
			}
			return fletchEntry;
		}

		public static Dictionary<string, FletchEntry> Merge(Dictionary<string, FletchEntry> builtIn, Dictionary<string, FletchEntry> overrides)
		{
			return SpeciesTable.Merge<FletchEntry>(builtIn, overrides);
		}

		public static int ClampPercent(int percent)
		{
			if (percent >= 0)
			{
				if (percent <= 100)
				{
					return percent;
				}
				return 100;
			}
			return 0;
		}

		public static int PlaceableAmount(int shotCount, int maxStack)
		{
			if (shotCount <= 0 || maxStack <= 0)
			{
				return 0;
			}
			if (shotCount >= maxStack)
			{
				return maxStack;
			}
			return shotCount;
		}

		public static string EnchantmentSetKey(IEnumerable<int> enchantmentIds)
		{
			if (enchantmentIds == null)
			{
				return string.Empty;
			}
			List<int> list = new List<int>(enchantmentIds);
			if (list.Count == 0)
			{
				return string.Empty;
			}
			list.Sort();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < list.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(';');
				}
				stringBuilder.Append(list[i].ToString(CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		public static bool ShouldMergeEnchantedStack(string incomingKey, IEnumerable<StackSlot> sameIdStacks, out bool anyDifferentPartial, out int sameKeyCapacity)
		{
			anyDifferentPartial = false;
			sameKeyCapacity = 0;
			incomingKey = incomingKey ?? string.Empty;
			bool result = false;
			if (sameIdStacks != null)
			{
				foreach (StackSlot sameIdStack in sameIdStacks)
				{
					if (sameIdStack.FreeSpace > 0)
					{
						if (string.Equals(sameIdStack.Key ?? string.Empty, incomingKey, StringComparison.Ordinal))
						{
							result = true;
							sameKeyCapacity += sameIdStack.FreeSpace;
						}
						else
						{
							anyDifferentPartial = true;
						}
					}
				}
			}
			return result;
		}
	}
	public static class FeedLadder
	{
		public const string Cure = "cure";

		public const string Relic = "relic";

		public const string BuffFood = "bufffood";

		public const string Heal = "heal";

		public const string Meal = "meal";

		public static readonly IReadOnlyList<string> Order = new string[5] { "cure", "relic", "bufffood", "heal", "meal" };

		public static int IndexOf(string rung)
		{
			for (int i = 0; i < Order.Count; i++)
			{
				if (string.Equals(rung, Order[i], StringComparison.Ordinal))
				{
					return i;
				}
			}
			return -1;
		}

		public static bool IsTerminal(string rung)
		{
			if (Order.Count > 0)
			{
				return string.Equals(rung, Order[Order.Count - 1], StringComparison.Ordinal);
			}
			return false;
		}

		public static bool VerdictIsAClaim(string rung, bool wouldConsume)
		{
			if (!IsTerminal(rung))
			{
				return true;
			}
			return wouldConsume;
		}

		public static string Describe(IReadOnlyList<string> order = null)
		{
			IReadOnlyList<string> readOnlyList = order ?? Order;
			List<string> list = new List<string>(readOnlyList.Count);
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				list.Add($"{i + 1} {readOnlyList[i]}");
			}
			return string.Join(" -> ", list.ToArray());
		}

		public static string Mismatch(IReadOnlyList<string> registered)
		{
			if (registered == null)
			{
				return "the feed registry is null";
			}
			if (registered.Count == Order.Count)
			{
				bool flag = true;
				for (int i = 0; i < Order.Count; i++)
				{
					if (!string.Equals(registered[i], Order[i], StringComparison.Ordinal))
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return null;
				}
			}
			return "registered [" + Describe(registered) + "] but the declared ladder is [" + Describe() + "]";
		}
	}
	public readonly struct DualListedFood
	{
		public string Species { get; }

		public string BuffKey { get; }

		public string DietKey { get; }

		public bool ByCategory { get; }

		public DualListedFood(string species, string buffKey, string dietKey, bool byCategory)
		{
			Species = species;
			BuffKey = buffKey;
			DietKey = dietKey;
			ByCategory = byCategory;
		}
	}
	public readonly struct FeedPlan
	{
		public bool FeedsAsMeal { get; }

		public bool AppliesBuff { get; }

		public bool IsMealPlusBuff
		{
			get
			{
				if (FeedsAsMeal)
				{
					return AppliesBuff;
				}
				return false;
			}
		}

		public int ConsumesOnAccept
		{
			get
			{
				if (!FeedsAsMeal && !AppliesBuff)
				{
					return 0;
				}
				return 1;
			}
		}

		public FeedPlan(bool feedsAsMeal, bool appliesBuff)
		{
			FeedsAsMeal = feedsAsMeal;
			AppliesBuff = appliesBuff;
		}
	}
	public static class FeedPrecedence
	{
		public static FoodEntry MatchingDietRow(IReadOnlyList<FoodEntry> diet, int itemId, string itemName, IReadOnlyCollection<string> itemCategories)
		{
			if (diet == null)
			{
				return null;
			}
			foreach (FoodEntry item in diet)
			{
				if (item != null && PetDiet.Matches(item, itemId, itemName, itemCategories))
				{
					return item;
				}
			}
			return null;
		}

		public static bool IsMeal(IReadOnlyList<FoodEntry> diet, int itemId, string itemName, IReadOnlyCollection<string> itemCategories)
		{
			return MatchingDietRow(diet, itemId, itemName, itemCategories) != null;
		}

		public static FeedPlan Plan(bool hasBuffRow, FoodEntry dietRow)
		{
			return new FeedPlan(dietRow != null, hasBuffRow);
		}

		public static bool BuffFoodApplies(bool hasBuffRow, FoodEntry dietRow)
		{
			return hasBuffRow;
		}

		public static List<DualListedFood> DualListed(BuffFoodEntry entry, IReadOnlyList<FoodEntry> diet, Func<BuffFoodDef, IReadOnlyCollection<string>> categoriesOf)
		{
			List<DualListedFood> list = new List<DualListedFood>();
			if (entry?.Foods == null || diet == null)
			{
				return list;
			}
			foreach (BuffFoodDef food in entry.Foods)
			{
				if (food != null)
				{
					IReadOnlyCollection<string> itemCategories = categoriesOf?.Invoke(food);
					FoodEntry foodEntry = MatchingDietRow(diet, food.ItemId.GetValueOrDefault(), food.Key, itemCategories);
					if (foodEntry != null)
					{
						list.Add(new DualListedFood(entry.Species, food.Key, foodEntry.Key, foodEntry.Category != null));
					}
				}
			}
			return list;
		}
	}
	public readonly struct FieldReader
	{
		private readonly string _context;

		private readonly Action<string> _warn;

		public string Context => _context;

		public Action<string> Sink => _warn;

		public FieldReader(string context, Action<string> warn)
		{
			_context = context;
			_warn = warn;
		}

		public void Say(string message)
		{
			if (_warn != null)
			{
				_warn(string.IsNullOrEmpty(_context) ? message : (_context + ": " + message));
			}
		}

		public void Unknown(string key, string valid)
		{
			Say("unknown key '" + key + "' (valid: " + valid + ").");
		}

		public void Wrong(string field, string expected, string fallback = null)
		{
			Say("'" + field + "' must be " + expected + (string.IsNullOrEmpty(fallback) ? "" : (" — " + fallback)) + ".");
		}

		public bool Num(string field, object value, out double result, string expected = null, string fallback = null)
		{
			if (value is double num)
			{
				result = num;
				return true;
			}
			result = 0.0;
			Wrong(field, expected ?? "a number", fallback);
			return false;
		}

		public bool Int(string field, object value, out int result, string expected = null, string fallback = null)
		{
			result = 0;
			if (!Num(field, value, out var result2, expected, fallback))
			{
				return false;
			}
			result = (int)result2;
			return true;
		}

		public bool Str(string field, object value, out string result, string expected = null, string fallback = null)
		{
			if (value is string text && text.Trim().Length > 0)
			{
				result = text.Trim();
				return true;
			}
			result = null;
			Wrong(field, expected ?? "a non-empty string", fallback);
			return false;
		}

		public bool Bool(string field, object value, out bool result, string expected = null, string fallback = null)
		{
			if (value is bool flag)
			{
				result = flag;
				return true;
			}
			result = false;
			Wrong(field, expected ?? "true or false", fallback);
			return false;
		}

		public bool Items(string field, object value, out List<object> result, string expected = null, string fallback = null)
		{
			if (value is List<object> list)
			{
				result = list;
				return true;
			}
			result = null;
			Wrong(field, expected ?? "an ARRAY", fallback);
			return false;
		}

		public bool Obj(string field, object value, out Dictionary<string, object> result, string expected = null, string fallback = null)
		{
			if (value is Dictionary<string, object> dictionary)
			{
				result = dictionary;
				return true;
			}
			result = null;
			Wrong(field, expected ?? "an object", fallback);
			return false;
		}

		public bool Enum<T>(string field, object value, out T result, string expected = null, string fallback = null) where T : struct
		{
			if (value is string text && EnumRead.TryName<T>(text.Trim(), out result))
			{
				return true;
			}
			result = default(T);
			Wrong(field, expected ?? ("one of " + string.Join(", ", System.Enum.GetNames(typeof(T)))), fallback);
			return false;
		}
	}
	public static class FoodCategories
	{
		public const string Meat = "Meat";

		public const string Fish = "Fish";

		public const string Vegetable = "Vegetable";

		public const string Egg = "Egg";

		public const string Bread = "Bread";

		public const string Mushroom = "Mushroom";

		public const string RationIngredient = "RationIngredient";

		public const string Water = "Water";

		public static readonly string[] All = new string[8] { "Meat", "Fish", "Vegetable", "Egg", "Bread", "Mushroom", "RationIngredient", "Water" };

		public static bool TryCanonical(string raw, out string canonical)
		{
			canonical = null;
			if (string.IsNullOrEmpty(raw))
			{
				return false;
			}
			string text = Squash(raw);
			if (text.Length == 0)
			{
				return false;
			}
			string[] all = All;
			foreach (string text2 in all)
			{
				if (string.Equals(text, Squash(text2), StringComparison.OrdinalIgnoreCase))
				{
					canonical = text2;
					return true;
				}
			}
			return false;
		}

		public static string Label(string category)
		{
			return "any " + Spaced(category);
		}

		public static string Spaced(string category)
		{
			if (string.IsNullOrEmpty(category))
			{
				return category;
			}
			StringBuilder stringBuilder = new StringBuilder(category.Length + 4);
			for (int i = 0; i < category.Length; i++)
			{
				if (i > 0 && char.IsUpper(category[i]) && !char.IsUpper(category[i - 1]))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(category[i]);
			}
			return stringBuilder.ToString();
		}

		public static string ValidList()
		{
			return string.Join(", ", All);
		}

		private static string Squash(string s)
		{
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			foreach (char c in s)
			{
				if (c != ' ' && c != '-' && c != '_')
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class FoodHexMeal
	{
		public string Key;

		public int? ItemId;

		public string HexId;
	}
	public sealed class FoodHexEntry
	{
		public string Species;

		public double? BuildUpPercent;

		public int? Window;

		public List<FoodHexMeal> Meals = new List<FoodHexMeal>();
	}
	public struct HexBuildUp
	{
		public string HexId;

		public float Percent;

		public int MealCount;
	}
	public static class FoodHexes
	{
		public const int MaxWindow = 20;

		public const int DefaultWindow = 3;

		public const float DefaultBuildUpPercent = 20f;

		public static Dictionary<string, FoodHexEntry> Parse(string json, Action<string> warn = null)
		{
			return JsonTable.Read(json, warn, "species", "an object of species → food-hex objects", ParseEntry);
		}

		private static FoodHexEntry ParseEntry(string species, object value, Action<string> warn)
		{
			FieldReader f = new FieldReader("'" + species + "'", warn);
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Say("value must be an object — species skipped.");
				return null;
			}
			FoodHexEntry foodHexEntry = new FoodHexEntry
			{
				Species = species
			};
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "builduppercent":
				{
					if (f.Num("buildUpPercent", item.Value, out var result2, "a number > 0", "using the config default"))
					{
						if (result2 > 0.0)
						{
							foodHexEntry.BuildUpPercent = result2;
						}
						else
						{
							f.Wrong("buildUpPercent", "a number > 0", "using the config default");
						}
					}
					break;
				}
				case "window":
				{
					if (!f.Num("window", item.Value, out var result3, $"a number 1..{20}", "using the config default"))
					{
						break;
					}
					if (result3 >= 1.0)
					{
						foodHexEntry.Window = (int)result3;
						if (foodHexEntry.Window > 20)
						{
							f.Say($"'window' {foodHexEntry.Window} exceeds the hard max {20} — clamped.");
							foodHexEntry.Window = 20;
						}
					}
					else
					{
						f.Wrong("window", $"a number 1..{20}", "using the config default");
					}
					break;
				}
				case "meals":
				{
					if (!f.Obj("meals", item.Value, out Dictionary<string, object> result, "an OBJECT of food-key → hex-name pairs"))
					{
						break;
					}
					foreach (KeyValuePair<string, object> item2 in result)
					{
						FoodHexMeal foodHexMeal = ParseMeal(f, item2.Key, item2.Value);
						if (foodHexMeal != null)
						{
							foodHexEntry.Meals.Add(foodHexMeal);
						}
					}
					break;
				}
				default:
					f.Unknown(item.Key, "buildUpPercent, window, meals");
					break;
				}
			}
			if (foodHexEntry.Meals.Count == 0)
			{
				f.Say("missing/empty required 'meals' — species skipped.");
				return null;
			}
			return foodHexEntry;
		}

		private static FoodHexMeal ParseMeal(FieldReader f, string key, object value)
		{
			string text = (key ?? "").Trim();
			if (text.Length == 0)
			{
				f.Say("empty meal key — entry skipped.");
				return null;
			}
			if (text.IndexOf('|') >= 0 || text.IndexOf('\t') >= 0 || text.IndexOf('\n') >= 0 || text.IndexOf('\r') >= 0)
			{
				f.Say("meal key '" + text + "' contains a reserved character ('|', tab, or newline) — entry skipped.");
				return null;
			}
			if (!(value is string text2) || text2.Trim().Length == 0)
			{
				f.Say("meal '" + text + "' must map to a non-empty status-effect name string — entry skipped.");
				return null;
			}
			ItemKey val = default(ItemKey);
			ItemKey.TryRead((object)text, ref val);
			return new FoodHexMeal
			{
				Key = ((ItemKey)(ref val)).Key,
				HexId = text2.Trim(),
				ItemId = ((ItemKey)(ref val)).ItemId
			};
		}

		public static Dictionary<string, FoodHexEntry> Merge(Dictionary<string, FoodHexEntry> builtIn, Dictionary<string, FoodHexEntry> overrides)
		{
			return SpeciesTable.Merge<FoodHexEntry>(builtIn, overrides);
		}

		public static FoodHexEntry Resolve(Dictionary<string, FoodHexEntry> table, string speciesId)
		{
			FoodHexEntry result = default(FoodHexEntry);
			if (!SpeciesTable.TryResolve<FoodHexEntry>(table, speciesId, ref result, (string)null))
			{
				return null;
			}
			return result;
		}

		public static string MatchMeal(FoodHexEntry entry, int itemId, string itemName)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (entry == null)
			{
				return null;
			}
			foreach (FoodHexMeal meal in entry.Meals)
			{
				ItemKey val = new ItemKey(meal.Key, meal.ItemId);
				if (((ItemKey)(ref val)).Matches(itemId, itemName))
				{
					return meal.Key;
				}
			}
			return null;
		}

		public static int ClampWindow(int window)
		{
			if (window >= 1)
			{
				if (window <= 20)
				{
					return window;
				}
				return 20;
			}
			return 1;
		}

		public static void RecordMeal(List<string> history, string mealKey)
		{
			if (history != null && !string.IsNullOrEmpty(mealKey))
			{
				history.Add(mealKey);
				while (history.Count > 20)
				{
					history.RemoveAt(0);
				}
			}
		}

		public static List<HexBuildUp> ComputeBuildups(FoodHexEntry entry, IReadOnlyList<string> history, int configWindow, float configPercent)
		{
			List<HexBuildUp> list = new List<HexBuildUp>();
			if (entry == null || history == null || history.Count == 0)
			{
				return list;
			}
			int num = ClampWindow(entry.Window ?? configWindow);
			float num2 = (float)(entry.BuildUpPercent ?? ((double)configPercent));
			if (num2 <= 0f)
			{
				return list;
			}
			List<string> list2 = new List<string>();
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			int num3 = 0;
			int num4 = history.Count - 1;
			while (num4 >= 0 && num3 < num)
			{
				string text = HexFor(entry, history[num4]);
				if (text != null)
				{
					num3++;
					if (dictionary.TryGetValue(text, out var value))
					{
						dictionary[text] = value + 1;
					}
					else
					{
						dictionary[text] = 1;
						list2.Add(text);
					}
				}
				num4--;
			}
			foreach (string item in list2)
			{
				list.Add(new HexBuildUp
				{
					HexId = item,
					Percent = (float)dictionary[item] * num2,
					MealCount = dictionary[item]
				});
			}
			return list;
		}

		private static string HexFor(FoodHexEntry entry, string mealKey)
		{
			if (string.IsNullOrEmpty(mealKey))
			{
				return null;
			}
			foreach (FoodHexMeal meal in entry.Meals)
			{
				if (string.Equals(meal.Key, mealKey, StringComparison.OrdinalIgnoreCase))
				{
					return meal.HexId;
				}
			}
			return null;
		}
	}
	public enum KillFavorStat
	{
		StaminaCostReduction,
		ManaCostReduction,
		Protection,
		MovementSpeed,
		AllResistances,
		CooldownReduction
	}
	public sealed class KillFavorDef
	{
		public KillFavorStat Stat;

		public float[] AmountByTier;

		public float PerStack;
	}
	public sealed class ForTheKillEntry
	{
		public string Species;

		public string StatusName;

		public double? BuildupPercent;

		public KillFavorDef KillBuff;
	}
	public static class KillFavor
	{
		public const string StatusIdentifier = "BW_KillFavor";

		public const int StatusNumId = 87062;

		public static float Amount(KillFavorDef def, LoyaltyTier tier)
		{
			if (def?.AmountByTier == null || def.AmountByTier.Length == 0 || tier == LoyaltyTier.Gone)
			{
				return 0f;
			}
			int num = Loyalty.PayoutLevel(tier);
			if (num <= 0)
			{
				return 0f;
			}
			float[] array = new float[def.AmountByTier.Length + 1];
			array[0] = 0f;
			for (int i = 0; i < def.AmountByTier.Length; i++)
			{
				array[i + 1] = def.AmountByTier[i];
			}
			return LoyaltyCurve.Sample(array, num, 8);
		}

		public static float Amount(KillFavorDef def, LoyaltyTier tier, int stacksSpent)
		{
			if (def == null || tier == LoyaltyTier.Gone)
			{
				return 0f;
			}
			if (def.PerStack > 0f)
			{
				if (stacksSpent > 0)
				{
					return def.PerStack * (float)stacksSpent;
				}
				return 0f;
			}
			return Amount(def, tier);
		}
	}
	public static class ExecuteHeal
	{
		public enum Verdict
		{
			AlreadyPaid,
			NothingToPay,
			GuestNoOp,
			NoAnchor,
			Pay
		}

		public static float Amount(int loyaltyPayoutLevel, int stacks, float perTierPerStack)
		{
			if (loyaltyPayoutLevel <= 0 || stacks <= 0 || perTierPerStack <= 0f)
			{
				return 0f;
			}
			return (float)((loyaltyPayoutLevel > 8) ? 8 : loyaltyPayoutLevel) * 0.5f * (float)stacks * perTierPerStack;
		}

		public static Verdict Decide(bool alreadyPaid, float heal, bool isGuest, bool hasAnchor)
		{
			if (alreadyPaid)
			{
				return Verdict.AlreadyPaid;
			}
			if (heal <= 0f)
			{
				return Verdict.NothingToPay;
			}
			if (isGuest)
			{
				return Verdict.GuestNoOp;
			}
			if (!hasAnchor)
			{
				return Verdict.NoAnchor;
			}
			return Verdict.Pay;
		}

		public static bool SettlesLedger(Verdict verdict, bool healApplied)
		{
			if (verdict != Verdict.NothingToPay)
			{
				return verdict == Verdict.Pay && healApplied;
			}
			return true;
		}
	}
	public static class ForTheKill
	{
		public const double MinBuildup = 1.0;

		public const double MaxBuildup = 100.0;

		public static Dictionary<string, ForTheKillEntry> Parse(string json, Action<string> warn = null)
		{
			return JsonTable.Read(json, warn, "species", "an object of species → forTheKill objects", ParseEntry);
		}

		private static ForTheKillEntry ParseEntry(string speciesKey, object value, Action<string> warn)
		{
			FieldReader f = new FieldReader("'" + speciesKey + "'", warn);
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Say("value must be an object — species skipped.");
				return null;
			}
			ForTheKillEntry forTheKillEntry = new ForTheKillEntry
			{
				Species = speciesKey
			};
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "status":
				{
					if (f.Str("status", item.Value, out string result2, "a non-empty status name string"))
					{
						forTheKillEntry.StatusName = result2;
					}
					break;
				}
				case "buildup":
				{
					if (f.Num("buildup", item.Value, out var result, null, "ignored (direct apply)"))
					{
						if (result < 1.0)
						{
							f.Say($"'buildup' {result} below {1.0} — clamped.");
							result = 1.0;
						}
						if (result > 100.0)
						{
							f.Say($"'buildup' {result} above {100.0} — clamped.");
							result = 100.0;
						}
						forTheKillEntry.BuildupPercent = result;
					}
					break;
				}
				case "killbuff":
					forTheKillEntry.KillBuff = ParseKillBuff(f, item.Value);
					break;
				default:
					f.Unknown(item.Key, "status, buildup, killBuff");
					break;
				}
			}
			if (string.IsNullOrEmpty(forTheKillEntry.StatusName))
			{
				f.Say("missing required 'status' — species skipped.");
				return null;
			}
			return forTheKillEntry;
		}

		private static KillFavorDef ParseKillBuff(FieldReader f, object value)
		{
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Wrong("killBuff", "an object", "ignored (strike only)");
				return null;
			}
			KillFavorStat? killFavorStat = null;
			float[] array = null;
			float num = 0f;
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "stat":
				{
					if (item.Value is string text && EnumRead.TryName<KillFavorStat>(text.Trim(), out var value2))
					{
						killFavorStat = value2;
					}
					else
					{
						f.Say($"killBuff 'stat' '{item.Value}' unknown " + "(valid: " + string.Join(", ", Enum.GetNames(typeof(KillFavorStat))) + ").");
					}
					break;
				}
				case "amounts":
					if (item.Value is List<object> { Count: 4 } list)
					{
						array = new float[4];
						for (int i = 0; i < 4; i++)
						{
							if (list[i] is double num2)
							{
								array[i] = (float)num2;
								continue;
							}
							array[i] = 0f;
							f.Say($"killBuff 'amounts'[{i}] is not a number — that tier grants 0.");
						}
					}
					else
					{
						f.Say("killBuff 'amounts' must be a 4-number array (payout bands 1–4) — ignored.");
					}
					break;
				case "perstack":
				{
					if (f.Num("perStack", item.Value, out var result, null, "ignored"))
					{
						if (result <= 0.0)
						{
							f.Say($"killBuff 'perStack' {result} must be > 0 — ignored.");
						}
						else
						{
							num = (float)result;
						}
					}
					break;
				}
				default:
					f.Say("unknown killBuff key '" + item.Key + "' (valid: stat, amounts, perStack).");
					break;
				}
			}
			if (!killFavorStat.HasValue || (array == null && num <= 0f))
			{
				f.Say("killBuff needs 'stat' plus either a 4-number 'amounts' or a positive 'perStack' — ignored (strike only).");
				return null;
			}
			if (array != null && num > 0f)
			{
				f.Say("killBuff has BOTH 'amounts' and 'perStack' — author exactly one; ignored (strike only).");
				return null;
			}
			return new KillFavorDef
			{
				Stat = killFavorStat.Value,
				AmountByTier = array,
				PerStack = num
			};
		}

		public static Dictionary<string, ForTheKillEntry> Merge(Dictionary<string, ForTheKillEntry> builtIn, Dictionary<string, ForTheKillEntry> overrides)
		{
			return SpeciesTable.Merge<ForTheKillEntry>(builtIn, overrides);
		}

		public static ForTheKillEntry Resolve(Dictionary<string, ForTheKillEntry> table, string speciesId)
		{
			ForTheKillEntry result = default(ForTheKillEntry);
			if (!SpeciesTable.TryResolve<ForTheKillEntry>(table, speciesId, ref result, (string)null))
			{
				return null;
			}
			return result;
		}
	}
	public static class HealthRecovery
	{
		public const int MinLevel = 1;

		public const int MaxLevel = 5;

		public const int DefaultLevel = 1;

		public const double DurationSeconds = 600.0;

		private static readonly double[] Rates = new double[5] { 0.2, 0.25, 0.3, 0.4, 0.5 };

		public static double RatePerSecond(int level)
		{
			if (level > 0)
			{
				return Rates[((level > 5) ? 5 : level) - 1];
			}
			return 0.0;
		}

		public static int ClampLevel(int level)
		{
			if (level > 0)
			{
				if (level >= 1)
				{
					if (level <= 5)
					{
						return level;
					}
					return 5;
				}
				return 1;
			}
			return 0;
		}

		public static int EffectiveLevel(int? foodLevel, bool isTamingFood)
		{
			if (!isTamingFood)
			{
				return ClampLevel(foodLevel ?? 1);
			}
			return 5;
		}

		public static double TickHeal(int level, double dt)
		{
			if (!(dt > 0.0))
			{
				return 0.0;
			}
			return RatePerSecond(level) * dt;
		}

		public static double TotalHeal(int level)
		{
			return RatePerSecond(level) * 600.0;
		}

		public static string Describe(int level, double secondsLeft)
		{
			return string.Format(CultureInfo.InvariantCulture, "level {0} (+{1} HP/s, {2}s left)", level, RatePerSecond(level), Math.Round(secondsLeft));
		}
	}
	public static class Hostility
	{
		public const double DefaultRecencySeconds = 1.0;

		public static readonly string[] FriendlyFactions = new string[3] { "Player", "Merchants", "NONE" };

		public static readonly string[] AmbiguousFactions = new string[1] { "Merchants" };

		public static bool IsAmbiguousFaction(string faction)
		{
			if (string.IsNullOrEmpty(faction))
			{
				return false;
			}
			for (int i = 0; i < AmbiguousFactions.Length; i++)
			{
				if (string.Equals(AmbiguousFactions[i], faction, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsFriendlyFaction(string faction)
		{
			return IsFriendlyFaction(faction, lockedByCompanionAi: false);
		}

		public static bool IsFriendlyFaction(string faction, bool lockedByCompanionAi)
		{
			if (string.IsNullOrEmpty(faction))
			{
				return true;
			}
			for (int i = 0; i < FriendlyFactions.Length; i++)
			{
				if (string.Equals(FriendlyFactions[i], faction, StringComparison.Ordinal))
				{
					if (lockedByCompanionAi)
					{
						return !IsAmbiguousFaction(faction);
					}
					return true;
				}
			}
			return false;
		}

		public static bool IsHostileTarget(bool isAI, bool isSelf, bool isOwnAnchor, string faction, bool aliveNow, double secondsSinceDeath, bool requireAlive, double recencySeconds = 1.0, bool lockedByCompanionAi = false)
		{
			if (!IsHostileIdentity(isAI, isSelf, isOwnAnchor, faction, lockedByCompanionAi))
			{
				return false;
			}
			if (aliveNow)
			{
				return true;
			}
			if (requireAlive)
			{
				return false;
			}
			if (secondsSinceDeath > 0.0)
			{
				return secondsSinceDeath <= recencySeconds;
			}
			return false;
		}

		public static bool IsHostileIdentity(bool isAI, bool isSelf, bool isOwnAnchor, string faction, bool lockedByCompanionAi = false)
		{
			if (!isAI || isSelf || isOwnAnchor)
			{
				return false;
			}
			return !IsFriendlyFaction(faction, lockedByCompanionAi);
		}
	}
	public static class HuntCooldown
	{
		public const float DivergenceEpsilon = 0.25f;

		public static float WantSkillCooldown(bool syncEnabled, bool hasSpeciesRow, float speciesCooldownSeconds, float baseCooldownSeconds)
		{
			float result = AtLeastZero(baseCooldownSeconds);
			if (!syncEnabled || !hasSpeciesRow)
			{
				return result;
			}
			return AtLeastZero(speciesCooldownSeconds);
		}

		public static float AdoptedCooldownSeconds(float committedRealCooldown, float tableCooldownSeconds)
		{
			if (!(committedRealCooldown > 0f))
			{
				return AtLeastZero(tableCooldownSeconds);
			}
			return committedRealCooldown;
		}

		public static bool Diverged(float skillRemainingSeconds, float petRemainingSeconds, float epsilon = 0.25f)
		{
			return Math.Abs(skillRemainingSeconds - petRemainingSeconds) > AtLeastZero(epsilon);
		}

		public static double Drain(double secondsLeft, double dt)
		{
			if (secondsLeft <= 0.0)
			{
				return 0.0;
			}
			if (dt <= 0.0)
			{
				return secondsLeft;
			}
			double num = secondsLeft - dt;
			if (!(num > 0.0))
			{
				return 0.0;
			}
			return num;
		}

		public static double EffectiveRemainder(bool syncEnabled, double savedSecondsLeft)
		{
			if (!syncEnabled || !(savedSecondsLeft > 0.0))
			{
				return 0.0;
			}
			return savedSecondsLeft;
		}

		private static float AtLeastZero(float v)
		{
			if (!(v > 0f))
			{
				return 0f;
			}
			return v;
		}
	}
	public enum InfuseElement
	{
		None,
		Fire,
		Frost
	}
	public struct InfuseStatus
	{
		public InfuseElement Element;

		public double Expiry;
	}
	public static class InfuseRider
	{
		public const int InfuseFireSkillId = 8200103;

		public const int InfuseFrostSkillId = 8200102;

		public const float DefaultRiderFraction = 0.25f;

		public const float DefaultDurationSeconds = 180f;

		public static InfuseStatus None => new InfuseStatus
		{
			Element = InfuseElement.None,
			Expiry = 0.0
		};

		public static bool IsInfuseSkill(int skillId)
		{
			if (skillId != 8200103)
			{
				return skillId == 8200102;
			}
			return true;
		}

		public static InfuseElement ElementFor(int skillId)
		{
			return skillId switch
			{
				8200103 => InfuseElement.Fire, 
				8200102 => InfuseElement.Frost, 
				_ => InfuseElement.None, 
			};
		}

		public static string Token(InfuseElement element)
		{
			return element switch
			{
				InfuseElement.Fire => "Fire", 
				InfuseElement.Frost => "Frost", 
				_ => string.Empty, 
			};
		}

		public static InfuseStatus Cast(InfuseStatus current, int skillId, double now, float durationSeconds)
		{
			InfuseElement infuseElement = ElementFor(skillId);
			if (infuseElement == InfuseElement.None)
			{
				return current;
			}
			return new InfuseStatus
			{
				Element = infuseElement,
				Expiry = now + (double)((durationSeconds > 0f) ? durationSeconds : 0f)
			};
		}

		public static InfuseStatus Retime(InfuseStatus current, double now, float secondsLeft)
		{
			if (current.Element == InfuseElement.None || current.Expiry <= now)
			{
				return current;
			}
			return new InfuseStatus
			{
				Element = current.Element,
				Expiry = now + (double)((secondsLeft > 0f) ? secondsLeft : 0f)
			};
		}

		public static InfuseElement ActiveElement(InfuseStatus status, double now)
		{
			if (status.Element == InfuseElement.None || !(now < status.Expiry))
			{
				return InfuseElement.None;
			}
			return status.Element;
		}

		public static float ActiveFraction(InfuseStatus status, double now, float fraction, bool enabled)
		{
			if (!enabled || fraction <= 0f)
			{
				return 0f;
			}
			if (ActiveElement(status, now) != InfuseElement.None)
			{
				return fraction;
			}
			return 0f;
		}

		public static string Explain(InfuseStatus status, double now, float fraction, bool enabled)
		{
			if (!enabled)
			{
				return "zeroed: [InfuseEcho] Enable is false";
			}
			if (fraction <= 0f)
			{
				return "zeroed: [InfuseEcho] RiderFraction is 0 or negative";
			}
			if (status.Element == InfuseElement.None)
			{
				return "zeroed: no infusion has been cast (the cast gate never armed one)";
			}
			if (status.Expiry <= now)
			{
				return "zeroed: the infusion lapsed";
			}
			return "active: " + status.Element.ToString() + " at fraction " + fraction.ToString("0.###", CultureInfo.InvariantCulture) + ", " + SecondsRemaining(status, now).ToString("0.#", CultureInfo.InvariantCulture) + "s left";
		}

		public static double SecondsRemaining(InfuseStatus status, double now)
		{
			if (status.Element == InfuseElement.None || status.Expiry <= now)
			{
				return 0.0;
			}
			return status.Expiry - now;
		}
	}
	public static class ItemHeals
	{
		public const float MinHeal = 0.5f;

		public const float FullFraction = 0.999f;

		public const float MinLandedFraction = 0.25f;

		public const float AiSentinel = -99999f;

		public static float Quantity(bool isModifier, float quantity, float quantityOnAI, bool isAi, float maxHealth)
		{
			float num = ((quantityOnAI != -99999f && isAi) ? quantityOnAI : quantity);
			if (!isModifier)
			{
				return num;
			}
			return num * 0.01f * maxHealth;
		}

		public static float Total(IReadOnlyList<float> quantities)
		{
			if (quantities == null)
			{
				return 0f;
			}
			float num = 0f;
			for (int i = 0; i < quantities.Count; i++)
			{
				if (quantities[i] > 0f)
				{
					num += quantities[i];
				}
			}
			return num;
		}

		public static bool CarriesHeal(bool enabled, float total)
		{
			if (enabled)
			{
				return total >= 0.5f;
			}
			return false;
		}

		public static bool WouldHeal(bool enabled, float total, bool hasAnchor, float current, float max, bool lowerRungClaims)
		{
			if (!CarriesHeal(enabled, total))
			{
				return false;
			}
			if (!hasAnchor || max <= 0f)
			{
				return false;
			}
			if (current / max >= 0.999f)
			{
				return false;
			}
			float num = Landed(total, current, max);
			if (num < 0.5f || num < total * 0.25f)
			{
				return false;
			}
			return !lowerRungClaims;
		}

		public static float Landed(float total, float current, float max)
		{
			if (total <= 0f || max <= 0f)
			{
				return 0f;
			}
			float num = max - current;
			if (num <= 0f)
			{
				return 0f;
			}
			if (!(total < num))
			{
				return num;
			}
			return total;
		}

		public static bool RefusedForWaste(bool enabled, float total, bool hasAnchor, float current, float max)
		{
			if (!CarriesHeal(enabled, total))
			{
				return false;
			}
			if (!hasAnchor || max <= 0f)
			{
				return false;
			}
			if (current / max >= 0.999f)
			{
				return true;
			}
			float num = Landed(total, current, max);
			if (!(num < 0.5f))
			{
				return num < total * 0.25f;
			}
			return true;
		}

		public static string Explain(bool enabled, float total, bool hasAnchor, float current, float max, bool lowerRungClaims)
		{
			if (!enabled)
			{
				return "off: [Systems] EnableItemHealing is false";
			}
			if (total < 0.5f)
			{
				if (!(total <= 0f))
				{
					return string.Format(CultureInfo.InvariantCulture, "inert: this item's own health restore is {0:0.##} HP — below the {1} HP floor", total, 0.5f);
				}
				return "inert: this item carries no health restore of its own";
			}
			if (!hasAnchor || max <= 0f)
			{
				return "idle: no live anchor to heal (bodiless bond, a DOWNED pet, or a GUEST — the anchor lives on the master, so a healing item can only be applied there)";
			}
			float num = current / max;
			if (num >= 0.999f)
			{
				return string.Format(CultureInfo.InvariantCulture, "nothing to heal: the pet is at {0:P0} health — the offer is refused WITHOUT consuming", num);
			}
			float num2 = Landed(total, current, max);
			if (num2 < 0.5f || num2 < total * 0.25f)
			{
				return string.Format(CultureInfo.InvariantCulture, "too little to heal: only {0:0.##} of the item's {1:0.##} HP could land ({2:F0}/{3:F0}) — refused WITHOUT consuming, so a smaller remedy can be spent instead", num2, total, current, max);
			}
			if (lowerRungClaims)
			{
				return "not ours: a lower rung claims this offer (a diet food that also heals is fed as a MEAL and heals by its authored per-food value, not by the item's)";
			}
			return string.Format(CultureInfo.InvariantCulture, "healing: {0:0.##} HP from the item's own vanilla effect ({1:0.##} of it can land)", total, num2);
		}

		public static string Toast(string species, float healed)
		{
			return string.Format(CultureInfo.InvariantCulture, "{0} laps up the draught and steadies ({1:0} health).", string.IsNullOrEmpty(species) ? "Your pet" : species, Math.Round(healed));
		}
	}
	public static class JsonTable
	{
		public static string DuplicateMessage(string key, string keyNoun)
		{
			return "'" + key + "': duplicate " + keyNoun + " key — the later entry wins.";
		}

		public static string RootMessage(string rootShape)
		{
			return "root must be " + rootShape + ".";
		}

		public static Dictionary<string, T> Read<T>(string json, Action<string> warn, string keyNoun, string rootShape, Func<string, object, Action<string>, T> entryFn) where T : class
		{
			Dictionary<string, T> dictionary = new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase);
			if (!TryReadRoot(json, warn, keyNoun, rootShape, out Dictionary<string, object> root))
			{
				return dictionary;
			}
			ReadInto(root, dictionary, warn, keyNoun, null, entryFn);
			return dictionary;
		}

		public static bool TryReadRoot(string json, Action<string> warn, string keyNoun, string rootShape, out Dictionary<string, object> root)
		{
			root = null;
			if (string.IsNullOrEmpty(json) || json.Trim().Length == 0)
			{
				return false;
			}
			object obj;
			try
			{
				obj = Json.Parse(json, (Action<string>)delegate(string k)
				{
					warn?.Invoke(DuplicateMessage(k, keyNoun));
				});
			}
			catch (FormatException ex)
			{
				warn?.Invoke(ex.Message);
				return false;
			}
			if (!(obj is Dictionary<string, object> dictionary))
			{
				warn?.Invoke(RootMessage(rootShape));
				return false;
			}
			root = dictionary;
			return true;
		}

		public static void ReadInto<T>(Dictionary<string, object> source, Dictionary<string, T> dest, Action<string> warn, string keyNoun, string ctxPrefix, Func<string, object, Action<string>, T> entryFn) where T : class
		{
			if (source == null || dest == null || entryFn == null)
			{
				return;
			}
			foreach (KeyValuePair<string, object> item in source)
			{
				T val = entryFn(item.Key, item.Value, warn);
				if (val != null)
				{
					if (dest.ContainsKey(item.Key))
					{
						warn?.Invoke(DuplicateMessage(string.IsNullOrEmpty(ctxPrefix) ? item.Key : (ctxPrefix + "." + item.Key), keyNoun));
					}
					dest[item.Key] = val;
				}
			}
		}
	}
	public static class LeapArc
	{
		public static double Height(double t, double apexHeight)
		{
			if (t <= 0.0 || t >= 1.0)
			{
				return 0.0;
			}
			return 4.0 * apexHeight * t * (1.0 - t);
		}

		public static void Sample(double sx, double sy, double sz, double ex, double ey, double ez, double apexHeight, double t, out double x, out double y, out double z)
		{
			if (t < 0.0)
			{
				t = 0.0;
			}
			if (t > 1.0)
			{
				t = 1.0;
			}
			x = sx + (ex - sx) * t;
			y = sy + (ey - sy) * t + Height(t, apexHeight);
			z = sz + (ez - sz) * t;
		}
	}
	public static class LeapGate
	{
		public const double MinLeapMeters = 1.0;

		public static bool ShouldLeap(bool enabled, bool hasTarget, double distanceMeters, double leapRangeMeters)
		{
			if (!enabled || !hasTarget)
			{
				return false;
			}
			if (leapRangeMeters <= 0.0)
			{
				return false;
			}
			if (distanceMeters >= 1.0)
			{
				return distanceMeters <= leapRangeMeters;
			}
			return false;
		}
	}
	public struct LeapMsg
	{
		public bool PlayerLeaps;

		public double PlayerStartX;

		public double PlayerStartY;

		public double PlayerStartZ;

		public double PlayerEndX;

		public double PlayerEndY;

		public double PlayerEndZ;

		public bool PetLeaps;

		public double PetStartX;

		public double PetStartY;

		public double PetStartZ;

		public double PetEndX;

		public double PetEndY;

		public double PetEndZ;
	}
	public static class LeapProtocol
	{
		private const string Ver = "v1";

		public static string Build(in LeapMsg m)
		{
			return string.Join("|", "v1", m.PlayerLeaps ? "1" : "0", Triple(m.PlayerStartX, m.PlayerStartY, m.PlayerStartZ), Triple(m.PlayerEndX, m.PlayerEndY, m.PlayerEndZ), m.PetLeaps ? "1" : "0", Triple(m.PetStartX, m.PetStartY, m.PetStartZ), Triple(m.PetEndX, m.PetEndY, m.PetEndZ));
		}

		public static bool TryParse(string payload, out LeapMsg m)
		{
			m = default(LeapMsg);
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length != 7 || array[0] != "v1")
			{
				return false;
			}
			if (TryFlag(array[1], out m.PlayerLeaps) && TryTriple(array[2], out m.PlayerStartX, out m.PlayerStartY, out m.PlayerStartZ) && TryTriple(array[3], out m.PlayerEndX, out m.PlayerEndY, out m.PlayerEndZ) && TryFlag(array[4], out m.PetLeaps) && TryTriple(array[5], out m.PetStartX, out m.PetStartY, out m.PetStartZ))
			{
				return TryTriple(array[6], out m.PetEndX, out m.PetEndY, out m.PetEndZ);
			}
			return false;
		}

		private static string Triple(double x, double y, double z)
		{
			return x.ToString("0.##", CultureInfo.InvariantCulture) + "," + y.ToString("0.##", CultureInfo.InvariantCulture) + "," + z.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static bool TryFlag(string s, out bool v)
		{
			v = s == "1";
			if (!(s == "1"))
			{
				return s == "0";
			}
			return true;
		}

		private static bool TryTriple(string s, out double x, out double y, out double z)
		{
			return LeapNumbers.TryTriple(s, out x, out y, out z);
		}
	}
	internal static class LeapNumbers
	{
		public const double MaxAbsMeters = 100000.0;

		public static bool IsSane(double v)
		{
			if (!double.IsNaN(v) && !double.IsInfinity(v))
			{
				return Math.Abs(v) < 100000.0;
			}
			return false;
		}

		public static bool TryTriple(string s, out double x, out double y, out double z)
		{
			x = (y = (z = 0.0));
			if (string.IsNullOrEmpty(s))
			{
				return false;
			}
			string[] array = s.Split(new char[1] { ',' });
			if (array.Length != 3)
			{
				return false;
			}
			if (!double.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out x) || !double.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out y) || !double.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out z))
			{
				return false;
			}
			if (IsSane(x) && IsSane(y) && IsSane(z))
			{
				return true;
			}
			x = (y = (z = 0.0));
			return false;
		}
	}
	public static class StompProtocol
	{
		private const string Ver = "v1";

		public static string Build(double x, double y, double z)
		{
			return "v1|" + x.ToString("0.##", CultureInfo.InvariantCulture) + "," + y.ToString("0.##", CultureInfo.InvariantCulture) + "," + z.ToString("0.##", CultureInfo.InvariantCulture);
		}

		public static bool TryParse(string payload, out double x, out double y, out double z)
		{
			x = (y = (z = 0.0));
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length != 2 || array[0] != "v1")
			{
				return false;
			}
			return LeapNumbers.TryTriple(array[1], out x, out y, out z);
		}
	}
	public enum LoyaltyTier
	{
		Gone,
		Broken,
		Fraying,
		Guarded,
		Cautious,
		Steady,
		Trusting,
		Devoted,
		Unshaken,
		Boundless,
		Sworn,
		Fierce,
		Mythic,
		Eternal
	}
	public enum LoyaltyEvent
	{
		FeedPreferred,
		FeedBondFood,
		DayWithoutFeeding,
		DayWithoutDrinking,
		PetCriticallyHurt,
		PetDowned,
		DefeatedNearbyEnemy,
		CrossedRegionBonded,
		SynergyGranted,
		ForTheKillExecuteKill
	}
	public static class Loyalty
	{
		public const int Min = 0;

		public const int Max = 250;

		public const int FractionCap = 100;

		public const int MaxPayoutLevel = 8;

		public const int LegacyMaxPayoutLevel = 4;

		public const float PayoutUnit = 0.5f;

		public const int CrossedRegionPoints = 5;

		public const int CrossedRegionFace = 100;

		public const double DefaultGainScale = 0.05;

		public static LoyaltyTier Tier(int value)
		{
			return LoyaltyLadder.TierFor(value);
		}

		public static int PayoutLevel(LoyaltyTier tier)
		{
			return LoyaltyLadder.Payout(tier);
		}

		public static double LadderFraction(int value)
		{
			return (double)PayoutLevel(Tier(value)) / 8.0;
		}

		public static int DeltaFor(LoyaltyEvent ev, int speciesDailyDecay = 15)
		{
			return ev switch
			{
				LoyaltyEvent.FeedPreferred => 10, 
				LoyaltyEvent.FeedBondFood => 20, 
				LoyaltyEvent.DayWithoutFeeding => -(int)Math.Round((double)speciesDailyDecay * 0.5, MidpointRounding.ToEven), 
				LoyaltyEvent.DayWithoutDrinking => -(int)Math.Round((double)speciesDailyDecay * 0.5, MidpointRounding.ToEven), 
				LoyaltyEvent.PetCriticallyHurt => -10, 
				LoyaltyEvent.PetDowned => -20, 
				LoyaltyEvent.DefeatedNearbyEnemy => 20, 
				LoyaltyEvent.CrossedRegionBonded => 100, 
				LoyaltyEvent.SynergyGranted => 20, 
				LoyaltyEvent.ForTheKillExecuteKill => 60, 
				_ => 0, 
			};
		}

		public static int Apply(int value, LoyaltyEvent ev, int speciesDailyDecay = 15)
		{
			return Clamp(value + DeltaFor(ev, speciesDailyDecay));
		}

		public static int ApplyDelta(int value, int delta)
		{
			return Clamp(value + delta);
		}

		public static bool NextTier(int value, out LoyaltyTier next, out int atValue)
		{
			LoyaltyTier loyaltyTier = Tier(value);
			LoyaltyTier top = LoyaltyLadder.Top;
			if (loyaltyTier >= top)
			{
				next = top;
				atValue = TierFloor(top);
				return false;
			}
			next = loyaltyTier + 1;
			atValue = TierFloor(next);
			return true;
		}

		public static bool NextPayoutTier(int value, out LoyaltyTier next, out int atValue)
		{
			LoyaltyTier loyaltyTier = Tier(value);
			int num = PayoutLevel(loyaltyTier);
			LoyaltyTier top = LoyaltyLadder.Top;
			while (loyaltyTier < top)
			{
				loyaltyTier++;
				if (PayoutLevel(loyaltyTier) > num)
				{
					next = loyaltyTier;
					atValue = TierFloor(loyaltyTier);
					return true;
				}
			}
			next = top;
			atValue = TierFloor(top);
			return false;
		}

		public static int TierFloor(LoyaltyTier tier)
		{
			return LoyaltyLadder.Floor(tier);
		}

		public static int InitialLoyaltyFor(int configInitial, bool wildUnknownLearned, int tierBonus = 2)
		{
			int num = Clamp(configInitial);
			if (!wildUnknownLearned || tierBonus <= 0)
			{
				return num;
			}
			LoyaltyTier loyaltyTier = Tier(num) + tierBonus;
			if (loyaltyTier > LoyaltyTier.Trusting)
			{
				loyaltyTier = LoyaltyTier.Trusting;
			}
			int num2 = TierFloor(loyaltyTier);
			if (num2 <= num)
			{
				return num;
			}
			return num2;
		}

		public static int Clamp(int value)
		{
			if (value >= 0)
			{
				if (value <= 250)
				{
					return value;
				}
				return 250;
			}
			return 0;
		}

		public static double Fraction(int value)
		{
			if (value > 0)
			{
				if (value < 100)
				{
					return (double)value / 100.0;
				}
				return 1.0;
			}
			return 0.0;
		}

		public static int BankGain(double scaledGain, ref double carry)
		{
			if (carry < 0.0 || double.IsNaN(carry) || double.IsInfinity(carry))
			{
				carry = 0.0;
			}
			if (!(scaledGain > 0.0) || double.IsNaN(scaledGain) || double.IsInfinity(scaledGain))
			{
				return 0;
			}
			double num = scaledGain + carry;
			if (num >= 250.0)
			{
				carry = 0.0;
				return 250;
			}
			int num2 = (int)Math.Floor(num);
			carry = num - (double)num2;
			return num2;
		}
	}
	public static class LoyaltyCurve
	{
		public static float Sample(float[] anchors, int level, int max)
		{
			if (anchors == null || anchors.Length == 0)
			{
				return 0f;
			}
			if (anchors.Length == 1 || max <= 0)
			{
				return anchors[0];
			}
			if (level <= 0)
			{
				return anchors[0];
			}
			if (level >= max)
			{
				return anchors[^1];
			}
			double num = (double)level / (double)max * (double)(anchors.Length - 1);
			int num2 = (int)Math.Floor(num);
			if (num2 >= anchors.Length - 1)
			{
				return anchors[^1];
			}
			double num3 = num - (double)num2;
			return (float)((double)anchors[num2] + (double)(anchors[num2 + 1] - anchors[num2]) * num3);
		}

		public static int SampleInt(int[] anchors, int level, int max)
		{
			if (anchors == null || anchors.Length == 0)
			{
				return 0;
			}
			float[] array = new float[anchors.Length];
			for (int i = 0; i < anchors.Length; i++)
			{
				array[i] = anchors[i];
			}
			return (int)Math.Round(Sample(array, level, max), MidpointRounding.AwayFromZero);
		}
	}
	public sealed class LadderRow
	{
		public LoyaltyTier Tier;

		public string Name;

		public int Floor;

		public int Payout;

		public bool Lock;

		public int PowerStep;

		public LadderRow(LoyaltyTier tier, string name, int floor, int payout, bool @lock, int powerStep)
		{
			Tier = tier;
			Name = name;
			Floor = floor;
			Payout = payout;
			Lock = @lock;
			PowerStep = powerStep;
		}

		public LadderRow Clone()
		{
			return new LadderRow(Tier, Name, Floor, Payout, Lock, PowerStep);
		}
	}
	public static class LoyaltyLadder
	{
		public const int TierCount = 14;

		public static readonly LadderRow[] Default = new LadderRow[14]
		{
			new LadderRow(LoyaltyTier.Gone, "Gone", 0, 0, @lock: false, 0),
			new LadderRow(LoyaltyTier.Broken, "Broken", 1, 1, @lock: false, 0),
			new LadderRow(LoyaltyTier.Fraying, "Fraying", 15, 2, @lock: false, 0),
			new LadderRow(LoyaltyTier.Guarded, "Guarded", 40, 3, @lock: false, 0),
			new LadderRow(LoyaltyTier.Cautious, "Cautious", 55, 3, @lock: true, 0),
			new LadderRow(LoyaltyTier.Steady, "Steady", 75, 4, @lock: false, 0),
			new LadderRow(LoyaltyTier.Trusting, "Trusting", 90, 4, @lock: true, 0),
			new LadderRow(LoyaltyTier.Devoted, "Devoted", 100, 4, @lock: false, 0),
			new LadderRow(LoyaltyTier.Unshaken, "Unshaken", 125, 5, @lock: true, 1),
			new LadderRow(LoyaltyTier.Boundless, "Boundless", 150, 5, @lock: false, 2),
			new LadderRow(LoyaltyTier.Sworn, "Sworn", 175, 6, @lock: true, 3),
			new LadderRow(LoyaltyTier.Fierce, "Fierce", 200, 7, @lock: false, 4),
			new LadderRow(LoyaltyTier.Mythic, "Mythic", 225, 7, @lock: true, 5),
			new LadderRow(LoyaltyTier.Eternal, "Eternal", 250, 8, @lock: true, 6)
		};

		private static LadderRow[] _rows = Default;

		public static LadderRow[] Rows => _rows;

		public static bool IsOverridden => _rows != Default;

		public static LoyaltyTier Top => _rows[_rows.Length - 1].Tier;

		public static void Reset()
		{
			_rows = Default;
		}

		public static LadderRow Row(LoyaltyTier tier)
		{
			int num = (int)tier;
			if (num < 0)
			{
				num = 0;
			}
			if (num >= _rows.Length)
			{
				num = _rows.Length - 1;
			}
			return _rows[num];
		}

		public static LoyaltyTier TierFor(int value)
		{
			for (int num = _rows.Length - 1; num > 0; num--)
			{
				if (value >= _rows[num].Floor)
				{
					return _rows[num].Tier;
				}
			}
			return _rows[0].Tier;
		}

		public static int Floor(LoyaltyTier tier)
		{
			return Row(tier).Floor;
		}

		public static int Payout(LoyaltyTier tier)
		{
			return Row(tier).Payout;
		}

		public static int PowerStep(LoyaltyTier tier)
		{
			return Row(tier).PowerStep;
		}

		public static bool IsLock(LoyaltyTier tier)
		{
			return Row(tier).Lock;
		}

		public static string Name(LoyaltyTier tier)
		{
			return Row(tier).Name;
		}

		public static int LockFloorAtOrBelow(int value)
		{
			for (int num = _rows.Length - 1; num > 0; num--)
			{
				if (_rows[num].Lock && value >= _rows[num].Floor)
				{
					return _rows[num].Floor;
				}
			}
			return 0;
		}

		public static LoyaltyTier RepresentativeTier(int payout)
		{
			if (payout <= 0)
			{
				return _rows[0].Tier;
			}
			for (int i = 0; i < _rows.Length; i++)
			{
				if (_rows[i].Payout >= payout)
				{
					return _rows[i].Tier;
				}
			}
			return Top;
		}

		public static bool TryParseOverride(string spec, out LadderRow[] rows, out string error)
		{
			rows = Default;
			error = null;
			if (string.IsNullOrWhiteSpace(spec))
			{
				return true;
			}
			string[] array = spec.Split(new char[1] { ',' });
			if (array.Length != 14)
			{
				error = $"LadderOverride needs exactly {14} comma-separated rows, got {array.Length}.";
				return false;
			}
			LadderRow[] array2 = new LadderRow[14];
			for (int i = 0; i < 14; i++)
			{
				LadderRow ladderRow = Default[i].Clone();
				string[] array3 = array[i].Trim().Split(new char[1] { ':' });
				if (array3.Length < 1 || array3.Length > 4 || !int.TryParse(array3[0].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out ladderRow.Floor))
				{
					error = $"LadderOverride row {i} ('{array[i].Trim()}') is not floor[:payout[:lock[:power]]].";
					return false;
				}
				if (array3.Length > 1 && array3[1].Trim().Length > 0 && !int.TryParse(array3[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out ladderRow.Payout))
				{
					error = $"LadderOverride row {i}: payout '{array3[1].Trim()}' is not an integer.";
					return false;
				}
				if (array3.Length > 2 && array3[2].Trim().Length > 0)
				{
					string text = array3[2].Trim();
					if (text == "1")
					{
						ladderRow.Lock = true;
					}
					else
					{
						if (!(text == "0"))
						{
							error = $"LadderOverride row {i}: lock '{text}' must be 0 or 1.";
							return false;
						}
						ladderRow.Lock = false;
					}
				}
				if (array3.Length > 3 && array3[3].Trim().Length > 0 && !int.TryParse(array3[3].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out ladderRow.PowerStep))
				{
					error = $"LadderOverride row {i}: power '{array3[3].Trim()}' is not an integer.";
					return false;
				}
				array2[i] = ladderRow;
			}
			if (array2[0].Floor != 0)
			{
				error = "LadderOverride row 0 (Gone) must have floor 0.";
				return false;
			}
			for (int j = 1; j < 14; j++)
			{
				if (array2[j].Floor <= array2[j - 1].Floor)
				{
					error = $"LadderOverride floors must strictly ascend (row {j}: {array2[j].Floor} <= {array2[j - 1].Floor}).";
					return false;
				}
				if (array2[j].Payout < array2[j - 1].Payout)
				{
					error = $"LadderOverride payouts must not fall (row {j}: {array2[j].Payout} < {array2[j - 1].Payout}).";
					return false;
				}
			}
			for (int k = 0; k < 14; k++)
			{
				if (array2[k].Payout < 0 || array2[k].Payout > 8)
				{
					error = $"LadderOverride row {k}: payout {array2[k].Payout} outside 0..{8}.";