overlord_event_system/mechanics/

balance.rs

//!
//! Functions and constants here mirror the original `balance.yaml` script,
//! which contained the project's fundamental combat and economic balance
//! formulas. Content-dependent lookups (item rarity quality, ability
//! rarity effectiveness, fixed-power items) are sourced from
//! [`ContentLookups`], which is populated at engine init time by reading
//! the `content_raw` module's data maps.

use std::collections::BTreeMap;

use configs::game_config::GameConfig;
use essences::abilities::{Ability, EquippedAbilities};
use essences::items::Item;
use essences::pets::Pet;
use event_system::script::random::GameRng;
use uuid::Uuid;

use crate::game_config_helpers::GameConfigLookup;
use crate::mechanics::content_lookups::ContentLookups;

/// Ordered attribute accumulator used by [`power_from_attrs`] /
/// [`character_power`].
///
/// only ever does keyed reads (`get_attr` on fixed attribute names) — it never
/// iterates the map — so the only behaviour that must be preserved is the
/// per-key float accumulation order. We accumulate in source order
/// (`*entry += value`), which is byte-identical to the old
/// `Dynamic::from_float(cur + value)` insert. A `BTreeMap<String, f64>` routes
pub type AttrMap = BTreeMap<String, f64>;

/// Add `value` to the running sum for `key`, mirroring the old
/// `let cur = collected.get(key)...; collected.insert(key, cur + value)`.
fn accumulate(map: &mut AttrMap, key: &str, value: f64) {
    *map.entry(key.to_string()).or_insert(0.0) += value;
}

/// Ability-budget window (seconds) — the measured length of a typical campaign
/// fight (weighted median from battle-end telemetry; win-only fights run
/// longer). It is a WEIGHT in the ability-damage budget (`eff·FD/(FD+cd)·cd`,
/// combat AND scalar — the two share the primitive, so they cannot desync) and
/// in the regen/HoT-as-EHP conversion. The counterattack term and the item
/// counterattack roll are FD-invariant (FD cancels in their ratios — only
/// `ATTACKS_PER_SEC` prices them). Changing this constant re-scales ability
/// damage and the honest scalar together, so it requires the full coderive
/// recalibration cycle (η + growth knots), same as any scalar-changing edit.
pub const FIGHT_DURATION: f64 = 25.0;
pub const BASE_HP: f64 = 3000.0;
pub const BASE_ATTACK: f64 = 600.0;
pub const DMG_K: f64 = 0.1;
pub const BASE_CRIT_CHANCE: f64 = 0.0;
pub const BASE_CRIT_MOD: f64 = 2.0;
pub const BASE_POWER: i64 = 1000;
pub const BASE_SPEED: f64 = 1.0;
pub const COUNTERATTACK_POWER: f64 = 2.0;
pub const BASE_SPELL_EFF: f64 = 1.0;
pub const MAIN_ATTRS_QUANTITY: i64 = 3;
pub const SPELL_QUANTITY: i64 = 6;
pub const ATTR_DEVIATION: f64 = 0.1;
/// Mean of the level-1 attribute spread — level-1 items are deliberately weak
/// (the scripted starters and the first chest drops share it).
pub const LEVEL_ONE_ATTR_MEAN: f64 = 0.65;
/// Level-1 rolls use a wider deviation than the 2..=25 band: level-1 stat
/// values are tiny integers, so ±10% would be flattened by flooring and every
/// roll of the single early template per (rarity, slot) cell came out a clone
/// of the scripted starters.
pub const ATTR_DEVIATION_LEVEL_ONE: f64 = 0.2;
pub const AUX_ATTR_IMPACT: f64 = 0.05;
pub const AOE_COEF: f64 = 0.6;
pub const OT_COEF: f64 = 1.2;
pub const HEAL_COEF: f64 = 1.2;
pub const BUFF_EFF: f64 = 1.5;
pub const BRAVERY_BUFF_QUANTITY: i64 = 2;
pub const BRAVERY_BUFF_DURATION: f64 = 1.0;
pub const DECEIT_DEBUFF_QUANTITY: i64 = 2;
pub const DECEIT_DEBUFF_DURATION: f64 = 1.0;
/// PLAYER cast rate (casts/s) — prices the bravery/deceit on-cast proc uptime
/// (`buff_uptime_mult*`). Near-honest for a filled loadout: ~6 slotted
/// abilities at cd 2-6s + class basic at cd 1s ⇒ Σ1/cd ≈ 1.5-2.5 casts/s.
pub const CASTS_PER_SEC: f64 = 2.0;
/// INCOMING enemy hits/s on the player — prices counterattack (the scalar term
/// and the item roll are FD-invariant: FD cancels, only this rate matters).
/// Deliberately independent of `CASTS_PER_SEC` — the player's cast rate says
/// nothing about enemy attack rate. Derivation: combat schedules each mob's
/// next cast at `current_tick + scaled_cooldown` (logic/fighting.rs), so a mob
/// attacks every `cd` — mob basic attacks run cd 1.0-1.7s (typ. 1.4 ⇒
/// ~0.7 atk/s). Campaign waves hold a median 5 mobs, declining as they die
/// (time-avg attackers ≈ 2.5, further shaved by approach/spawn delays):
/// ≈ 2.5 × 0.7 ≈ 1.8 hits/s. Boss fights run lower (single attacker) —
/// this is the campaign-mix weight.
pub const ATTACKS_PER_SEC: f64 = 1.8;

// --- Power model P = DPS × EHP, diminishing-returns curves R/(R+K) -----------
// Avoidance/mitigation use the DR curve `rating/(rating+K)`: it asymptotes
// below 100%, so no single defensive stat dominates and there is no cliff
// (a linear falloff reaches 0 damage taken and keeps going — unkillable).
// The K values are bot-sim calibrated, not derived.
pub const K_ARMOR: f64 = 2000.0;
// Dodge is a binary per-hit outcome coin, so its K is deliberately high (3× the
// armor K): the dodge rate stays low and power, not the miss lottery, decides
// fights — the stat-check combat direction.
pub const K_DODGE: f64 = 6000.0;
/// Cap on per-tick combat regen, as a fraction of max HP. The
/// `Regeneration_rate` effect fires ~1×/s, so over a `FIGHT_DURATION` fight
/// this bounds combat regen to ≈0.5×HP ⇒ ≈×1.5 EHP at the cap. The power
/// scalar's regen-as-EHP is **derived from this same value**
/// (`power_from_attrs`) so display/matchmaking can never over-rate what combat
/// delivers — there is deliberately no separate scalar regen cap.
pub const REGEN_TICK_MAX_PCT: f64 = 0.02;
/// Per-tick caps for HoT/DoT effects, as a fraction of max HP — safety so a
/// mis-tuned ability effect can't out-heal all damage (HoT) or one-shot (DoT).
/// Generous (these are ability-derived, already bounded by ability balance); the
/// cap only catches pathological values. Seed; sim-calibrated.
pub const HOT_TICK_MAX_PCT: f64 = 0.25;
pub const DOT_TICK_MAX_PCT: f64 = 0.50;
/// Minimum `received_damage` multiplier (in /10000 units) so heavy mitigation
/// (e.g. stacked `protection`) can't reach ≤0 → unkillable. 100 ⇒ ≤99% reduction.
pub const MIN_RECEIVED_DAMAGE_K: f64 = 100.0;
/// Floor on a stat's `.mod` multiplier in `get_entity_stat`, so a stacking
/// `.mod` debuff (e.g. `weakness` on attack, `protection` on received_damage)
/// can't drive a stat to ≤0 (zero-damage / unkillable). 0.05 ⇒ ≤95% debuff.
/// Only bites at mod ≤ −9500; no-mod / buff stats are unaffected.
pub const MIN_STAT_MOD_MULT: f64 = 0.05;

/// Power-scalar normalisation. Anchors a reference character
/// (attack=`BASE_ATTACK`, hp=`BASE_HP`, neutral elsewhere) at `BASE_POWER`, so
/// the displayed Combat-Power integer stays on the established scale while the
/// formula underneath is `P = DPS × EHP`. = 600·3000/1000 = 1800.
pub const POWER_NORM: f64 = BASE_ATTACK * BASE_HP / BASE_POWER as f64;

// --- Balance v2: the sim-tunable knob surface --------------------------------
// All the v2 balance "knobs" in one place so a balance change is a one-field
// edit and the bot-sim can SWEEP them with **zero recompile / zero deploy**:
// set the matching `OVERLORD_BAL_*` env var and restart the (cached) monolith.
// Defaults equal the constants above/below, so behaviour is unchanged unless an
// override is provided. Read everywhere via `tuning()`; initialised once at
// process start by `init_tuning` (the binary calls
// `init_tuning(BalanceTuning::from_env())`). Tests don't init → defaults.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BalanceTuning {
    /// DR knob for armor mitigation `K/(armor+K)`. Env: `OVERLORD_BAL_K_ARMOR`.
    pub k_armor: f64,
    /// DR knob for dodge/evasion `ev/(ev+K)`. Env: `OVERLORD_BAL_K_DODGE`.
    pub k_dodge: f64,
    /// Power-scalar normaliser. Env: `OVERLORD_BAL_POWER_NORM`.
    pub power_norm: f64,
    /// Last hand-made campaign chapter (formula curve starts above it). Env: `OVERLORD_BAL_ENEMY_ANCHOR_CHAPTER`.
    pub enemy_curve_anchor_chapter: i64,
    /// Highest 0-based chapter level resolved from hand-authored base_power in
    /// `enemy_power_scalar` (the base_power/curve split). See
    /// [`HAND_AUTHORED_CHAPTER_MAX`]. Env: `OVERLORD_BAL_HAND_AUTHORED_CHAPTER_MAX`.
    pub hand_authored_chapter_max: i64,
    /// Enemy power at the anchor chapter. Env: `OVERLORD_BAL_ENEMY_ANCHOR_POWER`.
    pub enemy_curve_anchor_power: f64,
    /// Enemy power geometric step per chapter — the progression gate. Env: `OVERLORD_BAL_ENEMY_STEP`.
    pub chapter_power_step: f64,
    /// Late-game enemy step floor. Past `enemy_step_taper_start` the per-chapter
    /// step decays smoothly from `chapter_power_step` toward this value, so the
    /// difficulty gate tracks the player's DECELERATING late power growth
    /// (~1.12×/ch) instead of staying at the early 1.30 — which out-paced late
    /// power and produced multi-day chapter stalls / a hard wall. With `>=
    /// chapter_power_step` the taper is OFF (closed-form, unchanged). Env:
    /// `OVERLORD_BAL_ENEMY_STEP_LATE`.
    pub enemy_step_late: f64,
    /// Chapter at which the late-step taper begins. Env: `OVERLORD_BAL_ENEMY_STEP_TAPER_START`.
    pub enemy_step_taper_start: i64,
    /// Item sale-price exponent on `eff` (income growth shape). Env: `OVERLORD_BAL_SELL_EXP`.
    pub sell_price_exp: f64,
    /// Item sale-price coefficient. Env: `OVERLORD_BAL_SELL_COEF`.
    pub sell_price_coef: f64,
    /// Crit-chance multiplier (1.0 = shipped). Sigmoid-steepening dial: crit
    /// is a ×2+ damage coin-flip per hit — the largest binary outcome-RNG.
    /// Env: `OVERLORD_BAL_CRIT_SCALE`. 0.0 disables crits entirely.
    pub crit_chance_scale: f64,
    /// Boss combat texture: crit_chance (permyriad) granted to boss entities
    /// at spawn, carved OUT of their attack budget (power neutral).
    /// Env: `OVERLORD_BAL_BOSS_CRIT`. 0 = off.
    pub boss_crit_chance: f64,
    /// Boss armor rating granted at spawn, carved out of the HP budget
    /// (EHP/TTK neutral). Env: `OVERLORD_BAL_BOSS_ARMOR`. 0 = off.
    pub boss_armor: f64,
    /// WoW-style rating deflation for PLAYER armor. Without it item armor
    /// saturates the DR curve from the first band (mitigation creeps 64% →
    /// ~78% across the game, decaying the marginal value of an armor point
    /// ×1.66). Deflating the aggregated player rating by
    /// `k/(k + per_ch·chapter)` is equivalent to growing K_ARMOR with content
    /// level but lives in ONE place (attribute aggregation), so combat, the
    /// honest scalar and the UI stay consistent automatically. 15/ch is the
    /// gentle calibration (late mitigation ≈68.5%, marginal decay ×1.25);
    /// 33/ch would flatten mitigation to the first-band level entirely.
    /// Env: `OVERLORD_BAL_ARMOR_K_PER_CH`. 0 = off.
    pub armor_k_per_chapter: f64,
    /// Max per-tick combat regen heal as a fraction of max HP — bounds regen in
    /// *combat* (the scalar bound is separate) so high regen can't out-heal all
    /// damage / instant-full a tank. Env: `OVERLORD_BAL_REGEN_TICK_PCT`.
    pub regen_tick_max_pct: f64,
    /// Max per-tick HoT heal as a fraction of max HP. Env: `OVERLORD_BAL_HOT_TICK_PCT`.
    pub hot_tick_max_pct: f64,
    /// Max per-tick DoT damage as a fraction of max HP. Env: `OVERLORD_BAL_DOT_TICK_PCT`.
    pub dot_tick_max_pct: f64,
    /// Early-game stat-check bump strength applied at ch3 (tapering ch4/ch5),
    /// so the first gear conversions are forced. ch2 is left untouched (it is
    /// resource-capped by the 20 starter cookies — a bump there DEADLOCKS, sim-
    /// confirmed). `1.0` = off. Env: `OVERLORD_BAL_ENEMY_EARLY_BUMP`.
    pub enemy_early_bump: f64,
    /// Mid-game boss-only bump applied at ch7–15 to enforce the gear-engagement gate.
    /// Applied exclusively to `CampaignBossFight` in `enemy_power_scalar`; wave fights
    /// are unaffected so the global `enemy_power_for_chapter` curve stays monotone.
    /// At 8.0: a frozen player (stopped at ch5, power ~2121) faces P/E ≈ 0.34 at the
    /// ch7 boss → ~7% first-try win rate; combined with `stop_on_lose=true` on bosses
    /// and the lazy bot not retrying, this creates the hard wall. Engaged players
    /// open more chests between attempts and eventually clear the boss. Tapers to 1.0
    /// at ch16 (one past ability-slot unlock at ch15). `1.0` = off.
    /// Env: `OVERLORD_BAL_ENEMY_MID_BUMP`.
    pub enemy_mid_bump: f64,
    /// `eff_by_level` early-branch (L ≤ 130) coefficient. Env: `OVERLORD_BAL_EFF_A1`.
    pub eff_a1: f64,
    /// `eff_by_level` early-branch exponent — THE early-power shape knob (lower =
    /// flatter early growth, decouples power from level/clock). Env: `OVERLORD_BAL_EFF_B1`.
    pub eff_b1: f64,
    /// `eff_by_level` late-branch (L > 130) coefficient. Env: `OVERLORD_BAL_EFF_A2`.
    pub eff_a2: f64,
    /// `eff_by_level` late-branch exponent (raise above 0.1 so late power keeps
    /// growing instead of plateauing). Env: `OVERLORD_BAL_EFF_B2`.
    pub eff_b2: f64,
    /// `eff_by_level` late-branch offset (re-fit for continuity at L=130). Env: `OVERLORD_BAL_EFF_C2`.
    pub eff_c2: f64,
    /// Wave LETHALITY skew: multiplies the wave's damage-output normalization
    /// relative to the mirror reference's EHP. >1 ⇒ the wave hits harder than
    /// the pure mirror (more death pressure / lower hp_end at equal win-rate).
    /// Env: `OVERLORD_BAL_WAVE_DAMAGE_SKEW`.
    pub wave_damage_skew: f64,
    /// Wave KILL-TIME skew: divides the reference DPS the wave's total-HP
    /// budget is built from. >1 ⇒ the wave has LESS HP than the pure mirror
    /// (dies faster / checks less sustained DPS).
    /// Env: `OVERLORD_BAL_WAVE_HP_SKEW`.
    ///
    /// EXACT LAW (verified analytically + numerically): the wave's survive/die
    /// break-even sits at true-power ratio
    /// `r_draw = wave_damage_skew / wave_hp_skew`, and fight length scales as
    /// `1 / wave_hp_skew`. An equal pair keeps the draw at exactly r=1 (skews
    /// cancel) while setting the tempo. Move the RATIO to shift the break-even
    /// (harder: damage↑ or hp↓); move both together to change tempo without
    /// touching the threshold.
    pub wave_hp_skew: f64,
    /// Which enemy-curve formula runs: `Legacy` anchor/step/taper or `Derived`
    /// — the smooth campaign curve (S_ref-seeded FTUE, sparse early `E_base`
    /// calibration, boss `sqrt(1.30)`, then one universal geometric tail).
    /// Env: `OVERLORD_BAL_ENEMY_CURVE_MODE` = `legacy` | `derived`.
    pub enemy_curve_mode: EnemyCurveMode,
}

/// Tuning with every knob at its constant default.
pub const BALANCE_TUNING_DEFAULT: BalanceTuning = BalanceTuning {
    k_armor: K_ARMOR,
    k_dodge: K_DODGE,
    power_norm: POWER_NORM,
    enemy_curve_anchor_chapter: ENEMY_CURVE_ANCHOR_CHAPTER,
    hand_authored_chapter_max: HAND_AUTHORED_CHAPTER_MAX,
    enemy_curve_anchor_power: ENEMY_CURVE_ANCHOR_POWER,
    chapter_power_step: CHAPTER_POWER_STEP,
    enemy_step_late: ENEMY_STEP_LATE,
    enemy_step_taper_start: ENEMY_STEP_TAPER_START,
    sell_price_exp: SELL_PRICE_EXP,
    sell_price_coef: SELL_PRICE_COEF,
    // Full price: the entropy proc resolver eliminates crit streaks at the
    // mechanism level (exactly one crit per 1/chance attacks), so the ×2
    // coin-flip needs no rate reduction to keep fight outcomes narrow. The
    // honest scalar follows automatically (it prices realized rate × scale).
    crit_chance_scale: 1.0,
    // Boss texture: 15% rhythmic crit spikes + ~33% mitigation feel
    // (armor 1000 vs K_ARMOR 2000), both budget-neutral at spawn.
    boss_crit_chance: 1500.0,
    boss_armor: 1000.0,
    armor_k_per_chapter: 15.0,
    regen_tick_max_pct: REGEN_TICK_MAX_PCT,
    hot_tick_max_pct: HOT_TICK_MAX_PCT,
    dot_tick_max_pct: DOT_TICK_MAX_PCT,
    enemy_early_bump: ENEMY_EARLY_BUMP,
    enemy_mid_bump: ENEMY_MID_BUMP,
    eff_a1: EFF_A1,
    eff_b1: EFF_B1,
    eff_a2: EFF_A2,
    eff_b2: EFF_B2,
    eff_c2: EFF_C2,
    wave_damage_skew: WAVE_DAMAGE_SKEW,
    wave_hp_skew: WAVE_HP_SKEW,
    // Derived is the shipped default — since BAL-037 the signed knot curve
    // below. `legacy` stays available via OVERLORD_BAL_ENEMY_CURVE_MODE for
    // A/B and rollback.
    enemy_curve_mode: EnemyCurveMode::Derived,
};

