using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Rinor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.8.0")]
[assembly: AssemblyInformationalVersion("0.2.8")]
[assembly: AssemblyProduct("Nornforged.Core")]
[assembly: AssemblyTitle("Nornforged.Core")]
[assembly: AssemblyVersion("0.2.8.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Nornforged.Core
{
	public static class ArsenalRegistry
	{
		public static readonly string[] Ids = new string[23]
		{
			"flanking_edge", "dueling_edge", "surrounded_edge", "relentless_edge", "grounded_impact", "martial_rhythm", "highground", "giant_hunter", "airborne_hunter", "steady_release",
			"pinning_shot", "shield_breath", "shield_mending", "shield_rebuke", "shield_composure", "parry_riposte", "wet_conduit", "cinder_hunter", "frozen_focus", "arcane_precision",
			"spell_repair", "sorcerers_breath", "soul_shelter"
		};

		public static void Add(List<PerkDefinition> target)
		{
			M("flanking_edge", "Flanking Edge", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct melee damage while behind the enemy, within the rear 120-degree arc.");
			M("dueling_edge", "Dueling Edge", PerkClass.Standard, 3.0, 220.0, "+{amount}% direct melee damage when the target is the only living hostile enemy within 6 m of you.");
			M("surrounded_edge", "Surrounded Edge", PerkClass.Special, 5.0, 420.0, "+{amount}% direct melee damage while at least 3 living hostile enemies are within 8 m of you.");
			M("relentless_edge", "Relentless Edge", PerkClass.Special, 5.0, 360.0, "+{amount}% direct melee damage against the same enemy you last dealt acknowledged direct damage to, within 3 s. This bonus does not stack with itself.");
			M("grounded_impact", "Grounded Impact", PerkClass.Standard, 5.0, 300.0, "+{amount}% native melee knockback against a grounded enemy; targets retain their native mass, resistance and knockback rules.", "attack,combat_damage,knockback");
			M("martial_rhythm", "Martial Rhythm", PerkClass.Ultra, 5.0, 85.0, "Every third paid manual melee attack that deals acknowledged direct enemy damage refunds {amount}% of that attack's actual stamina cost, capped at 85%. One count and refund per attack, even when it hits several enemies.", "direct_damage,attack_stamina");
			R("highground", "High Ground", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct projectile damage when its launch point is at least 3 m above the impact point.");
			R("giant_hunter", "Giant Hunter", PerkClass.Standard, 3.0, 270.0, "+{amount}% direct projectile damage against an enemy whose maximum health is at least 3 times yours.");
			R("airborne_hunter", "Airborne Hunter", PerkClass.Special, 5.0, 450.0, "+{amount}% direct projectile damage against an airborne enemy that is neither grounded nor swimming.");
			R("steady_release", "Steady Release", PerkClass.Special, 5.0, 330.0, "+{amount}% direct projectile damage while above 50% stamina and after at least 8 s without taking health damage; checked at impact.");
			R("pinning_shot", "Pinning Shot", PerkClass.Standard, 5.0, 240.0, "+{amount}% native stagger buildup from projectile hits at least 15 m from the launch point; no extra health damage.", "stagger_damage,projectile");
			C(S("shield_breath", "Shield Breath", PerkClass.Special, 5.0, 85.0, "A successful enemy block refunds {amount}% of stamina actually spent blocking, capped at 85%; {cooldown} s cooldown. The refund occurs after native block success is decided."), 1.0, 20.0);
			C(S("shield_mending", "Shield Mending", PerkClass.Special, 1.0, 60.0, "A successful enemy block restores {amount}% of this shield's missing durability; {cooldown} s cooldown.", "block,durability"), 3.0, 45.0);
			C(S("shield_rebuke", "Shield Rebuke", PerkClass.Ultra, 10.0, 600.0, "A successful enemy melee block deals frost damage equal to {amount}% of the physical and elemental damage actually blocked; {cooldown} s cooldown. Native frost resistance applies; no secondary triggers."), 2.0, 30.0);
			C(S("shield_composure", "Shield Composure", PerkClass.Standard, 5.0, 85.0, "A successful enemy projectile block shortens your remaining stamina-regeneration delay by {amount}%, capped at 85%; {cooldown} s cooldown."), 1.0, 15.0);
			C(S("parry_riposte", "Parry Riposte", PerkClass.Ultra, 15.0, 750.0, "A successful timed enemy shield block grants +{amount}% direct melee damage for 4 s; {cooldown} s cooldown. The same shield must remain equipped.", "block,parry"), 3.0, 35.0);
			E("wet_conduit", "Wet Conduit", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct spell damage against an enemy with the native Wet status before impact.");
			E("cinder_hunter", "Cinder Hunter", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct spell damage against an enemy already affected by native Burning before impact.");
			E("frozen_focus", "Frozen Focus", PerkClass.Special, 5.0, 360.0, "+{amount}% direct spell damage against an enemy already affected by the native Frost slow before impact.");
			E("arcane_precision", "Arcane Precision", PerkClass.Special, 5.0, 420.0, "+{amount}% direct spell damage while above 75% health and above 50% Eitr; checked at impact.", "direct_damage,eitr");
			C(E("spell_repair", "Spell Repair", PerkClass.Special, 1.0, 60.0, "Acknowledged direct enemy spell damage restores {amount}% of the attacking staff's missing durability; {cooldown} s cooldown.", "direct_damage,durability"), 3.0, 45.0);
			C(E("sorcerers_breath", "Sorcerer's Breath", PerkClass.Ultra, 5.0, 75.0, "A direct offensive-spell enemy kill restores {amount}% maximum stamina; {cooldown} s cooldown. Damage-over-time and secondary kills do not count."), 3.0, 40.0);
			C(E("soul_shelter", "Soul Shelter", PerkClass.Ultra, 5.0, 75.0, "A direct offensive-spell enemy kill grants a barrier worth {amount}% maximum health for 6 s; {cooldown} s cooldown. Barriers take the strongest remaining amount; damage-over-time and secondary kills do not count."), 5.0, 60.0);
			static void C(PerkDefinition p, double min, double max)
			{
				p.Parameters.Add(new PerkParameter
				{
					Id = "cooldown",
					Min = min,
					Max = max,
					Unit = "s",
					Precision = 3,
					HigherIsBetter = false
				});
			}
			PerkDefinition D(string id, string name, PerkClass cls, double min, double max, string trigger, string categories, string caps)
			{
				PerkDefinition perkDefinition = new PerkDefinition
				{
					Id = id,
					Name = name,
					Effect = id,
					Class = cls,
					Categories = categories.Split(',').ToList(),
					RequiredCapabilities = caps.Split(',').ToList(),
					Parameters = new List<PerkParameter>
					{
						new PerkParameter
						{
							Id = "amount",
							Min = min,
							Max = max,
							Precision = 3,
							Unit = "%"
						}
					},
					Trigger = trigger,
					Stacking = "Conditional damage bonuses add before one multiplier and keep separate actual-damage attribution. Item-only effects use the attacking weapon or the shield that actually blocked. Character-wide cooldowns survive equipment swaps.",
					SafetyLimits = "Enemy direct hits only; secondary and reflected hits cannot start bonuses or rewards. Resource refunds require confirmed damage or actual successful blocks. Native resistance, armor, blocking, ownership and resource maxima remain."
				};
				target.Add(perkDefinition);
				return perkDefinition;
			}
			PerkDefinition E(string id, string name, PerkClass cls, double min, double max, string text, string caps = "direct_damage")
			{
				return D(id, name, cls, min, max, text, "offensive_staff", caps);
			}
			PerkDefinition M(string id, string name, PerkClass cls, double min, double max, string text, string caps = "direct_damage")
			{
				return D(id, name, cls, min, max, text, "melee", caps);
			}
			PerkDefinition R(string id, string name, PerkClass cls, double min, double max, string text, string caps = "direct_damage,projectile")
			{
				return D(id, name, cls, min, max, text, "bow,crossbow", caps);
			}
			PerkDefinition S(string id, string name, PerkClass cls, double min, double max, string text, string caps = "block")
			{
				return D(id, name, cls, min, max, text, "shield", caps);
			}
		}
	}
	public static class Balance020
	{
		public const string Version = "0.2.0";

		public const int GameplayPrecision = 3;

		public static void Apply(IReadOnlyList<PerkDefinition> definitions)
		{
			Dictionary<string, (double, double)> dictionary = Ranges();
			int num = 0;
			foreach (PerkDefinition definition in definitions)
			{
				foreach (PerkParameter parameter in definition.Parameters)
				{
					string text = definition.Id + "." + parameter.Id;
					if (!dictionary.TryGetValue(text, out var value))
					{
						throw new InvalidOperationException("Missing reviewed 0.2.0 balance range: " + text);
					}
					parameter.Min = value.Item1;
					parameter.Max = value.Item2;
					parameter.Precision = 3;
					num++;
				}
			}
			if (num != dictionary.Count)
			{
				throw new InvalidOperationException("The 0.2.0 balance table contains an unused parameter range.");
			}
		}

		public static Dictionary<string, (double Min, double Max)> Ranges()
		{
			Dictionary<string, (double, double)> result = new Dictionary<string, (double, double)>(StringComparer.Ordinal);
			A("razor_edge", 1.0, 50.0);
			A("runic_potency", 1.0, 48.0);
			A("efficient_strikes", 1.0, 38.0);
			A("quickstrike", 0.5, 25.0);
			A("quick_draw", 1.0, 35.0);
			A("rapid_reload", 1.0, 35.0);
			A("steady_aim", 1.0, 38.0);
			A("eitr_efficiency", 0.5, 35.0);
			A("punishing_blows", 1.0, 55.0);
			A("crushing_force", 1.0, 50.0);
			A("duelists_guard", 1.0, 50.0);
			A("reinforced", 3.0, 220.0);
			A("lightweight", 1.0, 75.0);
			A("frostbound", 0.5, 28.0);
			A("emberbound", 0.5, 28.0);
			A("resource_breaker", 1.0, 65.0);
			A("efficient_labor", 1.0, 38.0);
			A("swift_labor", 0.5, 30.0);
			A("resource_magnet", 2.0, 180.0);
			A("extended_reach", 1.0, 55.0);
			A("haulers_strength", 1.0, 35.0);
			A("builders_reach", 1.0, 70.0);
			A("green_hands", 1.0, 45.0);
			A("patient_angler", 1.0, 45.0);
			A("long_cast", 1.0, 55.0);
			A("fortified", 0.5, 30.0);
			A("vitality", 0.5, 22.0);
			A("endurance", 0.5, 25.0);
			A("runic_reservoir", 1.0, 30.0);
			A("recovery", 1.0, 50.0);
			A("second_wind", 1.0, 50.0);
			A("runic_flow", 1.0, 50.0);
			A("fleetfoot", 0.25, 12.0);
			A("tireless", 1.0, 32.0);
			A("nimble", 1.0, 32.0);
			A("springstep", 1.0, 32.0);
			A("riverstride", 1.0, 32.0);
			A("quiet_steps", 1.0, 32.0);
			string[] array = new string[8] { "fire", "frost", "lightning", "poison", "spirit", "blunt", "slash", "pierce" };
			foreach (string text in array)
			{
				A("ward_" + text, 0.5, (text == "fire" || text == "frost") ? 20 : 16);
			}
			A("soft_landing", 2.0, 75.0);
			A("efficient_guard", 1.0, 38.0);
			A("firm_grip", 1.0, 60.0);
			A("stormspark", 5.0, 100.0);
			C("stormspark", 3.0, 24.0);
			A("executioner", 3.0, 65.0);
			A("runic_reserve", 3.0, 65.0);
			A("veinbreaker", 10.0, 220.0);
			A("natures_favor", 1.0, 65.0);
			A("master_repair", 1.0, 9.0);
			C("master_repair", 1.0, 20.0);
			A("emergency_ward", 2.0, 35.0);
			C("emergency_ward", 20.0, 240.0);
			A("windstep", 1.0, 30.0);
			C("windstep", 3.0, 45.0);
			A("runic_guard", 2.0, 30.0);
			C("runic_guard", 5.0, 90.0);
			A("second_breath", 2.0, 35.0);
			C("second_breath", 15.0, 180.0);
			A("calm_heart", 3.0, 70.0);
			A("patient_recovery", 3.0, 70.0);
			A("deep_breath", 3.0, 70.0);
			A("steady_foothold", 3.0, 60.0);
			C("steady_foothold", 4.0, 75.0);
			A("travelers_vigor", 3.0, 60.0);
			A("thors_judgment", 20.0, 650.0);
			C("thors_judgment", 2.5, 40.0);
			A("fenrirs_hunger", 0.5, 18.0);
			A("fatebreaker", 10.0, 550.0);
			P("fatebreaker", "boss", 3.0, 200.0);
			C("fatebreaker", 2.0, 60.0);
			A("phantom_strike", 10.0, 500.0);
			P("phantom_strike", "chance", 2.0, 65.0);
			C("phantom_strike", 1.0, 35.0);
			A("winter_sovereign", 15.0, 600.0);
			C("winter_sovereign", 3.0, 65.0);
			A("runic_echo", 10.0, 450.0);
			C("runic_echo", 2.0, 50.0);
			A("ymirs_awakening", 50.0, 900.0);
			C("ymirs_awakening", 3.0, 75.0);
			A("earths_bounty", 5.0, 225.0);
			A("eternal_temper", 25.0, 99.0);
			A("tireless_creator", 5.0, 95.0);
			P("tireless_creator", "chance", 2.0, 80.0);
			A("runic_momentum", 2.0, 80.0);
			C("runic_momentum", 3.0, 75.0);
			A("worldsmith", 2.0, 20.0);
			C("worldsmith", 1.0, 45.0);
			A("freyrs_garden", 5.0, 80.0);
			A("aegirs_favor", 2.0, 90.0);
			A("yggdrasils_shelter", 5.0, 90.0);
			C("yggdrasils_shelter", 10.0, 240.0);
			A("bifrost_stride", 3.0, 60.0);
			P("bifrost_stride", "reduction", 5.0, 85.0);
			C("bifrost_stride", 1.0, 45.0);
			A("einherjars_return", 5.0, 90.0);
			C("einherjars_return", 600.0, 3600.0);
			A("heimdalls_bastion", 5.0, 90.0);
			C("heimdalls_bastion", 5.0, 120.0);
			A("guardians_wrath", 10.0, 450.0);
			C("guardians_wrath", 1.5, 40.0);
			A("runic_rebound", 10.0, 500.0);
			C("runic_rebound", 2.0, 60.0);
			A("fates_renewal", 5.0, 90.0);
			C("fates_renewal", 5.0, 120.0);
			A("ancient_resolve", 2.0, 70.0);
			C("ancient_resolve", 5.0, 120.0);
			A("travelers_mercy", 0.2, 3.0);
			C("travelers_mercy", 0.75, 60.0);
			A("norns_respite", 5.0, 350.0);
			A("undying_tenacity", 2.0, 70.0);
			A("dulled", 1.0, 32.0);
			A("faded_runes", 1.0, 32.0);
			A("exhausting", 1.0, 35.0);
			A("sluggish", 0.25, 15.0);
			A("brittle", 3.0, 65.0);
			A("heavy", 2.0, 100.0);
			A("restrictive", 0.25, 8.0);
			A("poor_guard", 1.0, 35.0);
			A("thin_plating", 1.0, 25.0);
			A("draining", 0.25, 15.0);
			A("frail", 0.25, 15.0);
			A("tiring", 1.0, 25.0);
			A("unbalanced", 1.0, 45.0);
			A("short_reach", 1.0, 30.0);
			A("slow_mending", 1.0, 25.0);
			A("burdened", 1.0, 25.0);
			A("vulnerable", 0.5, 18.0);
			A("runic_leak", 1.0, 35.0);
			return result;
			void A(string id, double min, double max)
			{
				result.Add(id + ".amount", (min, max));
			}
			void C(string id, double min, double max)
			{
				P(id, "cooldown", min, max);
			}
			void P(string id, string parameter, double min, double max)
			{
				result.Add(id + "." + parameter, (min, max));
			}
		}
	}
	public static class Balance021
	{
		public const string Version = "0.2.1";

		public const int GameplayPrecision = 3;

		private static readonly HashSet<string> HighRankParameters;

		static Balance021()
		{
			HighRankParameters = new HashSet<string>(StringComparer.Ordinal);
			string[] array = "razor_edge,runic_potency,punishing_blows,crushing_force,duelists_guard,reinforced,frostbound,emberbound,resource_breaker,extended_reach,haulers_strength,builders_reach,long_cast,fortified,vitality,endurance,runic_reservoir,recovery,second_wind,runic_flow,stormspark,executioner,veinbreaker,emergency_ward,runic_guard,calm_heart,patient_recovery,deep_breath,travelers_vigor,thors_judgment,fatebreaker,phantom_strike,winter_sovereign,runic_echo,ymirs_awakening,yggdrasils_shelter,heimdalls_bastion,guardians_wrath,runic_rebound,norns_respite,work_breath,work_reserve,steady_supplies,breath_of_hearth,guard_focus,storm_step,opening_cut,desperate_edge,farshot,point_blank,ambushers_edge,retaliation_edge,guardbreaker,spellbattery,followthrough,tyrs_measure,bloodstar,flanking_edge,dueling_edge,surrounded_edge,relentless_edge,grounded_impact,highground,giant_hunter,airborne_hunter,steady_release,pinning_shot,shield_rebuke,parry_riposte,wet_conduit,cinder_hunter,frozen_focus,arcane_precision,soul_shelter".Split(',');
			foreach (string text in array)
			{
				HighRankParameters.Add(text + ".amount");
			}
			HighRankParameters.Add("fatebreaker.boss");
		}

		public static bool AllowsHighRankMaximum(string definitionId, string parameterId)
		{
			return HighRankParameters.Contains(definitionId + "." + parameterId);
		}

		public static void Apply(IReadOnlyList<PerkDefinition> definitions)
		{
			Dictionary<string, double> dictionary = ReviewedMaxima();
			int num = 0;
			foreach (PerkDefinition definition in definitions)
			{
				foreach (PerkParameter parameter in definition.Parameters)
				{
					if (dictionary.TryGetValue(definition.Id + "." + parameter.Id, out var value))
					{
						if (parameter.Unit != "%" || value < parameter.Max)
						{
							throw new InvalidOperationException("Invalid reviewed 0.2.1 percentage maximum: " + definition.Id + "." + parameter.Id);
						}
						parameter.Max = value;
						num++;
					}
					parameter.Precision = 3;
					if (AllowsHighRankMaximum(definition.Id, parameter.Id))
					{
						if (definition.Class == PerkClass.Negative || parameter.Unit != "%" || !parameter.HigherIsBetter)
						{
							throw new InvalidOperationException("Invalid high-rank percentage contract: " + definition.Id + "." + parameter.Id);
						}
						parameter.HighRankMaxima = new Dictionary<int, double>
						{
							[9] = parameter.Max * 1.5,
							[10] = parameter.Max * 2.0,
							[11] = parameter.Max * 2.5,
							[12] = parameter.Max * 3.0
						};
					}
				}
			}
			if (num != dictionary.Count)
			{
				throw new InvalidOperationException("The 0.2.1 balance table contains an unused parameter maximum.");
			}
		}

		public static Dictionary<string, double> ReviewedMaxima()
		{
			return new Dictionary<string, double>(StringComparer.Ordinal)
			{
				["razor_edge.amount"] = 150.0,
				["runic_potency.amount"] = 144.0,
				["efficient_strikes.amount"] = 85.0,
				["quickstrike.amount"] = 75.0,
				["quick_draw.amount"] = 90.0,
				["rapid_reload.amount"] = 85.0,
				["steady_aim.amount"] = 85.0,
				["eitr_efficiency.amount"] = 85.0,
				["punishing_blows.amount"] = 165.0,
				["crushing_force.amount"] = 150.0,
				["duelists_guard.amount"] = 150.0,
				["reinforced.amount"] = 660.0,
				["lightweight.amount"] = 80.0,
				["frostbound.amount"] = 84.0,
				["emberbound.amount"] = 84.0,
				["resource_breaker.amount"] = 195.0,
				["efficient_labor.amount"] = 85.0,
				["swift_labor.amount"] = 90.0,
				["resource_magnet.amount"] = 540.0,
				["extended_reach.amount"] = 165.0,
				["haulers_strength.amount"] = 105.0,
				["builders_reach.amount"] = 210.0,
				["green_hands.amount"] = 85.0,
				["patient_angler.amount"] = 85.0,
				["long_cast.amount"] = 165.0,
				["fortified.amount"] = 90.0,
				["vitality.amount"] = 66.0,
				["endurance.amount"] = 75.0,
				["runic_reservoir.amount"] = 90.0,
				["recovery.amount"] = 150.0,
				["second_wind.amount"] = 150.0,
				["runic_flow.amount"] = 150.0,
				["fleetfoot.amount"] = 36.0,
				["tireless.amount"] = 85.0,
				["nimble.amount"] = 85.0,
				["springstep.amount"] = 85.0,
				["riverstride.amount"] = 85.0,
				["quiet_steps.amount"] = 85.0,
				["ward_fire.amount"] = 60.0,
				["ward_frost.amount"] = 60.0,
				["ward_lightning.amount"] = 48.0,
				["ward_poison.amount"] = 48.0,
				["ward_spirit.amount"] = 48.0,
				["ward_blunt.amount"] = 48.0,
				["ward_slash.amount"] = 48.0,
				["ward_pierce.amount"] = 48.0,
				["soft_landing.amount"] = 85.0,
				["efficient_guard.amount"] = 85.0,
				["firm_grip.amount"] = 80.0,
				["stormspark.amount"] = 300.0,
				["executioner.amount"] = 195.0,
				["runic_reserve.amount"] = 100.0,
				["veinbreaker.amount"] = 660.0,
				["natures_favor.amount"] = 195.0,
				["emergency_ward.amount"] = 105.0,
				["windstep.amount"] = 65.0,
				["runic_guard.amount"] = 90.0,
				["second_breath.amount"] = 100.0,
				["calm_heart.amount"] = 210.0,
				["patient_recovery.amount"] = 210.0,
				["deep_breath.amount"] = 210.0,
				["steady_foothold.amount"] = 75.0,
				["travelers_vigor.amount"] = 180.0,
				["thors_judgment.amount"] = 1950.0,
				["fenrirs_hunger.amount"] = 54.0,
				["fatebreaker.amount"] = 1650.0,
				["fatebreaker.boss"] = 600.0,
				["phantom_strike.amount"] = 1500.0,
				["phantom_strike.chance"] = 99.0,
				["winter_sovereign.amount"] = 1800.0,
				["runic_echo.amount"] = 1350.0,
				["ymirs_awakening.amount"] = 2700.0,
				["earths_bounty.amount"] = 250.0,
				["eternal_temper.amount"] = 99.0,
				["tireless_creator.amount"] = 100.0,
				["tireless_creator.chance"] = 99.0,
				["runic_momentum.amount"] = 90.0,
				["freyrs_garden.amount"] = 85.0,
				["aegirs_favor.amount"] = 99.0,
				["yggdrasils_shelter.amount"] = 270.0,
				["bifrost_stride.amount"] = 65.0,
				["bifrost_stride.reduction"] = 85.0,
				["einherjars_return.amount"] = 100.0,
				["heimdalls_bastion.amount"] = 270.0,
				["guardians_wrath.amount"] = 1350.0,
				["runic_rebound.amount"] = 1500.0,
				["fates_renewal.amount"] = 100.0,
				["ancient_resolve.amount"] = 75.0,
				["travelers_mercy.amount"] = 3.0,
				["norns_respite.amount"] = 1050.0,
				["undying_tenacity.amount"] = 75.0,
				["dulled.amount"] = 64.0,
				["faded_runes.amount"] = 64.0,
				["exhausting.amount"] = 70.0,
				["sluggish.amount"] = 30.0,
				["brittle.amount"] = 80.0,
				["heavy.amount"] = 200.0,
				["restrictive.amount"] = 16.0,
				["poor_guard.amount"] = 70.0,
				["thin_plating.amount"] = 50.0,
				["draining.amount"] = 30.0,
				["frail.amount"] = 30.0,
				["tiring.amount"] = 50.0,
				["unbalanced.amount"] = 90.0,
				["short_reach.amount"] = 60.0,
				["slow_mending.amount"] = 50.0,
				["burdened.amount"] = 50.0,
				["vulnerable.amount"] = 36.0,
				["runic_leak.amount"] = 70.0,
				["work_stride.amount"] = 54.0,
				["work_breath.amount"] = 180.0,
				["work_reserve.amount"] = 90.0,
				["pack_frame.amount"] = 75.0,
				["work_recovery.amount"] = 85.0,
				["tool_grace.amount"] = 85.0,
				["tool_care.amount"] = 80.0,
				["supply_sense.amount"] = 600.0,
				["measured_work.amount"] = 85.0,
				["rhythmic_work.amount"] = 100.0,
				["craftsman_trance.amount"] = 85.0,
				["field_second_wind.amount"] = 100.0,
				["steady_supplies.amount"] = 360.0,
				["repairing_touch.amount"] = 54.0,
				["rough_care.amount"] = 130.0,
				["fumbling.amount"] = 120.0,
				["short_breath.amount"] = 50.0,
				["overpacked.amount"] = 50.0,
				["muffled_steps.amount"] = 80.0,
				["shadowweave.amount"] = 75.0,
				["featherbound.amount"] = 150.0,
				["slow_feast.amount"] = 100.0,
				["rain_shedding.amount"] = 85.0,
				["camp_memory.amount"] = 100.0,
				["measured_parry.amount"] = 80.0,
				["longstride.amount"] = 85.0,
				["rainwalker.amount"] = 65.0,
				["anchor_stance.amount"] = 85.0,
				["breath_of_hearth.amount"] = 480.0,
				["guard_focus.amount"] = 480.0,
				["skyward_leap.amount"] = 150.0,
				["oathkeepers_reserve.amount"] = 240.0,
				["storm_step.amount"] = 900.0,
				["valkyrie_poise.amount"] = 85.0,
				["opening_cut.amount"] = 195.0,
				["desperate_edge.amount"] = 210.0,
				["farshot.amount"] = 225.0,
				["point_blank.amount"] = 150.0,
				["ambushers_edge.amount"] = 180.0,
				["retaliation_edge.amount"] = 360.0,
				["guardbreaker.amount"] = 300.0,
				["spellbattery.amount"] = 300.0,
				["followthrough.amount"] = 360.0,
				["tyrs_measure.amount"] = 1500.0,
				["bloodstar.amount"] = 750.0,
				["runesurge.amount"] = 100.0,
				["quiet_construction.amount"] = 80.0,
				["careful_demolition.amount"] = 85.0,
				["leveling_focus.amount"] = 85.0,
				["raising_focus.amount"] = 85.0,
				["seed_focus.amount"] = 85.0,
				["cultivation_focus.amount"] = 85.0,
				["luring_glimmer.amount"] = 150.0,
				["hook_window.amount"] = 200.0,
				["bait_keeper.amount"] = 99.0,
				["restoration_reserve.amount"] = 100.0,
				["fortress_oath.amount"] = 75.0,
				["weatherseal.amount"] = 95.0,
				["artisan_renewal.amount"] = 100.0,
				["verdant_clock.amount"] = 85.0,
				["deep_roots.amount"] = 35.0,
				["harvest_moon.amount"] = 80.0,
				["unbroken_line.amount"] = 250.0,
				["stillwater_pact.amount"] = 85.0,
				["tidal_memory.amount"] = 100.0,
				["hooked_fortune.amount"] = 99.0,
				["earthshaper.amount"] = 180.0,
				["stoneweaver.amount"] = 250.0,
				["pathfinder.amount"] = 250.0,
				["terraced_wisdom.amount"] = 180.0
			};
		}
	}
	public static class CompactPerkDescriptions
	{
		private static readonly IReadOnlyDictionary<string, string> Templates = CreateTemplates();

		public static string Template(PerkDefinition def)
		{
			if (def == null)
			{
				throw new ArgumentNullException("def");
			}
			if (def.DefinitionVersion != 1 || !Templates.TryGetValue(def.Id, out string value))
			{
				return def.Trigger;
			}
			return value;
		}

		private static IReadOnlyDictionary<string, string> CreateTemplates()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal)
			{
				["razor_edge"] = "+{amount}% physical damage",
				["runic_potency"] = "+{amount}% existing elemental damage",
				["efficient_strikes"] = "-{amount}% attack stamina cost",
				["quickstrike"] = "+{amount}% melee attack speed",
				["quick_draw"] = "+{amount}% bow draw speed",
				["rapid_reload"] = "-{amount}% crossbow reload time",
				["steady_aim"] = "-{amount}% aiming stamina cost",
				["eitr_efficiency"] = "-{amount}% Eitr cost",
				["punishing_blows"] = "+{amount}% direct damage vs staggered enemies",
				["crushing_force"] = "+{amount}% direct-hit stagger",
				["duelists_guard"] = "+{amount}% block power",
				["reinforced"] = "+{amount}% max durability",
				["lightweight"] = "-{amount}% item weight",
				["frostbound"] = "+{amount}% base damage as Frost",
				["emberbound"] = "+{amount}% base damage as Fire",
				["resource_breaker"] = "+{amount}% gathering damage",
				["efficient_labor"] = "-{amount}% work stamina cost",
				["swift_labor"] = "+{amount}% work, build and reel speed",
				["resource_magnet"] = "+{amount}% wood/stone/ore pickup radius while held",
				["extended_reach"] = "+{amount}% tool reach",
				["haulers_strength"] = "+{amount}% base carry capacity",
				["builders_reach"] = "+{amount}% build/repair reach",
				["green_hands"] = "-{amount}% planting stamina cost",
				["patient_angler"] = "-{amount}% reeling stamina cost",
				["long_cast"] = "+{amount}% cast distance and line length",
				["fortified"] = "+{amount}% Armor",
				["vitality"] = "+{amount}% max HP from base + food",
				["endurance"] = "+{amount}% max stamina from base + food",
				["runic_reservoir"] = "+{amount}% existing food Eitr",
				["recovery"] = "+{amount}% HP regen",
				["second_wind"] = "+{amount}% stamina regen",
				["runic_flow"] = "+{amount}% Eitr regen",
				["fleetfoot"] = "+{amount}% walk/run speed",
				["tireless"] = "-{amount}% sprint stamina cost",
				["nimble"] = "-{amount}% dodge stamina cost",
				["springstep"] = "-{amount}% jump stamina cost",
				["riverstride"] = "-{amount}% swim stamina cost",
				["quiet_steps"] = "-{amount}% sneak stamina cost",
				["soft_landing"] = "-{amount}% fall damage",
				["efficient_guard"] = "-{amount}% block stamina cost",
				["firm_grip"] = "-{amount}% knockback taken while blocking",
				["stormspark"] = "Direct hit: chain {amount}% damage to 1 enemy within 8m; CD {cooldown}s",
				["executioner"] = "+{amount}% direct damage vs enemies below 20% HP",
				["runic_reserve"] = "Every 5th manual spell: refund {amount}% Eitr spent",
				["veinbreaker"] = "Every 6th gather hit: +{amount}% gathering damage",
				["natures_favor"] = "+{amount}% average natural-resource yield on first drops",
				["master_repair"] = "Repair up to 3 owned pieces within {amount}m; CD {cooldown}s",
				["emergency_ward"] = "Hit leaves HP below 30%: {amount}% max-HP barrier for 4s; CD {cooldown}s",
				["windstep"] = "Dodge: +{amount}% movement for 2s; CD {cooldown}s",
				["runic_guard"] = "Block: {amount}% max-HP barrier for 4s; CD {cooldown}s",
				["second_breath"] = "Below 20% stamina: restore {amount}% max stamina; CD {cooldown}s",
				["calm_heart"] = "8s unharmed: +{amount}% HP regen",
				["patient_recovery"] = "Below 50% HP: +{amount}% HP regen",
				["deep_breath"] = "Below 40% stamina: +{amount}% stamina regen",
				["steady_foothold"] = "Taking damage: -{amount}% stagger taken for 4s; CD {cooldown}s",
				["travelers_vigor"] = "Above 80% HP: +{amount}% stamina regen",
				["thors_judgment"] = "Every 6th direct hit: {amount}% lightning damage, up to 3 enemies/8m; CD {cooldown}s",
				["fenrirs_hunger"] = "Heal {amount}% of direct damage dealt; shared cap 3% max HP/s",
				["fatebreaker"] = "+{amount}% direct damage vs enemies below 30% HP (bosses +{boss}%); CD {cooldown}s",
				["phantom_strike"] = "Direct hit: {chance}% chance of {amount}% extra damage; CD {cooldown}s",
				["winter_sovereign"] = "Every 8th direct hit: {amount}% frost damage in 5m; CD {cooldown}s",
				["runic_echo"] = "Every 4th manual offensive cast: repeat {amount}% direct damage; CD {cooldown}s",
				["ymirs_awakening"] = "Every 8th gather hit: {amount}% gathering damage in 3m; CD {cooldown}s",
				["earths_bounty"] = "+{amount}% average natural-resource yield on first drops",
				["eternal_temper"] = "{amount}% chance to avoid durability loss",
				["tireless_creator"] = "Successful work: {chance}% chance to refund {amount}% stamina spent",
				["runic_momentum"] = "Every 5th successful work action: +{amount}% work speed for 6s; CD {cooldown}s",
				["worldsmith"] = "Repair up to 10 owned pieces within {amount}m; CD {cooldown}s",
				["freyrs_garden"] = "Left Shift: plant 3x3, -{amount}% total stamina cost; needs all seeds",
				["aegirs_favor"] = "Catch: {amount}% chance of 1 extra matching fish",
				["yggdrasils_shelter"] = "Hit leaves HP below 35%: {amount}% max-HP barrier for 6s; CD {cooldown}s",
				["bifrost_stride"] = "Dodge: +{amount}% movement for 3s, next dodge cost -{reduction}%; CD {cooldown}s",
				["einherjars_return"] = "Survive lethal hit at {amount}% max HP + 2s protection; shared CD {cooldown}s",
				["heimdalls_bastion"] = "3 blocks in 5s: {amount}% max-HP barrier for 6s; CD {cooldown}s",
				["guardians_wrath"] = "Block: next direct melee hit within 3s deals +{amount}%; CD {cooldown}s",
				["runic_rebound"] = "Block enemy projectile: reflect {amount}% incoming damage; CD {cooldown}s",
				["fates_renewal"] = "Below 15% stamina: restore {amount}% max stamina; CD {cooldown}s",
				["ancient_resolve"] = "Taking damage: -{amount}% damage taken for 4s; CD {cooldown}s",
				["travelers_mercy"] = "Dodge: heal {amount}% max HP (shared cap 3%/s); CD {cooldown}s",
				["norns_respite"] = "12s unharmed: +{amount}% HP regen",
				["undying_tenacity"] = "Below 30% HP: -{amount}% stagger taken",
				["dulled"] = "-{amount}% physical/gathering damage",
				["faded_runes"] = "-{amount}% existing elemental spell damage",
				["exhausting"] = "+{amount}% stamina costs",
				["sluggish"] = "-{amount}% attack/work animation speed",
				["brittle"] = "-{amount}% max durability",
				["heavy"] = "+{amount}% item weight",
				["restrictive"] = "-{amount}% movement speed",
				["poor_guard"] = "-{amount}% block power",
				["thin_plating"] = "-{amount}% Armor",
				["draining"] = "-{amount}% max stamina from base + food",
				["frail"] = "-{amount}% max HP from base + food",
				["tiring"] = "-{amount}% stamina regen",
				["unbalanced"] = "+{amount}% knockback taken",
				["short_reach"] = "-{amount}% tool reach",
				["slow_mending"] = "-{amount}% HP regen",
				["burdened"] = "-{amount}% base carry capacity",
				["vulnerable"] = "+{amount}% physical damage taken after resistance",
				["runic_leak"] = "+{amount}% Eitr costs",
				["work_stride"] = "Successful work: +{amount}% movement for 8s with same tool",
				["work_breath"] = "Successful work: +{amount}% stamina regen for 8s with same tool",
				["work_reserve"] = "+{amount}% max stamina from base + food while held",
				["pack_frame"] = "-{amount}% materials/seed/bait/fish weight while held",
				["work_recovery"] = "Successful work: -{amount}% remaining stamina regen delay",
				["tool_grace"] = "-{amount}% tool equip/sheathe time",
				["tool_care"] = "-{amount}% tool durability loss",
				["supply_sense"] = "+{amount}% materials/seed/bait/fish pickup radius while held",
				["measured_work"] = "After 3 work successes: -{amount}% work cost; resets on swap/10s idle",
				["rhythmic_work"] = "Every 3rd work success: refund {amount}% stamina spent",
				["craftsman_trance"] = "Every 6th work success: next 3 work costs -{amount}%; CD {cooldown}s; reset on swap/10s idle",
				["field_second_wind"] = "Every 8th work success: restore {amount}% max stamina; CD {cooldown}s",
				["steady_supplies"] = "Every 8th work success: +{amount}% carry capacity for 12s with same tool; CD {cooldown}s",
				["repairing_touch"] = "Every 10th work success: repair {amount}% missing tool durability; CD {cooldown}s",
				["tool_courier"] = "Every 8th work success: pull up to 24 supplies within {amount}m; CD {cooldown}s",
				["rough_care"] = "+{amount}% tool durability loss",
				["fumbling"] = "+{amount}% tool equip/sheathe time",
				["short_breath"] = "Successful work: -{amount}% stamina regen for 8s with same tool",
				["overpacked"] = "+{amount}% materials/seed/bait/fish weight while held",
				["muffled_steps"] = "-{amount}% noise radius (80% cap)",
				["shadowweave"] = "-{amount}% visibility while sneaking (75% cap)",
				["featherbound"] = "+{amount}% jump height (150% cap)",
				["slow_feast"] = "+{amount}% food duration (100% cap)",
				["rain_shedding"] = "-{amount}% Wet duration (85% cap)",
				["camp_memory"] = "+{amount}% next Rested duration (100% cap)",
				["measured_parry"] = "+{amount}% shield parry bonus (80% cap)",
				["longstride"] = "Running for 4s: -{amount}% jump stamina cost",
				["rainwalker"] = "While Wet: +{amount}% movement speed",
				["anchor_stance"] = "After blocking still for 1.5s: -{amount}% block cost",
				["breath_of_hearth"] = "While Resting: +{amount}% HP regen",
				["guard_focus"] = "Block: +{amount}% stamina regen for 6s; CD {cooldown}s",
				["skyward_leap"] = "1 extra jump/landing, +{amount}% height (150% cap); stamina required; CD {cooldown}s",
				["oathkeepers_reserve"] = "Block: gain {amount}% blocked damage as stamina (15% max-stamina cap); CD {cooldown}s",
				["storm_step"] = "Dodge: +{amount}% stamina regen for 4s; CD {cooldown}s",
				["valkyrie_poise"] = "-{amount}% fall damage; 30% prevented damage to stamina (20% max cap); refund CD {cooldown}s",
				["opening_cut"] = "+{amount}% direct damage vs targets above 90% HP",
				["desperate_edge"] = "Below 25% stamina: +{amount}% direct damage",
				["farshot"] = "+{amount}% direct projectile damage at 15m+ from launch",
				["point_blank"] = "+{amount}% direct projectile damage within 5m of launch",
				["ambushers_edge"] = "+{amount}% direct damage vs unalerted enemies",
				["retaliation_edge"] = "After taking HP damage: +{amount}% direct damage for 4s",
				["guardbreaker"] = "+{amount}% direct damage vs blocking humanoids",
				["spellbattery"] = "Above 80% Eitr: +{amount}% direct spell damage",
				["followthrough"] = "Direct hit: next direct hit on a different enemy within 3s deals +{amount}%",
				["tyrs_measure"] = "Below 50% HP: +{amount}% direct boss damage; CD {cooldown}s",
				["bloodstar"] = "Direct enemy kill: +{amount}% direct damage for 6s; no buffed-kill refresh; CD {cooldown}s",
				["runesurge"] = "Direct spell hit: refund {amount}% Eitr spent (20% max Eitr/cast cap); CD {cooldown}s",
				["quiet_construction"] = "-{amount}% build/repair/demolition noise",
				["careful_demolition"] = "-{amount}% successful demolition stamina cost",
				["leveling_focus"] = "-{amount}% level-ground stamina cost",
				["raising_focus"] = "-{amount}% raise-ground stamina cost",
				["seed_focus"] = "-{amount}% planting stamina cost",
				["cultivation_focus"] = "-{amount}% cultivation stamina cost",
				["luring_glimmer"] = "+{amount}% fish attraction radius; correct bait required",
				["hook_window"] = "+{amount}% manual hook window (base 0.5s); correct bait",
				["bait_keeper"] = "Catch: {amount}% chance to return 1 bait used",
				["restoration_reserve"] = "Manual repair: restore {amount}% max stamina; CD {cooldown}s",
				["fortress_oath"] = "New owned pieces take {amount}% less hit damage (75% cap)",
				["weatherseal"] = "New owned pieces take {amount}% less weather damage; need support",
				["artisan_renewal"] = "Manual repair: restore {amount}% missing hammer durability; CD {cooldown}s",
				["verdant_clock"] = "New plants: -{amount}% growth time (85% cap); normal growing conditions",
				["deep_roots"] = "New plants: -{amount}% spacing radius (35% cap); normal growing conditions",
				["harvest_moon"] = "Plant: advance up to 6 nearby owned healthy plants by {amount}% base growth; CD {cooldown}s",
				["unbroken_line"] = "+{amount}% line stretch before breaking",
				["stillwater_pact"] = "Hooked fish struggling: -{amount}% fishing stamina cost",
				["tidal_memory"] = "Catch: restore {amount}% max stamina; CD {cooldown}s",
				["hooked_fortune"] = "Correct-bait nibble: {amount}% auto-hook chance; reel normally; CD {cooldown}s",
				["earthshaper"] = "+{amount}% level-ground radius (8m cap); whole area needs permission",
				["stoneweaver"] = "+{amount}% height per paid raise-ground action; native terrain limits",
				["pathfinder"] = "+{amount}% paint-ground radius (8m cap); whole area needs permission",
				["terraced_wisdom"] = "+{amount}% smoothing radius (8m cap); whole area needs permission",
				["flanking_edge"] = "+{amount}% direct melee damage from rear 120-degree arc",
				["dueling_edge"] = "+{amount}% direct melee damage vs sole enemy within 6m",
				["surrounded_edge"] = "3+ enemies within 8m: +{amount}% direct melee damage",
				["relentless_edge"] = "+{amount}% direct melee damage vs last directly hit enemy for 3s; no stacking",
				["grounded_impact"] = "+{amount}% melee knockback vs grounded enemies",
				["martial_rhythm"] = "Every 3rd paid melee attack with direct damage: refund {amount}% stamina spent (85% cap)",
				["highground"] = "+{amount}% direct projectile damage launched 3m+ above impact",
				["giant_hunter"] = "+{amount}% direct projectile damage vs enemies with 3x your max HP",
				["airborne_hunter"] = "+{amount}% direct projectile damage vs airborne enemies; not swimmers",
				["steady_release"] = "At impact: above 50% stamina + 8s unharmed, +{amount}% direct projectile damage",
				["pinning_shot"] = "+{amount}% projectile stagger at 15m+ from launch; no extra HP damage",
				["shield_breath"] = "Enemy block: refund {amount}% block stamina spent (85% cap); CD {cooldown}s",
				["shield_mending"] = "Enemy block: repair {amount}% missing shield durability; CD {cooldown}s",
				["shield_rebuke"] = "Enemy melee block: return {amount}% blocked damage as Frost; CD {cooldown}s",
				["shield_composure"] = "Enemy projectile block: -{amount}% stamina regen delay (85% cap); CD {cooldown}s",
				["parry_riposte"] = "Parry: +{amount}% direct melee damage for 4s with same shield; CD {cooldown}s",
				["wet_conduit"] = "+{amount}% direct spell damage vs Wet enemies",
				["cinder_hunter"] = "+{amount}% direct spell damage vs Burning enemies",
				["frozen_focus"] = "+{amount}% direct spell damage vs Frost-slowed enemies",
				["arcane_precision"] = "At impact: above 75% HP + 50% Eitr, +{amount}% direct spell damage",
				["spell_repair"] = "Direct spell hit: repair {amount}% missing staff durability; CD {cooldown}s",
				["sorcerers_breath"] = "Direct spell kill: restore {amount}% max stamina; no DOT/procs; CD {cooldown}s",
				["soul_shelter"] = "Direct spell kill: {amount}% max-HP barrier for 6s, strongest only; no DOT/procs; CD {cooldown}s"
			};
			string[] array = new string[8] { "fire", "frost", "lightning", "poison", "spirit", "blunt", "slash", "pierce" };
			foreach (string text in array)
			{
				dictionary.Add("ward_" + text, "-{amount}% incoming " + text + " damage after resistance");
			}
			return dictionary;
		}
	}
	public static class ConfigurationValidator
	{
		public static List<string> Validate(GameplayConfig config, IEnumerable<ItemProfile>? profiles = null, bool requireDiversePools = true)
		{
			List<string> list = new List<string>();
			if (config.SchemaVersion != 1)
			{
				list.Add("Unsupported gameplay configuration schema.");
			}
			if (config.Rarities == null || config.StrengthBands == null || config.Perks == null || config.Limits == null || config.ItemOverrides == null)
			{
				list.Add("Configuration tables must not be null.");
				return list;
			}
			if (config.Rarities.Any((RarityDefinition r) => r == null) || config.StrengthBands.Any((StrengthBand b) => b == null) || config.Perks.Any((PerkDefinition p) => p == null) || config.ItemOverrides.Any((ItemOverride o) => o == null))
			{
				list.Add("Configuration tables must not contain null entries.");
				return list;
			}
			bool flag = config.Rarities.Any((RarityDefinition r) => r.Rank == 0);
			if (config.Rarities.Count != (flag ? 19 : 18))
			{
				list.Add("The full 18 nonzero rarities are required, optionally with rank-zero Default as a nineteenth outcome.");
			}
			if (((IEnumerable<RarityDefinition>)config.Rarities).Sum((Func<RarityDefinition, long>)((RarityDefinition r) => r.Weight)) != 10000)
			{
				list.Add("Rarity weights must total exactly 10,000; automatic normalization is forbidden.");
			}
			if (config.Rarities.Select((RarityDefinition r) => r.Id).Distinct<string>(StringComparer.Ordinal).Count() != config.Rarities.Count)
			{
				list.Add("Rarity IDs must be unique.");
			}
			if (config.Rarities.Select((RarityDefinition r) => r.Rank).Distinct().Count() != config.Rarities.Count)
			{
				list.Add("Rarity ranks must be unique.");
			}
			foreach (RarityDefinition rarity in config.Rarities)
			{
				if (string.IsNullOrWhiteSpace(rarity.Id) || string.IsNullOrWhiteSpace(rarity.Name))
				{
					list.Add("Rarity IDs and names must be present.");
				}
				if (rarity.Weight < 0 || rarity.Rank < -6 || rarity.Rank > 12)
				{
					list.Add("Invalid rarity weight or rank: " + rarity.Id);
				}
				if (rarity.Rank == 0 != (rarity.Id == "default"))
				{
					list.Add("Only Default may use rank zero: " + rarity.Id);
				}
				if (PerkSelector.Slots(rarity).Any((int n) => n < 0 || n > 12) || ((IEnumerable<int>)PerkSelector.Slots(rarity)).Sum((Func<int, long>)((int n) => n)) != Math.Abs((long)rarity.Rank))
				{
					list.Add("Perk allocation must equal absolute rarity rank: " + rarity.Id);
				}
				if ((rarity.Rank < 0 && rarity.NegativeSlots != -rarity.Rank) || (rarity.Rank > 0 && rarity.NegativeSlots != 0))
				{
					list.Add("Only negative rarities allocate penalties: " + rarity.Id);
				}
				if (rarity.UltraSlots > 0 && rarity.Rank != 12)
				{
					list.Add("Ultra perks are exclusive to Transcendent.");
				}
				if (!Regex.IsMatch(rarity.Color ?? "", "^#[0-9a-fA-F]{6}$"))
				{
					list.Add("Invalid rarity color: " + rarity.Id);
				}
			}
			if (config.StrengthBands.Count == 0 || ((IEnumerable<StrengthBand>)config.StrengthBands).Sum((Func<StrengthBand, long>)((StrengthBand b) => b.Weight)) != 10000)
			{
				list.Add("Strength band weights must total exactly 10,000.");
			}
			int num = 0;
			foreach (StrengthBand strengthBand in config.StrengthBands)
			{
				if (strengthBand.MinScore != num || strengthBand.MaxScore < strengthBand.MinScore || strengthBand.MaxScore > 10000 || strengthBand.Weight < 0)
				{
					list.Add("Strength bands must cover scores 0–10000 exactly once in order, without gaps or overlap.");
				}
				num = strengthBand.MaxScore + 1;
			}
			if (num != 10001)
			{
				list.Add("Strength bands must include the exact score 10000.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (PerkDefinition perk in config.Perks)
			{
				if (!hashSet.Add(perk.Id) || string.IsNullOrWhiteSpace(perk.Id))
				{
					list.Add("Missing or duplicate perk ID: " + perk.Id);
				}
				if (string.IsNullOrWhiteSpace(perk.Name) || string.IsNullOrWhiteSpace(perk.Effect) || string.IsNullOrWhiteSpace(perk.Trigger) || string.IsNullOrWhiteSpace(perk.Stacking) || string.IsNullOrWhiteSpace(perk.SafetyLimits))
				{
					list.Add("Perk must declare its name, implemented effect, trigger, stacking, and safety rules: " + perk.Id);
				}
				if (perk.Weight < 0 || perk.DefinitionVersion < 1 || !Enum.IsDefined(typeof(PerkClass), perk.Class))
				{
					list.Add("Invalid perk weight, class, or definition version: " + perk.Id);
				}
				if (perk.Categories == null || perk.RequiredCapabilities == null || perk.ExcludedNativeEffects == null || perk.ExclusionGroups == null || perk.IncompatibleIds == null || perk.Parameters == null)
				{
					list.Add("Perk metadata collections must be defined: " + perk.Id);
					continue;
				}
				if (perk.Parameters.Count == 0)
				{
					list.Add("Every perk requires a randomized numerical parameter: " + perk.Id);
				}
				HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
				foreach (PerkParameter parameter in perk.Parameters)
				{
					if (parameter == null)
					{
						list.Add("Perk parameter must not be null: " + perk.Id);
						continue;
					}
					if (!hashSet2.Add(parameter.Id) || string.IsNullOrWhiteSpace(parameter.Id))
					{
						list.Add("Duplicate or absent parameter: " + perk.Id);
					}
					if (!Finite(parameter.Min) || !Finite(parameter.Max) || parameter.Min >= parameter.Max || parameter.Precision < 0 || parameter.Precision > 6 || string.IsNullOrWhiteSpace(parameter.Unit))
					{
						list.Add("Invalid randomized parameter range, precision, or unit: " + perk.Id + "." + parameter.Id);
					}
					if (parameter.HighRankMaxima == null)
					{
						list.Add("High-rank maxima must be an object, empty for untiered or historical ranges: " + perk.Id + "." + parameter.Id);
					}
					else
					{
						if (parameter.HighRankMaxima.Count <= 0)
						{
							continue;
						}
						if (parameter.HighRankMaxima.Count != 4)
						{
							list.Add("A high-rank maximum map must declare all four ranks 9 through 12, or be empty: " + perk.Id + "." + parameter.Id);
						}
						if (!Balance021.AllowsHighRankMaximum(perk.Id, parameter.Id) || perk.Class == PerkClass.Negative || parameter.Unit != "%" || !parameter.HigherIsBetter)
						{
							list.Add("High-rank maxima are only supported for reviewed uncapped beneficial percentages: " + perk.Id + "." + parameter.Id);
						}
						double num2 = parameter.Max;
						for (int num3 = 9; num3 <= 12; num3++)
						{
							if (parameter.HighRankMaxima.TryGetValue(num3, out var value))
							{
								if (!Finite(value) || value < num2 || value > 9000.0)
								{
									list.Add("High-rank maxima must be finite, nondecreasing, at least the base maximum and at most 9000: " + perk.Id + "." + parameter.Id);
								}
								num2 = value;
							}
						}
						if (parameter.HighRankMaxima.Keys.Any((int rank) => rank < 9 || rank > 12))
						{
							list.Add("High-rank maxima support only ranks 9 through 12: " + perk.Id + "." + parameter.Id);
						}
					}
				}
			}
			if (((IEnumerable<PerkDefinition>)config.Perks).Sum((Func<PerkDefinition, long>)((PerkDefinition p) => p.Weight)) > int.MaxValue)
			{
				list.Add("Perk weight total exceeds supported integer range.");
			}
			foreach (PerkDefinition item in config.Perks.Where((PerkDefinition p) => p.IncompatibleIds != null))
			{
				foreach (string incompatibleId in item.IncompatibleIds)
				{
					if (!hashSet.Contains(incompatibleId) || incompatibleId == item.Id)
					{
						list.Add("Unknown or self-referencing incompatible perk: " + item.Id + " -> " + incompatibleId);
					}
				}
			}
			BalanceLimits limits = config.Limits;
			double[] array = new double[6] { limits.MovementSpeedPercent, limits.AttackSpeedPercent, limits.CostReductionPercent, limits.DamageReductionPercent, limits.ResourceBonusPercent, limits.HealingMaxHealthPerSecondPercent };
			foreach (double num5 in array)
			{
				if (!Finite(num5) || num5 < 0.0 || num5 > 1000.0)
				{
					list.Add("Aggregate percent caps must be finite and between 0 and 1000.");
				}
			}
			if (limits.CostReductionPercent >= 100.0 || limits.DamageReductionPercent >= 100.0)
			{
				list.Add("Cost and damage reduction caps must be below 100%.");
			}
			if (!Finite(limits.StatFloorMultiplier) || limits.StatFloorMultiplier <= 0.0 || limits.StatFloorMultiplier > 1.0 || !Finite(limits.MaximumCostMultiplier) || limits.MaximumCostMultiplier < 1.0 || limits.MaximumCostMultiplier > 20.0)
			{
				list.Add("Stat floors and action-cost limits must preserve usable equipment.");
			}
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			foreach (ItemOverride itemOverride in config.ItemOverrides)
			{
				if (string.IsNullOrWhiteSpace(itemOverride.Prefab) || !hashSet3.Add(itemOverride.Prefab) || (itemOverride.Enabled && string.IsNullOrWhiteSpace(itemOverride.Category)) || itemOverride.Capabilities == null || itemOverride.NativeEffects == null)
				{
					list.Add("Invalid or duplicate supported-item override: " + itemOverride.Prefab);
				}
			}
			if (list.Count == 0 && profiles != null)
			{
				foreach (ItemProfile profile in profiles)
				{
					list.AddRange(ValidateProfile(config, profile, requireDiversePools));
				}
			}
			return list;
		}

		public static List<string> ValidateProfile(GameplayConfig config, ItemProfile profile, bool requireDiversePools = false)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(profile.Category) || profile.Capabilities == null || profile.NativeEffects == null)
			{
				list.Add("Item classification is incomplete: " + profile.Prefab);
				return list;
			}
			PerkSelector perkSelector = new PerkSelector(config.Perks);
			foreach (RarityDefinition rarity in config.Rarities)
			{
				try
				{
					if (!perkSelector.CanComplete(profile, rarity))
					{
						list.Add(profile.Prefab + " (" + profile.Category + ") cannot complete " + rarity.Name + ".");
					}
				}
				catch (InvalidOperationException ex)
				{
					list.Add(profile.Prefab + ": " + ex.Message);
					break;
				}
			}
			if (requireDiversePools)
			{
				int[] array = new int[4] { 15, 6, 6, 8 };
				int cls;
				for (cls = 0; cls < 4; cls++)
				{
					if (config.Rarities.Any((RarityDefinition r) => PerkSelector.Slots(r)[cls] > 0))
					{
						int num = config.Perks.Count((PerkDefinition p) => p.Class == (PerkClass)cls && Compatibility.Supports(p, profile));
						if (num < array[cls])
						{
							string[] obj = new string[8]
							{
								profile.Category,
								" has ",
								num.ToString(),
								" eligible ",
								null,
								null,
								null,
								null
							};
							PerkClass perkClass = (PerkClass)cls;
							obj[4] = perkClass.ToString();
							obj[5] = " perks; requires at least ";
							obj[6] = array[cls].ToString();
							obj[7] = " for random variety.";
							list.Add(string.Concat(obj));
						}
					}
				}
			}
			return list;
		}

		private static bool Finite(double value)
		{
			if (!double.IsNaN(value))
			{
				return !double.IsInfinity(value);
			}
			return false;
		}
	}
	public sealed class DamageContribution
	{
		public string OwnerId { get; set; } = "";

		public string OriginId { get; set; } = "";

		public string SourceId { get; set; } = "base";

		public string Element { get; set; } = "damage";

		public double Amount { get; set; }

		public DamageContribution Copy(double? amount = null)
		{
			return new DamageContribution
			{
				OwnerId = OwnerId,
				OriginId = OriginId,
				SourceId = SourceId,
				Element = Element,
				Amount = (amount ?? Amount)
			};
		}
	}
	public static class DamagePartition
	{
		public static bool Finite(double v)
		{
			if (!double.IsNaN(v))
			{
				return !double.IsInfinity(v);
			}
			return false;
		}

		public static List<DamageContribution> Reconcile(IEnumerable<DamageContribution> sources, IReadOnlyDictionary<string, double> typedDamage, double actualDamage, string fallbackOwner = "", string fallbackOrigin = "")
		{
			if (!Finite(actualDamage) || actualDamage <= 0.0)
			{
				return new List<DamageContribution>();
			}
			List<DamageContribution> source = sources.Where((DamageContribution x) => Finite(x.Amount) && x.Amount > 0.0).ToList();
			List<DamageContribution> list = new List<DamageContribution>();
			foreach (KeyValuePair<string, double> pair in typedDamage.Where<KeyValuePair<string, double>>((KeyValuePair<string, double> x) => Finite(x.Value) && x.Value > 0.0))
			{
				List<DamageContribution> source2 = source.Where((DamageContribution x) => x.Element == pair.Key).ToList();
				double total = source2.Sum((DamageContribution x) => x.Amount);
				if (total <= 0.0)
				{
					list.Add(new DamageContribution
					{
						OwnerId = fallbackOwner,
						OriginId = fallbackOrigin,
						Element = pair.Key,
						Amount = pair.Value
					});
				}
				else
				{
					list.AddRange(source2.Select((DamageContribution x) => x.Copy(pair.Value * x.Amount / total)));
				}
			}
			double num = list.Sum((DamageContribution x) => x.Amount);
			if (num <= 0.0)
			{
				return new List<DamageContribution>
				{
					new DamageContribution
					{
						OwnerId = fallbackOwner,
						OriginId = fallbackOrigin,
						Amount = actualDamage
					}
				};
			}
			foreach (DamageContribution item in list)
			{
				item.Amount *= actualDamage / num;
			}
			list.OrderByDescending((DamageContribution x) => x.Amount).First().Amount += actualDamage - list.Sum((DamageContribution x) => x.Amount);
			return Merge(list);
		}

		public static List<DamageContribution> Merge(IEnumerable<DamageContribution> values)
		{
			return (from x in values
				where Finite(x.Amount) && x.Amount > 0.0
				group x by x.OwnerId + "\u001f" + x.SourceId + "\u001f" + x.Element).Select(delegate(IGrouping<string, DamageContribution> g)
			{
				DamageContribution damageContribution = g.Last().Copy();
				damageContribution.Amount = g.Sum((DamageContribution x) => x.Amount);
				return damageContribution;
			}).ToList();
		}

		public static List<DamageContribution> RoundPartition(IEnumerable<DamageContribution> values, double total)
		{
			List<DamageContribution> list = Merge(values);
			if (list.Count == 0)
			{
				return list;
			}
			long num = (long)Math.Round(Math.Max(0.0, total) * 1000.0, MidpointRounding.AwayFromZero);
			double num2 = list.Sum((DamageContribution x) => x.Amount);
			if (num2 <= 0.0)
			{
				return new List<DamageContribution>();
			}
			List<(int, double)> list2 = new List<(int, double)>();
			long num3 = 0L;
			for (int num4 = 0; num4 < list.Count; num4++)
			{
				double num5 = list[num4].Amount / num2 * (double)num;
				long num6 = (long)Math.Floor(num5);
				list[num4].Amount = (double)num6 / 1000.0;
				num3 += num6;
				list2.Add((num4, num5 - (double)num6));
			}
			foreach (var item in (from x in list2
				orderby x.fraction descending, x.index
				select x).Take((int)Math.Max(0L, num - num3)))
			{
				list[item.Item1].Amount += 0.001;
			}
			return list;
		}
	}
	public sealed class DamageLedgerSnapshot
	{
		public double WindowSeconds { get; set; }

		public double TotalDamage { get; set; }

		public double Dps => TotalDamage / WindowSeconds;

		public int HitCount { get; set; }

		public bool CapacityLimited { get; set; }

		public List<DamageContribution> Sources { get; set; } = new List<DamageContribution>();
	}
	public sealed class DamageLedger
	{
		private sealed class Entry
		{
			internal double Time;

			internal double Actual;

			internal string Id = "";

			internal List<DamageContribution> Parts = new List<DamageContribution>();
		}

		public const int MaximumEventSources = 256;

		private readonly LinkedList<Entry> entries = new LinkedList<Entry>();

		private readonly Dictionary<string, double> ids = new Dictionary<string, double>(StringComparer.Ordinal);

		private readonly Queue<(string id, double time)> idOrder = new Queue<(string, double)>();

		private readonly object gate = new object();

		private readonly int capacity;

		private readonly double retention;

		private double lastEviction = double.NegativeInfinity;

		public int RetainedEvents
		{
			get
			{
				lock (gate)
				{
					return entries.Count;
				}
			}
		}

		public int RetainedIds
		{
			get
			{
				lock (gate)
				{
					return ids.Count;
				}
			}
		}

		public DamageLedger(int capacity = 60000, double retentionSeconds = 1800.0)
		{
			if (capacity < 1 || retentionSeconds < 1.0)
			{
				throw new ArgumentOutOfRangeException();
			}
			this.capacity = capacity;
			retention = retentionSeconds;
		}

		public bool Add(string id, double now, double actual, IEnumerable<DamageContribution> contributions)
		{
			if (string.IsNullOrWhiteSpace(id) || !DamagePartition.Finite(now) || !DamagePartition.Finite(actual) || actual <= 0.0)
			{
				return false;
			}
			lock (gate)
			{
				Prune(now);
				if (ids.ContainsKey(id))
				{
					return false;
				}
				List<DamageContribution> list = DamagePartition.Merge(contributions);
				double num = list.Sum((DamageContribution x) => x.Amount);
				if (list.Count == 0 || list.Count > 256 || !DamagePartition.Finite(num) || num <= 0.0)
				{
					return false;
				}
				foreach (DamageContribution item in list)
				{
					item.Amount *= actual / num;
				}
				ids[id] = now;
				idOrder.Enqueue((id, now));
				entries.AddLast(new Entry
				{
					Id = id,
					Time = now,
					Actual = actual,
					Parts = list
				});
				while (entries.Count > capacity)
				{
					lastEviction = entries.First.Value.Time;
					entries.RemoveFirst();
				}
				while (ids.Count > capacity * 2)
				{
					(string, double) tuple = idOrder.Dequeue();
					ids.Remove(tuple.Item1);
				}
				return true;
			}
		}

		private void Prune(double now)
		{
			while (entries.First != null && entries.First.Value.Time <= now - retention)
			{
				entries.RemoveFirst();
			}
			while (idOrder.Count > 0 && idOrder.Peek().time <= now - retention)
			{
				(string, double) tuple = idOrder.Dequeue();
				ids.Remove(tuple.Item1);
			}
		}

		public DamageLedgerSnapshot Snapshot(double now, double windowSeconds)
		{
			if (!DamagePartition.Finite(now) || !DamagePartition.Finite(windowSeconds) || windowSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException();
			}
			lock (gate)
			{
				Prune(now);
				windowSeconds = Math.Min(retention, windowSeconds);
				List<Entry> list = entries.Where((Entry x) => x.Time > now - windowSeconds && x.Time <= now).ToList();
				return new DamageLedgerSnapshot
				{
					WindowSeconds = windowSeconds,
					TotalDamage = list.Sum((Entry x) => x.Actual),
					HitCount = list.Count,
					CapacityLimited = (lastEviction > now - windowSeconds),
					Sources = DamagePartition.Merge(list.SelectMany((Entry x) => x.Parts))
				};
			}
		}

		public void Clear()
		{
			lock (gate)
			{
				entries.Clear();
				ids.Clear();
				idOrder.Clear();
				lastEviction = double.NegativeInfinity;
			}
		}
	}
	public sealed class DamageOverTimePool
	{
		private sealed class Bucket
		{
			internal List<DamageContribution> Remaining = new List<DamageContribution>();

			internal List<DamageContribution> LastWeights = new List<DamageContribution>();
		}

		public const int MaximumSources = 1024;

		private readonly Dictionary<string, Bucket> buckets = new Dictionary<string, Bucket>(StringComparer.Ordinal);

		private Bucket Get(string element)
		{
			if (!buckets.TryGetValue(element, out Bucket value))
			{
				value = (buckets[element] = new Bucket());
			}
			return value;
		}

		public void Add(string element, double nativeBefore, double nativeAfter, IEnumerable<DamageContribution> incoming)
		{
			Bucket bucket = Get(element);
			Sync(bucket, element, Math.Max(0.0, nativeBefore));
			double num = Math.Max(0.0, nativeAfter - nativeBefore);
			if (num > 0.0)
			{
				bucket.Remaining = Bound(DamagePartition.Merge(bucket.Remaining.Concat(Scale(incoming, element, num))), element);
			}
			bucket.LastWeights = bucket.Remaining.Select((DamageContribution x) => x.Copy()).ToList();
		}

		public void Replace(string element, double nativeBefore, double attempted, double nativeAfter, IEnumerable<DamageContribution> incoming)
		{
			Bucket bucket = Get(element);
			Sync(bucket, element, Math.Max(0.0, nativeBefore));
			if (attempted >= nativeBefore)
			{
				bucket.Remaining = Bound(Scale(incoming, element, Math.Max(0.0, nativeAfter)), element);
				bucket.LastWeights = bucket.Remaining.Select((DamageContribution x) => x.Copy()).ToList();
			}
		}

		public List<DamageContribution> Take(string element, double tickDamage)
		{
			if (tickDamage <= 0.0)
			{
				return new List<DamageContribution>();
			}
			Bucket bucket = Get(element);
			List<DamageContribution> result = Scale((bucket.Remaining.Count > 0) ? bucket.Remaining : bucket.LastWeights, element, tickDamage);
			double num = bucket.Remaining.Sum((DamageContribution x) => x.Amount);
			if (num > 0.0)
			{
				bucket.Remaining = Scale(bucket.Remaining, element, Math.Max(0.0, num - tickDamage));
			}
			return result;
		}

		private static List<DamageContribution> Scale(IEnumerable<DamageContribution> source, string element, double amount)
		{
			if (amount <= 0.0)
			{
				return new List<DamageContribution>();
			}
			List<DamageContribution> list = DamagePartition.Merge(source.Where((DamageContribution x) => x.Element == element));
			double num = list.Sum((DamageContribution x) => x.Amount);
			if (num <= 0.0)
			{
				return new List<DamageContribution>
				{
					new DamageContribution
					{
						Element = element,
						Amount = amount
					}
				};
			}
			foreach (DamageContribution item in list)
			{
				item.Amount *= amount / num;
			}
			return list;
		}

		private static List<DamageContribution> Bound(List<DamageContribution> rows, string element)
		{
			if (rows.Count <= 1024)
			{
				return rows;
			}
			List<DamageContribution> list = rows.OrderByDescending((DamageContribution x) => x.Amount).Take(1023).ToList();
			list.Add(new DamageContribution
			{
				Element = element,
				Amount = rows.Sum((DamageContribution x) => x.Amount) - list.Sum((DamageContribution x) => x.Amount)
			});
			return list;
		}

		private static void Sync(Bucket b, string element, double native)
		{
			double num = b.Remaining.Sum((DamageContribution x) => x.Amount);
			if (num > native)
			{
				b.Remaining = Scale(b.Remaining, element, native);
			}
			else if (native > num)
			{
				b.Remaining.Add(new DamageContribution
				{
					Element = element,
					Amount = native - num
				});
			}
		}
	}
	public static class Defaults
	{
		public const string Version = "0.2.2";

		public static List<RarityDefinition> Rarities()
		{
			return new List<RarityDefinition>
			{
				R("worthless", "Worthless", -6, 30, "#60646C"),
				R("ruined", "Ruined", -5, 70, "#746357"),
				R("broken", "Broken", -4, 150, "#8D5550"),
				R("damaged", "Damaged", -3, 250, "#AA725C"),
				R("worn", "Worn", -2, 300, "#A8977C"),
				R("inferior", "Inferior", -1, 400, "#B6B0A3"),
				R("default", "Default", 0, 3500, "#B9B9B9"),
				R("common", "Common", 1, 2500, "#E0E0E0"),
				R("uncommon", "Uncommon", 2, 1500, "#63C76A"),
				R("rare", "Rare", 3, 660, "#4B92F1"),
				R("very_rare", "Very Rare", 4, 300, "#50CFD8"),
				R("exceptional", "Exceptional", 5, 150, "#6B63E8"),
				R("epic", "Epic", 6, 75, "#AB62EB"),
				R("heroic", "Heroic", 7, 40, "#DF69B2"),
				R("legendary", "Legendary", 8, 20, "#F49B3D"),
				R("mythic", "Mythic", 9, 18, "#F05B68", 8, 1),
				R("exalted", "Exalted", 10, 15, "#DDB52F", 8, 2),
				R("divine", "Divine", 11, 12, "#FFE48A", 9, 2),
				R("transcendent", "Transcendent", 12, 10, "#BEF6FF", 9, 0, 3)
			};
		}

		private static RarityDefinition R(string id, string name, int rank, int weight, string color, int standard = 0, int special = 0, int ultra = 0)
		{
			return new RarityDefinition
			{
				Id = id,
				Name = name,
				Rank = rank,
				Weight = weight,
				Color = color,
				NegativeSlots = ((rank < 0) ? (-rank) : 0),
				StandardSlots = ((rank >= 0) ? ((standard == 0) ? rank : standard) : 0),
				SpecialSlots = special,
				UltraSlots = ultra
			};
		}

		public static List<StrengthBand> StrengthBands()
		{
			return new List<StrengthBand>
			{
				new StrengthBand
				{
					MinScore = 0,
					MaxScore = 999,
					Weight = 8000
				},
				new StrengthBand
				{
					MinScore = 1000,
					MaxScore = 2499,
					Weight = 1400
				},
				new StrengthBand
				{
					MinScore = 2500,
					MaxScore = 4999,
					Weight = 450
				},
				new StrengthBand
				{
					MinScore = 5000,
					MaxScore = 7999,
					Weight = 120
				},
				new StrengthBand
				{
					MinScore = 8000,
					MaxScore = 9499,
					Weight = 28
				},
				new StrengthBand
				{
					MinScore = 9500,
					MaxScore = 10000,
					Weight = 2
				}
			};
		}
	}
	public static class EffectiveRange
	{
		public static PerkParameter ForRank(PerkParameter parameter, int rank)
		{
			if (parameter == null)
			{
				throw new ArgumentNullException("parameter");
			}
			double value;
			double max = ((parameter.HighRankMaxima != null && parameter.HighRankMaxima.TryGetValue(rank, out value)) ? value : parameter.Max);
			return new PerkParameter
			{
				Id = parameter.Id,
				Min = parameter.Min,
				Max = max,
				Unit = parameter.Unit,
				Precision = parameter.Precision,
				HigherIsBetter = parameter.HigherIsBetter,
				HighRankMaxima = new Dictionary<int, double>()
			};
		}
	}
	public sealed class FateGenerator
	{
		private readonly GameplayConfig config;

		private readonly IRandomSource rarityRandom;

		private readonly IRandomSource selectionRandom;

		private readonly IRandomSource cosmeticRandom;

		private readonly StrengthSampler strength;

		private readonly PerkSelector selector;

		private readonly Dictionary<string, List<string>> validationCache = new Dictionary<string, List<string>>(StringComparer.Ordinal);

		private readonly object gate = new object();

		public FateGenerator(GameplayConfig config, IRandomSource? rarityRng = null, IRandomSource? selectionRng = null, IRandomSource? strengthRng = null, IRandomSource? cosmeticRng = null)
		{
			List<string> list = ConfigurationValidator.Validate(config);
			if (list.Count != 0)
			{
				throw new ArgumentException(string.Join("\n", list));
			}
			this.config = JsonConvert.DeserializeObject<GameplayConfig>(JsonConvert.SerializeObject((object)config));
			rarityRandom = rarityRng ?? new CryptoRandomSource();
			selectionRandom = selectionRng ?? new CryptoRandomSource();
			cosmeticRandom = cosmeticRng ?? new CryptoRandomSource();
			strength = new StrengthSampler(this.config.StrengthBands, strengthRng ?? new CryptoRandomSource());
			selector = new PerkSelector(this.config.Perks);
		}

		public List<string> Validate(ItemProfile profile)
		{
			string key = JsonConvert.SerializeObject((object)new string[4]
			{
				profile.Prefab,
				profile.Category,
				string.Join("|", profile.Capabilities.OrderBy<string, string>((string s) => s, StringComparer.Ordinal)),
				string.Join("|", profile.NativeEffects.OrderBy<string, string>((string s) => s, StringComparer.Ordinal))
			});
			lock (gate)
			{
				if (!validationCache.TryGetValue(key, out List<string> value))
				{
					value = ConfigurationValidator.ValidateProfile(config, profile);
					validationCache.Add(key, value);
				}
				return new List<string>(value);
			}
		}

		public Fateprint Roll(ItemProfile profile, string transactionId, string itemId, string crafterId, string crafterName)
		{
			if (string.IsNullOrWhiteSpace(transactionId) || string.IsNullOrWhiteSpace(itemId))
			{
				throw new ArgumentException("Each committed craft requires transaction and item identifiers.");
			}
			List<string> list = Validate(profile);
			if (list.Count != 0)
			{
				throw new InvalidOperationException(string.Join("\n", list));
			}
			lock (gate)
			{
				RarityDefinition rarity = WeightedRandom.Select(config.Rarities, (RarityDefinition r) => r.Weight, rarityRandom);
				List<PerkDefinition> list2 = selector.Select(profile, rarity, selectionRandom);
				return new Fateprint
				{
					ItemId = itemId,
					TransactionId = transactionId,
					RarityId = rarity.Id,
					Rank = rarity.Rank,
					CrafterId = (crafterId ?? ""),
					CrafterName = (crafterName ?? ""),
					CosmeticSeed = cosmeticRandom.NextInt(int.MaxValue),
					Perks = list2.Select((PerkDefinition d) => strength.Roll(d, rarity.Rank)).ToList(),
					Epithet = EpithetFor(list2)
				};
			}
		}

		private static string EpithetFor(IEnumerable<PerkDefinition> definitions)
		{
			HashSet<string> hashSet = new HashSet<string>(definitions.Select((PerkDefinition p) => p.Id), StringComparer.Ordinal);
			if (hashSet.Contains("thors_judgment") || hashSet.Contains("stormspark"))
			{
				return "Storm-Etched";
			}
			if (hashSet.Contains("winter_sovereign") || hashSet.Contains("frostbound"))
			{
				return "Frost-Kissed";
			}
			if (hashSet.Contains("earths_bounty") || hashSet.Contains("natures_favor"))
			{
				return "Deepvein";
			}
			if (hashSet.Contains("yggdrasils_shelter") || hashSet.Contains("emergency_ward"))
			{
				return "Oathguard";
			}
			return "";
		}
	}
	public sealed class GameplayConfigUpgradeResult
	{
		public bool Upgraded { get; internal set; }

		public string Json { get; internal set; } = "";

		public string FromVersion { get; internal set; } = "";

		public string ToVersion { get; internal set; } = "0.2.2";

		public string Diagnostic { get; internal set; } = "";
	}
	public static class GameplayConfigUpgrade
	{
		public const string LegacyDefaultVersion = "0.1.0";

		public static string LegacyDefaultJson()
		{
			return FrozenDefaultJson("0.1.0");
		}

		public static string FrozenDefaultJson(string version)
		{
			if (version != "0.1.0" && version != "0.2.0" && version != "0.2.1")
			{
				throw new ArgumentException("No frozen default exists for version " + version, "version");
			}
			using Stream stream = typeof(GameplayConfigUpgrade).Assembly.GetManifestResourceStream("Nornforged.Core.Defaults.v" + version + ".json") ?? throw new InvalidOperationException("The frozen " + version + " default configuration resource is missing.");
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		public static GameplayConfigUpgradeResult UpgradeUntouchedDefaults(string json)
		{
			//IL_013f: Expected O, but got Unknown
			//IL_0039: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			GameplayConfigUpgradeResult gameplayConfigUpgradeResult = new GameplayConfigUpgradeResult
			{
				Json = (json ?? "")
			};
			if (string.IsNullOrWhiteSpace(json) || json.Length > 2097152)
			{
				gameplayConfigUpgradeResult.Diagnostic = "Configuration was preserved unchanged; it is empty or exceeds the supported size.";
				return gameplayConfigUpgradeResult;
			}
			try
			{
				JsonLoadSettings val = new JsonLoadSettings
				{
					DuplicatePropertyNameHandling = (DuplicatePropertyNameHandling)2,
					CommentHandling = (CommentHandling)0
				};
				JObject val2 = JObject.Parse(json, val);
				string text = JsonConvert.SerializeObject((object)new GameplayConfig
				{
					Perks = Registry.CreateDefault()
				}, (Formatting)1);
				if (JToken.DeepEquals((JToken)(object)val2, (JToken)(object)JObject.Parse(text, val)))
				{
					gameplayConfigUpgradeResult.FromVersion = "0.2.2";
					gameplayConfigUpgradeResult.Diagnostic = "Configuration already matches the 0.2.2 defaults; no file change is needed.";
					return gameplayConfigUpgradeResult;
				}
				string[] array = new string[3] { "0.2.1", "0.2.0", "0.1.0" };
				foreach (string text2 in array)
				{
					if (JToken.DeepEquals((JToken)(object)val2, (JToken)(object)JObject.Parse(FrozenDefaultJson(text2), val)))
					{
						gameplayConfigUpgradeResult.FromVersion = text2;
						break;
					}
				}
				if (gameplayConfigUpgradeResult.FromVersion.Length == 0)
				{
					gameplayConfigUpgradeResult.Diagnostic = "Configuration preserved unchanged. Only complete untouched 0.1.0, 0.2.0 or 0.2.1 defaults are automatically upgraded; compare custom settings with the 0.2.2 defaults manually.";
					return gameplayConfigUpgradeResult;
				}
				gameplayConfigUpgradeResult.Json = text;
				gameplayConfigUpgradeResult.Upgraded = true;
				gameplayConfigUpgradeResult.Diagnostic = "Untouched default gameplay configuration upgraded from " + gameplayConfigUpgradeResult.FromVersion + " to 0.2.2. Existing item Fateprints and prepared-transaction snapshots are unchanged.";
				return gameplayConfigUpgradeResult;
			}
			catch (JsonException ex)
			{
				JsonException ex2 = ex;
				gameplayConfigUpgradeResult.Diagnostic = "Configuration preserved unchanged because its JSON could not be safely compared: " + ((Exception)(object)ex2).Message;
				return gameplayConfigUpgradeResult;
			}
		}
	}
	public enum PerkClass
	{
		Standard,
		Special,
		Ultra,
		Negative
	}
	public sealed class ItemProfile
	{
		public string Prefab { get; set; } = "";

		public string Category { get; set; } = "";

		public HashSet<string> Capabilities { get; set; } = new HashSet<string>(StringComparer.Ordinal);

		public HashSet<string> NativeEffects { get; set; } = new HashSet<string>(StringComparer.Ordinal);
	}
	public sealed class PerkParameter
	{
		public string Id { get; set; } = "";

		public double Min { get; set; }

		public double Max { get; set; }

		public string Unit { get; set; } = "%";

		public int Precision { get; set; } = 3;

		public bool HigherIsBetter { get; set; } = true;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public Dictionary<int, double> HighRankMaxima { get; set; } = new Dictionary<int, double>();
	}
	public sealed class PerkDefinition
	{
		public string Id { get; set; } = "";

		public string Name { get; set; } = "";

		public PerkClass Class { get; set; }

		public List<string> Categories { get; set; } = new List<string>();

		public List<string> RequiredCapabilities { get; set; } = new List<string>();

		public List<string> ExcludedNativeEffects { get; set; } = new List<string>();

		public int Weight { get; set; } = 1;

		public List<string> ExclusionGroups { get; set; } = new List<string>();

		public List<string> IncompatibleIds { get; set; } = new List<string>();

		public List<PerkParameter> Parameters { get; set; } = new List<PerkParameter>();

		public string Effect { get; set; } = "";

		public string Trigger { get; set; } = "While equipped.";

		public string Stacking { get; set; } = "Add contributions before aggregate caps.";

		public string SafetyLimits { get; set; } = "";

		public int DefinitionVersion { get; set; } = 1;
	}
	public sealed class RarityDefinition
	{
		public string Id { get; set; } = "";

		public string Name { get; set; } = "";

		public int Rank { get; set; }

		public int Weight { get; set; }

		public int StandardSlots { get; set; }

		public int SpecialSlots { get; set; }

		public int UltraSlots { get; set; }

		public int NegativeSlots { get; set; }

		public string Color { get; set; } = "#FFFFFF";

		public int PerkCount => StandardSlots + SpecialSlots + UltraSlots + NegativeSlots;
	}
	public sealed class StrengthBand
	{
		public int MinScore { get; set; }

		public int MaxScore { get; set; }

		public int Weight { get; set; }
	}
	public sealed class RolledPerk
	{
		public string Id { get; set; } = "";

		public int DefinitionVersion { get; set; } = 1;

		public Dictionary<string, double> Values { get; set; } = new Dictionary<string, double>(StringComparer.Ordinal);

		public Dictionary<string, int> QualityScores { get; set; } = new Dictionary<string, int>(StringComparer.Ordinal);
	}
	public sealed class Fateprint
	{
		public const int CurrentSchema = 2;

		public int SchemaVersion { get; set; } = 2;

		public string ItemId { get; set; } = "";

		public string TransactionId { get; set; } = "";

		public string RarityId { get; set; } = "";

		public int Rank { get; set; }

		public List<RolledPerk> Perks { get; set; } = new List<RolledPerk>();

		public string CrafterId { get; set; } = "";

		public string CrafterName { get; set; } = "";

		public int CosmeticSeed { get; set; }

		public string Epithet { get; set; } = "";
	}
	public sealed class BalanceLimits
	{
		public double MovementSpeedPercent { get; set; } = 65.0;

		public double AttackSpeedPercent { get; set; } = 90.0;

		public double CostReductionPercent { get; set; } = 85.0;

		public double DamageReductionPercent { get; set; } = 75.0;

		public double ResourceBonusPercent { get; set; } = 250.0;

		public double HealingMaxHealthPerSecondPercent { get; set; } = 3.0;

		public double StatFloorMultiplier { get; set; } = 0.2;

		public double MaximumCostMultiplier { get; set; } = 3.0;
	}
	public sealed class ItemOverride
	{
		public string Prefab { get; set; } = "";

		public bool Enabled { get; set; } = true;

		public string Category { get; set; } = "";

		public List<string> Capabilities { get; set; } = new List<string>();

		public List<string> NativeEffects { get; set; } = new List<string>();
	}
	public sealed class GameplayConfig
	{
		public int SchemaVersion { get; set; } = 1;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public List<RarityDefinition> Rarities { get; set; } = Defaults.Rarities();

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public List<StrengthBand> StrengthBands { get; set; } = Defaults.StrengthBands();

		public List<PerkDefinition> Perks { get; set; } = new List<PerkDefinition>();

		public BalanceLimits Limits { get; set; } = new BalanceLimits();

		public List<ItemOverride> ItemOverrides { get; set; } = new List<ItemOverride>();
	}
	public static class Compatibility
	{
		public static bool Supports(PerkDefinition perk, ItemProfile item)
		{
			if (perk.Weight > 0 && (perk.Categories.Count == 0 || perk.Categories.Contains("*") || perk.Categories.Contains(item.Category)) && perk.RequiredCapabilities.All(item.Capabilities.Contains))
			{
				return !perk.ExcludedNativeEffects.Any(item.NativeEffects.Contains);
			}
			return false;
		}

		public static bool CanCombine(PerkDefinition left, PerkDefinition right)
		{
			if (left.Id != right.Id && !left.IncompatibleIds.Contains(right.Id) && !right.IncompatibleIds.Contains(left.Id))
			{
				return !left.ExclusionGroups.Intersect<string>(right.ExclusionGroups, StringComparer.Ordinal).Any();
			}
			return false;
		}
	}
	public sealed class PerkSelector
	{
		private readonly IReadOnlyList<PerkDefinition> registry;

		public PerkSelector(IReadOnlyList<PerkDefinition> registry)
		{
			this.registry = registry;
		}

		public static int[] Slots(RarityDefinition rarity)
		{
			return new int[4] { rarity.StandardSlots, rarity.SpecialSlots, rarity.UltraSlots, rarity.NegativeSlots };
		}

		public bool CanComplete(ItemProfile profile, RarityDefinition rarity)
		{
			List<PerkDefinition> pool = registry.Where((PerkDefinition p) => Compatibility.Supports(p, profile)).ToList();
			int budget = 250000;
			return Complete(pool, Slots(rarity), ref budget);
		}

		public List<PerkDefinition> Select(ItemProfile profile, RarityDefinition rarity, IRandomSource random)
		{
			List<PerkDefinition> list = registry.Where((PerkDefinition p) => Compatibility.Supports(p, profile)).ToList();
			int[] array = Slots(rarity);
			List<PerkDefinition> list2 = new List<PerkDefinition>();
			int cls;
			for (cls = 0; cls < array.Length; cls++)
			{
				while (array[cls] > 0)
				{
					array[cls]--;
					List<PerkDefinition> list3 = new List<PerkDefinition>();
					foreach (PerkDefinition candidate in list.Where((PerkDefinition p) => p.Class == (PerkClass)cls))
					{
						List<PerkDefinition> pool = list.Where((PerkDefinition p) => Compatibility.CanCombine(candidate, p)).ToList();
						int budget = 250000;
						if (Complete(pool, array, ref budget))
						{
							list3.Add(candidate);
						}
					}
					if (list3.Count == 0)
					{
						throw new InvalidOperationException("Cannot complete " + rarity.Name + " allocation for " + profile.Prefab + ". Craft must be blocked before materials are consumed.");
					}
					PerkDefinition winner = WeightedRandom.Select(list3, (PerkDefinition p) => p.Weight, random);
					list2.Add(winner);
					list.RemoveAll((PerkDefinition p) => !Compatibility.CanCombine(winner, p));
				}
			}
			return list2;
		}

		private static bool Complete(List<PerkDefinition> pool, int[] remaining, ref int budget)
		{
			if (--budget <= 0)
			{
				throw new InvalidOperationException("Perk compatibility search exceeded its safety budget; simplify exclusions. Configuration is not approved for crafting.");
			}
			int chosenClass = -1;
			int num = int.MaxValue;
			int cls;
			for (cls = 0; cls < remaining.Length; cls++)
			{
				if (remaining[cls] != 0)
				{
					int num2 = pool.Count((PerkDefinition p) => p.Class == (PerkClass)cls);
					if (num2 < remaining[cls])
					{
						return false;
					}
					int num3 = num2 - remaining[cls];
					if (num3 < num)
					{
						num = num3;
						chosenClass = cls;
					}
				}
			}
			if (chosenClass < 0)
			{
				return true;
			}
			List<PerkDefinition> list = pool.Where((PerkDefinition p) => p.Class == (PerkClass)chosenClass).ToList();
			for (int num4 = 0; num4 <= list.Count - remaining[chosenClass]; num4++)
			{
				PerkDefinition candidate = list[num4];
				HashSet<string> earlier = new HashSet<string>(from p in list.Take(num4 + 1)
					select p.Id, StringComparer.Ordinal);
				List<PerkDefinition> pool2 = pool.Where((PerkDefinition p) => !earlier.Contains(p.Id) && Compatibility.CanCombine(candidate, p)).ToList();
				remaining[chosenClass]--;
				bool num5 = Complete(pool2, remaining, ref budget);
				remaining[chosenClass]++;
				if (num5)
				{
					return true;
				}
			}
			return false;
		}
	}
	public sealed class FateprintReadResult
	{
		public Fateprint? Value { get; internal set; }

		public bool IsValid => Value != null;

		public bool Migrated { get; internal set; }

		public string Diagnostic { get; internal set; } = "";

		public string OriginalJson { get; internal set; } = "";
	}
	public static class FateprintSerializer
	{
		public const string CustomDataKey = "nornforged.fate";

		private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
		{
			TypeNameHandling = (TypeNameHandling)0,
			MaxDepth = 20,
			Culture = CultureInfo.InvariantCulture,
			FloatParseHandling = (FloatParseHandling)0,
			MissingMemberHandling = (MissingMemberHandling)0
		};

		public static string Serialize(Fateprint fateprint)
		{
			string text = Validate(fateprint);
			if (text != null)
			{
				throw new ArgumentException(text);
			}
			return JsonConvert.SerializeObject((object)fateprint, (Formatting)0, Settings);
		}

		public static FateprintReadResult Deserialize(string json)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			FateprintReadResult fateprintReadResult = new FateprintReadResult
			{
				OriginalJson = (json ?? "")
			};
			if (string.IsNullOrWhiteSpace(json))
			{
				fateprintReadResult.Diagnostic = "No Fateprint: equipment remains Unrated.";
				return fateprintReadResult;
			}
			if (json.Length > 131072)
			{
				fateprintReadResult.Diagnostic = "Oversized Fateprint disabled; original metadata preserved.";
				return fateprintReadResult;
			}
			try
			{
				JObject val = JsonConvert.DeserializeObject<JObject>(json, Settings);
				if (val == null)
				{
					throw new JsonException("Fateprint object is missing.");
				}
				int valueOrDefault = ((JToken)val).Value<int?>((object)"SchemaVersion").GetValueOrDefault();
				if (valueOrDefault != 1 && valueOrDefault != 2)
				{
					throw new JsonException("Unknown Fateprint schema " + valueOrDefault + ".");
				}
				if (valueOrDefault == 1)
				{
					val["SchemaVersion"] = JToken.op_Implicit(2);
					JToken obj = val["Perks"];
					foreach (JObject item in ((IEnumerable)(((object)((obj is JArray) ? obj : null)) ?? ((object)new JArray()))).OfType<JObject>())
					{
						if (item["DefinitionVersion"] == null)
						{
							item["DefinitionVersion"] = JToken.op_Implicit(1);
						}
					}
					if (val["CosmeticSeed"] == null)
					{
						val["CosmeticSeed"] = JToken.op_Implicit(0);
					}
					if (val["Epithet"] == null)
					{
						val["Epithet"] = JToken.op_Implicit("");
					}
					fateprintReadResult.Migrated = true;
				}
				Fateprint fateprint = ((JToken)val).ToObject<Fateprint>(JsonSerializer.Create(Settings));
				string text = ((fateprint == null) ? "Missing Fateprint object." : Validate(fateprint));
				if (text != null)
				{
					throw new JsonException(text);
				}
				fateprintReadResult.Value = fateprint;
				fateprintReadResult.Diagnostic = (fateprintReadResult.Migrated ? "Migrated Fateprint schema 1 to 2 without changing rolled values." : "");
			}
			catch (Exception ex) when (ex is JsonException || ex is ArgumentException || ex is InvalidOperationException || ex is FormatException || ex is OverflowException)
			{
				fateprintReadResult.Value = null;
				fateprintReadResult.Diagnostic = "Fateprint effects disabled; base item and original metadata preserved: " + ex.Message;
			}
			return fateprintReadResult;
		}

		public static string? Validate(Fateprint value)
		{
			if (value.SchemaVersion != 2)
			{
				return "Unsupported Fateprint schema.";
			}
			if (string.IsNullOrWhiteSpace(value.ItemId) || value.ItemId.Length > 256 || string.IsNullOrWhiteSpace(value.TransactionId) || value.TransactionId.Length > 256 || string.IsNullOrWhiteSpace(value.RarityId))
			{
				return "Fateprint item, transaction, and rarity identifiers are required.";
			}
			if (value.CrafterId == null || value.CrafterName == null || value.Epithet == null)
			{
				return "Fateprint optional text must be an empty string rather than null.";
			}
			if (value.Rank < -6 || value.Rank > 12 || value.Perks == null || value.Perks.Count != Math.Abs(value.Rank))
			{
				return "Fateprint rank does not match its exact perk count.";
			}
			if (value.Rank == 0 != (value.RarityId == "default"))
			{
				return "Only a signed Default outcome may have rank zero and no perks.";
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (RolledPerk perk in value.Perks)
			{
				if (perk == null || string.IsNullOrWhiteSpace(perk.Id) || !hashSet.Add(perk.Id) || perk.DefinitionVersion < 1 || perk.Values == null || perk.QualityScores == null)
				{
					return "Fateprint contains invalid or duplicate perk definitions.";
				}
				if (perk.Values.Count == 0 || perk.Values.Count > 32 || perk.Values.Count != perk.QualityScores.Count)
				{
					return "Fateprint numerical parameters are incomplete.";
				}
				foreach (KeyValuePair<string, double> value3 in perk.Values)
				{
					if (string.IsNullOrWhiteSpace(value3.Key) || double.IsNaN(value3.Value) || double.IsInfinity(value3.Value) || !perk.QualityScores.TryGetValue(value3.Key, out var value2) || value2 < 0 || value2 > 10000)
					{
						return "Fateprint contains an invalid numerical value or quality score.";
					}
				}
			}
			return null;
		}

		public static Fateprint Clone(Fateprint value)
		{
			return Deserialize(Serialize(value)).Value;
		}
	}
	public sealed class TransactionReceipt
	{
		public string TransactionId { get; set; } = "";

		public string RequestFingerprint { get; set; } = "";

		public List<Fateprint> Items { get; set; } = new List<Fateprint>();
	}
	public sealed class CraftTransactionLedger
	{
		private readonly object gate = new object();

		private readonly Dictionary<string, TransactionReceipt> receipts = new Dictionary<string, TransactionReceipt>(StringComparer.Ordinal);

		public int Count
		{
			get
			{
				lock (gate)
				{
					return receipts.Count;
				}
			}
		}

		public CraftTransactionLedger(string? snapshot = null)
		{
			if (string.IsNullOrWhiteSpace(snapshot))
			{
				return;
			}
			foreach (TransactionReceipt receipt in JsonConvert.DeserializeObject<List<TransactionReceipt>>(snapshot) ?? throw new ArgumentException("Ledger is missing."))
			{
				if (string.IsNullOrWhiteSpace(receipt.TransactionId) || string.IsNullOrWhiteSpace(receipt.RequestFingerprint) || receipt.Items == null || receipt.Items.Count == 0 || receipt.Items.Any((Fateprint f) => FateprintSerializer.Validate(f) != null || f.TransactionId != receipt.TransactionId))
				{
					throw new ArgumentException("Corrupt authority transaction ledger. Do not silently reset it.");
				}
				receipts.Add(receipt.TransactionId, receipt);
			}
		}

		public List<Fateprint> GetOrCommit(string transactionId, string fingerprint, Func<List<Fateprint>> generate, Action<string> persistSnapshot)
		{
			if (string.IsNullOrWhiteSpace(transactionId) || string.IsNullOrWhiteSpace(fingerprint))
			{
				throw new ArgumentException("Transaction ID and immutable request fingerprint are required.");
			}
			lock (gate)
			{
				if (receipts.TryGetValue(transactionId, out TransactionReceipt value))
				{
					if (value.RequestFingerprint != fingerprint)
					{
						throw new InvalidOperationException("Transaction identifier reused with a different request.");
					}
					return value.Items.Select(FateprintSerializer.Clone).ToList();
				}
				List<Fateprint> list = generate();
				if (list == null || list.Count == 0 || list.Any((Fateprint f) => FateprintSerializer.Validate(f) != null || f.TransactionId != transactionId) || list.Select((Fateprint f) => f.ItemId).Distinct<string>(StringComparer.Ordinal).Count() != list.Count)
				{
					throw new InvalidOperationException("Generated transaction must contain valid, individually identified item outcomes.");
				}
				TransactionReceipt transactionReceipt = new TransactionReceipt
				{
					TransactionId = transactionId,
					RequestFingerprint = fingerprint,
					Items = list.Select(FateprintSerializer.Clone).ToList()
				};
				receipts.Add(transactionId, transactionReceipt);
				try
				{
					persistSnapshot(SnapshotUnsafe());
				}
				catch
				{
					receipts.Remove(transactionId);
					throw;
				}
				return transactionReceipt.Items.Select(FateprintSerializer.Clone).ToList();
			}
		}

		public string Snapshot()
		{
			lock (gate)
			{
				return SnapshotUnsafe();
			}
		}

		private string SnapshotUnsafe()
		{
			return JsonConvert.SerializeObject((object)receipts.Values.OrderBy<TransactionReceipt, string>((TransactionReceipt r) => r.TransactionId, StringComparer.Ordinal));
		}
	}
	public interface IRandomSource
	{
		int NextInt(int exclusiveUpperBound);
	}
	public sealed class CryptoRandomSource : IRandomSource
	{
		public int NextInt(int exclusiveUpperBound)
		{
			if (exclusiveUpperBound <= 0)
			{
				throw new ArgumentOutOfRangeException("exclusiveUpperBound");
			}
			return RandomNumberGenerator.GetInt32(exclusiveUpperBound);
		}
	}
	public sealed class DeterministicRandomSource : IRandomSource
	{
		private ulong state;

		public DeterministicRandomSource(ulong seed)
		{
			state = seed;
		}

		private ulong Next()
		{
			ulong num = (state += 11400714819323198485uL);
			long num2 = (long)(num ^ (num >> 30)) * -4658895280553007687L;
			long num3 = (num2 ^ (num2 >>> 27)) * -7723592293110705685L;
			return (ulong)(num3 ^ (num3 >>> 31));
		}

		public int NextInt(int exclusiveUpperBound)
		{
			if (exclusiveUpperBound <= 0)
			{
				throw new ArgumentOutOfRangeException("exclusiveUpperBound");
			}
			ulong num = (ulong)exclusiveUpperBound;
			ulong num2 = (0 - num) % num;
			ulong num3;
			do
			{
				num3 = Next();
			}
			while (num3 < num2);
			return (int)(num3 % num);
		}
	}
	public static class WeightedRandom
	{
		public static T Select<T>(IReadOnlyList<T> choices, Func<T, int> weight, IRandomSource random)
		{
			long num = 0L;
			foreach (T choice in choices)
			{
				int num2 = weight(choice);
				if (num2 < 0)
				{
					throw new ArgumentException("Weights must not be negative.");
				}
				num += num2;
			}
			if (num <= 0 || num > int.MaxValue)
			{
				throw new ArgumentException("Weight total must be positive and fit in a signed integer.");
			}
			int num3 = random.NextInt((int)num);
			foreach (T choice2 in choices)
			{
				num3 -= weight(choice2);
				if (num3 < 0)
				{
					return choice2;
				}
			}
			throw new InvalidOperationException("Random source returned an out-of-bounds ticket.");
		}
	}
	public sealed class StrengthSampler
	{
		private readonly IReadOnlyList<StrengthBand> bands;

		private readonly IRandomSource random;

		public StrengthSampler(IReadOnlyList<StrengthBand> bands, IRandomSource random)
		{
			this.bands = bands;
			this.random = random;
		}

		public int SampleScore()
		{
			StrengthBand strengthBand = WeightedRandom.Select(bands, (StrengthBand b) => b.Weight, random);
			return strengthBand.MinScore + random.NextInt(strengthBand.MaxScore - strengthBand.MinScore + 1);
		}

		public static double Interpolate(PerkParameter parameter, int score)
		{
			if (score < 0 || score > 10000)
			{
				throw new ArgumentOutOfRangeException("score");
			}
			double num = (double)score / 10000.0;
			return Math.Round(parameter.HigherIsBetter ? (parameter.Min + num * (parameter.Max - parameter.Min)) : (parameter.Max - num * (parameter.Max - parameter.Min)), parameter.Precision, MidpointRounding.AwayFromZero);
		}

		public RolledPerk Roll(PerkDefinition definition, int rank = 0)
		{
			RolledPerk rolledPerk = new RolledPerk
			{
				Id = definition.Id,
				DefinitionVersion = definition.DefinitionVersion
			};
			foreach (PerkParameter parameter in definition.Parameters)
			{
				int num = SampleScore();
				rolledPerk.QualityScores.Add(parameter.Id, num);
				rolledPerk.Values.Add(parameter.Id, Interpolate(EffectiveRange.ForRank(parameter, rank), num));
			}
			return rolledPerk;
		}
	}
	public static class Registry
	{
		public static readonly string[] Categories = new string[17]
		{
			"melee", "bow", "crossbow", "offensive_staff", "support_staff", "shield", "pickaxe", "axe", "hammer", "hoe",
			"cultivator", "fishing", "helmet", "chest", "legs", "cape", "accessory"
		};

		public static List<PerkDefinition> CreateDefault()
		{
			List<PerkDefinition> result = new List<PerkDefinition>();
			string cats = "melee,bow,crossbow,offensive_staff,axe,pickaxe";
			string cats2 = "pickaxe,axe,hammer,hoe,cultivator,fishing";
			S("razor_edge", "Razor Edge", 2.0, 32.0, "+{amount}% physical damage on this weapon.", cats, "physical");
			S("runic_potency", "Runic Potency", 2.0, 25.0, "+{amount}% existing elemental damage; added elements are excluded from this baseline.", cats, "elemental");
			S("efficient_strikes", "Efficient Strikes", 2.0, 20.0, "-{amount}% attack stamina cost on this weapon.", cats, "attack_stamina");
			S("quickstrike", "Quickstrike", 1.0, 12.0, "+{amount}% melee attack animation speed.", "melee,axe,pickaxe");
			S("quick_draw", "Quick Draw", 3.0, 20.0, "+{amount}% bow draw speed.", "bow");
			S("rapid_reload", "Rapid Reload", 3.0, 18.0, "-{amount}% crossbow reload time.", "crossbow");
			S("steady_aim", "Steady Aim", 3.0, 20.0, "-{amount}% aiming stamina cost.", "bow,crossbow", "aim_stamina");
			S("eitr_efficiency", "Eitr Efficiency", 2.0, 18.0, "-{amount}% Eitr cost.", "", "eitr");
			S("punishing_blows", "Punishing Blows", 3.0, 25.0, "+{amount}% direct damage against staggered enemies.", cats);
			S("crushing_force", "Crushing Force", 3.0, 25.0, "+{amount}% stagger buildup on direct hits.", cats, "stagger_damage");
			S("duelists_guard", "Duelist's Guard", 3.0, 25.0, "+{amount}% item block power.", "", "block");
			S("reinforced", "Reinforced", 10.0, 120.0, "+{amount}% maximum item durability.", "", "durability");
			S("lightweight", "Lightweight", 5.0, 60.0, "-{amount}% item weight.", "", "weight");
			S("frostbound", "Frostbound", 2.0, 15.0, "Add frost damage equal to {amount}% of baseline attack damage, before Nornforged bonuses.", cats);
			S("emberbound", "Emberbound", 2.0, 15.0, "Add fire damage equal to {amount}% of baseline attack damage, before Nornforged bonuses.", cats);
			S("resource_breaker", "Resource Breaker", 3.0, 35.0, "+{amount}% native gathering damage; native tool tier is unchanged.", "pickaxe,axe", "gathering");
			S("efficient_labor", "Efficient Labor", 3.0, 20.0, "-{amount}% tool action stamina cost.", cats2, "stamina");
			S("swift_labor", "Swift Labor", 2.0, 15.0, "+{amount}% working animation, building cadence and fishing reeling speed.", cats2, "working");
			S("resource_magnet", "Resource Magnet", 10.0, 100.0, "+{amount}% pickup radius for wood, stone and ore resource materials while this tool is held.", "pickaxe,axe", "gathering");
			S("extended_reach", "Extended Reach", 5.0, 25.0, "+{amount}% tool working reach.", cats2, "working");
			S("haulers_strength", "Hauler's Strength", 3.0, 15.0, "+{amount}% carrying capacity from the unmodified vanilla baseline.");
			S("builders_reach", "Builder's Reach", 5.0, 30.0, "+{amount}% building and repair reach.", "hammer");
			S("green_hands", "Green Hands", 3.0, 25.0, "-{amount}% planting stamina cost.", "cultivator");
			S("patient_angler", "Patient Angler", 3.0, 25.0, "-{amount}% reeling stamina cost.", "fishing");
			S("long_cast", "Long Cast", 5.0, 25.0, "+{amount}% horizontal casting distance with the same vertical arc, and maximum fishing line length.", "fishing");
			S("fortified", "Fortified", 2.0, 15.0, "+{amount}% armor on this item.", "helmet,chest,legs,cape", "armor");
			S("vitality", "Vitality", 2.0, 10.0, "+{amount}% maximum health from vanilla base health plus current food.");
			S("endurance", "Endurance", 2.0, 10.0, "+{amount}% maximum stamina from vanilla base stamina plus current food.");
			S("runic_reservoir", "Runic Reservoir", 2.0, 12.0, "+{amount}% maximum Eitr from current food; grants no Eitr without a native Eitr pool.", "", "mage");
			S("recovery", "Recovery", 3.0, 20.0, "+{amount}% food and status-effect health regeneration.");
			S("second_wind", "Second Wind", 3.0, 20.0, "+{amount}% stamina regeneration.");
			S("runic_flow", "Runic Flow", 3.0, 20.0, "+{amount}% Eitr regeneration.", "", "mage");
			S("fleetfoot", "Fleetfoot", 1.0, 5.0, "+{amount}% walking, jogging and running speed while equipped.");
			S("tireless", "Tireless", 3.0, 15.0, "-{amount}% sprint stamina cost.");
			S("nimble", "Nimble", 3.0, 15.0, "-{amount}% dodge stamina cost.");
			S("springstep", "Springstep", 3.0, 15.0, "-{amount}% jump stamina cost.");
			S("riverstride", "Riverstride", 3.0, 15.0, "-{amount}% swimming stamina cost.");
			S("quiet_steps", "Quiet Steps", 3.0, 15.0, "-{amount}% sneaking stamina cost.");
			string[] array = new string[8] { "fire", "frost", "lightning", "poison", "spirit", "blunt", "slash", "pierce" };
			foreach (string text in array)
			{
				S("ward_" + text, char.ToUpperInvariant(text[0]) + text.Substring(1) + " Ward", 2.0, (text == "fire" || text == "frost") ? 10 : 6, "-{amount}% incoming " + text + " damage after native resistance.").ExcludedNativeEffects.Add(text + "_immunity");
			}
			S("soft_landing", "Soft Landing", 10.0, 60.0, "-{amount}% fall damage.", "legs,cape").ExcludedNativeEffects.Add("fall_immunity");
			S("efficient_guard", "Efficient Guard", 3.0, 20.0, "-{amount}% blocking stamina cost.", "shield");
			S("firm_grip", "Firm Grip", 5.0, 30.0, "-{amount}% knockback received while blocking.", "shield");
			Cool(A("stormspark", "Stormspark", 15.0, 40.0, "A direct hit chains {amount}% of damage actually dealt to one other enemy within 8 m; {cooldown} s cooldown.", cats), 6.0, 12.0);
			A("executioner", "Executioner", 10.0, 30.0, "+{amount}% direct damage against enemies below 20% health.", cats);
			A("runic_reserve", "Runic Reserve", 10.0, 30.0, "Every fifth manual spell refunds {amount}% of Eitr actually spent.", "offensive_staff,support_staff", "eitr");
			A("veinbreaker", "Veinbreaker", 30.0, 90.0, "Every sixth successful gathering strike deals +{amount}% gathering damage.", "pickaxe,axe", "gathering");
			A("natures_favor", "Nature's Favor", 5.0, 20.0, "+{amount}% average yield when eligible natural resources are first produced.", "pickaxe,axe", "gathering");
			PerkDefinition perkDefinition = A("master_repair", "Master Repair", 2.0, 5.0, "A successful repair