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("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c48b2eb6460f1b993d9ddb914cbdc5ff6f1d22c6")]
[assembly: AssemblyProduct("Beastwhispering.Core")]
[assembly: AssemblyTitle("Beastwhispering.Core")]
[assembly: AssemblyMetadata("BuildStamp", "c48b2eb 2026-07-30")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	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 enum CounterVerdict
	{
		Inactive,
		Expired,
		AlreadyCountered,
		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 void Begin(double now, double windowSeconds)
		{
			Open = true;
			ExpireAt = now + ((windowSeconds > 0.0) ? windowSeconds : 0.0);
			_countered.Clear();
			CounterCount = 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();
		}

		public CounterVerdict TryCounter(string attackerUid, double now, bool perAttackerOnce)
		{
			if (!Open)
			{
				return CounterVerdict.Inactive;
			}
			if (now >= ExpireAt)
			{
				return CounterVerdict.Expired;
			}
			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);
			}
			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 BlanketHeatingBlanket = 87100;

		public const int BlanketCoolingBlanket = 87101;

		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 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[66]
		{
			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(87100, "blanket.heating-blanket", "blankets", BwIdRegistry.ItemId, "Heating Blanket"),
			new BwIdEntry(87101, "blanket.cooling-blanket", "blankets", BwIdRegistry.ItemId, "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(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 all but severed.", 
				LoyaltyTier.Broken => "The communion is all but severed.", 
				LoyaltyTier.Fraying => "The communion is fraying.", 
				LoyaltyTier.Steady => "The communion holds steady.", 
				LoyaltyTier.Devoted => "The communion runs deep.", 
				_ => "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);
		}
	}
	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 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;
			}
			_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 HungerTimer(double secondsPerDay, double secondsSinceFed = 0.0)
		{
			SecondsPerDay = secondsPerDay;
			SecondsSinceFed = secondsSinceFed;
			_daysApplied = ((secondsPerDay > 0.0) ? ((int)(secondsSinceFed / secondsPerDay)) : 0);
		}

		public void Feed()
		{
			SecondsSinceFed = 0.0;
			_daysApplied = 0;
		}

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

		public int Tick(double dt)
		{
			SecondsSinceFed += dt;
			if (SecondsPerDay <= 0.0)
			{
				return 0;
			}
			int num = (int)(SecondsSinceFed / SecondsPerDay);
			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.Steady,
				Percent = 30,
				FlatX = 5,
				ItemId = 87202,
				EnchantmentId = 87222
			},
			new FeatherQuality
			{
				Quality = "Resplendent",
				Tier = LoyaltyTier.Devoted,
				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 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 Relic = "relic";

		public const string BuffFood = "bufffood";

		public const string Meal = "meal";

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

		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
	}
	public sealed class KillFavorDef
	{
		public KillFavorStat Stat;

		public float[] AmountByTier;
	}
	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 || tier == LoyaltyTier.Gone)
			{
				return 0f;
			}
			int num = (int)(tier - 1);
			if (num < 0 || num >= def.AmountByTier.Length)
			{
				return 0f;
			}
			return def.AmountByTier[num];
		}
	}
	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;
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				string text = item.Key.ToLowerInvariant();
				KillFavorStat value2;
				if (!(text == "stat"))
				{
					if (text == "amounts")
					{
						if (item.Value is List<object> { Count: 4 } list)
						{
							array = new float[4];
							for (int i = 0; i < 4; i++)
							{
								array[i] = ((list[i] is double num) ? ((float)num) : 0f);
							}
						}
						else
						{
							f.Say("killBuff 'amounts' must be a 4-number array (Broken, Fraying, Steady, Devoted) — ignored.");
						}
					}
					else
					{
						f.Say("unknown killBuff key '" + item.Key + "' (valid: stat, amounts).");
					}
				}
				else if (item.Value is string text2 && EnumRead.TryName<KillFavorStat>(text2.Trim(), out value2))
				{
					killFavorStat = value2;
				}
				else
				{
					f.Say($"killBuff 'stat' '{item.Value}' unknown " + "(valid: " + string.Join(", ", Enum.GetNames(typeof(KillFavorStat))) + ").");
				}
			}
			if (!killFavorStat.HasValue || array == null)
			{
				f.Say("killBuff needs both 'stat' and a 4-number 'amounts' — ignored (strike only).");
				return null;
			}
			return new KillFavorDef
			{
				Stat = killFavorStat.Value,
				AmountByTier = array
			};
		}

		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 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 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 enum LanternAction
	{
		None,
		Create,
		Destroy
	}
	public static class LanternRules
	{
		public static LanternAction Mirror(bool playerHas, bool bodyAlive, bool cloneAlive)
		{
			if (playerHas && bodyAlive && !cloneAlive)
			{
				return LanternAction.Create;
			}
			if (cloneAlive && (!playerHas || !bodyAlive))
			{
				return LanternAction.Destroy;
			}
			return LanternAction.None;
		}
	}
	public enum LoyaltyTier
	{
		Gone,
		Broken,
		Fraying,
		Steady,
		Devoted
	}
	public enum LoyaltyEvent
	{
		FeedPreferred,
		FeedBondFood,
		DayWithoutFeeding,
		PetCriticallyHurt,
		PetDowned,
		DefeatedNearbyEnemy,
		CrossedRegionBonded
	}
	public static class Loyalty
	{
		public const int Min = 0;

		public const int Max = 100;

		public const double DefaultGainScale = 0.05;

		public static LoyaltyTier Tier(int value)
		{
			if (value <= 39)
			{
				if (value > 0)
				{
					if (value <= 14)
					{
						return LoyaltyTier.Broken;
					}
					return LoyaltyTier.Fraying;
				}
				return LoyaltyTier.Gone;
			}
			if (value <= 74)
			{
				return LoyaltyTier.Steady;
			}
			return LoyaltyTier.Devoted;
		}

		public static int DeltaFor(LoyaltyEvent ev, int speciesDailyDecay = 15)
		{
			return ev switch
			{
				LoyaltyEvent.FeedPreferred => 10, 
				LoyaltyEvent.FeedBondFood => 20, 
				LoyaltyEvent.DayWithoutFeeding => -speciesDailyDecay, 
				LoyaltyEvent.PetCriticallyHurt => -10, 
				LoyaltyEvent.PetDowned => -20, 
				LoyaltyEvent.DefeatedNearbyEnemy => 5, 
				LoyaltyEvent.CrossedRegionBonded => 5, 
				_ => 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)
		{
			switch (Tier(value))
			{
			case LoyaltyTier.Gone:
				next = LoyaltyTier.Broken;
				atValue = 1;
				return true;
			case LoyaltyTier.Broken:
				next = LoyaltyTier.Fraying;
				atValue = 15;
				return true;
			case LoyaltyTier.Fraying:
				next = LoyaltyTier.Steady;
				atValue = 40;
				return true;
			case LoyaltyTier.Steady:
				next = LoyaltyTier.Devoted;
				atValue = 75;
				return true;
			default:
				next = LoyaltyTier.Devoted;
				atValue = 100;
				return false;
			}
		}

		public static int Clamp(int value)
		{
			if (value >= 0)
			{
				if (value <= 100)
				{
					return value;
				}
				return 100;
			}
			return 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 >= 100.0)
			{
				carry = 0.0;
				return 100;
			}
			int num2 = (int)Math.Floor(num);
			carry = num - (double)num2;
			return num2;
		}
	}
	public enum PetBuffStat
	{
		PhysicalDamage,
		EtherealDamage,
		DecayDamage,
		ElectricDamage,
		FrostDamage,
		FireDamage,
		MovementSpeed,
		BagCapacity
	}
	public sealed class PetBuffDef
	{
		public PetBuffStat Stat;

		public float AmountPerLevel;

		public float MaxAmount;
	}
	public readonly struct ResolvedBuff
	{
		public PetBuffStat Stat { get; }

		public float Amount { get; }

		public ResolvedBuff(PetBuffStat stat, float amount)
		{
			Stat = stat;
			Amount = amount;
		}
	}
	public static class PetBuffs
	{
		public static int Level(LoyaltyTier tier)
		{
			return (int)tier;
		}

		public static bool IsFlat(PetBuffStat stat)
		{
			return stat == PetBuffStat.BagCapacity;
		}

		public static string DisplayName(PetBuffStat stat)
		{
			return stat switch
			{
				PetBuffStat.PhysicalDamage => "Physical damage", 
				PetBuffStat.EtherealDamage => "Ethereal damage", 
				PetBuffStat.DecayDamage => "Decay damage", 
				PetBuffStat.ElectricDamage => "Electric damage", 
				PetBuffStat.FrostDamage => "Frost damage", 
				PetBuffStat.FireDamage => "Fire damage", 
				PetBuffStat.MovementSpeed => "movement speed", 
				PetBuffStat.BagCapacity => "bag capacity", 
				_ => stat.ToString(), 
			};
		}

		public static float Amount(PetBuffDef def, LoyaltyTier tier)
		{
			if (def == null)
			{
				return 0f;
			}
			int num = Level(tier);
			if (IsFlat(def.Stat))
			{
				if (num <= 0)
				{
					return 0f;
				}
				float amountPerLevel = def.AmountPerLevel;
				float num2 = ((float.IsPositiveInfinity(def.MaxAmount) || def.MaxAmount < amountPerLevel) ? amountPerLevel : def.MaxAmount);
				if (num < Level(LoyaltyTier.Devoted))
				{
					return amountPerLevel + (float)(num - 1) * ((num2 - amountPerLevel) / 4f);
				}
				return num2;
			}
			float num3 = def.AmountPerLevel * (float)num;
			if (!(num3 > def.MaxAmount))
			{
				return num3;
			}
			return def.MaxAmount;
		}

		public static List<ResolvedBuff> Resolve(Dictionary<string, List<PetBuffDef>> table, string speciesId, LoyaltyTier tier)
		{
			List<ResolvedBuff> list = new List<ResolvedBuff>();
			if (!TryGet(table, speciesId, out List<PetBuffDef> defs))
			{
				return list;
			}
			foreach (PetBuffDef item in defs)
			{
				float num = Amount(item, tier);
				if (num > 0f)
				{
					list.Add(new ResolvedBuff(item.Stat, num));
				}
			}
			return list;
		}

		public static float BagCapacityTotal(float speciesAmount, bool speciesEnabled, float beastOfBurdenAmount, bool beastOfBurdenLearned)
		{
			float num = 0f;
			if (speciesEnabled && speciesAmount > 0f)
			{
				num += speciesAmount;
			}
			if (beastOfBurdenLearned && beastOfBurdenAmount > 0f)
			{
				num += beastOfBurdenAmount;
			}
			return num;
		}

		public static Dictionary<string, List<PetBuffDef>> Parse(string text, Action<string> warn = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, List<PetBuffDef>> dictionary = new Dictionary<string, List<PetBuffDef>>(StringComparer.OrdinalIgnoreCase);
			foreach (TableLine item2 in SpeciesTable.Lines(text, '\n'))
			{
				string text2 = item2.Fields[0].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				if (!EnumRead.TryName<PetBuffStat>(text2, out var value))
				{
					warn?.Invoke("'" + item2.Key + "': unknown buff stat '" + text2 + "' (valid: " + string.Join(", ", Enum.GetNames(typeof(PetBuffStat))) + ").");
				}
				else
				{
					PetBuffDef item = new PetBuffDef
					{
						Stat = value,
						AmountPerLevel = SpeciesTable.FloatOr(item2.Fields, 1, 1f, warn, item2.Key),
						MaxAmount = SpeciesTable.FloatOr(item2.Fields, 2, float.PositiveInfinity, warn, item2.Key)
					};
					if (!dictionary.TryGetValue(item2.Key, out var value2))
					{
						value2 = (dictionary[item2.Key] = new List<PetBuffDef>());
					}
					value2.Add(item);
				}
			}
			return dictionary;
		}

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

		public static bool TryGet(Dictionary<string, List<PetBuffDef>> table, string speciesId, out List<PetBuffDef> defs)
		{
			return SpeciesTable.TryResolve<List<PetBuffDef>>(table, speciesId, ref defs, (string)null);
		}
	}
	public enum ComfortSide
	{
		None,
		Cold,
		Hot
	}
	public sealed class ComfortRelief
	{
		public ComfortSide Side;

		public int ReliefSteps;

		public double EscalateMult;

		public bool Immune;
	}
	public readonly struct ComfortReading
	{
		public int StepsOutside { get; }

		public ComfortSide Side { get; }

		public double EscalateMult { get; }

		public int RawStepsOutside { get; }

		public bool Immune { get; }

		public static ComfortReading InBand => new ComfortReading(0, ComfortSide.None, 1.0, 0);

		public ComfortReading(int stepsOutside, ComfortSide side, double escalateMult, int rawStepsOutside, bool immune = false)
		{
			StepsOutside = stepsOutside;
			Side = side;
			EscalateMult = escalateMult;
			RawStepsOutside = rawStepsOutside;
			Immune = immune;
		}
	}
	public static class PetComfort
	{
		public static ComfortSide SideOf(TempStep ambient, ComfortBand band)
		{
			if (ambient < band.Min)
			{
				return ComfortSide.Cold;
			}
			if (ambient > band.Max)
			{
				return ComfortSide.Hot;
			}
			return ComfortSide.None;
		}

		public static ComfortReading Evaluate(TempStep ambient, ComfortBand band, ComfortRelief relief = null)
		{
			return Evaluate(ambient, band, (relief == null) ? null : new ComfortRelief[1] { relief });
		}

		public static ComfortReading Evaluate(TempStep ambient, ComfortBand band, IReadOnlyList<ComfortRelief> reliefs)
		{
			int num = Temperature.StepsOutside(ambient, band);
			if (num <= 0)
			{
				return ComfortReading.InBand;
			}
			ComfortSide comfortSide = SideOf(ambient, band);
			if (reliefs != null)
			{
				for (int i = 0; i < reliefs.Count; i++)
				{
					if (reliefs[i] != null && reliefs[i].Immune)
					{
						return new ComfortReading(0, comfortSide, 1.0, num, immune: true);
					}
				}
			}
			int num2 = 0;
			double num3 = 1.0;
			if (reliefs != null)
			{
				for (int j = 0; j < reliefs.Count; j++)
				{
					ComfortRelief comfortRelief = reliefs[j];
					if (comfortRelief != null && comfortRelief.Side == comfortSide && comfortRelief.ReliefSteps > 0)
					{
						num2 += comfortRelief.ReliefSteps;
						if (comfortRelief.EscalateMult > num3)
						{
							num3 = comfortRelief.EscalateMult;
						}
					}
				}
			}
			int num4 = Math.Max(0, num - num2);
			double escalateMult = ((num4 > 0 && num2 > 0) ? num3 : 1.0);
			return new ComfortReading(num4, comfortSide, escalateMult, num);
		}
	}
	public static class SpeciesComfort
	{
		public const string DefaultKey = "Default";

		public static Dictionary<string, ComfortBand> Parse(string text, Action<string> warn = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, ComfortBand> dictionary = new Dictionary<string, ComfortBand>(StringComparer.OrdinalIgnoreCase);
			foreach (TableLine item in SpeciesTable.Lines(text, '\n'))
			{
				string[] fields = item.Fields;
				TempStep step;
				TempStep step2;
				if (fields.Length < 2)
				{
					warn?.Invoke("'" + item.Raw + "': expected Species=MinStep,MaxStep.");
				}
				else if (!TryParseStep(fields[0], out step) || !TryParseStep(fields[1], out step2))
				{
					warn?.Invoke("'" + item.Key + "': unknown step name (valid: " + string.Join(", ", Enum.GetNames(typeof(TempStep))) + ").");
				}
				else if (step > step2)
				{
					warn?.Invoke("'" + item.Key + "': inverted band " + fields[0].Trim() + ">" + fields[1].Trim() + " — line skipped.");
				}
				else
				{
					dictionary[item.Key] = new ComfortBand(step, step2);
				}
			}
			return dictionary;
		}

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

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

		private static bool TryParseStep(string s, out TempStep step)
		{
			return EnumRead.TryName<TempStep>(s.Trim(), out step);
		}
	}
	public sealed class BlanketDef
	{
		public string Key = "";

		public ComfortSide Side;

		public int ReliefSteps;

		public double EscalateMult;

		public double DurationSeconds;

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

		public ComfortRelief ToRelief()
		{
			return new ComfortRelief
			{
				Side = Side,
				ReliefSteps = ReliefSteps,
				EscalateMult = EscalateMult
			};
		}
	}
	public static class Blankets
	{
		public static Dictionary<string, BlanketDef> Parse(string text, Action<string> warn = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, BlanketDef> dictionary = new Dictionary<string, BlanketDef>(StringComparer.OrdinalIgnoreCase);
			foreach (TableLine item in SpeciesTable.Lines(text, '\n'))
			{
				string[] fields = item.Fields;
				if (fields.Length < 5)
				{
					warn?.Invoke("'" + item.Raw + "': expected Name=Side,ReliefSteps,EscalateMult,DurationSeconds,Ingredient….");
					continue;
				}
				string text2 = fields[0].Trim();
				if (!TryParseSide(text2, out var side) || side == ComfortSide.None)
				{
					warn?.Invoke("'" + item.Key + "': side must be Cold or Hot, got '" + text2 + "'.");
					continue;
				}
				BlanketDef blanketDef = new BlanketDef
				{
					Key = item.Key,
					Side = side,
					ReliefSteps = (int)SpeciesTable.DoubleOr(fields, 1, 3.0, warn, item.Key),
					EscalateMult = SpeciesTable.DoubleOr(fields, 2, 3.0, warn, item.Key),
					DurationSeconds = SpeciesTable.DoubleOr(fields, 3, 900.0, warn, item.Key)
				};
				for (int i = 4; i < fields.Length; i++)
				{
					string text3 = fields[i].Trim();
					if (text3.Length > 0)
					{
						blanketDef.Ingredients.Add(text3);
					}
				}
				if (blanketDef.Ingredients.Count == 0)
				{
					warn?.Invoke("'" + item.Key + "': no ingredients — line skipped (an uncraftable blanket helps no one).");
				}
				else
				{
					dictionary[item.Key] = blanketDef;
				}
			}
			return dictionary;
		}

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

		private static bool TryParseSide(string s, out ComfortSide side)
		{
			return EnumRead.TryName<ComfortSide>(s, out side);
		}
	}
	public enum FoodKind
	{
		None,
		Preferred,
		Bond
	}
	public readonly struct FoodMatch
	{
		public static readonly FoodMatch None = new FoodMatch(FoodKind.None, 0);

		public FoodKind Kind { get; }

		public int LoyaltyGain { get; }

		public bool IsMatch => Kind != FoodKind.None;

		public FoodMatch(FoodKind kind, int loyaltyGain)
		{
			Kind = kind;
			LoyaltyGain = loyaltyGain;
		}
	}
	public enum FeedOutcome
	{
		Satiated,
		NotInterested,
		Fed
	}
	public sealed class FoodEntry
	{
		public string Key;

		public int? ItemId;

		public string Category;

		public FoodKind Kind;

		public int LoyaltyGain;

		public float? Heal;

		public int? HealthRecovery;
	}
	public sealed class DietEntry
	{
		public double? HungerSecondsPerDay;

		public List<FoodEntry> Foods;

		public DietEntry(List<FoodEntry> foods = null, double? hungerSecondsPerDay = null)
		{
			Foods = foods ?? new List<FoodEntry>();
			HungerSecondsPerDay = hungerSecondsPerDay;
		}
	}
	public readonly struct FeedDecision
	{
		public FeedOutcome Outcome { get; }

		public FoodKind Kind { get; }

		public int LoyaltyGain { get; }

		public float Heal { get; }

		public int HealthRecoveryLevel { get; }

		public string MatchedKey { get; }

		public FeedDecision(FeedOutcome outcome, FoodKind kind, int loyaltyGain, float heal, int healthRecoveryLevel, string matchedKey)
		{
			Outcome = outcome;
			Kind = kind;
			LoyaltyGain = loyaltyGain;
			Heal = heal;
			HealthRecoveryLevel = healthRecoveryLevel;
			MatchedKey = matchedKey;
		}

		public FoodMatch ToFoodMatch()
		{
			if (Outcome != FeedOutcome.Fed)
			{
				return FoodMatch.None;
			}
			return new FoodMatch(Kind, LoyaltyGain);
		}
	}
	public static class PetDiet
	{
		public const string DefaultKey = "Default";

		public const int DefaultPreferredLoyalty = 10;

		public const int DefaultBondLoyalty = 20;

		public static Dictionary<string, DietEntry> Parse(string json, Action<string> warn = null)
		{
			return JsonTable.Read(json, warn, "species", "an object of species → food arrays", ParseDiet);
		}

		private static DietEntry ParseDiet(string species, object value, Action<string> warn)
		{
			if (value is List<object> foods)
			{
				return new DietEntry(ParseFoods(species, foods, warn));
			}
			FieldReader fieldReader = new FieldReader("'" + species + "'", warn);
			if (value is Dictionary<string, object> dictionary)
			{
				double? hungerSecondsPerDay = null;
				List<object> list = null;
				foreach (KeyValuePair<string, object> item in dictionary)
				{
					string text = item.Key.ToLowerInvariant();
					double result2;
					if (!(text == "hungersecondsperday"))
					{
						if (text == "foods")
						{
							if (fieldReader.Items("foods", item.Value, out List<object> result, "an ARRAY of food objects", "species skipped"))
							{
								list = result;
							}
						}
						else
						{
							fieldReader.Unknown(item.Key, "hungerSecondsPerDay, foods");
						}
					}
					else if (fieldReader.Num("hungerSecondsPerDay", item.Value, out result2, null, "using the global default"))
					{
						hungerSecondsPerDay = result2;
						if (result2 <= 0.0)
						{
							fieldReader.Say($"hungerSecondsPerDay {result2} disables hunger and decay — this pet stays permanently feedable and never loses loyalty to hunger.");
						}
					}
				}
				if (list == null)
				{
					fieldReader.Say("object form requires a 'foods' array — species skipped.");
					return null;
				}
				return new DietEntry(ParseFoods(species, list, warn), hungerSecondsPerDay);
			}
			fieldReader.Say("value must be a food ARRAY or an OBJECT with a 'foods' array — species skipped.");
			return null;
		}

		private static List<FoodEntry> ParseFoods(string species, List<object> foods, Action<string> warn)
		{
			List<FoodEntry> list = new List<FoodEntry>();
			for (int i = 0; i < foods.Count; i++)
			{
				FoodEntry foodEntry = ParseFood(species, i, foods[i], warn);
				if (foodEntry != null)
				{
					list.Add(foodEntry);
				}
			}
			return list;
		}

		private static FoodEntry ParseFood(string species, int index, object value, Action<string> warn)
		{
			FieldReader f = new FieldReader($"'{species}' food #{index + 1}", warn);
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Say("must be an object — entry skipped.");
				return null;
			}
			FoodEntry foodEntry = new FoodEntry
			{
				Kind = FoodKind.Preferred
			};
			bool flag = false;
			bool flag2 = false;
			int? num = null;
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "item":
					flag = TryReadItem(f, item.Value, foodEntry);
					break;
				case "category":
					flag2 = TryReadCategory(f, item.Value, foodEntry);
					break;
				case "kind":
				{
					if (item.Value is string name && TryParseKind(name, out var kind))
					{
						foodEntry.Kind = kind;
					}
					else
					{
						f.Say($"unknown kind '{item.Value}' (valid: Preferred, Bond) — using Preferred.");
					}
					break;
				}
				case "loyalty":
				{
					if (f.Int("loyalty", item.Value, out var result2, null, "using the kind default"))
					{
						num = result2;
					}
					break;
				}
				case "heal":
				{
					if (f.Num("heal", item.Value, out var result3, null, "using the global fallback"))
					{
						foodEntry.Heal = (float)result3;
					}
					break;
				}
				case "healthrecovery":
				{
					if (f.Int("healthRecovery", item.Value, out var result, $"a number {1}-{5}", $"using the default ({1})"))
					{
						int num2 = ((result < 1) ? 1 : ((result > 5) ? 5 : result));
						if (num2 != result)
						{
							f.Say($"'healthRecovery' {result} out of range {1}-{5} — clamped to {num2}.");
						}
						foodEntry.HealthRecovery = num2;
					}
					break;
				}
				default:
					f.Unknown(item.Key, "item, category, kind, loyalty, heal, healthRecovery");
					break;
				}
			}
			if (flag && flag2)
			{
				f.Say("has BOTH 'item' and 'category' — ambiguous, entry skipped (write two foods).");
				return null;
			}
			if (!flag && !flag2)
			{
				f.Say("missing/invalid required 'item' (or 'category') — entry skipped.");
				return null;
			}
			foodEntry.LoyaltyGain = num ?? ((foodEntry.Kind == FoodKind.Bond) ? 20 : 10);
			return foodEntry;
		}

		private static bool TryReadItem(FieldReader f, object value, FoodEntry entry)
		{
			ItemKey val = default(ItemKey);
			if (ItemKey.TryRead(value, ref val))
			{
				entry.Key = ((ItemKey)(ref val)).Key;
				entry.ItemId = ((ItemKey)(ref val)).ItemId;
				return true;
			}
			f.Wrong("item", "a number (ItemID) or non-empty string (display name)");
			return false;
		}

		private static bool TryReadCategory(FieldReader f, object value, FoodEntry entry)
		{
			if (!(value is string text) || text.Trim().Length == 0)
			{
				f.Wrong("category", "a non-empty string (valid: " + FoodCategories.ValidList() + ")");
				return false;
			}
			if (FoodCategories.TryCanonical(text, out string canonical))
			{
				entry.Category = canonical;
			}
			else
			{
				entry.Category = text.Trim();
				f.Say("unknown category '" + text.Trim() + "' (valid: " + FoodCategories.ValidList() + ") — the entry will never match.");
			}
			entry.Key = FoodCategories.Label(entry.Category);
			return true;
		}

		private static bool TryParseKind(string name, out FoodKind kind)
		{
			if (string.Equals(name, "Preferred", StringComparison.OrdinalIgnoreCase))
			{
				kind = FoodKind.Preferred;
				return true;
			}
			if (string.Equals(name, "Bond", StringComparison.OrdinalIgnoreCase))
			{
				kind = FoodKind.Bond;
				return true;
			}
			kind = FoodKind.Preferred;
			return false;
		}

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

		public static IReadOnlyList<FoodEntry> Resolve(Dictionary<string, DietEntry> table, string speciesId)
		{
			DietEntry dietEntry = default(DietEntry);
			if (!SpeciesTable.TryResolve<DietEntry>(table, speciesId, ref dietEntry, "Default") || dietEntry?.Foods == null)
			{
				return Array.Empty<FoodEntry>();
			}
			return dietEntry.Foods;
		}

		public static double? HungerSecondsPerDay(Dictionary<string, DietEntry> table, string speciesId)
		{
			DietEntry dietEntry = default(DietEntry);
			if (!SpeciesTable.TryResolve<DietEntry>(table, speciesId, ref dietEntry, "Default"))
			{
				return null;
			}
			return dietEntry?.HungerSecondsPerDay;
		}

		public static FeedDecision Decide(bool satiated, IReadOnlyList<FoodEntry> diet, int itemId, string itemName, float fallbackHeal)
		{
			return Decide(satiated, diet, itemId, itemName, null, fallbackHeal);
		}

		public static FeedDecision Decide(bool satiated, IReadOnlyList<FoodEntry> diet, int itemId, string itemName, IReadOnlyCollection<string> itemCategories, float fallbackHeal)
		{
			if (satiated)
			{
				return new FeedDecision(FeedOutcome.Satiated, FoodKind.None, 0, 0f, 0, null);
			}
			FoodEntry foodEntry = null;
			if (diet != null)
			{
				foreach (FoodEntry item in diet)
				{
					if (item != null && Matches(item, itemId, itemName, itemCategories))
					{
						if (item.Kind == FoodKind.Bond)
						{
							foodEntry = item;
							break;
						}
						if (foodEntry == null)
						{
							foodEntry = item;
						}
					}
				}
			}
			if (foodEntry == null)
			{
				return new FeedDecision(FeedOutcome.NotInterested, FoodKind.None, 0, 0f, 0, null);
			}
			return new FeedDecision(FeedOutcome.Fed, foodEntry.Kind, foodEntry.LoyaltyGain, foodEntry.Heal ?? fallbackHeal, foodEntry.HealthRecovery ?? 1, foodEntry.Key);
		}

		public static bool Matches(FoodEntry entry, int itemId, string itemName)
		{
			return Matches(entry, itemId, itemName, null);
		}

		public static bool Matches(FoodEntry entry, int itemId, string itemName, IReadOnlyCollection<string> itemCategories)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (entry == null)
			{
				return false;
			}
			if (entry.Category != null)
			{
				if (itemCategories == null)
				{
					return false;
				}
				foreach (string itemCategory in itemCategories)
				{
					if (string.Equals(itemCategory, entry.Category, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
				return false;
			}
			ItemKey val = new ItemKey(entry.Key, entry.ItemId);
			return ((ItemKey)(ref val)).Matches(itemId, itemName);
		}
	}
	public enum GearSlot
	{
		Any = -1,
		Helmet,
		Chest,
		Legs,
		Foot,
		Hands,
		RightHand,
		LeftHand,
		Back,
		Quiver
	}
	public enum GearEffectKind
	{
		LoyaltyGainMult,
		LoyaltyDecayMult,
		PetHealthMult,
		PetDamageMult,
		PetDefenseMult,
		PetSpeedMult
	}
	public sealed class GearEffectDef
	{
		public GearEffectKind Kind;

		public float Value;
	}
	public sealed class GearEntry
	{
		public string ItemKey;

		public int? ItemId;

		public GearSlot Slot = GearSlot.Any;

		public string Species;

		public List<GearEffectDef> Effects = new List<GearEffectDef>();
	}
	public readonly struct EquippedItem
	{
		public readonly int ItemId;

		public readonly string Name;

		public readonly GearSlot Slot;

		public EquippedItem(int itemId, string name, GearSlot slot)
		{
			ItemId = itemId;
			Name = name;
			Slot = slot;
		}
	}
	public sealed class GearEffects
	{
		public static readonly GearEffects None = new GearEffects(1f, 1f, new StatModifiers());

		public float LoyaltyGainMult { get; }

		public float LoyaltyDecayMult { get; }

		public StatModifiers PetStats { get; }

		public bool IsIdentity
		{
			get
			{
				if (LoyaltyGainMult == 1f && LoyaltyDecayMult == 1f && PetStats.Health == 1f && PetStats.Damage == 1f && PetStats.Defense == 1f)
				{
					return PetStats.Speed == 1f;
				}
				return false;
			}
		}

		public GearEffects(float loyaltyGainMult, float loyaltyDecayMult, StatModifiers petStats)
		{
			LoyaltyGainMult = loyaltyGainMult;
			LoyaltyDecayMult = loyaltyDecayMult;
			PetStats = petStats ?? new StatModifiers();
		}
	}
	public static class PetGear
	{
		public static Dictionary<string, GearEntry> Parse(string json, Action<string> warn = null)
		{
			return JsonTable.Read(json, warn, "item", "an object of item → gear-effect objects", ParseEntry);
		}

		private static GearEntry ParseEntry(string itemKey, object value, Action<string> warn)
		{
			string text = (itemKey ?? "").Trim();
			if (text.Length == 0)
			{
				warn?.Invoke("empty item key — entry skipped.");
				return null;
			}
			FieldReader f = new FieldReader("'" + text + "'", warn);
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Say("value must be an object — entry skipped.");
				return null;
			}
			ItemKey val = default(ItemKey);
			ItemKey.TryRead((object)text, ref val);
			GearEntry gearEntry = new GearEntry
			{
				ItemKey = ((ItemKey)(ref val)).Key,
				ItemId = ((ItemKey)(ref val)).ItemId
			};
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "slot":
				{
					if (!f.Enum<GearSlot>("slot", item.Value, out var result2, "name a slot (" + string.Join(", ", Enum.GetNames(typeof(GearSlot))) + ")", "entry skipped"))
					{
						return null;
					}
					gearEntry.Slot = result2;
					break;
				}
				case "species":
				{
					if (!f.Str("species", item.Value, out string result3, null, "entry skipped"))
					{
						return null;
					}
					gearEntry.Species = result3;
					break;
				}
				case "effects":
				{
					if (!f.Items("effects", item.Value, out List<object> result, "an ARRAY of {kind, value} objects"))
					{
						break;
					}
					foreach (object item2 in result)
					{
						GearEffectDef gearEffectDef = ParseEffect(f, item2);
						if (gearEffectDef != null)
						{
							gearEntry.Effects.Add(gearEffectDef);
						}
					}
					break;
				}
				default:
					f.Unknown(item.Key, "slot, species, effects");
					break;
				}
			}
			if (gearEntry.Effects.Count == 0)
			{
				f.Say("missing/empty required 'effects' — entry skipped.");
				return null;
			}
			return gearEntry;
		}

		private static GearEffectDef ParseEffect(FieldReader f, object value)
		{
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Say("each effect must be an object {kind, value} — one skipped.");
				return null;
			}
			if (!dictionary.TryGetValue("kind", out var value2) || !(value2 is string text))
			{
				f.Say("an effect is missing a string 'kind' — skipped.");
				return null;
			}
			if (!EnumRead.TryName<GearEffectKind>(text.Trim(), out var value3))
			{
				f.Say("unknown effect kind '" + text + "' (valid: " + string.Join(", ", Enum.GetNames(typeof(GearEffectKind))) + ") — skipped (a table for a future build stays loadable).");
				return null;
			}
			if (!dictionary.TryGetValue("value", out var value4) || !(value4 is double num) || num <= 0.0)
			{
				f.Say($"effect '{value3}' needs a numeric 'value' > 0 (a multiplier; 1.5 = +50%) — skipped.");
				return null;
			}
			return new GearEffectDef
			{
				Kind = value3,
				Value = (float)num
			};
		}

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

		public static GearEffects Resolve(Dictionary<string, GearEntry> table, IReadOnlyList<EquippedItem> worn, string speciesId, Action<string> log = null)
		{
			if (table == null || table.Count == 0 || worn == null || worn.Count == 0)
			{
				return GearEffects.None;
			}
			float num = 1f;
			float num2 = 1f;
			StatModifiers statModifiers = new StatModifiers();
			bool flag = false;
			foreach (GearEntry value in table.Values)
			{
				if (!MatchesWorn(value, worn, out var hit) || !SpeciesMatches(value.Species, speciesId))
				{
					continue;
				}
				flag = true;
				foreach (GearEffectDef effect in value.Effects)
				{
					switch (effect.Kind)
					{
					case GearEffectKind.LoyaltyGainMult:
						num *= effect.Value;
						break;
					case GearEffectKind.LoyaltyDecayMult:
						num2 *= effect.Value;
						break;
					case GearEffectKind.PetHealthMult:
						statModifiers.Health *= effect.Value;
						break;
					case GearEffectKind.PetDamageMult:
						statModifiers.Damage *= effect.Value;
						break;
					case GearEffectKind.PetDefenseMult:
						statModifiers.Defense *= effect.Value;
						break;
					case GearEffectKind.PetSpeedMult:
						statModifiers.Speed *= effect.Value;
						break;
					}
				}
				log?.Invoke($"{value.ItemKey} (slot {hit.Slot}) -> {Describe(value)}");
			}
			if (!flag)
			{
				return GearEffects.None;
			}
			return new GearEffects(num, num2, statModifiers);
		}

		private static bool MatchesWorn(GearEntry entry, IReadOnlyList<EquippedItem> worn, out EquippedItem hit)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < worn.Count; i++)
			{
				EquippedItem equippedItem = worn[i];
				ItemKey val = new ItemKey(entry.ItemKey, entry.ItemId);
				if (((ItemKey)(ref val)).Matches(equippedItem.ItemId, equippedItem.Name) && (entry.Slot == GearSlot.Any || entry.Slot == equippedItem.Slot))
				{
					hit = equippedItem;
					return true;
				}
			}
			hit = default(EquippedItem);
			return false;
		}

		public static bool SpeciesMatches(string filter, string speciesId)
		{
			return Species.NameMatches(speciesId, filter);
		}

		private static string Describe(GearEntry entry)
		{
			List<string> list = new List<string>();
			foreach (GearEffectDef effect in entry.Effects)
			{
				list.Add($"{effect.Kind} x{effect.Value:0.###}");
			}
			return string.Join(", ", list);
		}
	}
	public sealed class GiftDrop
	{
		public string Key;

		public int? ItemId;

		public int Qty = 1;

		public double Chance;

		public double ChanceAt100;
	}
	public sealed class PetGiftEntry
	{
		public string Species;

		public double NothingChance;

		public double NothingChanceAt100;

		public GiftDrop Default;

		public List<GiftDrop> Drops = new List<GiftDrop>();
	}
	public sealed class GiftMix
	{
		public double[] DropChances;

		public double DefaultChance;

		public double NothingChance;
	}
	public sealed class GiftAuditFinding
	{
		public bool Error;

		public string Message;
	}
	public static class PetGifts
	{
		public const string DefaultKey = "Default";

		private const double Epsilon = 1E-09;

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

		private static PetGiftEntry 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;
			}
			PetGiftEntry petGiftEntry = new PetGiftEntry
			{
				Species = speciesKey
			};
			bool flag = false;
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "default":
					petGiftEntry.Default = ParseDefault(f, item.Value);
					break;
				case "drops":
				{
					if (!f.Items("drops", item.Value, out List<object> result, "an ARRAY of drop objects"))
					{
						break;
					}
					foreach (object item2 in result)
					{
						GiftDrop giftDrop = ParseDrop(f, speciesKey, item2);
						if (giftDrop != null)
						{
							petGiftEntry.Drops.Add(giftDrop);
						}
					}
					break;
				}
				case "nothingchance":
					petGiftEntry.NothingChance = ReadChance(f, "nothingChance", item.Value, 0.0);
					break;
				case "nothingchanceat100":
					petGiftEntry.NothingChanceAt100 = ReadChance(f, "nothingChanceAt100", item.Value, 0.0);
					flag = true;
					break;
				default:
					f.Unknown(item.Key, "default, drops, nothingChance, nothingChanceAt100");
					break;
				}
			}
			if (!flag)
			{
				petGiftEntry.NothingChanceAt100 = petGiftEntry.NothingChance;
			}
			if (petGiftEntry.Default == null)
			{
				f.Say("missing required 'default' drop — species skipped.");
				return null;
			}
			foreach (GiftAuditFinding item3 in Audit(petGiftEntry))
			{
				f.Say(item3.Message);
			}
			return petGiftEntry;
		}

		private static GiftDrop ParseDefault(FieldReader f, object value)
		{
			if (value is Dictionary<string, object> dictionary)
			{
				GiftDrop giftDrop = new GiftDrop();
				foreach (KeyValuePair<string, object> item in dictionary)
				{
					string text = item.Key.ToLowerInvariant();
					if (!(text == "item"))
					{
						if (text == "qty")
						{
							giftDrop.Qty = ReadQty(f, "default", item.Value);
						}
						else
						{
							f.Say("unknown default key '" + item.Key + "' (valid: item, qty — the default's chance is computed, never authored).");
						}
					}
					else
					{
						ReadItem(f, "default", item.Value, giftDrop);
					}
				}
				if (giftDrop.Key == null)
				{
					f.Say("'default' object missing a usable 'item'.");
					return null;
				}
				return giftDrop;
			}
			GiftDrop giftDrop2 = new GiftDrop();
			if (!ReadItem(f, "default", value, giftDrop2))
			{
				return null;
			}
			return giftDrop2;
		}

		private static GiftDrop ParseDrop(FieldReader f, string speciesKey, object value)
		{
			if (!(value is Dictionary<string, object> dictionary))
			{
				f.Say("each drop must be an object — drop skipped.");
				return null;
			}
			GiftDrop giftDrop = new GiftDrop();
			bool flag = false;
			bool flag2 = false;
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				switch (item.Key.ToLowerInvariant())
				{
				case "item":
					ReadItem(f, "drop", item.Value, giftDrop);
					break;
				case "chance":
				{
					if (f.Num("chance", item.Value, out var result, null, "drop skipped"))
					{
						giftDrop.Chance = result;
						flag = true;
					}
					break;
				}
				case "chanceat100":
					giftDrop.ChanceAt100 = ReadChance(f, "chanceAt100", item.Value, 0.0);
					flag2 = true;
					break;
				case "qty":
					giftDrop.Qty = ReadQty(f, "drop", item.Value);
					break;
				default:
					f.Say("unknown drop key '" + item.Key + "' (valid: item, chance, chanceAt100, qty).");
					break;
				}
			}
			if (giftDrop.Key == null)
			{
				f.Say("drop missing required 'item' — drop skipped.");
				return null;
			}
			FieldReader fieldReader = new FieldReader("'" + speciesKey + "/" + giftDrop.Key + "'", f.Sink);
			if (!flag)
			{
				fieldReader.Say("drop missing required 'chance' — drop skipped.");
				return null;
			}
			if (!(giftDrop.Chance > 0.0) || giftDrop.Chance > 1.0)
			{
				fieldReader.Wrong("chance", "in (0,1]", "drop skipped");
				return null;
			}
			if (!flag2)
			{
				giftDrop.ChanceAt100 = giftDrop.Chance;
			}
			return giftDrop;
		}

		private static bool ReadItem(FieldReader f, string where, object value, GiftDrop drop)
		{
			ItemKey val = default(ItemKey);
			if (ItemKey.TryRead(value, ref val))
			{
				drop.Key = ((ItemKey)(ref val)).Key;
				drop.ItemId = ((ItemKey)(ref val)).ItemId;
				return true;
			}
			f.Say(where + " item must be a number or an item-name string.");
			return false;
		}

		private static double ReadChance(FieldReader f, string name, object value, double fallback)
		{
			if (f.Num(name, value, out var result, null, "using " + fallback.ToString("0.###", CultureInfo.InvariantCulture)))
			{
				if (result < 0.0 || result > 1.0)
				{
					f.Say("'" + name + "' " + result.ToString("0.###", CultureInfo.InvariantCulture) + " outside [0,1] — clamped.");
					if (!(result < 0.0))
					{
						return 1.0;
					}
					return 0.0;
				}
				return result;
			}
			return fallback;
		}

		private static int ReadQty(Fiel