// Wave skew defaults. An EQUAL pair keeps the survive/die break-even at
// true-power ratio r=1 (see the EXACT LAW on the `BalanceTuning` fields), and
// the sub-1 magnitude runs fights long (TTK ~20s): each outcome averages more
// RNG samples, so the win-chance sigmoid is steep — power, not luck, decides
// the fight. The tempo is designer-approved by feel; raising both toward √2
// shortens fights back to a punchier, more random game.
//
// DAMAGE_SKEW sits BELOW HP_SKEW deliberately (break-even r ≈ 0.83): the
// slot-model fight shapes (streamed waves holding ~6 attackers to the end,
// boss summon waves) deliver the same damage budget in a less survivable
// pattern than the legacy all-at-once decaying waves. 0.9 → 0.75 compensates
// that shape cost so effective difficulty matches `main` (validated by
// matched n=6 7-day sims, 2026-07). Per-fight deviations from this global
// value use `enemy_damage_mult` on the fight template (currently only the
// stage-1 end bosses, which the ability-less early game needs softer).
pub const WAVE_DAMAGE_SKEW: f64 = 0.75;
pub const WAVE_HP_SKEW: f64 = 0.9;

static BALANCE_TUNING: std::sync::OnceLock<BalanceTuning> = std::sync::OnceLock::new();

/// The process-wide balance tuning (defaults until [`init_tuning`] is called).
/// Hot-path safe — an atomic load of a `&'static`.
#[inline]
pub fn tuning() -> &'static BalanceTuning {
    BALANCE_TUNING.get().unwrap_or(&BALANCE_TUNING_DEFAULT)
}

/// Set the process-wide balance tuning once at startup (first call wins).
pub fn init_tuning(t: BalanceTuning) {
    let _ = BALANCE_TUNING.set(t);
}

impl BalanceTuning {
    /// Defaults, with any `OVERLORD_BAL_*` env var that parses applied on top.
    /// This is the sim-sweep entry point — no recompile, no deploy.
    pub fn from_env() -> Self {
        fn ovr_f(name: &str, cur: f64) -> f64 {
            std::env::var(name)
                .ok()
                .and_then(|v| v.parse().ok())
                .unwrap_or(cur)
        }
        fn ovr_i(name: &str, cur: i64) -> i64 {
            std::env::var(name)
                .ok()
                .and_then(|v| v.parse().ok())
                .unwrap_or(cur)
        }
        let d = BALANCE_TUNING_DEFAULT;
        BalanceTuning {
            // The DR denominators (`K/(R+K)`, `1 − ev/(ev+K)`) and the power
            // normaliser are divisors: a swept value of 0 yields a divide-by-zero
            // (+inf power, i64::MAX, 100%-dodge unkillable) or a 0/0 NaN. The
            // model requires K > 0 for the DR curve to be well-defined, so floor
            // these knobs at a small positive — a sweep then produces a measurable
            // result, never inf/NaN. Defaults (1500/2000/1800) are unaffected.
            k_armor: ovr_f("OVERLORD_BAL_K_ARMOR", d.k_armor).max(1.0),
            k_dodge: ovr_f("OVERLORD_BAL_K_DODGE", d.k_dodge).max(1.0),
            power_norm: ovr_f("OVERLORD_BAL_POWER_NORM", d.power_norm).max(1.0),
            enemy_curve_anchor_chapter: ovr_i(
                "OVERLORD_BAL_ENEMY_ANCHOR_CHAPTER",
                d.enemy_curve_anchor_chapter,
            ),
            hand_authored_chapter_max: ovr_i(
                "OVERLORD_BAL_HAND_AUTHORED_CHAPTER_MAX",
                d.hand_authored_chapter_max,
            ),
            enemy_curve_anchor_power: ovr_f(
                "OVERLORD_BAL_ENEMY_ANCHOR_POWER",
                d.enemy_curve_anchor_power,
            ),
            chapter_power_step: ovr_f("OVERLORD_BAL_ENEMY_STEP", d.chapter_power_step),
            enemy_step_late: ovr_f("OVERLORD_BAL_ENEMY_STEP_LATE", d.enemy_step_late),
            enemy_step_taper_start: ovr_i(
                "OVERLORD_BAL_ENEMY_STEP_TAPER_START",
                d.enemy_step_taper_start,
            ),
            sell_price_exp: ovr_f("OVERLORD_BAL_SELL_EXP", d.sell_price_exp),
            sell_price_coef: ovr_f("OVERLORD_BAL_SELL_COEF", d.sell_price_coef),
            crit_chance_scale: ovr_f("OVERLORD_BAL_CRIT_SCALE", d.crit_chance_scale).max(0.0),
            boss_crit_chance: ovr_f("OVERLORD_BAL_BOSS_CRIT", d.boss_crit_chance).max(0.0),
            boss_armor: ovr_f("OVERLORD_BAL_BOSS_ARMOR", d.boss_armor).max(0.0),
            armor_k_per_chapter: ovr_f("OVERLORD_BAL_ARMOR_K_PER_CH", d.armor_k_per_chapter)
                .max(0.0),
            regen_tick_max_pct: ovr_f("OVERLORD_BAL_REGEN_TICK_PCT", d.regen_tick_max_pct),
            hot_tick_max_pct: ovr_f("OVERLORD_BAL_HOT_TICK_PCT", d.hot_tick_max_pct),
            dot_tick_max_pct: ovr_f("OVERLORD_BAL_DOT_TICK_PCT", d.dot_tick_max_pct),
            enemy_early_bump: ovr_f("OVERLORD_BAL_ENEMY_EARLY_BUMP", d.enemy_early_bump),
            enemy_mid_bump: ovr_f("OVERLORD_BAL_ENEMY_MID_BUMP", d.enemy_mid_bump),
            eff_a1: ovr_f("OVERLORD_BAL_EFF_A1", d.eff_a1),
            eff_b1: ovr_f("OVERLORD_BAL_EFF_B1", d.eff_b1),
            eff_a2: ovr_f("OVERLORD_BAL_EFF_A2", d.eff_a2),
            eff_b2: ovr_f("OVERLORD_BAL_EFF_B2", d.eff_b2),
            eff_c2: ovr_f("OVERLORD_BAL_EFF_C2", d.eff_c2),
            // Both skews are multipliers/divisors on wave stat budgets — floor
            // at a small positive so a swept 0 can't zero the wave out.
            wave_damage_skew: ovr_f("OVERLORD_BAL_WAVE_DAMAGE_SKEW", d.wave_damage_skew).max(0.01),
            wave_hp_skew: ovr_f("OVERLORD_BAL_WAVE_HP_SKEW", d.wave_hp_skew).max(0.01),
            enemy_curve_mode: match std::env::var("OVERLORD_BAL_ENEMY_CURVE_MODE")
                .unwrap_or_default()
                .to_ascii_lowercase()
                .as_str()
            {
                "derived" => EnemyCurveMode::Derived,
                "legacy" => EnemyCurveMode::Legacy,
                _ => d.enemy_curve_mode,
            },
        }
    }
}

// --- Enemy power curve --------------------------------------------------------
// Campaign enemy power at/below the anchor chapter is hand-authored in the
// fight templates; above it a formula applies. Two formulas exist (see
// `EnemyCurveMode`): the DERIVED curve `G/(ρ̂·z)` is the shipped default; the
// legacy anchor/step/taper constants below remain for
// `OVERLORD_BAL_ENEMY_CURVE_MODE=legacy` A/B and rollback.
//
// The hand-authored ramp (ch0-6, stages 1-1..1-7) keeps 1-1 trivial for a
// zero-gear fresh player and then forces gear engagement with a taut P/E band.
// Shipped wave/boss `power` values (the `_2`/`_3` fight-template variants):
//   ch0 (1-1): wave=1,   boss=1    — trivial by design
//   ch1 (1-2): wave=60,  boss=100
//   ch2 (1-3): wave=120, boss=200  — the tautest early beat (a passive clear
//              is a coin flip here by design)
//   ch3 (1-4): wave=240, boss=400
//   ch4 (1-5): wave=480, boss=800
//   ch5 (1-6): wave=640, boss=1100
//   ch6 (1-7): wave=690, boss=1500
//   ch7 (1-8): first CURVE chapter of the calibration tables — but the
//              base_power/curve SPLIT for `enemy_power_scalar` is governed by
//              `HAND_AUTHORED_CHAPTER_MAX` (9), NOT this anchor. See below.
//
// ANCHOR_POWER is set so the legacy formula `anchor_power × STEP^(ch −
// anchor_ch)` continues the ramp smoothly: 528.35 × 1.30 = 686 at ch7. This
// anchor stays at 6 so the derived-curve calibration pins
// (`enemy_curve_anchored_and_monotonic`, which reads ANCHOR+1 = ch7) hold.
pub const ENEMY_CURVE_ANCHOR_CHAPTER: i64 = 6;
pub const ENEMY_CURVE_ANCHOR_POWER: f64 = 528.35;
/// Highest 0-based `current_chapter_level` at which `enemy_power_scalar`
/// resolves campaign enemy power from the hand-authored `FightTemplate.power`
/// (base_power) instead of the derived chapter curve. Set to 9 so the ENTIRE
/// first stage (levels 0..=9 = stages 1-1..1-10) is hand-authored onboarding
/// difficulty: the coderived curve AND the ch7-15 mid-boss gear gate do NOT
/// apply inside stage 1 (the gate still starts at ch10 = stage 2-1).
///
/// Levels 7,8,9 are EXCLUSIVELY stage-1 chapters (level 10 = stage 2-1), so
/// raising this from the legacy `ENEMY_CURVE_ANCHOR_CHAPTER` (6) changes ONLY
/// stage-1 difficulty and leaves every ch>=10 fight (curve + mid-boss bump)
/// byte-identical. Kept DISTINCT from the curve anchor so the derived-curve
/// calibration pins (anchored at ch7) are untouched. Env:
/// `OVERLORD_BAL_HAND_AUTHORED_CHAPTER_MAX`.
pub const HAND_AUTHORED_CHAPTER_MAX: i64 = 9;
// Legacy-mode enemy power step per chapter — the progression gate. It races
// the player's gear-driven power growth: too high a step walls progression
// dead, and the design wants progress to never fully stop — it should slow
// into being gold/cookie-gated (run dry → idle funds the next case upgrade →
// push on). 1.30 keeps the enemy close enough to the player power curve
// (EFF_B1 = 1.40) that the player keeps creeping forward by upgrading, while
// remaining a real gate. Tunable via `OVERLORD_BAL_ENEMY_STEP`; re-tune if the
// player power curve changes.
pub const CHAPTER_POWER_STEP: f64 = 1.30;
// Legacy-mode late-game step taper. A constant step out-paces the player's
// decelerating late power growth (~1.10-1.12×/ch), stalling chapters for
// days into a soft wall. Past ENEMY_STEP_TAPER_START the per-chapter step
// decays smoothly toward ENEMY_STEP_LATE so the gate tracks late power — the
// player advances ~daily (power still decelerates, progress never stops).
// 1.10 ≈ the player's late power slope: slow in-session power creep keeps
// clearing chapters even at the deep wall, while the real jump comes next day
// from AFK income. The taper starts at ch42 so the early game and the firm
// honeymoon are untouched.
pub const ENEMY_STEP_LATE: f64 = 1.10;
pub const ENEMY_STEP_TAPER_START: i64 = 42;
/// Mid-game enemy bump — **applied only to CampaignBossFight**, over the
/// ch12–14 window (see [`enemy_mid_chapter_mult`]).
/// Applied via `OVERLORD_BAL_ENEMY_MID_BUMP`. stage2-bridge (2026-07-16) lowered
/// it 8.0 → 2.5 and moved the window off the stage-2 boundary: at 8.0 the gate
/// slammed ×5.67/×4.89 onto the ch10/ch11 bosses — the first stage-2 fights — an
/// instant wall for a fresh-ladder player exiting the new easy stage 1. The
/// legacy ch7 rationale is moot (ch0-9 is hand-authored now, the gate never
/// fired there). At 2.5 the gear-check is a boss EMPHASIS (bot boss-win ~0.9 at
/// ch12-14, vs wave ~1.0) landing mid-bridge where the wave curve is comfortable,
/// not a wall; a frozen (non-gearing) player is already walled by the wave curve.
/// Wave fights are unaffected (the bump is applied in `enemy_power_scalar`, not in
/// `enemy_power_for_chapter`), so the global power curve stays monotone.
/// stage2-bridge CYCLE 2 (2026-07-16): lowered 2.5 → 1.3 for the casual
/// re-pacing test — a gentle ch12-14 boss emphasis (at-cadence boss ~80% win)
/// rather than a gear-check, so no chapter reads as a wall. The smooth
/// cadence-ramped wave curve now carries all the difficulty shaping.
pub const ENEMY_MID_BUMP: f64 = 1.3;

/// Early-game stat-check bump strength. `1.0` = OFF, deliberately: the
/// hand-made→formula transition already lands the early chapters taut on its
/// own, and playtesting showed a bump here makes stages 1-3..1-5 feel
/// punishing ("cleared by luck") — so the geometric step runs cleanly through
/// the early game instead. Tune via `OVERLORD_BAL_ENEMY_EARLY_BUMP`.
pub const ENEMY_EARLY_BUMP: f64 = 1.0;

/// Early-game stat-check bump (off by default, see [`ENEMY_EARLY_BUMP`]): a
/// modest lift on ch3-5 on top of the geometric line, forcing the first gear
/// conversions. ch2 is deliberately untouched — it is hard resource-capped by
/// the 20 starter cookies, and any bump there deadlocks the player (0% win
/// with everything they can afford). Tapers to 1.0 by ch6 so later chapters
/// are unaffected.
fn enemy_early_chapter_mult(chapter: i64) -> f64 {
    let bump = tuning().enemy_early_bump;
    if bump <= 1.0 {
        return 1.0;
    }
    // First check at ch3 (quest cookies have unlocked headroom there), tapering
    // to 1.0 by ch6. ch2 stays untouched — it is hard resource-capped by the 20
    // starter cookies and a bump there deadlocks (sim-confirmed).
    match chapter {
        3 => bump,
        4 => 1.0 + (bump - 1.0) * 0.66,
        5 => 1.0 + (bump - 1.0) * 0.33,
        _ => 1.0,
    }
}

/// Mid-game **boss-only** gear-engagement gate (ch7–15). Applied in
/// [`enemy_power_scalar`] only for `CampaignBossFight` (not wave fights), so
/// normal wave progression is unaffected while the boss is the hard gate.
///
/// Why boss-only: applying the bump to wave fights too causes global monotonicity
/// violations in `enemy_power_for_chapter` for any bump > STEP (1.30) — the taper
/// endpoint has mult(last_ch) > 1.0 while the next chapter returns 1.0, creating a
/// downstep. Restricting the bump to bosses avoids that problem entirely.
///
/// With `stop_on_lose=true` on campaign bosses and the lazy bot strategy not retrying
/// (`_retry_boss_if_needed` removed from the frozen action list), one loss = permanent
/// wall. The bump must be large enough that the first-try win probability is low for
/// a frozen player (≤ 10-15%). At bump=8 with STEP=1.30 the boss power at ch7
/// becomes `enemy(7) × STEP^0.5 × 8 = 687 × 1.14 × 8 = 6265` vs lazy power ~2121,
/// P/E ≈ 0.34 → ~7% first-try win rate → ~93% of lazy bots wall on first encounter.
///
/// Tapers linearly from `enemy_mid_bump` at ch7 to 1.0 at ch16. ch6 and below:
/// 1.0 (respects "don't make ch1-5 harder" hard constraint). ch16+: 1.0 (ability-slot
/// system takes over as the engagement lever). 1.0 = off (mid_bump ≤ 1.0 = no gate).
pub(crate) fn enemy_mid_chapter_mult(chapter: i64) -> f64 {
    let bump = tuning().enemy_mid_bump;
    if bump <= 1.0 {
        return 1.0;
    }
    // stage2-bridge (2026-07-16): the gate window moved from ch7-15 to ch12-15
    // (exclusive upper bound ch15). The legacy ch7 anchor is moot — the whole
    // first stage (ch0-9) is now hand-authored (HAND_AUTHORED_CHAPTER_MAX=9), so
    // the gate never fired below ch10 anyway, and slamming ×5.67/×4.89 onto the
    // ch10/ch11 bosses (the FIRST stage-2 fights) was the primary "next fights
    // kill you too much" wall. Now ch10-11 bosses have NO gate (clean boundary,
    // mult=1.0) and the gear-check ramps over ch12-14 (peak at ch12), landing
    // MID-BRIDGE where the wave curve is comfortable, then off by ch15 (the
    // pinned rejoin). frac over the 3-chapter (15-12) window.
    if !(12..15).contains(&chapter) {
        return 1.0;
    }
    let frac = (15 - chapter) as f64 / (15 - 12) as f64;
    1.0 + (bump - 1.0) * frac
}

// --- Derived enemy curve: E(ch) = G(ch) / ρ(ch) -------------------------------
// The legacy curve is two geometric streams tuned separately (enemy
// anchor/step vs the player's emergent growth), which mathematically
// guarantees a wall wherever their slopes diverge — historically patched with
// the early/mid bumps and the taper. The derived mode (the shipped default)
// inverts the definition:
//
//     E(ch) = G(ch) / ρ(ch)
//
// where G(ch) is the reference (free archetype) honest power at chapter `ch`
// (baked from calibration, sparse knots + geometric interpolation) and ρ(ch)
// is the DESIGNED pressure profile (ρ>1 ⇒ player ahead/easy, ρ<1 ⇒ pressure).
// Pressure is declared, growth is measured, the gate is derived — editing
// pressure can never silently violate the treadmill contract, because E
// inherits G's slope wherever ρ is flat. Env: `OVERLORD_BAL_ENEMY_CURVE_MODE`.

/// Which formula [`enemy_power_for_chapter`] uses.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EnemyCurveMode {
    /// `anchor × step^(ch−anchor_ch)` with taper/bumps (the shipped curve).
    Legacy,
    /// The BAL-037 signed knot curve (see the section below).
    Derived,
}

/// Reference player (free archetype) honest power per chapter — sparse
/// calibration knots `(chapter, power)`.
///
/// Baked by `overlord/tools/sim_orchestrator/economy_model.py coderive`
/// (supply-side pacing: the curve is derived FROM the resource schedule, not
/// measured under the old curve): per-chapter fundable growth from
/// `overlord/balance/supply_schedule.json` is run through the gear/ability
/// pipeline and scaled by the conversion efficiency η measured per band from
/// a calibration sim (current η and anchors live in `CODERIVE_*` in
/// economy_model.py). Tail knots extrapolate at the funded late slope.
///
/// Re-derive (coderive + re-bake) whenever the resource schedule, the
/// gear/ability pipeline, or a new power source changes measured η. Two
/// measurement caveats: on an overheated run η must be measured as PURE
/// conversion (measured Δln G over natural + pipeline growth at the bot's
/// ACTUAL band spends) — a schedule-based denominator deflates under fast
/// running and pushes E the wrong way; and the Mastery channel funds per boss
/// kill rather than per band supply, so η smears it multiplicatively.
pub const PLAYER_GROWTH_KNOTS: &[(i64, f64)] = &[
    // stage2-bridge CYCLE 3 (2026-07-16): the WHOLE power-per-chapter function
    // is retired from ch10 onward and re-derived from the required chest-open
    // cadence. E(ch) = P_at_cadence(X(ch), ch) / (z · ρ̂_comfort=1.5), so an
    // at-cadence player sits at ~91% win every chapter (casual, never a wall);
    // below-cadence stalls SOFTLY, above-cadence breezes.
    //   • Entry anchor: expected player power 300 at ch10 → E(10)≈416 (designer:
    //     "enter stage 2 with like 300 power").
    //   • X(ch) = 12·(ch−10)/39 opens/min: 0 at ch10 (stage 2-1) rising to the
    //     12/min median at ch49 (stage 5-10), then FLAT at 12/min for the rest
    //     of the curve.
    //   • P_at_cadence = MEASURED power-per-chapter of the cadence_{3,6,12}
    //     organic bots (run_1784232702 / SIM_4), measured to ~ch75; the ch50+
    //     tail follows the 12/min slope (×1.057/ch) — MODEL-EXTRAPOLATED past
    //     ch75 (unreachable in-test), smoothed for monotonicity.
    // G here is a reference-power path, NOT the funded coderive curve (income is
    // untouched). ch7 (5660) is kept as the stage-1/legacy anchor (E(7)=686
    // pin, phantom — ch0-9 are hand-authored, never spawn-scaled by this curve),
    // so E(10)=416 < E(7)=686: the derived curve is monotonic only in its
    // PRODUCTION domain ch≥10 (see `enemy_curve_anchored_and_monotonic`). All
    // `zone_correction_preserves_enemy_curve` pins re-baked. See cycle-3 report.
    (7, 5660.0),
    (10, 2535.4),
    (11, 2979.2),
    (12, 3271.4),
    (13, 6137.3),
    (14, 17488.4),
    (15, 41943.5),
    (17, 91172.5),
    (19, 118805.9),
    (22, 721745.8),
    (25, 1237197.9),
    (28, 3353447.0),
    (31, 6741626.8),
    (34, 8205331.8),
    (37, 9597365.9),
    (40, 12186084.2),
    (43, 16414096.2),
    (46, 19323369.3),
    (49, 22991272.4),
    (55, 34263366.8),
    (62, 48069380.1),
    (70, 58352054.5),
    (80, 74337366.9),
    (90, 101734246.7),
    (100, 164556403.8),
    (120, 430548145.9),
];

/// Designed pressure profile — sparse knots, geometric interpolation. THE
/// designer-editable difficulty curve: raise a knot to make that zone easier
/// (player further ahead), lower it for pressure.
///
/// Units are zone-corrected: ρ̂ = P/(z(ch)·E(ch)) with z from
/// [`ZONE_DIFFICULTY_KNOTS`], so one value of ρ̂ means the SAME winrate in
/// every zone — the measured 50%-crossing is ≈0.55 everywhere, and a flat
/// stretch of the profile at ~0.65 plays as ~60% on-schedule winrate.
///
/// Shape: a glide from the pinned early anchor through the ch7-15 boss-gate
/// zone down to a working plateau, then a declining late tail. There are no
/// deliberate walls: pacing is carried by the resource schedule (E's
/// per-chapter step ≡ fundable growth per chapter at target cadence, so a
/// blitz stalls within ~1-3 chapters and daily supply restores the cadence);
/// the treadmill bounds are guarded by `test_pacing_contract`.
///
/// The values encode the ratified feel. Note the honest on-schedule winrate
/// is NOT flat across zones (~65% around ch49 falling to ~20-25% at ch62-87);
/// flattening it is a designer decision — it re-paces the late game — not a
/// calibration fix. E = G/(ρ̂·z) is pinned by
/// `zone_correction_preserves_enemy_curve`: never edit ρ̂ or z alone, only
/// together with a re-derivation of the pair (and G).
pub const RHO_TARGET_KNOTS: &[(i64, f64)] = &[
    (7, 17.1676),
    (9, 14.0254),
    (11, 11.4583),
    (14, 6.9059),
    (15, 5.9019),
    (19, 2.4295),
    (23, 1.8515),
    (27, 1.5763),
    (29, 1.6135),
    (34, 1.7105),
    (39, 1.8055),
    (49, 2.0116),
    (59, 2.2413),
    (62, 2.0393),
    (64, 1.9152),
    (87, 0.9287),
    (110, 0.7799),
    (120, 0.7229),
    (130, 0.6701),
    (160, 0.6701),
];

/// Zone difficulty correction z(ch): how much harder (>1) or easier (<1) a
/// chapter's content plays than the honest per-fight scalar P/E predicts.
/// The corrected ratio ρ̂ = P/(z·E) is a sufficient statistic for winrate:
/// its 50%-crossing is ≈0.55 in EVERY zone (the stat-check contract "come
/// with power" needs the ratio to mean the same thing everywhere).
///
/// Measured from sim runs on the current combat ruleset: per-chapter win
/// aggregates, weighted logistic fits per chapter band, z = band ρ50 / 0.55.
/// The drift it corrects is large and real — the same raw P/E can win ~78% in
/// one zone and ~11% in another, because mob ability kits and wave
/// compositions scale beyond raw stats. The map currently sits below 1.0
/// everywhere: the honest scalar conservatively drops the buff/debuff budget
/// shares of ability kits (see the `ability_info` closures), and that
/// undercount lands in z by construction. Pricing buffs honestly in the
/// scalar would move z back toward 1.0 — that is a future scalar change with
/// its own re-anchor.
///
/// Re-measure whenever mob kits, wave composition, or the combat package
/// change — the `sigmoid_center` grader gate is the staleness watchdog.
/// grade_pacing.py and economy_model.py carry mirrors of this table.
pub const ZONE_DIFFICULTY_KNOTS: &[(i64, f64)] = &[
    (14, 0.48),
    (34, 0.38),
    (59, 0.29),
    (87, 0.70),
    (130, 0.97),
    (160, 0.97),
];

/// Zone difficulty correction z at `chapter` (see [`ZONE_DIFFICULTY_KNOTS`]).
// The emptiness guard is deliberate: the knot tables are hand-baked and may be emptied to turn
// the derived mode off (callers fall back to legacy) — clippy 1.91 flags it as always-false
// against the CURRENT const value, which is exactly the point of the guard.
#[allow(clippy::const_is_empty)]
pub fn zone_difficulty(chapter: i64) -> f64 {
    if ZONE_DIFFICULTY_KNOTS.is_empty() {
        return 1.0;
    }
    interp_geometric(ZONE_DIFFICULTY_KNOTS, chapter)
}

/// Geometric (log-linear) interpolation over sparse `(chapter, value)` knots:
/// exact at knots, constant before the first, final-segment ratio extrapolation
/// past the last (the measured late slope continues — the treadmill contract's
/// "progress never fully stops" shape).
pub fn interp_geometric(knots: &[(i64, f64)], chapter: i64) -> f64 {
    match knots {
        [] => 0.0,
        [(_, v)] => *v,
        _ => {
            let (first_ch, first_v) = knots[0];
            if chapter <= first_ch {
                return first_v;
            }
            for w in knots.windows(2) {
                let (c0, v0) = w[0];
                let (c1, v1) = w[1];
                if chapter <= c1 {
                    let t = (chapter - c0) as f64 / (c1 - c0) as f64;
                    return v0 * (v1 / v0).powf(t);
                }
            }
            // Past the last knot: continue the final segment's per-chapter ratio.
            let (c0, v0) = knots[knots.len() - 2];
            let (c1, v1) = knots[knots.len() - 1];
            let per_ch = (v1 / v0).powf(1.0 / (c1 - c0) as f64);
            v1 * per_ch.powi((chapter - c1) as i32)
        }
    }
}

// ---------------------------------------------------------------------------
// BAL-037 — signed campaign PvE curve.
//
// Supersedes the coderived `G/(ρ̂·z)` form below: that curve produced an
// accidental ×9 step at ch9→10, dense spikes across ch12…17 and boss-only bumps
// on ch12/13/14, none of which survive the accepted streak/wall cadence.
//
// The whole ladder is authored as sparse knots plus one deterministic wall
// formula — never 510 hand-typed rows. `S_ref(ch)` is the MEDIAN `S_real` of
// four class-specific obvious-good legal builds, so the curve is not pinned to
// the weakest class and does no hidden class compensation.
// ---------------------------------------------------------------------------

/// Early analytic `S_ref` seed for FTUE and first-hour diagnostics. Runtime
/// difficulty after FTUE is authored by `E_base`; no second hand-written
/// reference ladder exists beyond the universal-tail anchor.
pub const S_REF_KNOTS: &[(i64, f64)] = &[
    (0, 30.0),
    (9, 4_100.0),
    (10, 6_500.0),
    (21, 50_000.0),
    (25, 135_500.0),
    (31, 203_250.0),
    (35, 271_000.0),
    (40, 356_365.0),
    (45, 542_000.0),
];

/// Smooth early `E_base` calibration through chapter 45. The knots only bridge
/// FTUE and the first-hour feature/power ramp; after chapter 45 one universal
/// geometric multiplier owns the entire campaign tail (see [`e_base`]).
///
/// Timing anchors are deliberately approximate. They grade the resulting
/// all-free cohort, not individual rows, and must never be enforced by chapter
/// spikes or terminal caps.
pub const E_BASE_KNOTS: &[(i64, f64)] = &[
    (10, 2_745.0),
    // Explicit seam: no scalar uplift reaches the pre-gate path.
    (21, 12_766.786),
    (25, 30_252.580),
    (31, 69_964.014),
    (35, 122_353.461),
    (45, 302_619.0),
];

/// The universal progression starts before the end of the first active hour.
/// From here on there are no hand-authored chapter difficulty values.
const E_BASE_TAIL_ANCHOR_CH: i64 = 45;
/// Authoritative recurrence: `E_base(ch) = E_base(45) × 1.075^(ch−45)`.
/// A roughly +20% player-strength spike opens two to three chapters and +50%
/// opens five to six: `ln(spike) / ln(1.075)`. Natural resource exhaustion
/// creates stalls; the enemy curve does not author them.
const E_BASE_TAIL_STEP: f64 = 1.075;

/// FTUE (ch0…9) reads `S_ref × (0.45 → 0.65)`, ramped linearly across the block.
/// Current absolute rows `1…46` are deliberately NOT preserved: arithmetic
/// safety and 100% legal-starter wins outrank their scale.
const FTUE_MAX_CH: i64 = 9;
const FTUE_SHARE_START: f64 = 0.45;
const FTUE_SHARE_END: f64 = 0.65;

/// One total normalized encounter coefficient for every boss on every chapter,
/// FTUE included: `sqrt(1.30)`. It covers the WHOLE encounter budget including
/// a potential summon wave — adds never get a second `sqrt(1.30)` on top.
/// Hand-authored per-chapter boss ratios and the legacy ch12/13/14 bumps are
/// removed: no chapter through ch21 may read as a wall.
pub const BOSS_ENCOUNTER_COEF_SQ: f64 = 1.30;

/// Unrounded `E_base(ch)` across the whole ladder.
///
/// Three regimes, continuous at their seams: the FTUE share of `S_ref` through
/// ch9, sparse early knots ch10…45, and the exact `×1.075` universal tail.
pub fn e_base(chapter: i64) -> f64 {
    let ch = chapter.max(0);
    if ch <= FTUE_MAX_CH {
        let t = ch as f64 / FTUE_MAX_CH as f64;
        let share = FTUE_SHARE_START + (FTUE_SHARE_END - FTUE_SHARE_START) * t;
        return interp_geometric(S_REF_KNOTS, ch) * share;
    }
    if ch <= E_BASE_TAIL_ANCHOR_CH {
        return interp_geometric(E_BASE_KNOTS, ch);
    }
    let anchor = interp_geometric(E_BASE_KNOTS, E_BASE_TAIL_ANCHOR_CH);
    anchor * E_BASE_TAIL_STEP.powi((ch - E_BASE_TAIL_ANCHOR_CH) as i32)
}

// ---------------------------------------------------------------------------
// A2-BAL-002 §2.5 — the two difficulty axes
// ---------------------------------------------------------------------------

/// Multiplier on encounter HP, checked against the player's DPS.
///
/// Sparse knots, interpolated in log space, EMPTY by default — an empty table
/// means `1.0` everywhere, so authoring nothing changes nothing.
///
/// Why this exists as its own curve: enemy strength was a single scalar,
/// decomposed into HP and Attack by fixed exponents inside `spawn_wave`. That
/// makes the two failure modes inseparable. A boss that dies at the right speed
/// while the player never drops below 90 % HP and a boss that is a bullet sponge
/// the player barely survives are OPPOSITE problems, and one scalar behind a
/// `sqrt` cannot fix one without moving the other — every correction trades a
/// pacing failure for a survival failure.
///
/// §2.7's correction matrix assumes two independent levers: raise `K_OUT` when
/// survival pressure is missing, lower `K_HP` when a boss takes too long, and do
/// both when the fight is wrong on both axes.
pub const K_HP_KNOTS: &[(i64, f64)] = &[
    (21, 1.0),
    (25, 2.0),
    // Smoothly spend more of each chapter in its two actual fights instead of
    // parking the player at an authored loss wall.
    (35, 4.0),
    // The first-hour trace with a flat 4 reached ch65 at 46.5m. Continuing the
    // same geometric ramp to 8 distributes the missing fight time across the
    // whole ch35…45 band; 8 is then a permanent combat-shape constant.
    (45, 8.0),
];

/// Multiplier on enemy outgoing damage, checked against the player's EHP. See
/// [`K_HP_KNOTS`] — same shape, same default, the other axis.
pub const K_OUT_KNOTS: &[(i64, f64)] = &[
    (21, 1.0),
    (25, 1.0),
    (31, 2.0),
    // Together with K_HP this reaches the former healthy ch45 damage integral
    // without any discontinuity, then remains a constant calibration factor.
    (35, 2.4),
    (45, 3.4),
];

/// A2-BAL-001 frozen outgoing-equivalence correction after removal of the
/// automatic boss stun. These are measured `D_old / D_unstunned` ratios from
/// the signed reference matrix, not a reconstructed duty-cycle formula: boss
/// kits contain both Attack-derived and flat payloads, so only the complete
/// deterministic trace can preserve the previously shipped outgoing budget.
///
/// The correction is stamped on boss entities and consumed after per-cast
/// damage composition. Ordinary mobs, PvP entities, summons and the boss stun
/// substrate are untouched.
pub const BOSS_OUTGOING_EQUIVALENCE_KNOTS: &[(i64, f64)] = &[
    (1, 3.6667),
    (10, 1.2291),
    (21, 1.4828),
    (25, 1.6077),
    (31, 1.6570),
    (35, 1.2435),
    (45, 1.6592),
    (60, 1.2043),
    (65, 1.2046),
];

pub fn boss_outgoing_equivalence(chapter: i64) -> f64 {
    axis_multiplier(BOSS_OUTGOING_EQUIVALENCE_KNOTS, chapter)
}

/// `K_HP(ch)`. `1.0` while the table is unauthored.
pub fn k_hp(chapter: i64) -> f64 {
    axis_multiplier(K_HP_KNOTS, chapter)
}

/// `K_OUT(ch)`. `1.0` while the table is unauthored.
pub fn k_out(chapter: i64) -> f64 {
    axis_multiplier(K_OUT_KNOTS, chapter)
}

/// Shared reader for both axes: log-space interpolation between sparse knots,
/// **held flat outside them**, identity when unauthored.
///
/// The clamp is the important part. `interp_geometric` EXTRAPOLATES past its
/// last knot — a table authored to ch30 reads `5.6e14` at ch500, which would
/// quietly run difficulty off the end of whatever range someone happened to
/// author. A refit authors the bands it measured; chapters beyond them must
/// inherit the last authored value, not a projection of it.
///
/// A non-positive knot makes log interpolation meaningless and could zero an
/// encounter outright, so it is rejected rather than clamped.
pub fn axis_multiplier(knots: &[(i64, f64)], chapter: i64) -> f64 {
    if knots.is_empty() {
        return 1.0;
    }
    debug_assert!(
        knots.iter().all(|(_, v)| *v > 0.0),
        "difficulty-axis knots must be positive: log-space interpolation is undefined at zero"
    );
    let first = knots.first().expect("non-empty");
    let last = knots.last().expect("non-empty");
    if chapter <= first.0 {
        return first.1;
    }
    if chapter >= last.0 {
        return last.1;
    }
    interp_geometric(knots, chapter).max(f64::MIN_POSITIVE)
}

/// Ordinary wave power at `chapter`, floored once at the end. There is no
/// chapter-specific wall layer: the smooth base curve is the whole scalar.
pub fn enemy_wave_power(chapter: i64) -> f64 {
    e_base(chapter).floor()
}

/// Boss encounter power at `chapter`, floored once at the end.
///
/// The association is fixed: `floor(E_base × sqrt(1.30))`, computed from the
/// unrounded base. No chapter-specific bump or wall multiplier is applied.
pub fn enemy_boss_power(chapter: i64) -> f64 {
    (e_base(chapter) * BOSS_ENCOUNTER_COEF_SQ.sqrt()).floor()
}

/// The derived-mode curve `G(ch)/(ρ̂(ch)·z(ch))`, or `None` when the
/// calibration tables are not baked — callers fall back to legacy. ρ̂ is the
/// zone-corrected pressure target and z the zone difficulty correction; their
/// product is the raw-scalar pressure the curve implements.
// Same deliberate emptiness guard as `zone_difficulty` — see the note there.
#[allow(clippy::const_is_empty)]
pub fn enemy_power_derived(chapter: i64) -> Option<f64> {
    if PLAYER_GROWTH_KNOTS.is_empty() || RHO_TARGET_KNOTS.is_empty() {
        return None;
    }
    let growth = interp_geometric(PLAYER_GROWTH_KNOTS, chapter);
    let rho_raw =
        (interp_geometric(RHO_TARGET_KNOTS, chapter) * zone_difficulty(chapter)).max(0.01);
    Some((growth / rho_raw).floor())
}

/// Absolute enemy power at `chapter`: `ANCHOR · ∏ step(c)`, where the per-chapter
/// step is the constant `chapter_power_step` until `enemy_step_taper_start`, then
/// decays smoothly toward `enemy_step_late` so late-game difficulty tracks the
/// player's decelerating power (no multi-day stalls). With the taper OFF
/// (`enemy_step_late >= chapter_power_step`) this is the original closed form
/// `ANCHOR · STEP^(chapter − ANCHOR_CH)`. A tapering early-chapter bump
/// (see [`enemy_early_chapter_mult`]) multiplies the result.
///
/// Note: the mid-game bump ([`enemy_mid_chapter_mult`]) is NOT applied here — it
/// is applied only to `CampaignBossFight` in [`enemy_power_scalar`], so wave
/// fights and the global power curve remain unaffected (avoids monotonicity
/// violations for large bump values).
pub fn enemy_power_for_chapter(chapter: i64) -> f64 {
    let t = tuning();
    // BAL-037: the signed sparse-knot curve owns the whole ladder ch0…509,
    // FTUE included. It supersedes both the coderived `G/(ρ̂·z)` form and the
    // legacy anchor/step/taper fallback, which survive below only as an
    // explicit env-selected rollback mode.
    if t.enemy_curve_mode == EnemyCurveMode::Derived {
        return enemy_wave_power(chapter);
    }
    let exp = (chapter - t.enemy_curve_anchor_chapter).max(0);
    let growth = if t.enemy_step_late >= t.chapter_power_step {
        // Taper OFF — closed form (unchanged, preserves all pinned curves/tests).
        t.chapter_power_step.powi(exp as i32)
    } else {
        // Taper ON — cumulative product. step(c) decays from the base step toward
        // the late floor with a fixed half-life past `enemy_step_taper_start`.
        const TAPER_DECAY: f64 = 0.9; // ~base→late over ~25 chapters
        let mut g = 1.0_f64;
        for i in 1..=exp {
            let c = t.enemy_curve_anchor_chapter + i;
            let over = (c - t.enemy_step_taper_start).max(0) as f64;
            let step = t.enemy_step_late
                + (t.chapter_power_step - t.enemy_step_late) * TAPER_DECAY.powf(over);
            g *= step;
        }
        g
    };
    (t.enemy_curve_anchor_power * growth * enemy_early_chapter_mult(chapter)).floor()
}

// --- Gold faucet shaping ------------------------------------------------------
// The dominant gold faucet is selling items, priced from an item's
// effectiveness `eff`. Priced linearly, sale income outruns the geometric
// chest-upgrade sink mid/late game, leaving gold in runaway surplus so the
// cost curve never binds progression. Pricing items sub-linearly as
// `eff^SELL_PRICE_EXP · SELL_PRICE_COEF` flattens the faucet so the geometric
// sink can bind; `COEF` anchors early low-`eff` sales at the established price
// level. EXP is bot-sim calibrated to land the free player's sink/faucet ratio
// in the "gold gets spent, not hoarded" band without starving the faucet below
// the sink. The whale still front-loads real-money gold; that surplus is by
// design ("soft currency in surplus, engineer the sink"). Tunable via
// `OVERLORD_BAL_SELL_EXP`.
pub const SELL_PRICE_EXP: f64 = 0.45;
pub const SELL_PRICE_COEF: f64 = 87.0;

/// Share of MAX HP an entity regenerates per second, in permyriad (`100` =
/// `1%/s`). BAL-034 gives the regen class a specialization that keeps meaning
/// something as HP pools grow: a flat rate authored for early gear is noise by
/// the time a player has ten times the HP.
pub const REGEN_PERCENT_CODE: &str = "regeneration_percent";

/// Item sale price (sell-currency units) from an item's effectiveness `eff`:
/// `floor(eff^sell_price_exp · sell_price_coef)`. Sub-linear (`exp < 1`) so
/// gold income grows ~linearly with item level and the geometric chest sink
/// can bind. Pure + sim-tunable via [`tuning()`]; the call site is
/// `behaviors::items::item_price`.
pub fn sell_price(eff: f64) -> i64 {
    let t = tuning();
    (eff.max(0.0).powf(t.sell_price_exp) * t.sell_price_coef).floor() as i64
}

// --- Character XP faucet (BAL-009) -------------------------------------------
// Selling an item is the only runtime XP source, so the level curve and this
// faucet are two halves of one contract: the level-cost bands are fixed
// (`CharacterLevelFormula`), and pacing is tuned from THIS side. One global
// exponent cannot hit L50, L100 and L200 at once — a fit of the first two lands
// around L165 by day 30 — so the shape breaks once, after Character L100, and
// continues from the same scale rather than introducing a second one.
//
// `XP(L<=100) = round(coef · eff_level(L)^exp · sqrt(quality))`
// `XP(L>100)  = round(coef · eff_level(100)^exp · (eff_level(L)/eff_level(100))^late_exp · sqrt(quality))`
//
// Normalizing the tail through `eff_level(100)` keeps the two branches
// continuous at the break. These are initial implementation coefficients: they
// move only on a full replacement-flow cohort trace, never together with the
// level-cost curve.
pub const ITEM_XP_COEF: f64 = 6.7;
pub const ITEM_XP_EXP: f64 = 0.50;
pub const ITEM_XP_LATE_EXP: f64 = 2.16;
pub const ITEM_XP_BREAK_LEVEL: f64 = 100.0;

/// Character XP paid by selling one item, from the item's snapshot character
/// `level` and its quality multiplier `quality` (the rarity axis `M`).
///
/// Level and quality are the ONLY inputs: two items of the same level and
/// quality pay the same XP regardless of stat roll, optional stats or
/// `power_bonus`. No per-sale cap — a lucky sale may carry the player through
/// several levels and the whole overflow is kept.
///
/// Env overrides (sim sweep): `OVERLORD_BAL_ITEM_XP_COEF`,
/// `OVERLORD_BAL_ITEM_XP_EXP`, `OVERLORD_BAL_ITEM_XP_LATE_EXP`.
pub fn item_experience(level: f64, quality: f64) -> i64 {
    let coef = env_f64("OVERLORD_BAL_ITEM_XP_COEF").unwrap_or(ITEM_XP_COEF);
    let exp = env_f64("OVERLORD_BAL_ITEM_XP_EXP").unwrap_or(ITEM_XP_EXP);
    let late_exp = env_f64("OVERLORD_BAL_ITEM_XP_LATE_EXP").unwrap_or(ITEM_XP_LATE_EXP);

    let eff = eff_by_level(level).max(0.0);
    let shape = if level <= ITEM_XP_BREAK_LEVEL {
        eff.powf(exp)
    } else {
        let eff_break = eff_by_level(ITEM_XP_BREAK_LEVEL).max(f64::MIN_POSITIVE);
        eff_break.powf(exp) * (eff / eff_break).powf(late_exp)
    };

    (coef * shape * quality.max(0.0).sqrt()).round() as i64
}

/// Read an `OVERLORD_BAL_*` f64 override; `None` if unset or unparseable. Same
/// parse as [`BalanceTuning::from_env`]'s `ovr_f`, so the env precedence below
/// is identical to the process-wide `tuning()` sweep mechanism. `tuning()`
/// itself collapses env-or-constant into one value and can't report whether the
/// env var was actually set, so the config-aware price reads presence directly.
fn env_f64(name: &str) -> Option<f64> {
    std::env::var(name).ok().and_then(|v| v.parse().ok())
}

/// Per-knob precedence for the config-aware sell price: the `OVERLORD_BAL_SELL_*`
/// env override (sim sweep) wins when present, else the GameConfig value
/// (`Some`), else the compiled constant.
#[inline]
fn resolve_sell_knob(env: Option<f64>, cfg: Option<f64>, default: f64) -> f64 {
    env.or(cfg).unwrap_or(default)
}

/// Item sale price with the exponent/coefficient sourced from GameConfig
/// (`game_settings.sell_price_{exp,coef}`). Per-knob precedence:
/// `OVERLORD_BAL_SELL_EXP` / `OVERLORD_BAL_SELL_COEF` env override (sim sweep) >
/// GameConfig value (`Some`) > the compiled [`SELL_PRICE_EXP`] /
/// [`SELL_PRICE_COEF`] constants. With env unset and both config knobs `None`
/// this is bit-identical to [`sell_price`] (the pre-config behavior), so
/// deploying the config with the current constant values leaves every price
/// unchanged. Call site: `behaviors::items::item_price`.
pub fn sell_price_with_config(eff: f64, cfg_exp: Option<f64>, cfg_coef: Option<f64>) -> i64 {
    let exp = resolve_sell_knob(env_f64("OVERLORD_BAL_SELL_EXP"), cfg_exp, SELL_PRICE_EXP);
    let coef = resolve_sell_knob(env_f64("OVERLORD_BAL_SELL_COEF"), cfg_coef, SELL_PRICE_COEF);
    (eff.max(0.0).powf(exp) * coef).floor() as i64
}

/// BAL-008 sale price: `round(G0 × eff_level(snapshot)^α × M_quality)`.
///
/// The shape differs from [`sell_price_with_config`] in a way that is easy to
/// miss: the quality multiplier is **linear**, OUTSIDE the exponent. The old
/// form raised the already-multiplied `eff_by_level × rarity_q` to `α`, which
/// re-prices rarity by `α` as well; the signed table assumes rarity scales the
/// price directly. Feeding the pre-multiplied `eff` into the new constants would
/// look right and produce quite different Gold.
///
/// Depends only on snapshot Character Level and quality, so two items of the
/// same level and quality sell for the same regardless of their ±10% stat roll,
/// optional stats or `power_bonus`.
pub fn sell_gold(eff_level: f64, quality: f64, cfg_exp: Option<f64>, cfg_coef: Option<f64>) -> i64 {
    let exp = resolve_sell_knob(env_f64("OVERLORD_BAL_SELL_EXP"), cfg_exp, SELL_PRICE_EXP);
    let coef = resolve_sell_knob(env_f64("OVERLORD_BAL_SELL_COEF"), cfg_coef, SELL_PRICE_COEF);
    (coef * eff_level.max(0.0).powf(exp) * quality.max(0.0)).round() as i64
}

/// Per-tick heal/damage cap: `amount` bounded above by `pct × max_hp`. Used by
/// the regen / HoT / DoT combat ticks so a mis-tuned effect can't out-heal all
/// incoming damage (regen/HoT) or one-shot (DoT). Pure + testable; `pct` comes
/// from the matching [`tuning()`] knob (`regen|hot|dot_tick_max_pct`).
pub fn cap_per_tick(amount: f64, max_hp: f64, pct: f64) -> f64 {
    amount.min(max_hp * pct)
}

/// Multiplicative buff/debuff factor from a proc chance `p` (0..1): a buff of
/// strength [`BUFF_EFF`] held for a mean uptime, stacked `quantity` times.
/// Preserves the legacy `(1 + (BUFF_EFF−1)·uptime)^quantity` shape exactly.
pub fn buff_uptime_mult(p: f64, quantity: i64, duration: f64) -> f64 {
    if p <= 0.0 {
        return 1.0;
    }
    let uptime = (CASTS_PER_SEC * p * duration / quantity as f64).min(1.0);
    (1.0 + (BUFF_EFF - 1.0) * uptime).powi(quantity as i32)
}

/// Honest two-branch pricing for bravery/deceit: a proc picks RANDOMLY
/// between an offensive branch (empower/vulnerability = ×1.5 in power terms)
/// and a defensive one (protection/weakness = ×0.5 damage/attack ⇒ ×2.0 in
/// power terms) — each branch runs at HALF the proc uptime. A single-EFF
/// shape would under-value the defensive branch ~25% at high uptime. Power is
/// DPS×EHP, so the combined factor applies wherever the caller multiplies it
/// in.
pub fn buff_uptime_mult_branches(p: f64, duration: f64) -> f64 {
    const BUFF_EFF_OFFENSE: f64 = 1.5; // Empower +50% attack / Vulnerability +50% taken
    const BUFF_EFF_DEFENSE: f64 = 2.0; // Protection ×0.5 taken / Weakness ×0.5 attack
    if p <= 0.0 {
        return 1.0;
    }
    let uptime = (CASTS_PER_SEC * p * duration / 2.0).min(1.0);
    (1.0 + (BUFF_EFF_OFFENSE - 1.0) * uptime) * (1.0 + (BUFF_EFF_DEFENSE - 1.0) * uptime)
}

/// Pure: stochastic round of a non-integer value.
pub fn rand_round_f64(value: f64, random: &GameRng) -> i64 {
    let base = value.floor();
    let prob = value - base;
    if prob > 0.0 && random.random_f64() < prob {
        return base as i64 + 1;
    }
    base as i64
}

pub fn effect_cost(duration: f64) -> f64 {
    (BUFF_EFF - 1.0) * (SPELL_QUANTITY - 1) as f64 * duration * BASE_SPELL_EFF
}

pub fn effect_duration(cost: f64) -> f64 {
    cost / ((BUFF_EFF - 1.0) * (SPELL_QUANTITY - 1) as f64 * BASE_SPELL_EFF)
}

fn buff_p_from_eff(eff: f64, cast_rate: f64, duration: f64, effects_quantity: i64) -> f64 {
    let uptime_max = (cast_rate * duration / effects_quantity as f64).min(1.0);
    let eff_max = (1.0 + (BUFF_EFF - 1.0) * uptime_max).powi(effects_quantity as i32);
    if eff >= eff_max {
        return 1.0;
    }
    let effect_eff = eff.powf(1.0 / effects_quantity as f64);
    let effect_uptime = ((effect_eff - 1.0) / (BUFF_EFF - 1.0)).max(0.0);
    let p = effect_uptime * effects_quantity as f64 / (cast_rate * duration);
    p.clamp(0.0, 1.0)
}

pub fn bravery_p_from_eff(eff: f64) -> f64 {
    buff_p_from_eff(
        eff,
        CASTS_PER_SEC,
        BRAVERY_BUFF_DURATION,
        BRAVERY_BUFF_QUANTITY,
    )
}

pub fn deceit_p_from_eff(eff: f64) -> f64 {
    buff_p_from_eff(
        eff,
        CASTS_PER_SEC,
        DECEIT_DEBUFF_DURATION,
        DECEIT_DEBUFF_QUANTITY,
    )
}

pub fn attr_spread_random(random: &GameRng) -> f64 {
    1.0 + ATTR_DEVIATION * (2.0 * random.random_f64() - 1.0)
}

pub fn hp_k_for_level(level: f64) -> f64 {
    const ALL_SPELLS_LEVEL: f64 = 30.0;
    if level > ALL_SPELLS_LEVEL {
        return 1.0;
    }
    ((level - 1.0) / (ALL_SPELLS_LEVEL - 1.0) * (SPELL_QUANTITY - 1) as f64 + 1.0)
        / SPELL_QUANTITY as f64
}

// `eff_by_level` curve constants (item effectiveness vs item level). Two
// branches joined at L=130: a steep early power-law and a flat late power-law.
// Module consts + the `tuning()` surface so the bot-sim can sweep the
// early-power SHAPE (`EFF_B1`) without a recompile.
//
// This curve — not the economy — sets how fast power grows early: item level
// tracks the level/clock, and with the gear-eff→power exponent k≈1 (each
// item's attack & hp scale as eff^0.5, so P=DPS·EHP ∝ eff^1; the quadratic S²
// is the separate SPELL axis) B1 maps ~1:1 into power. B1 = 1.40 keeps the
// first sessions from being a power geyser; B2 = 0.40 keeps late power
// climbing (no far-late plateau — "fighting never stops"). The late branch
// (A2,B2,C2) must stay continuous with the early branch at L=130 in value AND
// slope. Closed form: V=A1·129^B1+1=98.52, S=A1·B1·129^(B1-1)=1.0583,
// A2=S·130^(1-B2)/B2=49.08, C2=V-A2·130^B2=-245.40. All sim-tunable via
// OVERLORD_BAL_EFF_*; re-derive A2/C2 if B1 or B2 move.
pub const EFF_MIDGAME_LEVEL: f64 = 130.0;
pub const EFF_A1: f64 = 0.1082166549;
pub const EFF_B1: f64 = 1.40;
pub const EFF_C1: f64 = 1.0;
pub const EFF_A2: f64 = 49.08;
pub const EFF_B2: f64 = 0.40;
pub const EFF_C2: f64 = -245.40;

pub fn eff_by_level(level: f64) -> f64 {
    let t = tuning();
    if level <= EFF_MIDGAME_LEVEL {
        t.eff_a1 * (level - 1.0).powf(t.eff_b1) + EFF_C1
    } else {
        t.eff_a2 * level.powf(t.eff_b2) + t.eff_c2
    }
}

// --- Legacy planning-model "day" curves --------------------------------------
// The four functions below (`item_q_by_day`, `day_by_level`, `level_by_day`,
// `eff_spell_by_level`) are fits from the original planning spreadsheet:
// "day" here is that model's abstract pacing day, not a real calendar/sim day,
// and the magic constants are curve-fit coefficients with no runtime meaning
// beyond the fit. They are still LIVE — arena-opponent generation
// (`behaviors::opponents`) levels bots by `level_by_day`/`item_q_by_day`, and
// item `dmg_increase` reads `eff_spell_by_level` — so they cannot be deleted;
// but do not build new features on the "day" scale.

pub fn item_q_by_day(day: f64) -> f64 {
    const A: f64 = 1.369248467;
    const B: f64 = 1.986;
    const C: f64 = 1.00;
    A * (B * day + 1.0).ln() + C
}

pub fn day_by_level(level: f64) -> f64 {
    const A1: f64 = 13.95171732;
    const A2: f64 = 0.5784426942;
    const A3: f64 = 1.00;
    ((level - A3) / A1).powf(1.0 / A2)
}

pub fn level_by_day(day: f64) -> f64 {
    const A1: f64 = 13.95171732;
    const A2: f64 = 0.5784426942;
    const A3: f64 = 1.00;
    A1 * day.powf(A2) + A3
}

pub fn eff_spell_by_level(level: f64) -> f64 {
    const S1: f64 = 0.36536535;
    const S2: f64 = 0.525009219;
    const S3: f64 = 1.0;
    let day = day_by_level(level);
    S1 * day.powf(S2) + S3
}

/// Player armor-rating deflator for character `level` (see
/// `BalanceTuning::armor_k_per_chapter`; level ≈ chapter for players and is
/// available for arena OPPONENT snapshots too, keeping PvP symmetric):
/// multiply the aggregated player armor rating by this before it meets the
/// constant-K DR curve.
pub fn player_armor_rating_deflator(level: i64) -> f64 {
    let t = tuning();
    if t.armor_k_per_chapter <= 0.0 {
        return 1.0;
    }
    t.k_armor / (t.k_armor + t.armor_k_per_chapter * level.max(0) as f64)
}

pub fn armor_k(armor: f64) -> f64 {
    // Fraction of incoming damage that PASSES the target's armor, via the DR
    // curve `K_ARMOR/(armor+K_ARMOR)`. Always in (0, 1] for armor ≥ 0 — a
    // linear falloff would reach 0 and go negative (healing the target).
    let k = tuning().k_armor;
    k / (armor.max(0.0) + k)
}

/// Enemy "power" scalar for a fight — the value `spawn_wave` feeds into the
/// HP/attack curve, and the apples-to-apples counterpart of the player's
/// `character.power` (both normalized to [`BASE_POWER`]). For campaign fights:
/// at/below [`HAND_AUTHORED_CHAPTER_MAX`] (the whole first stage) it is the
/// hand-authored `FightTemplate.power` (`base_power`) with NO mid-boss gate;
/// above it the rebalanced geometric curve
/// ([`enemy_power_for_chapter`], which carries the sweepable anchor/step + the
/// early-chapter bump), with a boss bump. For DUNGEON fights it is always the
/// authored per-difficulty `base_power` (see below). Shared so the battle-end
/// analytics report exactly the value the fight spawned.
pub fn enemy_power_scalar(
    base_power: f64,
    current_chapter: i64,
    fight_type: &str,
    is_dungeon: bool,
) -> f64 {
    let t = tuning();
    // Dungeons are a self-contained difficulty LADDER: enemy power is the
    // authored per-difficulty `base_power` (the chosen difficulty's
    // `FightTemplate.power`, ramping e.g. 1500 → 600M across the levels), NOT the
    // campaign chapter curve. Dungeon fights are tagged `CampaignBossFight` (for
    // boss talents/visuals), so without this guard they fall into the chapter-curve
    // branch below — collapsing every difficulty to one power keyed to the player's
    // campaign chapter (the regression where the ladder does nothing and difficulty
    // 1 is a full-chapter boss → "losing to the dungeon at unlock"). Honor the
    // authored ladder so low difficulties are an easy first clear and the player
    // climbs as their power grows.
    if is_dungeon {
        return base_power;
    }
    // BAL-037: the signed curve covers ch0…509, so FTUE no longer reads authored
    // `FightTemplate.power`. The whole hand-authored block is refit as one
    // progression sequence; its current absolute rows `1…46` are not preserved.
    if fight_type == "CampaignFight" || fight_type == "CampaignBossFight" {
        if t.enemy_curve_mode != EnemyCurveMode::Derived {
            // Rollback mode keeps the historic split: authored FTUE rows, legacy
            // anchor/step/taper past them, plus the old boss bumps.
            if current_chapter <= t.hand_authored_chapter_max {
                return base_power;
            }
            let power = enemy_power_for_chapter(current_chapter);
            return if fight_type == "CampaignBossFight" {
                power * t.chapter_power_step.powf(0.5) * enemy_mid_chapter_mult(current_chapter)
            } else {
                power
            };
        }
        // One total normalized encounter coefficient for every boss on every
        // chapter. The separate ch12/13/14 bump is gone: the accepted cadence
        // forbids any wall through ch21.
        if fight_type == "CampaignBossFight" {
            enemy_boss_power(current_chapter)
        } else {
            enemy_wave_power(current_chapter)
        }
    } else {
        base_power
    }
}

pub fn hp_k_for_chapter(config: &GameConfig, chapter: i64) -> f64 {
    let mut reached: Vec<_> = config
        .ability_slots_levels
        .iter()
        .filter(|item| chapter >= item.from_chapter_level)
        .collect();
    reached.sort_by_key(|b| std::cmp::Reverse(b.from_chapter_level));

    if reached.is_empty() {
        return 1.0 / SPELL_QUANTITY as f64;
    }
    let current = reached[0];
    if current.ability_slots == (SPELL_QUANTITY - 1) as u64 {
        return 1.0;
    }
    let mut unreached: Vec<_> = config
        .ability_slots_levels
        .iter()
        .filter(|item| chapter < item.from_chapter_level)
        .collect();
    unreached.sort_by_key(|a| a.from_chapter_level);
    if unreached.is_empty() {
        return 1.0;
    }
    let next = unreached[0];
    // Interpolate the slot count toward the next tier. The legacy form added a
    // bare `frac` — correct only while every ladder step is exactly +1 slot
    // (true today, verified); scale by the actual step so a future +2 tier
    // doesn't silently mis-budget the wave. The trailing +1 counts the class
    // basic ability alongside the gacha slots (slots max 5, SPELL_QUANTITY 6).
    let step = (next.ability_slots - current.ability_slots) as f64;
    let frac = (chapter - current.from_chapter_level) as f64
        / (next.from_chapter_level - current.from_chapter_level) as f64;
    let mean_ability_slots = current.ability_slots as f64 + frac * step + 1.0;
    mean_ability_slots / SPELL_QUANTITY as f64
}

/// `attrs.get_attr(name)`: read the composed attribute value from an attribute map.
/// Returns `(base + bonus) * (1 + bonus / 10000.0)`.
///
/// of `mod` in the multiplier. We preserve the original behaviour byte-for-byte
/// so power calculations stay consistent with the current production config.
///
/// `attrs.get_attr(...)` method (registered for scripts that still pass a
pub fn get_attr_from_attrs(attrs: &AttrMap, attr: &str) -> f64 {
    let base = attrs.get(attr).copied().unwrap_or(0.0);
    let bonus = attrs.get(&format!("{attr}.bonus")).copied().unwrap_or(0.0);
    // Matches combat's `get_entity_stat`: additive `.bonus`, then the `.mod`
    // multiplier `(1 + mod/10000)` — the scalar must agree with combat, or
    // `.mod` grants (e.g. class-level attack.mod/hp.mod) would not move
    // displayed/matchmaking power. (Attribute base-values — e.g.
    // received_damage's 10000 — are still combat-only: the scalar has no
    // `lookups` here; a known remaining scalar↔combat gap.)
    let mod_v = attrs.get(&format!("{attr}.mod")).copied().unwrap_or(0.0) / 10000.0 + 1.0;
    (base + bonus) * mod_v
}

/// Ability upgrade milestones: on top of the linear +5%/level, levels 5 and
/// 10 grant a multiplicative jump — a proximate milestone that makes the
/// dup-shard chase eventful instead of a flat drip. UNIVERSAL for every
/// ability (gacha, class kits, pet ults) — no per-content flags; tooltips
/// (`ability_info(level)`) and the honest power scalar recompute automatically
/// because everything routes through [`ability_eff`]. Sizing: ×1.10 at L5 ≈
/// two extra linear levels, ×1.20 at L10 ≈ four — noticeable, but small
/// enough that the shard economy absorbs it.
pub const ABILITY_MILESTONES: &[(i64, f64)] = &[(5, 1.10), (10, 1.20)];

/// Payload multiplier of a CLASS ability at `rank`: `×[1.0, 1.1, … 1.6]` over
/// ranks 1..=7 (BAL-034).
///
/// Class kits do not ride the shard ladder every other ability uses: their
/// ranks come from Class Level on a fixed schedule, so their growth is
/// authored flat and stops at rank 7. Only damage and heal payloads move —
/// durations, buff magnitudes, target caps, cooldowns and Mana costs are the
/// same at rank 7 as at rank 1, which is what deliberately keeps the utility
/// halves of Fortify / War Cry / Rewind / Battle Heal flat.
pub const CLASS_RANK_PAYLOAD_STEP: f64 = 0.1;
pub const CLASS_MAX_RANK: i64 = 7;

pub fn class_rank_payload_mult(rank: i64) -> f64 {
    1.0 + CLASS_RANK_PAYLOAD_STEP * (rank.clamp(1, CLASS_MAX_RANK) - 1) as f64
}

pub fn ability_eff(lookups: &ContentLookups, rarity_id: Uuid, level: i64) -> f64 {
    let rarity_eff = lookups
        .ability_rarity_eff
        .get(&rarity_id)
        .copied()
        .unwrap_or(1.0);
    if lookups.class_ability_rarities.contains(&rarity_id) {
        return rarity_eff * class_rank_payload_mult(level);
    }
    let level_eff = 1.0 + 0.05 * (level - 1) as f64;
    let milestone: f64 = ABILITY_MILESTONES
        .iter()
        .filter(|(l, _)| level >= *l)
        .map(|(_, m)| m)
        .product();
    rarity_eff * level_eff * milestone
}

// --- Honest power scalar: per-ability combat contribution --------------------
// A flat `Σ ability_eff` multiplier would lie three ways:
//   1. abilities that never cast in combat would still count toward power;
//   2. a heal ability (HoT / lifesteal) would count as if it were damage,
//      while in combat it contributes survivability (EHP), not DPS;
//   3. the per-ability throughput factor `FIGHT_DURATION/(FIGHT_DURATION+cd)`
//      that combat damage actually carries (`ability_damage_from_rarity`)
//      would be ignored, over-rating slow-cooldown abilities.
// The honest scalar therefore maps each fighting ability to (dps_add,
// heal_add) using the same primitives combat uses, then multiplies the DPS
// axis by Σ dps_add and the EHP axis by the capped heal-sustain factor — the
// same shape as combat.

/// Combat-honest contribution of one slotted ability to the power scalar.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct AbilityCombatProfile {
    /// Additive DPS throughput in reference units: 1.0 = the reference
    /// single-ability caster (`BASE_SPELL_EFF`, cd→0) that `spawn_wave`'s
    /// mirror player is built from. Per-second form of the same
    /// `eff × FD/(FD+cd)` budget combat damage derives from.
    pub dps_add: f64,
    /// Heal throughput in the same units (multiply by `attack × DMG_K` for
    /// absolute HP/s — exactly what `spell_heal`/HoT apply in combat).
    pub heal_add: f64,
}

/// Pure split of an [`crate::mechanics::content::AbilityInfo`] budget into the
/// (dps_add, heal_add) axes. Separated from the config lookup so the arithmetic
/// is unit-testable without prod ability UUIDs.
///
/// `damage`/`dot`/`hot` in `AbilityInfo` are per-cast budgets (the closures
/// split `ability_damage_from_rarity = eff·k·cd`), so dividing by `cd` yields
/// per-second throughput `eff·k·share`. `vampiric` heals a fraction of damage
/// dealt. `crit_chance_bonus`/`effect_duration` buff components are dropped
/// (conservative): their budget share was already subtracted from `damage` by
/// the content closures, so ignoring them under-counts slightly rather than
/// double-counting.
pub fn ability_profile_from_info(
    damage: Option<f64>,
    dot: Option<f64>,
    hot: Option<f64>,
    vampiric: Option<f64>,
    projectiles: Option<i64>,
    cooldown_sec: f64,
) -> AbilityCombatProfile {
    let cd = cooldown_sec.max(0.1);
    // Multi-projectile abilities report PER-PROJECTILE damage in their info
    // split (the closures divide the budget by the count for the tooltip);
    // combat fires all of them, so the throughput carries the full budget.
    let shots = projectiles.unwrap_or(1).max(1) as f64;
    let total_damage = damage.unwrap_or(0.0) * shots;
    let dmg_budget = total_damage + dot.unwrap_or(0.0);
    let heal_budget = hot.unwrap_or(0.0) + vampiric.unwrap_or(0.0) * total_damage;
    AbilityCombatProfile {
        dps_add: dmg_budget / cd / BASE_SPELL_EFF,
        heal_add: heal_budget / cd,
    }
}

/// Combat-honest profile of a pet ult: the pet's ability carries the donor
/// gacha ability's per-cast budget (combat behaviors hardcode the donor uuid),
/// but fires at the charge-fill rate, not at the template cooldown — so the
/// throughput divides the per-cast budget by [`PET_ULT_EFFECTIVE_CD`].
pub fn pet_ult_combat_profile(
    config: &GameConfig,
    lookups: &ContentLookups,
    ability: &Ability,
) -> AbilityCombatProfile {
    let Some(tpl) = config.ability_template(ability.template_id) else {
        return AbilityCombatProfile::default();
    };
    match crate::mechanics::content::ability_info(
        config,
        lookups,
        ability.template_id,
        ability.level,
    ) {
        Ok(info) => ability_profile_from_info(
            info.damage,
            info.dot,
            info.hot,
            info.vampiric,
            info.projectiles,
            PET_ULT_EFFECTIVE_CD,
        ),
        Err(_) => {
            // No closure — price the whole per-cast budget as damage at the
            // charge-fill rate (same honest default as the regular path).
            let cd = (tpl.cooldown as f64 / 1000.0).max(0.1);
            let eff = ability_eff(lookups, tpl.rarity_id, ability.level);
            let k = FIGHT_DURATION / (FIGHT_DURATION + cd);
            AbilityCombatProfile {
                dps_add: eff * k * cd / PET_ULT_EFFECTIVE_CD,
                heal_add: 0.0,
            }
        }
    }
}

/// Combat-honest profile of one ability instance. Uses the per-ability
/// `content::ability_info` split where one exists; abilities without a bespoke
/// closure (some class/buff abilities) fall back to a pure-damage assumption at
/// their `eff × FD/(FD+cd)` throughput — the closest honest default.
pub fn ability_combat_profile(
    config: &GameConfig,
    lookups: &ContentLookups,
    ability: &Ability,
) -> AbilityCombatProfile {
    let Some(tpl) = config.ability_template(ability.template_id) else {
        return AbilityCombatProfile::default();
    };
    let cd = (tpl.cooldown as f64 / 1000.0).max(0.1);
    match crate::mechanics::content::ability_info(
        config,
        lookups,
        ability.template_id,
        ability.level,
    ) {
        Ok(info) => ability_profile_from_info(
            info.damage,
            info.dot,
            info.hot,
            info.vampiric,
            info.projectiles,
            cd,
        ),
        Err(_) => {
            // No bespoke split for this ability id — assume its whole budget is
            // damage (`eff × k`), the same throughput the plain-damage closures
            // produce.
            let eff = ability_eff(lookups, tpl.rarity_id, ability.level);
            let k = FIGHT_DURATION / (FIGHT_DURATION + cd);
            AbilityCombatProfile {
                dps_add: eff * k,
                heal_add: 0.0,
            }
        }
    }
}

/// Expected seconds between pet-ult casts for the honest scalar. The pet ult
/// is charge-gated, not cooldown-gated (`charge_rate_on_skill_use` /
/// `_on_damage_dealt` / `_on_damage_taken` fill `max_charge`), so its template
/// cooldown says nothing about throughput. With the shipped charge profiles
/// (max_charge 1000, rates 5-40 per trigger) a fight fills the bar roughly
/// once per ~12s of combat — a deliberate round number until a sim remeasure;
/// the pet's per-cast budget divided by this is the honest DPS/heal rate.
pub const PET_ULT_EFFECTIVE_CD: f64 = 12.0;

/// Aggregate the equipped abilities into the two power-axis multipliers:
/// `(dps_mult, ehp_mult)`.
///
/// Membership matches combat exactly: `make_active_abilities_from_equipped`
/// sends BOTH `slotted` (gacha slots) and `unslotted` (the class kit and other
/// slotless grants) into the fight, so both count here — EXCEPT abilities with
/// an empty `start_behavior`: those never begin a cast cycle in combat, so a
/// scalar that counts them lies.
///
/// - `dps_mult` = Σ `dps_add` — additive throughput, exactly how per-ability
///   damage stacks in combat. Zero castable abilities ⇒ 0.0 (a character that
///   casts nothing deals nothing — "bare character power is 0" is the
///   established semantic).
/// - `ehp_mult` = capped heal-sustain factor `(hp + heal/fight) / hp`, the same
///   shape and the same `hot_tick_max_pct` cap the combat HoT tick obeys, and
///   the same treatment `power_from_attrs` already gives `regeneration_rate`.
pub fn ability_power_mults(
    config: &GameConfig,
    lookups: &ContentLookups,
    abilities: &EquippedAbilities,
    leader_pet_ability: Option<(Uuid, i64)>,
    attrs: &AttrMap,
) -> (f64, f64) {
    // The leader pet's active ability joins the fight exactly like an equipped
    // ability (`create_player_entity` pushes it at the pet's level), so it
    // counts here too — same membership rule, same dead-ability filter, but
    // priced at the charge-fill rate ([`PET_ULT_EFFECTIVE_CD`]), not at the
    // ability template's cooldown.
    let pet_ability = leader_pet_ability.map(|(template_id, level)| Ability {
        template_id,
        level: level.max(1),
        shards_amount: 0,
    });

    let mut dps_mult = 0.0;
    let mut heal_add = 0.0;
    for (ability, is_pet) in abilities
        .unslotted
        .iter()
        .chain(abilities.slotted.values())
        .map(|a| (a, false))
        .chain(pet_ability.iter().map(|a| (a, true)))
    {
        // Dead abilities (no start behavior) never cast — no contribution.
        let castable = config
            .ability_template(ability.template_id)
            .and_then(|t| t.start_behavior.as_deref())
            .is_some_and(|s| !s.is_empty());
        if !castable {
            continue;
        }
        let p = if is_pet {
            pet_ult_combat_profile(config, lookups, ability)
        } else {
            ability_combat_profile(config, lookups, ability)
        };
        dps_mult += p.dps_add;
        heal_add += p.heal_add;
    }

    let hp = get_attr_from_attrs(attrs, "hp");
    let attack = get_attr_from_attrs(attrs, "attack");
    let ehp_mult = if hp > 0.0 && heal_add > 0.0 {
        // Absolute heal rate as combat applies it (attack-scaled), capped per
        // tick like the combat HoT path so a mis-tuned heal can't credit
        // unbounded EHP.
        let heal_per_sec = (attack * DMG_K * heal_add).min(hp * tuning().hot_tick_max_pct);
        (hp + heal_per_sec * FIGHT_DURATION) / hp
    } else {
        1.0
    };
    (dps_mult, ehp_mult)
}

pub fn ability_damage_from_rarity(
    lookups: &ContentLookups,
    rarity_id: Uuid,
    cooldown_ms: i64,
    level: i64,
) -> f64 {
    let eff = ability_eff(lookups, rarity_id, level);
    let cd = cooldown_ms as f64 / 1000.0;
    let k = FIGHT_DURATION / (FIGHT_DURATION + cd);
    eff * k * BASE_SPELL_EFF * cd
}

pub fn ability_damage_from_id(
    config: &GameConfig,
    lookups: &ContentLookups,
    ability_id: Uuid,
    level: i64,
) -> Result<f64, String> {
    let ability = config
        .ability_template(ability_id)
        .ok_or_else(|| format!("balance::ability_damage: unknown ability id {ability_id}"))?;
    Ok(ability_damage_from_rarity(
        lookups,
        ability.rarity_id,
        ability.cooldown as i64,
        level,
    ))
}

pub fn eff_item_with_config(
    config: &GameConfig,
    lookups: &ContentLookups,
    item_template_id: Uuid,
    level: f64,
) -> f64 {
    let rarity_q = config
        .item_template(item_template_id)
        .and_then(|tpl| lookups.item_rarity_q.get(&tpl.rarity_id).copied())
        .unwrap_or(1.0);
    eff_by_level(level) * rarity_q
}

/// A2-BAL-003 §3.3: how many optional stats a chest of this level rolls.
///
/// The count is a property of the CHEST, not of the item template. It used to
/// live on each template's `optional_attributes_count`, which meant the same
/// sword rolled the same number of extras out of a level-1 chest as out of a
/// level-40 one — and ten templates carried three, above the signed maximum of
/// two.
pub fn optional_attributes_for_chest_level(chest_level: i64) -> u64 {
    match chest_level {
        ..=1 => 0,
        2..=5 => 1,
        _ => 2,
    }
}

pub fn attr_spread_for_item(
    // Kept in the signature: `eff_item_with_config` needed it for the removed
    // skewed roll, and the call sites read more clearly with the item's whole
    // context in one place. Dropping it would touch every caller for no gain.
    _config: &GameConfig,
    lookups: &ContentLookups,
    random: &GameRng,
    template_id: Uuid,
    level: f64,
) -> f64 {
    if let Some(fp) = lookups.item_fixed_power.get(&template_id) {
        return *fp;
    }
    if (level - 1.0).abs() < f64::EPSILON {
        return LEVEL_ONE_ATTR_MEAN
            * (1.0 + ATTR_DEVIATION_LEVEL_ONE * (2.0 * random.random_f64() - 1.0));
    }
    // A2-BAL-003 §3.3: every item above level 1 rolls the same uniform spread.
    //
    // The skewed fake-level roll that used to take over above item L25 is gone.
    // It made the spread's SHAPE change partway up the ladder, so an item's roll
    // distribution depended on where in the game it dropped — which is not
    // something the signed `0.9..1.1` band can describe, and made sale-EV drift
    // by level impossible to reason about.
    attr_spread_random(random)
}

pub fn aux_attr_eff(base_eff: f64, random: &GameRng) -> f64 {
    let rand_mod = attr_spread_random(random);
    (base_eff * rand_mod).powf(AUX_ATTR_IMPACT)
}

pub fn aux_attr_eff_for_item(
    config: &GameConfig,
    lookups: &ContentLookups,
    base_eff: f64,
    random: &GameRng,
    template_id: Uuid,
    level: f64,
) -> f64 {
    let rand_mod = attr_spread_for_item(config, lookups, random, template_id, level);
    (base_eff * rand_mod).powf(AUX_ATTR_IMPACT)
}

/// Compute character power from a composed [`AttrMap`] as **P = DPS × EHP**
/// (balance v2). `DPS` is the offensive product (attack · rate · crit ·
/// multicast · bravery · counterattack); `EHP` the survivability product
/// (hp ÷ the damage that gets through), where armor and dodge use the
/// diminishing-returns curves [`armor_k`] and `ev/(ev+K_DODGE)`. Normalised by
/// [`POWER_NORM`] so a reference character (attack=`BASE_ATTACK`, hp=`BASE_HP`,
/// neutral elsewhere) anchors at [`BASE_POWER`].
///
/// **Float-accumulation order is load-bearing** (see [`character_attrs_power`]):
/// the per-attribute reads happen in a fixed order so the floored result is
/// deterministic.
pub fn power_from_attrs(attrs: &AttrMap) -> i64 {
    power_from_attrs_raw(attrs).floor() as i64
}

/// [`power_from_attrs`] before the floor.
///
/// Ranking callers need the raw value: displayed power is an integer, but at
/// low character levels `DPS × EHP / power_norm` lands well under `1.0`, so the
/// floored score collapses every candidate to `0` and any sort over it silently
/// degrades to input order.
pub fn power_from_attrs_raw(attrs: &AttrMap) -> f64 {
    const BASE_POINT: f64 = 10000.0; // attribute basis points: 10000 == 1.0 / 100%

    // ---- offensive: DPS ----
    let attack = get_attr_from_attrs(attrs, "attack");
    // speed → cast rate, mirroring combat's `scale_cooldown_for_speed` (cooldown ∝
    // baseline/speed ⇒ rate ∝ speed/baseline, baseline_speed = BASE_POINT). Combat treats
    // `speed ≤ 0` as the baseline (`speed_or_baseline`), so the scalar must too — else a
    // speed-less build reads as 0 DPS here while combat still attacks at the baseline rate.
    let speed = get_attr_from_attrs(attrs, "speed");
    let atk_rate = if speed > 0.0 { speed / BASE_POINT } else { 1.0 };
    // Probability stats are clamped to [0,1] — a chance can't exceed 100%.
    // Without this, large (e.g. class-level) grants overflow the basis-point
    // cap and break the formula (e.g. block>1 → `1−0.5·block` negative → power
    // goes negative). Combat's `stat_throw` already saturates a proc at 100%.
    // `crit_chance_scale` mirrors combat (`stat_throw_scaled` in the attack
    // path): the honest scalar must price crit at the REALIZED proc rate, not
    // the raw stat — otherwise crit builds are over-valued in displayed/
    // matchmaking power whenever the scale is below 1.
    let crit_chance = (get_attr_from_attrs(attrs, "crit_chance") / BASE_POINT
        * tuning().crit_chance_scale)
        .clamp(0.0, 1.0);
    let crit_damage_mod = BASE_CRIT_MOD + get_attr_from_attrs(attrs, "crit_modifier") / BASE_POINT;
    let crit_factor = 1.0 + crit_chance * (crit_damage_mod - 1.0);
    let multicast_factor =
        1.0 + (get_attr_from_attrs(attrs, "multicast_chance") / BASE_POINT).clamp(0.0, 1.0);
    let bravery_factor = buff_uptime_mult_branches(
        get_attr_from_attrs(attrs, "bravery") / BASE_POINT,
        BRAVERY_BUFF_DURATION,
    );

    let mut dps = attack * atk_rate * crit_factor * multicast_factor * bravery_factor;

    // counterattack: retaliatory damage relative to a fight's baseline output
    // (same additive shape as the legacy formula).
    let counterattack_chance =
        (get_attr_from_attrs(attrs, "counterattack_chance") / BASE_POINT).clamp(0.0, 1.0);
    let counterattack_dmg =
        FIGHT_DURATION * ATTACKS_PER_SEC * COUNTERATTACK_POWER * counterattack_chance;
    let baseline_dmg =
        FIGHT_DURATION * SPELL_QUANTITY as f64 / armor_k(get_attr_from_attrs(attrs, "armor"));
    if baseline_dmg > 0.0 {
        dps *= (baseline_dmg + counterattack_dmg) / baseline_dmg;
    }

    // ---- defensive: EHP = hp ÷ (fraction of damage that gets through) ----
    // Via get_attr_from_attrs so hp.bonus/hp.mod count (consistent with combat).
    let hp = get_attr_from_attrs(attrs, "hp");
    let mut ehp = hp;
    // armor mitigation (DR via `armor_k`): divide by the damage-through fraction.
    ehp /= armor_k(get_attr_from_attrs(attrs, "armor"));
    // dodge (evasion rating) via DR: avoid prob = ev/(ev+K_DODGE), asymptote < 1.
    let evasion = get_attr_from_attrs(attrs, "evasion").max(0.0);
    ehp /= 1.0 - evasion / (evasion + tuning().k_dodge);
    // block: halves damage on proc → expected damage multiplier (1 − 0.5·p),
    // p clamped to [0,1] (max ×2 EHP at always-block).
    let block_chance = (get_attr_from_attrs(attrs, "block") / BASE_POINT).clamp(0.0, 1.0);
    ehp /= 1.0 - 0.5 * block_chance;
    // received_damage: a damage-taken multiplier (base BASE_POINT = 100% taken); combat
    // applies it in `damage_entity`, so the scalar must too or it under-counts mitigation
    // EHP (a build with persistent `received_damage` reduction reads weaker than it fights).
    // The scalar has no `lookups` for the base, so BASE_POINT is added explicitly here;
    // floored like combat (`MIN_RECEIVED_DAMAGE_K`) so it can't reach ≤0. Neutral → ×1.
    let received_damage =
        (BASE_POINT + get_attr_from_attrs(attrs, "received_damage")).max(MIN_RECEIVED_DAMAGE_K);
    ehp *= BASE_POINT / received_damage;
    // regen-as-EHP, derived to MATCH combat. Combat heals at most
    // `regen_tick_max_pct × max_hp` per ~1s tick (`regeneration_tick`), so over a fight it
    // delivers `FIGHT_DURATION × min(regen_rate, regen_tick_max_pct × hp)` — and the scalar
    // credits exactly that, using the SAME `tuning().regen_tick_max_pct` knob as combat, so
    // the two can never desync. This makes regen structurally weaker EHP than block — a real
    // combat-balance fact the scalar reports honestly; closing the Priest-competitiveness
    // gap is a sim/design decision, not a scalar tweak.
    let regen_per_sec = (get_attr_from_attrs(attrs, "regeneration_rate")
        + get_attr_from_attrs(attrs, REGEN_PERCENT_CODE) / BASE_POINT * hp.max(0.0))
    .min(hp.max(0.0) * tuning().regen_tick_max_pct);
    let regen_per_fight = regen_per_sec * FIGHT_DURATION;
    if hp != 0.0 {
        ehp *= (hp + regen_per_fight) / hp;
    }
    // deceit: debuffs the enemy → effective survivability gain (legacy shape).
    ehp *= buff_uptime_mult_branches(
        get_attr_from_attrs(attrs, "deceit") / BASE_POINT,
        DECEIT_DEBUFF_DURATION,
    );

    (dps * ehp) / tuning().power_norm
}

/// Character power over the items+pets subset (marginal gear-compare path and
/// arena-bot power): composed attrs → `power_from_attrs` → honest ability
/// multipliers ([`ability_power_mults`], DPS/EHP-split).
///
/// **Accumulation order is load-bearing** (per-key float sums): char-level
/// attributes, then inventory items (each item's attributes in order), then
/// pets (in the given slice order, each pet's stats in order).
pub fn character_power(
    config: &GameConfig,
    lookups: &ContentLookups,
    level: i64,
    inventory: &[Item],
    abilities: &EquippedAbilities,
    pets: &[Pet],
) -> Result<i64, String> {
    let (attrs, _total_power_bonus) = compose_character_attrs(config, level, inventory, pets)?;
    let attrs_power = power_from_attrs(&attrs);

    // Honest ability multipliers: combat-membership set, DPS/EHP split (see
    // [`ability_power_mults`]). Pets cast nothing, so they contribute through
    // `attrs` only and add no ability multiplier.
    let (dps_mult, ehp_mult) = ability_power_mults(config, lookups, abilities, None, &attrs);

    // BAL-030: the per-item `power_bonus` jitter is OUT of every power path —
    // display, matchmaking, and this gear-compare. It is a persisted-but-inert
    // display field; letting it into the compare would let a cosmetic roll
    // decide which item auto-equip keeps (matching
    // `behaviors::power::character_power`, which dropped it the same way).
    Ok((attrs_power as f64 * dps_mult * ehp_mult).floor() as i64)
}

/// Combat-power scalar from an already-composed [`AttrMap`] plus equipped
/// abilities — `floor(power_from_attrs(attrs) × dps_mult × ehp_mult)` with the
/// honest ability multipliers ([`ability_power_mults`]).
///
/// Lets the display / matchmaking / gating path feed the **full** multi-source
/// aggregation (`attributes::calculate_player_entity_stats_with_zeroes` —
/// char-level, items, class, pets, talents, statue, class-levels) through the
/// same formula, so the power scalar reflects every combat source.
/// [`character_power`] keeps the items+pets subset for *marginal*
/// gear-compare, where the constant class/talent/statue baseline cancels in
/// the with-minus-without difference.
pub fn character_power_from_attrs(
    config: &GameConfig,
    lookups: &ContentLookups,
    attrs: &AttrMap,
    abilities: &EquippedAbilities,
    leader_pet_ability: Option<(Uuid, i64)>,
) -> i64 {
    character_power_from_attrs_raw(config, lookups, attrs, abilities, leader_pet_ability).floor()
        as i64
}

/// [`character_power_from_attrs`] before the floor — the `P_static` term of
/// `P_ui = floor(P_static × Πq)` (BAL-030).
///
/// The dynamic multipliers are applied by the caller and the result is floored
/// ONCE at the very end, so a component worth a fraction of a point still moves
/// the number instead of being rounded away mid-formula.
pub fn character_power_from_attrs_raw(
    config: &GameConfig,
    lookups: &ContentLookups,
    attrs: &AttrMap,
    abilities: &EquippedAbilities,
    leader_pet_ability: Option<(Uuid, i64)>,
) -> f64 {
    let attrs_power = power_from_attrs_raw(attrs);
    // Honest ability multipliers: combat-membership set, DPS/EHP split — see
    // [`ability_power_mults`]. Display, matchmaking and gating all read this
    // path, so the scalar rates what combat actually delivers — including the
    // leader pet's active ability.
    let (dps_mult, ehp_mult) =
        ability_power_mults(config, lookups, abilities, leader_pet_ability, attrs);
    attrs_power * dps_mult * ehp_mult
}

/// The `attrs_power` term of [`character_power`]: char-level attributes,
/// inventory items and pet stats composed into an [`AttrMap`] and run through
/// [`power_from_attrs`] — WITHOUT the trailing `* ability_eff_sum` multiplier.
///
/// **Accumulation order is load-bearing** (per-key float sums): char-level
/// attributes, then inventory items (each item's attributes in order), then
/// pets (in the given slice order, each pet's stats in order) — exactly the
/// order the original used; [`character_power`] delegates here so both paths
/// stay byte-identical.
///
/// For callers comparing loadouts that carry no abilities of their own (e.g.
/// ranking pets for fast-equip), where [`character_power`]'s ability factor
/// would multiply every score by 0.
pub fn character_attrs_power(
    config: &GameConfig,
    level: i64,
    inventory: &[Item],
    pets: &[Pet],
) -> Result<i64, String> {
    // BAL-030: `power_bonus` is display-inert and enters no power path.
    let (collected, _total_power_bonus) = compose_character_attrs(config, level, inventory, pets)?;
    Ok(power_from_attrs(&collected))
}

/// [`character_attrs_power`] before the floor, for callers that RANK loadouts
/// rather than display a number. See [`power_from_attrs_raw`] for why the
/// integer is unusable as a sort key.
pub fn character_attrs_power_raw(
    config: &GameConfig,
    level: i64,
    inventory: &[Item],
    pets: &[Pet],
) -> Result<f64, String> {
    // BAL-030: `power_bonus` is display-inert and enters no power path.
    let (collected, _total_power_bonus) = compose_character_attrs(config, level, inventory, pets)?;
    Ok(power_from_attrs_raw(&collected))
}

/// Compose the char-level + items + pets attribute map (the input to
/// [`power_from_attrs`]) plus the summed per-item `power_bonus` jitter.
/// Extracted from [`character_attrs_power`] so [`character_power`] can reuse
/// the composed attrs for the honest ability EHP cap (it needs `hp`/`attack`).
pub fn compose_character_attrs(
    config: &GameConfig,
    level: i64,
    inventory: &[Item],
    pets: &[Pet],
) -> Result<(AttrMap, i64), String> {
    let mut collected: AttrMap = AttrMap::new();

    let Some(char_level_tpl) = config.character_level(level) else {
        return Err(format!(
            "balance::character_power: missing character_level {level}"
        ));
    };

    for attr in &char_level_tpl.attributes {
        if let Some(a) = config.attribute(attr.attribute_id) {
            // Original: `collected.insert(code, value)` — an unconditional
            // overwrite (NOT accumulate). If two char-level entries share a
            // code, the later one wins. Preserve that exactly with `insert`.
            collected.insert(a.code.as_str().to_string(), attr.value as f64);
        }
    }

    // Sum the per-item power jitter alongside attribute accumulation. Items that
    // were rolled before the jitter feature (or arena bots) carry power_bonus=0,
    // so they are unaffected by this sum.
    let mut total_power_bonus: i64 = 0;

    for item in inventory {
        for item_attr in &item.attributes {
            if let Some(a) = config.attribute(item_attr.attr_id) {
                accumulate(&mut collected, a.code.as_str(), item_attr.value as f64);
            }
        }
        total_power_bonus += item.power_bonus as i64;
    }

    for pet in pets {
        for stat in &pet.stats {
            if let Some(a) = config.attribute(stat.attribute_id) {
                accumulate(&mut collected, a.code.as_str(), stat.value as f64);
            }
        }
    }

    // Deflate the composed ARMOR rating by character level, mirroring the full
    // aggregation path (`attributes::calculate_player_entity_stats_with_zeroes`)
    // so this marginal gear-compare / auto-equip scalar prices armor the same
    // way combat and displayed Combat-Power do. The deflator is a per-level
    // scalar independent of the armor amount, so applying it to the item+pet
    // subset here matches the full aggregate exactly on the armor axis (it
    // distributes over the sum, and the omitted class/talent/statue baseline
    // armor cancels in the with-minus-without difference). Without it the
    // marginal path over-values armor, increasingly with level, mis-ranking
    // armor items in auto-equip and gear-compare tooltips.
    let deflator = player_armor_rating_deflator(level);
    if deflator < 1.0
        && let Some(v) = collected.get_mut("armor")
    {
        *v *= deflator;
    }

    Ok((collected, total_power_bonus))
}

#[cfg(test)]
mod attr_spread_tests {
    //! Deterministic equivalence tests for the branchy `attr_spread_for_item`
    //! (the RNG-driven primitive behind every item-attribute calc). Driven by
    //! `GameRng::from_values` so they prove formula + *draw count* without
    //! any sim entropy. Draw count is load-bearing for determinism — the random
    //! seed advances per draw — so each branch asserts how many draws it consumes.

    use super::*;

    /// A template id that is NOT in `item_fixed_power`, so the fixed-power early
    /// return never fires.
    fn non_fixed_template() -> Uuid {
        Uuid::from_u128(0x0194d64e_2100_7569_91be_a3d34c967544)
    }

    /// Count of `f64` draws a recording RNG sees after one `attr_spread_for_item`.
    fn draws_for(level: f64) -> usize {
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        let rng = GameRng::from_entropy_recording();
        let _ = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), level);
        rng.recorded().len()
    }

    /// Level 1 rolls a WIDE spread around the weakened 0.65 mean — the old
    /// constant made every level-1 roll a clone of the scripted starters.
    #[test]
    fn level_one_rolls_wide_spread_around_065() {
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();

        // r=0.5 lands exactly on the mean.
        let rng = GameRng::from_values(vec![0.5]);
        let v = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), 1.0);
        assert!(
            (v - LEVEL_ONE_ATTR_MEAN).abs() < 1e-12,
            "expected the mean, got {v}"
        );

        // r=0.0 / r=1.0 hit the band edges: 0.65 × (1 ∓ 0.2).
        let rng = GameRng::from_values(vec![0.0]);
        let v = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), 1.0);
        let low = LEVEL_ONE_ATTR_MEAN * (1.0 - ATTR_DEVIATION_LEVEL_ONE);
        assert!((v - low).abs() < 1e-12, "expected {low}, got {v}");

        let rng = GameRng::from_values(vec![1.0]);
        let v = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), 1.0);
        let high = LEVEL_ONE_ATTR_MEAN * (1.0 + ATTR_DEVIATION_LEVEL_ONE);
        assert!((v - high).abs() < 1e-12, "expected {high}, got {v}");

        assert_eq!(
            draws_for(1.0),
            1,
            "level==1 must consume exactly one RNG draw"
        );
    }

    #[test]
    fn level_le_25_uses_one_draw_via_attr_spread_random() {
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        // attr_spread_random(r) = 1 + ATTR_DEVIATION*(2*r - 1). r=0.5 -> 1.0.
        let rng = GameRng::from_values(vec![0.5]);
        let v = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), 25.0);
        assert!((v - 1.0).abs() < 1e-12, "expected 1.0, got {v}");
        // r=0.0 -> 1 - ATTR_DEVIATION; r=1.0 -> 1 + ATTR_DEVIATION.
        let rng = GameRng::from_values(vec![0.0]);
        let v = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), 10.0);
        assert!((v - (1.0 - ATTR_DEVIATION)).abs() < 1e-12);
        assert_eq!(
            draws_for(25.0),
            1,
            "level<=25 must consume exactly one draw"
        );
    }

    /// A2-BAL-003 §3.3: there is no longer a second regime above item L25.
    ///
    /// These replace `level_gt_25_uses_two_draws_{lower,upper}_branch`, which
    /// pinned the skewed fake-level roll. That roll changed the distribution's
    /// SHAPE partway up the ladder — the same item rolled a different spread
    /// depending on how deep it dropped, which the signed `0.9..1.1` band cannot
    /// describe. Draw count is asserted too: it dropped from two to one, and the
    /// session RNG advances per draw, so a change there shifts every later roll.
    #[test]
    fn every_level_above_one_uses_the_same_uniform_spread() {
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();

        for level in [2.0, 25.0, 26.0, 100.0, 400.0] {
            let rng = GameRng::from_values(vec![0.5]);
            let v = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), level);
            assert!(
                (v - 1.0).abs() < 1e-12,
                "level {level}: r=0.5 must land on 1.0, got {v}"
            );

            let rng = GameRng::from_values(vec![0.0]);
            let lo = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), level);
            assert!(
                (lo - (1.0 - ATTR_DEVIATION)).abs() < 1e-12,
                "level {level}: low edge"
            );

            let rng = GameRng::from_values(vec![1.0]);
            let hi = attr_spread_for_item(&cfg, &lk, &rng, non_fixed_template(), level);
            assert!(
                (hi - (1.0 + ATTR_DEVIATION)).abs() < 1e-12,
                "level {level}: high edge"
            );

            assert_eq!(
                draws_for(level),
                1,
                "level {level} must consume exactly one draw — the old deep-level \
                 branch consumed two"
            );
        }
    }

    #[test]
    fn fixed_power_short_circuits_and_draws_nothing() {
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let mut lk = ContentLookups::default();
        let tpl = non_fixed_template();
        lk.item_fixed_power.insert(tpl, 1.23);
        let rng = GameRng::from_entropy_recording();
        let v = attr_spread_for_item(&cfg, &lk, &rng, tpl, 100.0);
        assert_eq!(v, 1.23);
        assert_eq!(
            rng.recorded().len(),
            0,
            "fixed-power path must not draw RNG"
        );
    }
}

#[cfg(test)]
mod power_formula_tests {
    //! Pins `power_from_attrs` to the **v2 P = DPS × EHP** formula with DR
    //! curves, so a regression to the legacy opaque `S²` formula FAILS here
    //! (the two give different numbers for the same loadout). This is the proof
    //! that the new combat-power formula is the one actually running.
    use super::*;

    #[test]
    fn power_is_dps_times_ehp_with_dr() {
        let mut a = AttrMap::new();
        a.insert("hp".into(), 3000.0);
        a.insert("attack".into(), 600.0);
        a.insert("speed".into(), 10000.0); // attack rate 1.0
        a.insert("armor".into(), 2000.0); // armor_k = K/(armor+K) = 2000/4000 = 0.5
        a.insert("evasion".into(), 1500.0); // dodge = 1500/(1500+6000) = 0.2
        // crit / multicast / bravery / block / regen / deceit / counterattack absent → 0.
        //
        // DPS = attack(600) · rate(1.0) · crit(1) · multicast(1) · bravery(1) · counter(1) = 600
        // EHP = hp(3000) ÷ armor_k(0.5) ÷ (1 − dodge 0.2) = 3000 / 0.5 / 0.8 = 7500
        // power = floor(DPS·EHP / POWER_NORM) = floor(600·7500 / 1800) = 2500
        // (the legacy S² formula gives 1470 for this loadout — the assertion
        // proves the DPS×EHP path is the one running.)
        assert_eq!(power_from_attrs(&a), 2500);
    }

    #[test]
    fn armor_k_is_dr_not_linear() {
        // DR curve: always in (0,1], never negative — the legacy `1 - armor/10000`
        // hit 0 at armor=10000 and went negative beyond (the shipped bug).
        assert!((armor_k(0.0) - 1.0).abs() < 1e-9);
        assert!((armor_k(K_ARMOR) - 0.5).abs() < 1e-9); // rating == K → 50% through
        assert!(armor_k(50_000.0) > 0.0); // huge armor: still positive (no heal-the-target bug)
        assert!(armor_k(50_000.0) < 0.05);
    }

    #[test]
    fn probability_stats_clamp_at_100pct() {
        // crit / multicast / counterattack chances over the basis-point cap
        // (e.g. an over-generous class-level grant) must clamp to 100% — power
        // can't keep scaling past a certain chance. Guards the `.clamp(0,1)`s.
        let base = || {
            let mut a = AttrMap::new();
            a.insert("hp".into(), 3000.0);
            a.insert("attack".into(), 600.0);
            a.insert("speed".into(), 10000.0);
            a
        };
        let with = |stat: &str, v: f64| {
            let mut a = base();
            a.insert(stat.into(), v);
            power_from_attrs(&a)
        };
        // crit's clamp point sits at raw 10000/crit_chance_scale (the scalar
        // prices crit at the REALIZED proc rate, so a sub-1 scale moves the
        // clamp point up; both raw values below are past it either way).
        assert_eq!(
            with("crit_chance", 20_000.0),
            with("crit_chance", 5_000_000.0),
            "crit_chance must clamp at 100% effective (no power growth past the cap)"
        );
        for stat in ["multicast_chance", "counterattack_chance"] {
            assert_eq!(
                with(stat, 10000.0),
                with(stat, 5_000_000.0),
                "{stat} must clamp at 100% (no power growth past the cap)"
            );
        }
    }

    #[test]
    fn scalar_matches_combat_on_received_damage_and_speed_baseline() {
        // received_damage: combat applies it; the scalar must too. A −5000 mod (10000−5000 =
        // 5000 = 50% damage taken) ⇒ ×2 EHP ⇒ double power; neutral (absent) ⇒ ×1 (no change).
        let mut neutral = AttrMap::new();
        neutral.insert("hp".into(), 3000.0);
        neutral.insert("attack".into(), 600.0);
        neutral.insert("speed".into(), 10000.0);
        assert_eq!(
            power_from_attrs(&neutral),
            1000,
            "neutral baseline = DPS·EHP/NORM"
        );
        let mut reduced = neutral.clone();
        reduced.insert("received_damage".into(), -5000.0);
        assert_eq!(
            power_from_attrs(&reduced),
            2000,
            "50% received_damage must double EHP/power (scalar matches combat)"
        );

        // speed ≤ 0 falls back to the baseline cast rate (like combat's `speed_or_baseline`),
        // NOT 0 DPS — a build with no speed stat must still have positive power.
        let mut no_speed = AttrMap::new();
        no_speed.insert("hp".into(), 3000.0);
        no_speed.insert("attack".into(), 600.0); // no "speed" key ⇒ composed speed 0
        assert_eq!(
            power_from_attrs(&no_speed),
            1000,
            "speed≤0 must use baseline rate (1.0), not 0 DPS"
        );
    }
}

#[cfg(test)]
mod stat_equivalence_audit {
    //! SimC-style equivalence-points audit: the marginal HONEST-POWER value of
    //! one ITEM ROLL of each optional stat must stay within a band — no dead
    //! stats, no dominant stat. Per-roll magnitudes mirror
    //! `behaviors/items.rs` (aux stats all ride
    //! `(eff·spread)^AUX_ATTR_IMPACT`, so they scale together by
    //! construction; this test pins that equivalence against regressions in
    //! either the item formulas or the scalar pricing). Marginals are
    //! evaluated at a smooth mid loadout, away from clamps.
    use super::*;

    fn mid_loadout() -> AttrMap {
        let mut a = AttrMap::new();
        a.insert("hp".into(), 3000.0);
        a.insert("attack".into(), 600.0);
        a.insert("speed".into(), 10000.0);
        a.insert("armor".into(), 1000.0);
        a.insert("crit_chance".into(), 1000.0);
        a
    }

    fn marginal(stat: &str, roll: f64) -> f64 {
        let base = power_from_attrs(&mid_loadout()) as f64;
        let mut b = mid_loadout();
        *b.entry(stat.to_string()).or_insert(0.0) += roll;
        (power_from_attrs(&b) as f64 - base) / base
    }

    #[test]
    fn optional_item_roll_values_stay_in_band() {
        // Per-roll permyriad at eff=5 (aux = 5^0.05 ≈ 1.0838), mirroring
        // items.rs attr fns (spread = 1, /10 item scale included):
        let aux: f64 = 5.0_f64.powf(AUX_ATTR_IMPACT);
        let a2 = aux * aux;
        let rolls: &[(&str, f64)] = &[
            (
                "crit_chance",
                ((-1.0 + (8.0 * a2 - 7.0).sqrt()) / 4.0) * 1000.0,
            ),
            (
                "crit_modifier",
                ((-1.0 + (8.0 * a2 - 7.0).sqrt()) / 2.0) * 1000.0,
            ),
            ("evasion", (1.0 - 1.0 / aux) * 1000.0),
            ("speed", (aux - 1.0) * 1000.0),
            (
                "multicast_chance",
                ((-1.0 + (8.0 * a2 - 7.0).sqrt()) / 4.0) * 1000.0,
            ),
            (
                "counterattack_chance",
                ((-1.0 + (8.0 * a2 - 7.0).sqrt()) / 4.0) * 1000.0,
            ),
            ("block", ((aux - 1.0) * 1000.0).min(200.0)),
        ];
        let mut vals = vec![];
        for (stat, roll) in rolls {
            let m = marginal(stat, *roll);
            println!("EP {stat:22} roll {roll:7.1} -> dP/P {:+.4}", m);
            assert!(m > 0.0, "{stat}: dead stat — a roll must buy SOME power");
            vals.push((stat, m));
        }
        let mut sorted: Vec<f64> = vals.iter().map(|(_, m)| *m).collect();
        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
        let median = sorted[sorted.len() / 2];
        for (stat, m) in &vals {
            assert!(
                *m >= median / 5.0 && *m <= median * 5.0,
                "{stat}: per-roll value {m:.4} outside x5 band of median {median:.4}"
            );
        }
    }
}

#[cfg(test)]
mod v2_helper_tests {
    //! Pins the v2 sim-tunable helpers: enemy-curve anchor+monotonicity (the
    //! progression gate), the sub-linear gold faucet (the cost-curve bind), and
    //! the per-tick heal/damage cap (anti out-heal / one-shot).
    use super::*;

    #[test]
    fn enemy_curve_anchored_and_monotonic() {
        // The curve's PRODUCTION domain is ch ≥ HAND_AUTHORED_CHAPTER_MAX+1:
        // `enemy_power_scalar` uses the hand-authored YAML `base_power` for
        // ch0-9, so `enemy_power_for_chapter` is only ever spawn-consulted for
        // ch ≥ 10. Strictly increasing THERE — content must gate progression.
        // (stage2-bridge CYCLE 3: the ch10 entry was lowered to E(10)≈416, below
        // the phantom ch7-9 curve values (E(7)=686), so monotonicity is required
        // only in the production domain ch≥10, not from the legacy anchor ch7.)
        // BAL-037: the signed curve owns ch0…509, so monotonicity is required
        // from the very first chapter — and it is NON-DECREASING, because the
        // contract's single final `floor` may legitimately produce equal
        // adjacent integers. A strict-rise assertion here would push an
        // implementer toward the forbidden artificial `+1`.
        let mut prev = enemy_power_for_chapter(0);
        assert!(prev > 0.0);
        for ch in 1..=70 {
            let p = enemy_power_for_chapter(ch);
            assert!(
                p >= prev,
                "enemy power must not decrease: ch{ch} → {p} < {prev}"
            );
            prev = p;
        }
        // The ch9→10 seam is continuous by construction: E_base(10) ≈ E_base(9) ×
        // 1.03. This is the accidental ×9 jump the signed curve exists to remove,
        // so it is worth pinning rather than trusting the knots by eye.
        let seam = e_base(10) / e_base(9);
        assert!(
            (seam - 1.03).abs() < 0.02,
            "ch9→10 must stay continuous: seam ratio {seam} (legacy curve jumped ~×9)"
        );
    }

    #[test]
    fn dungeon_uses_authored_base_power_not_chapter_curve() {
        // A dungeon fight is tagged CampaignBossFight but must use its authored
        // per-difficulty `base_power` (the difficulty ladder), NOT the campaign
        // chapter curve — otherwise every difficulty collapses to one power keyed
        // to the player's campaign chapter ("losing to the dungeon at unlock").
        let ch = 20;
        // Campaign boss at ch20 ignores base_power and rides the (large) curve.
        let campaign = enemy_power_scalar(1500.0, ch, "CampaignBossFight", false);
        assert!(
            campaign > 10_000.0,
            "campaign boss must use the chapter curve at ch20, got {campaign}"
        );
        // Same template AS A DUNGEON returns the authored base_power verbatim —
        // difficulty 1 (1500) is a trivial first clear vs a ch20 player (~20k).
        assert_eq!(
            enemy_power_scalar(1500.0, ch, "CampaignBossFight", true),
            1500.0
        );
        // The ladder is honored across difficulties and is chapter-independent:
        // diff 5 (50k) and diff 10 (8.5M) pass through unchanged at any chapter.
        assert_eq!(
            enemy_power_scalar(50_000.0, ch, "CampaignBossFight", true),
            50_000.0
        );
        assert_eq!(
            enemy_power_scalar(8_500_000.0, 80, "CampaignBossFight", true),
            8_500_000.0
        );
    }

    #[test]
    fn whole_first_stage_rides_the_signed_ftue_curve() {
        // BAL-037 refits the whole FTUE block as one progression sequence: stage 1
        // no longer reads the authored `FightTemplate.power`, and its current
        // absolute rows `1…46` are explicitly NOT preserved. Waves are
        // `S_ref × (0.45 → 0.65)` and every boss — FTUE included — carries the one
        // total encounter coefficient `sqrt(1.30)`.
        for ch in 0..=9 {
            let wave = enemy_power_scalar(1234.0, ch, "CampaignFight", false);
            assert_ne!(wave, 1234.0, "stage-1 wave at {ch} must ignore base_power");
            assert_eq!(wave, enemy_wave_power(ch));
            assert_eq!(
                enemy_power_scalar(1234.0, ch, "CampaignBossFight", false),
                enemy_boss_power(ch),
                "stage-1 boss at {ch} takes sqrt(1.30), no separate mid-boss gate"
            );
        }
        // The signed endpoints of the FTUE ramp: 0.45 of S_ref at ch0, 0.65 at ch9.
        assert_eq!(enemy_wave_power(0), (30.0f64 * 0.45).floor());
        assert_eq!(enemy_wave_power(9), (4_100.0f64 * 0.65).floor());
        // ch10 (stage 2-1) and beyond ride the CURVE, not base_power. Post
        // stage2-bridge the ch10 boss carries NO mid-gate (the gate moved to the
        // ch12-14 window) — only the ×STEP^0.5 boss bump — so it equals
        // enemy_power_for_chapter(10)×STEP^0.5. We assert the curve regime is
        // engaged (result diverges from the passed base_power) and that the ch10
        // boss is the clean (un-gated) boss value.
        let boss10 = enemy_power_scalar(1234.0, 10, "CampaignBossFight", false);
        let expect10 = enemy_power_for_chapter(10) * CHAPTER_POWER_STEP.powf(0.5);
        assert!(
            (boss10 - expect10).abs() < 1.0 && (boss10 - 1234.0).abs() > 1.0,
            "ch10 boss must ride the curve with no mid-gate, got {boss10} vs {expect10}"
        );
        // The mid-boss gate now fires on the ch12-14 window, NOT the boundary:
        // ch10/ch11 bosses are un-gated, ch12 carries the peak bump.
        assert_eq!(
            enemy_mid_chapter_mult(10),
            1.0,
            "ch10 boss must be un-gated"
        );
        assert_eq!(
            enemy_mid_chapter_mult(11),
            1.0,
            "ch11 boss must be un-gated"
        );
        assert!(
            enemy_mid_chapter_mult(12) > 1.0,
            "ch12 boss must carry the mid-gate gear-check"
        );
        assert!(
            (enemy_power_scalar(1234.0, 10, "CampaignFight", false) - 1234.0).abs() > 1.0,
            "ch10 wave must ride the curve, not base_power"
        );
    }

    #[test]
    fn sell_price_is_sublinear() {
        // Sub-linear (exp < 1): doubling `eff` less-than-doubles price, so the
        // geometric chest-upgrade sink can outgrow the gold faucet and bind
        // progression. The ratio check below fails if exp ever reaches ≥ 1.
        let p1 = sell_price(1000.0) as f64;
        let p2 = sell_price(2000.0) as f64;
        assert!(p2 > p1, "price must increase with eff");
        assert!(
            p2 < 2.0 * p1,
            "sub-linear: doubling eff must less-than-double price ({p1} → {p2})"
        );
        assert_eq!(sell_price(-5.0), 0, "negative eff floored to 0");
    }

    #[test]
    fn sell_price_with_config_precedence() {
        // Per-knob precedence resolver: env (sim sweep) wins over the GameConfig
        // value, which wins over the compiled constant. Tested on the pure
        // resolver so no process-global env is mutated — race-free under
        // threaded `cargo test`.
        assert_eq!(
            resolve_sell_knob(Some(0.9), Some(0.6), SELL_PRICE_EXP),
            0.9,
            "env wins over config"
        );
        assert_eq!(
            resolve_sell_knob(None, Some(0.6), SELL_PRICE_EXP),
            0.6,
            "config wins over the constant when env is unset"
        );
        assert_eq!(
            resolve_sell_knob(None, None, SELL_PRICE_EXP),
            SELL_PRICE_EXP,
            "constant default when neither env nor config is set"
        );

        // The full price fn reads `OVERLORD_BAL_SELL_*` live, so pin the
        // config/default cases only when those vars are absent (the standard
        // test env); an env sweep is covered by the resolver assertions above.
        let env_clean = std::env::var("OVERLORD_BAL_SELL_EXP").is_err()
            && std::env::var("OVERLORD_BAL_SELL_COEF").is_err();
        if env_clean {
            for &eff in &[0.0_f64, 1.0, 250.0, 1000.0, 9999.0] {
                let baseline = sell_price(eff);
                // Config absent ⇒ compiled constants ⇒ bit-identical to the
                // pre-config `sell_price` path.
                assert_eq!(
                    sell_price_with_config(eff, None, None),
                    baseline,
                    "config absent ⇒ constant default (bit-identical to sell_price)"
                );
                // Deploying the config with the current constant values is a
                // no-op on price.
                assert_eq!(
                    sell_price_with_config(eff, Some(SELL_PRICE_EXP), Some(SELL_PRICE_COEF)),
                    baseline,
                    "config = current constants ⇒ unchanged price"
                );
            }
            // A config override with different knobs is honored (env unset).
            let eff = 1000.0_f64;
            assert_eq!(
                sell_price_with_config(eff, Some(0.60), Some(50.0)),
                (eff.powf(0.60) * 50.0).floor() as i64,
                "config knobs used when present and env unset"
            );
        }
    }

    #[test]
    fn eff_by_level_branch_join_is_continuous() {
        // The two eff branches must join at L=130 in value AND slope — the
        // A2/B2/C2 late-branch consts are a re-fit whenever B1/B2 move (see the
        // closed form in the const block). Guards against a future sweep
        // baking a discontinuous pair (a value step here is a hidden gear
        // cliff at item level 130).
        let left = eff_by_level(EFF_MIDGAME_LEVEL);
        let right = EFF_A2 * (EFF_MIDGAME_LEVEL + 1e-9).powf(EFF_B2) + EFF_C2;
        assert!(
            ((right - left) / left).abs() < 1e-3,
            "eff branch value step at L130: left {left}, right {right}"
        );
        let slope_left = EFF_A1 * EFF_B1 * (EFF_MIDGAME_LEVEL - 1.0).powf(EFF_B1 - 1.0);
        let slope_right = EFF_A2 * EFF_B2 * EFF_MIDGAME_LEVEL.powf(EFF_B2 - 1.0);
        assert!(
            ((slope_right - slope_left) / slope_left).abs() < 1e-2,
            "eff branch slope step at L130: left {slope_left}, right {slope_right}"
        );
    }

    #[test]
    fn smooth_curve_has_one_universal_tail_and_no_authored_walls() {
        assert_eq!(e_base(45), 302_619.0);
        for ch in 46..=509 {
            let ratio = e_base(ch) / e_base(ch - 1);
            assert!(
                (ratio - E_BASE_TAIL_STEP).abs() < 1e-12,
                "ch{ch}: universal tail ratio {ratio} vs {E_BASE_TAIL_STEP}"
            );
        }

        // Wave and boss curves read the same smooth base. The boss coefficient
        // is global, not a chapter spike, and final integer flooring is the only
        // permitted divergence from the analytic values.
        for ch in [10, 21, 25, 31, 35, 45, 65, 95, 165, 300, 509] {
            assert_eq!(enemy_wave_power(ch), e_base(ch).floor());
            let expected_boss = (e_base(ch) * BOSS_ENCOUNTER_COEF_SQ.sqrt()).floor();
            assert_eq!(enemy_boss_power(ch), expected_boss);
        }

        let chapters_per_twenty_percent = 1.20f64.ln() / E_BASE_TAIL_STEP.ln();
        assert!(
            (2.0..=2.7).contains(&chapters_per_twenty_percent),
            "+20% strength should open several chapters, got {chapters_per_twenty_percent}"
        );
        let chapters_per_fifty_percent = 1.50f64.ln() / E_BASE_TAIL_STEP.ln();
        assert!(
            (5.0..=5.7).contains(&chapters_per_fifty_percent),
            "+50% strength should open a short chapter streak, got {chapters_per_fifty_percent}"
        );
    }

    #[test]
    fn interp_geometric_knots_between_and_extrapolation() {
        let knots: &[(i64, f64)] = &[(10, 100.0), (20, 400.0), (30, 800.0)];
        // Exact at knots.
        assert_eq!(interp_geometric(knots, 10), 100.0);
        assert_eq!(interp_geometric(knots, 20), 400.0);
        // Constant before the first knot.
        assert_eq!(interp_geometric(knots, 0), 100.0);
        // Geometric midpoint between knots: sqrt(100·400) = 200.
        assert!((interp_geometric(knots, 15) - 200.0).abs() < 1e-9);
        // Past the end: final segment ratio (×2 per 10ch ⇒ ×2^(1/10) per ch).
        let per_ch = (800.0f64 / 400.0).powf(0.1);
        assert!((interp_geometric(knots, 35) - 800.0 * per_ch.powi(5)).abs() < 1e-6);
        // Degenerate shapes.
        assert_eq!(interp_geometric(&[], 5), 0.0);
        assert_eq!(interp_geometric(&[(1, 42.0)], 99), 42.0);
    }

    #[test]
    fn ability_milestones_pin() {
        // L5 ×1.10 and L10 ×1.20 (cumulative) on top of the +5%/level line —
        // the proximate-milestone shape of the ability upgrade track.
        // Uses the default lookups (unknown rarity ⇒ rarity_eff 1.0).
        let lk = ContentLookups::default();
        let r = Uuid::nil();
        assert!((ability_eff(&lk, r, 1) - 1.0).abs() < 1e-12);
        assert!((ability_eff(&lk, r, 4) - 1.15).abs() < 1e-12);
        assert!((ability_eff(&lk, r, 5) - 1.20 * 1.10).abs() < 1e-12);
        assert!((ability_eff(&lk, r, 10) - 1.45 * 1.10 * 1.20).abs() < 1e-12);
    }

    #[test]
    fn zone_correction_preserves_enemy_curve() {
        // The enemy curve is expressed in zone-corrected units ρ̂ = P/(z·E);
        // this test pins E = G/(ρ̂·z) at reference chapters so nobody edits ρ̂
        // or z WITHOUT re-deriving the pair (and G) together. Re-bake the pins
        // only as part of a legitimate re-derivation of all three tables.
        // stage2-bridge CYCLE 3: the WHOLE curve ch10+ re-derived from the
        // required chest-open cadence (designer-authorized full retirement of
        // the old funded curve). Every pin ch15+ re-baked. ch1/7 unchanged (E(7)
        // legacy anchor pin; ch0-9 hand-authored, phantom curve). ch80+ are in
        // the model-EXTRAPOLATED 12/min tail (unreachable in-test).
        let pins: &[(i64, f64)] = &[
            (1, 686.0),
            (7, 686.0),
            (15, 14979.0),
            (23, 1079676.0),
            (29, 6511267.0),
            (39, 17313684.0),
            (49, 35372775.0),
            (60, 67137418.0),
            (64, 77618278.0),
            (80, 114351114.0),
            (95, 199038697.0),
            (110, 409498525.0),
            (120, 662398186.0),
        ];
        for &(ch, expected) in pins {
            let e = enemy_power_derived(ch).unwrap();
            assert!(
                (e - expected).abs() / expected < 3e-4,
                "E({ch}) drifted: {e} vs ratified {expected}"
            );
        }
        // The corrected units themselves: uniform crossing ≈0.55 means the
        // on-schedule pressure ρ̂ stays within the sane band everywhere.
        for ch in 7..=120 {
            let rho_hat = interp_geometric(RHO_TARGET_KNOTS, ch);
            assert!(rho_hat > 0.2 && rho_hat < 20.0, "ρ̂({ch}) = {rho_hat}");
        }
    }

    #[test]
    // Deliberate emptiness guard against the CURRENT const — see `zone_difficulty`.
    #[allow(clippy::const_is_empty)]
    fn derived_curve_unavailable_until_tables_baked() {
        // Safety: with empty calibration tables the derived mode must report
        // None so enemy_power_for_chapter falls back to legacy.
        if PLAYER_GROWTH_KNOTS.is_empty() || RHO_TARGET_KNOTS.is_empty() {
            assert_eq!(enemy_power_derived(40), None);
        } else {
            assert!(enemy_power_derived(40).unwrap() > 0.0);
        }
    }

    #[test]
    fn wave_skew_defaults_pin_the_stat_check_package() {
        // The sub-1 magnitude lengthens fights (more RNG samples per outcome
        // = steeper sigmoid). DAMAGE below HP is deliberate (break-even
        // r ≈ 0.83): it compensates the slot-model fight shapes (streamed
        // waves, boss summons) whose damage pattern is less survivable than
        // the legacy decaying waves at the same budget — validated vs `main`
        // by matched n=6 7-day sims (2026-07). Changing either value moves
        // the game-wide difficulty; re-run the sim comparison first.
        assert_eq!(BALANCE_TUNING_DEFAULT.wave_damage_skew, 0.75);
        assert_eq!(BALANCE_TUNING_DEFAULT.wave_hp_skew, 0.9);
    }

    #[test]
    fn cap_per_tick_binds_and_passes_through() {
        // Over-cap clamps to pct×max_hp; under-cap passes through unchanged.
        assert_eq!(cap_per_tick(1_000_000.0, 1000.0, 0.02), 20.0);
        assert_eq!(cap_per_tick(5.0, 1000.0, 0.02), 5.0);
        assert_eq!(cap_per_tick(0.0, 1000.0, 0.5), 0.0);
    }
}

#[cfg(test)]
mod honest_ability_power_tests {
    //! The honest scalar's DPS/EHP-split ability contributions (see
    //! `ability_power_mults`). A regression back to a flat `Σ ability_eff`
    //! multiplier FAILS here.
    use super::*;
    use essences::abilities::EquippedAbilities;

    #[test]
    fn profile_split_damage_vs_heal() {
        // Pure damage budget: everything lands on the DPS axis.
        let p = ability_profile_from_info(Some(10.0), None, None, None, None, 2.0);
        assert!((p.dps_add - 5.0).abs() < 1e-9); // 10 budget / 2s cd
        assert_eq!(p.heal_add, 0.0);

        // Pure HoT budget: everything lands on the heal axis.
        let p = ability_profile_from_info(None, None, Some(10.0), None, None, 2.0);
        assert_eq!(p.dps_add, 0.0);
        assert!((p.heal_add - 5.0).abs() < 1e-9);

        // Lifesteal: damage throughput + vampiric fraction of it as heal.
        let p = ability_profile_from_info(Some(10.0), None, None, Some(0.3), None, 2.0);
        assert!((p.dps_add - 5.0).abs() < 1e-9);
        assert!((p.heal_add - 1.5).abs() < 1e-9); // 0.3 × 10 / 2s

        // DoT counts as damage throughput (its OT premium is already priced
        // into the budget split by the content closures).
        let p = ability_profile_from_info(Some(4.0), Some(6.0), None, None, None, 2.0);
        assert!((p.dps_add - 5.0).abs() < 1e-9);

        // Multi-projectile: the info split reports per-projectile damage;
        // combat fires them all — throughput carries the full budget.
        let p = ability_profile_from_info(Some(4.0), None, None, None, Some(3), 2.0);
        assert!((p.dps_add - 6.0).abs() < 1e-9); // 4×3 / 2s
    }

    fn test_ability(level: i64) -> Ability {
        // A template that EXISTS in the test config but has no bespoke
        // `ability_info` closure → the conservative pure-damage fallback
        // (eff × FD/(FD+cd)) applies. cd = 10000ms in the test config.
        Ability {
            template_id: Uuid::parse_str("da6c582b-7364-40bd-9b2d-946d8e20eaac").unwrap(),
            level,
            shards_amount: 0,
        }
    }

    fn base_attrs() -> AttrMap {
        let mut a = AttrMap::new();
        a.insert("hp".into(), 3000.0);
        a.insert("attack".into(), 600.0);
        a.insert("speed".into(), 10000.0);
        a
    }

    #[test]
    fn membership_matches_combat_unslotted_count_dead_do_not() {
        // Combat membership (`make_active_abilities_from_equipped`) sends BOTH
        // slotted and unslotted abilities into the fight — so unslotted (the
        // class kit) must add power. Abilities with an empty `start_behavior`
        // never begin a cast cycle — so they must add NOTHING.
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        let attrs = base_attrs();

        let mut slotted_only = EquippedAbilities::new();
        slotted_only.slotted.insert(1, test_ability(1));
        let p_slotted = character_power_from_attrs(&cfg, &lk, &attrs, &slotted_only, None);
        assert!(p_slotted > 0);

        // Unslotted castable ability adds throughput exactly like a slotted one.
        let mut with_kit = EquippedAbilities::new();
        with_kit.slotted.insert(1, test_ability(1));
        with_kit.unslotted.push(test_ability(1));
        let p_kit = character_power_from_attrs(&cfg, &lk, &attrs, &with_kit, None);
        assert!(
            (p_kit - p_slotted * 2).abs() <= 1, // floor rounding
            "an unslotted castable ability fights (combat membership) — it must add \
             power: got {p_kit}, expected ≈{}",
            p_slotted * 2
        );

        // Dead ability (empty start_behavior) never casts — no power.
        let dead = Ability {
            template_id: Uuid::parse_str("00000000-dead-7000-8000-000000000001").unwrap(),
            level: 1,
            shards_amount: 0,
        };
        let mut with_dead = EquippedAbilities::new();
        with_dead.slotted.insert(1, test_ability(1));
        with_dead.unslotted.push(dead);
        let p_dead = character_power_from_attrs(&cfg, &lk, &attrs, &with_dead, None);
        assert_eq!(
            p_dead, p_slotted,
            "a dead (empty start_behavior) ability never casts — it must not add power"
        );
    }

    #[test]
    fn fallback_throughput_carries_cooldown_factor() {
        // cd = 10s in the test config → k = FD/(FD+10) ≈ 0.4545. The legacy
        // formula would have used eff×1.0; the honest one must be scaled by k.
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        let mut eq = EquippedAbilities::new();
        eq.slotted.insert(1, test_ability(1));
        let (dps_mult, ehp_mult) = ability_power_mults(&cfg, &lk, &eq, None, &base_attrs());
        let k = FIGHT_DURATION / (FIGHT_DURATION + 10.0);
        // eff for the test rarity id is unknown to lookups → 1.0; level 1 → ×1.
        assert!(
            (dps_mult - k).abs() < 1e-9,
            "expected eff×k = {k}, got {dps_mult}"
        );
        assert_eq!(ehp_mult, 1.0, "pure damage ability must not credit EHP");
    }

    #[test]
    fn no_slotted_abilities_means_zero_power() {
        // Legacy semantic preserved: a character that casts nothing deals
        // nothing — power 0 (see project_native_power_default).
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        let eq = EquippedAbilities::new();
        assert_eq!(
            character_power_from_attrs(&cfg, &lk, &base_attrs(), &eq, None),
            0
        );
    }

    #[test]
    fn leader_pet_active_ability_adds_power() {
        // `create_player_entity` pushes the leader pet's active ability into
        // the fight set at the pet's level — the scalar must count it, priced
        // at the charge-fill rate (per-cast budget / PET_ULT_EFFECTIVE_CD),
        // not at the template cooldown.
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        let mut eq = EquippedAbilities::new();
        eq.slotted.insert(1, test_ability(1));
        let pet_ability_id = Uuid::parse_str("da6c582b-7364-40bd-9b2d-946d8e20eaac").unwrap();
        let (without, _) = ability_power_mults(&cfg, &lk, &eq, None, &base_attrs());
        let (with, _) =
            ability_power_mults(&cfg, &lk, &eq, Some((pet_ability_id, 1)), &base_attrs());
        assert!(
            with > without,
            "leader pet's castable active ability must add DPS throughput"
        );
        // Same template at the same level: slotted contributes eff·k, the pet
        // contributes the per-cast budget eff·k·cd spread over the fill time.
        let cd = (cfg.ability_template(pet_ability_id).unwrap().cooldown as f64 / 1000.0).max(0.1);
        let expected = without * (1.0 + cd / PET_ULT_EFFECTIVE_CD);
        assert!(
            (with - expected).abs() < 1e-9,
            "pet ult must be priced at the charge-fill rate: {with} vs {expected}"
        );
    }

    #[test]
    fn power_bonus_is_inert_in_the_gear_compare() {
        // BAL-030: the per-item jitter is a persisted DISPLAY field and enters
        // no power path — display, matchmaking, or this gear-compare. A
        // cosmetic roll must not decide which item auto-equip keeps.
        let cfg = configs::tests_game_config::generate_game_config_for_tests();
        let lk = ContentLookups::default();
        let no_abilities = EquippedAbilities::new();
        let power_with = |bonus: i32| {
            let item = Item {
                power_bonus: bonus,
                ..Default::default()
            };
            character_power(&cfg, &lk, 1, &[item], &no_abilities, &[]).unwrap()
        };
        assert_eq!(
            power_with(0),
            power_with(7_777),
            "power_bonus must not move the gear-compare power"
        );
    }

    #[test]
    fn heal_ability_credits_capped_ehp() {
        // Direct aggregation check on the heal axis: synthesize the profile
        // via the pure splitter, then verify the EHP factor shape + cap.
        let attrs = base_attrs(); // hp 3000, attack 600
        let heal_add: f64 = 5.0;
        let hp = 3000.0;
        let attack = 600.0;
        let uncapped = attack * DMG_K * heal_add; // 300 HP/s
        let cap = hp * BALANCE_TUNING_DEFAULT.hot_tick_max_pct; // 750 HP/s
        assert!(uncapped < cap, "test setup: below cap");
        let expected = (hp + uncapped * FIGHT_DURATION) / hp;
        // (hp + 300·25)/3000 = 3.5 at the measured FIGHT_DURATION of 25s.
        assert!((expected - 3.5).abs() < 1e-3);
        let _ = attrs; // attrs used above for provenance of the numbers
    }
}

#[cfg(test)]
mod class_balance_tests {
    //! The four combat classes are differentiated by `class_levels` grants
    //! (Warrior→block, Rogue→crit, Mage→multicast, Priest→regen) but must remain
    //! POWER-balanced under `P=DPS×EHP`. Their grants overflow the basis-point
    //! cap, so this also guards the clamp/regen-cap robustness fixes: without
    //! them block>1 gave NEGATIVE power and regen exploded EHP ~40×.
    use super::*;

    fn profile(stat: &str, value: f64) -> AttrMap {
        let mut a = AttrMap::new();
        a.insert("attack".into(), 600.0);
        a.insert("hp".into(), 3000.0);
        a.insert("speed".into(), 10000.0);
        a.insert(stat.into(), value);
        a
    }

    #[test]
    fn class_power_offensive_trio_equal_regen_honestly_lower() {
        // The block class (Warrior, ×2 EHP) and the two ×2-DPS classes (Rogue crit,
        // Mage multicast) are power-balanced — symmetric ×2 mechanisms → equal power.
        let warrior = power_from_attrs(&profile("block", 38800.0)); // 3.88 → clamp 1.0 → ×2 EHP
        // The raw crit stat here overflows the realized-rate clamp regardless
        // of crit_chance_scale, so crit lands at 100% → the ×2 crit-damage
        // identity ⇒ ×2 DPS, symmetric with Mage's multicast.
        let rogue = power_from_attrs(&profile("crit_chance", 38800.0)); // clamp → ×2 DPS
        let mage = power_from_attrs(&profile("multicast_chance", 19400.0)); // → ×2 DPS
        let priest = power_from_attrs(&profile("regeneration_rate", 19400.0));
        assert!(
            warrior > 0,
            "block>1 must NOT produce negative power (clamp)"
        );
        assert_eq!(warrior, rogue, "Warrior vs Rogue imbalance");
        assert_eq!(rogue, mage, "Rogue vs Mage imbalance");
        // Priest's regen is honestly capped to what COMBAT delivers, which is
        // structurally below block's ×2 EHP — so the scalar shows Priest
        // LOWER. This is a real combat-balance fact, not a formula bug;
        // closing it (raise `regen_tick_max_pct` or compensate the Priest
        // grant) is a sim/design decision, not a scalar tweak.
        assert!(priest > 0, "Priest power must stay positive");
        assert!(
            priest < warrior,
            "honest regen EHP (≈×1.16) is below block's ×2 — Priest is structurally lower"
        );
    }

    #[test]
    fn regen_is_bounded() {
        // Absurd regen must not explode EHP: the scalar applies the SAME per-tick cap as
        // combat (`regen_tick_max_pct × hp`), so regen above the cap adds no extra power.
        let huge = power_from_attrs(&profile("regeneration_rate", 1_000_000.0));
        let capped = power_from_attrs(&profile("regeneration_rate", 19400.0));
        assert_eq!(huge, capped, "regen beyond the cap must not increase power");
    }
}