overlord_event_system/mechanics/

stones.rs

//! Trigger/Effect Stone combat runtime — the arithmetic and the bookkeeping
//! keys. The orchestration is [`crate::logic::stones`].
//!
//! Per-fight trigger state lives in the player entity's `attributes`, the same
//! idiom as `stun_until_tick` and `stagger_procs`: the fight rebuilds its
//! entities, so the state resets by construction.
//!
//! Keys are namespaced `stone.*` so they cannot collide with a stat code —
//! [`crate::mechanics::fight::get_entity_stat`] composes `<code>`,
//! `<code>.bonus` and `<code>.mod`.

use essences::entity::Entity;
use essences::items::AttributeId;
use essences::stones::{StoneInventory, StoneKind};

use configs::stones::{EffectStoneTemplate, StonesSettings, TriggerStoneTemplate};

/// Tick at which the whole build may fire again — one key, not one per slot.
/// A condition that comes true inside the window is lost, and the sequence
/// counter behind it restarts ([`reset_sequence_counters`]).
pub const GLOBAL_COOLDOWN: &str = "stone.cd";

/// BAL-027 `Battle Rhythm`: fight-clock tick at which the interval trigger in
/// this socket fires next. `0` (absent) means "not armed yet" — the first
/// sighting arms the metronome without firing.
pub fn interval_due_key(item_type: essences::items::ItemType) -> String {
    format!("stone.interval_due.{item_type}")
}

/// Damage bonus armed for the caster's next attacks, in permyriad
/// (`2_000` = +20%). Consumed by [`crate::mechanics::fight::attack`], one
/// charge per damaging swing.
pub const NEXT_ATTACK_BONUS: &str = "stone.next_attack_bonus";

/// How many more attacks [`NEXT_ATTACK_BONUS`] applies to. `EF-C05` arms one,
/// `EF-R06` three, `EF-E07` five.
pub const NEXT_ATTACK_BONUS_CHARGES: &str = "stone.na_bonus_n";

/// Crit-chance bonus armed for the caster's next attacks, in permyriad, with
/// its own charge count. Consumed by [`crate::mechanics::fight::attack`].
pub const NEXT_ATTACK_CRIT: &str = "stone.na_crit";
pub const NEXT_ATTACK_CRIT_CHARGES: &str = "stone.na_crit_n";

/// Extra swings armed for the caster's next cast. Consumed by
/// [`crate::mechanics::fight::cast`], which queues them through a `Proc` sink.
pub const NEXT_ATTACK_EXTRA_HITS: &str = "stone.next_attack_extra_hits";

/// How many critical hits the player has landed in an unbroken row.
pub const CRIT_STREAK: &str = "stone.crit_streak";

// ---- Trigger memory -------------------------------------------------------

/// Sequence counters, one per condition family — the common tier counts events
/// ("every 5th attack") rather than reacting to each. A counter that completes
/// while on cooldown restarts from zero rather than banking its activation.
pub const SEQ_BASIC_ATTACK: &str = "stone.n.atk";
pub const SEQ_HIT_TAKEN: &str = "stone.n.hit";
pub const SEQ_SKILL_CAST: &str = "stone.n.skill";
pub const SEQ_DEFEAT: &str = "stone.n.kill";

/// `1` while the previous Core hit the player landed was a critical one —
/// `TR-R06` Corrected Aim needs "crit straight after non-crit".
pub const PREV_HIT_CRIT: &str = "stone.m.prev_crit";

/// `1` between an original Skill Cast and the next Basic Attack (`TR-C06`).
pub const AFTER_SKILL: &str = "stone.m.after_skill";

/// Slot index + 1 of the previous original Skill; `0` = none yet (`TR-R05`).
pub const LAST_SKILL: &str = "stone.m.last_skill";

/// Original Skills cast in a row without taking Core damage (`TR-L05`).
pub const SKILLS_WITHOUT_DAMAGE: &str = "stone.m.no_dmg_skills";

/// Lowest HP the hero has been at this phase, in permyriad of Max HP
/// (`TR-E03`). Absent reads as full health — see [`hp_low_water`].
///
/// A low-water mark, not a per-threshold latch: it only ever falls, so every
/// threshold is crossed exactly once per phase however much the hero heals.
pub const HP_LOW_WATER: &str = "stone.m.hp_low";

/// How many recent Core Dodges the runtime remembers, i.e. the largest `N` a
/// "N dodges within a window" condition can ask for.
pub const DODGE_RING: usize = 4;

/// Tick + 1 of the `index`-th most recent Core Dodge (`0` = the current one);
/// `0` means "no such dodge yet" (`TR-L02`).
///
/// A ring of ticks rather than a tumbling-window counter: the condition is "N
/// dodges inside the last W ticks", which the actual times answer without an
/// edge case at the window boundary.
pub fn dodge_tick_key(index: usize) -> String {
    format!("stone.m.dg{index}")
}

/// The hero's HP as permyriad of Max HP.
pub fn hp_permyriad(entity: &Entity) -> i64 {
    let max_hp = entity.max_hp.max(1) as i128;
    (entity.hp as i128 * 10_000 / max_hp) as i64
}

/// The phase's low-water HP mark. An absent key means the mark has never been
/// written, which is full health — not zero, which would read as "already dead"
/// and disarm every HP threshold for the whole fight.
pub fn hp_low_water(entity: &Entity) -> i64 {
    match attr(entity, HP_LOW_WATER) {
        0 => 10_000,
        recorded => recorded,
    }
}

/// What the player is currently swinging: [`CAST_KIND_BASIC`] or
/// [`CAST_KIND_SKILL`], `0` before the first cast.
///
/// A `Damage` event carries no "which ability produced me" field, but the
/// `CastAbility` that produced it arrives first, so the runtime remembers the
/// kind and reads it back when the hit lands.
pub const CAST_KIND: &str = "stone.m.cast_kind";
pub const CAST_KIND_BASIC: i64 = 1;
pub const CAST_KIND_SKILL: i64 = 2;

/// Mana the resolving cast actually paid, in x100 fixed point PLUS ONE — `0`
/// means "no payment recorded", so a genuinely free cast (`1`) is still
/// distinguishable from a cast that never went through the pool at all.
///
/// Written at the mana gate (`handle_start_cast_ability`), where the one true
/// cost — after stone rescaling and the `Budget Plan` discount, without the
/// `Open Tab` surcharge — is decided. The mana conditions of laws
/// (`SkillManaAtMost` / `SkillManaAtLeast`) and trigger stones (`TR-C03` /
/// `TR-E02`) read it back when the cast resolves, so both systems judge the
/// price actually paid instead of re-deriving it and drifting.
pub const PAID_MANA: &str = "stone.m.paid_mana";

/// `1` once every equipped Skill has been cast at least once this phase
/// (`TR-L03`). A latch, so the condition fires on the cast that completed the
/// spellbook and not on every cast afterwards.
pub const SPELLBOOK_DONE: &str = "stone.m.spellbook";

/// `TR-R04` Wide Cast counts how many targets one original Skill reached.
///
/// A multi-target cast arrives as one `CastAbility` per target, all inside the
/// cast's own animation window, so "reached N targets" is "the N-th event of the
/// same Skill inside [`CAST_RUN_WINDOW_TICKS`]": `CAST_RUN_TICK` is when the run
/// opened, `CAST_RUN_SLOT` which Skill it is, `CAST_RUN_COUNT` how many events
/// have arrived.
pub const CAST_RUN_TICK: &str = "stone.m.crun_t";
pub const CAST_RUN_SLOT: &str = "stone.m.crun_s";
pub const CAST_RUN_COUNT: &str = "stone.m.crun_n";

/// How long one cast's per-target events may take to arrive. Half a second —
/// the shipped cast animation. Two separate casts of the same Skill are always
/// further apart (ability cooldowns are tens of seconds), so the window cannot
/// merge them into one oversized "wide" cast.
pub const CAST_RUN_WINDOW_TICKS: i64 = 500;

/// `TR-L04` Perfect Sequence is a three-step state machine: Skill → Basic
/// Attack → *different* Skill, all inside one window. `SEQ_STAGE` is how far it
/// has come (`0`/`1`/`2`), `SEQ_STAGE_TICK` when it started, `SEQ_STAGE_SKILL`
/// which Skill opened it (so "another" can be checked).
pub const SEQ_STAGE: &str = "stone.m.seq_stage";
pub const SEQ_STAGE_TICK: &str = "stone.m.seq_t";
pub const SEQ_STAGE_SKILL: &str = "stone.m.seq_skill";

// ---- Effect state ---------------------------------------------------------
//
// Armed by an Effect Stone fire, spent by whoever the effect acts on. Charge
// keys pair with a magnitude key; both are cleared together when the last
// charge is spent, so a stale magnitude can never apply for free.

/// Incoming-damage reduction armed for the next hits taken, permyriad + charges
/// (`EF-C04`).
pub const HIT_REDUCTION: &str = "stone.dr_pct";
pub const HIT_REDUCTION_CHARGES: &str = "stone.dr_n";

/// Timed incoming-damage reduction, permyriad (`EF-R04`). Expiry is the
/// scheduled inverse, like every other timed stone attribute.
pub const INCOMING_REDUCTION: &str = "stone.dr_timed";

/// Fully blocked hits with a retaliation behind them (`EF-E06`): charges, plus
/// the retaliation damage precomputed at arm time so the block site needs no
/// lookup of the attacker.
pub const GUARD_CHARGES: &str = "stone.guard_n";
pub const GUARD_RETALIATION: &str = "stone.guard_dmg";

/// While positive, Core damage may not take the player below 1 HP (`EF-L05`).
pub const DAMAGE_FLOOR: &str = "stone.floor";

/// Share of landed Core damage healed back, permyriad, timed (`EF-R05`).
pub const LIFESTEAL: &str = "stone.lifesteal";

/// Timed outgoing bonuses, permyriad: all damage (`EF-L06`) and original Skills
/// only (`EF-R03`). Both land as derived damage on top of the real hit, so they
/// can never re-enter a trigger.
pub const DAMAGE_BUFF: &str = "stone.dmg_buff";
pub const SKILL_BUFF: &str = "stone.skill_buff";

/// One-shot original-Skill payload bonus, permyriad + charges (`EF-C08`,
/// `EF-L08`).
pub const NEXT_SKILL_BONUS: &str = "stone.ns_bonus";
pub const NEXT_SKILL_BONUS_CHARGES: &str = "stone.ns_bonus_n";

/// Splash armed on the next original Skills (`EF-R08`) and on the next Basic
/// Attacks (`EF-L03`): permyriad of Attack dealt to every living enemy.
pub const NEXT_SKILL_SPLASH: &str = "stone.ns_splash";
pub const NEXT_SKILL_SPLASH_CHARGES: &str = "stone.ns_splash_n";

/// Derived copies spread off the next original Skill onto a **bounded** number
/// of extra targets (`EF-E08`): the share of that Skill's own landed payload
/// each copy carries, and how many additional targets it may reach.
///
/// Its own key pair, not the splash pair: splash is a flat share of Attack
/// against the whole enemy line, a split copy is a share of *this* hit against
/// a capped number of targets, and sharing keys would let one overwrite the
/// other when both are socketed.
pub const NEXT_SKILL_SPLIT: &str = "stone.ns_split";
pub const NEXT_SKILL_SPLIT_TARGETS: &str = "stone.ns_split_n";
pub const NEXT_ATTACK_SPLASH: &str = "stone.na_splash";
pub const NEXT_ATTACK_SPLASH_CHARGES: &str = "stone.na_splash_n";

/// Derived copies of the next original Skill (`EF-E01`, `EF-L02`): the strong
/// copy, the weak one, and how many copies are owed.
pub const NEXT_SKILL_ECHO: &str = "stone.ns_echo";
pub const NEXT_SKILL_ECHO_WEAK: &str = "stone.ns_echo2";
pub const NEXT_SKILL_ECHO_CHARGES: &str = "stone.ns_echo_n";

/// Derived hits added to the next Basic Attack (`EF-E02`): permyriad of Attack
/// per hit, and how many hits.
pub const NEXT_ATTACK_DERIVED: &str = "stone.na_derived";
pub const NEXT_ATTACK_DERIVED_CHARGES: &str = "stone.na_derived_n";

/// Every sequence counter, for the "an activation lost on cooldown restarts the
/// count" rule (acceptance criterion #5).
pub const SEQUENCE_COUNTERS: [&str; 4] =
    [SEQ_BASIC_ATTACK, SEQ_HIT_TAKEN, SEQ_SKILL_CAST, SEQ_DEFEAT];

/// How many equipped Skill slots the runtime remembers per phase. A build with
/// fewer equipped Skills leaves the tail keys at zero.
pub const SKILL_SLOTS: usize = 5;

/// Tick + 1 of the last cast of the player's equipped Skill in slot `index`;
/// `0` = not cast this phase.
///
/// Separate keys rather than a packed bitmask: `TR-E05` asks how many slots
/// were used inside a window, which needs the individual ticks.
pub fn skill_last_cast_key(index: usize) -> String {
    format!("stone.m.sk{index}")
}

/// Raw attribute read; a missing key is zero.
pub fn attr(entity: &Entity, key: &str) -> i64 {
    entity.attributes.0.get(key).copied().unwrap_or(0)
}

/// Zeroes every sequence counter, called when a condition came true while the
/// global cooldown was running.
///
/// All-or-nothing rather than per-stone: the counters are per event family and
/// shared by every stone counting that family, so leaving one alive would let a
/// second stone inherit a count the player already spent.
pub fn reset_sequence_counters(entity: &mut Entity) {
    for key in SEQUENCE_COUNTERS {
        entity.attributes.set(key, 0);
    }
}

/// The magnitude of a `(magnitude, charges)` pair, or `None` when it is spent.
/// Reading is separate from spending because the fight primitives only see
/// `&Entity`, while the stone runtime holds it mutably.
pub fn armed_magnitude(entity: &Entity, magnitude_key: &str, charges_key: &str) -> Option<i64> {
    let magnitude = attr(entity, magnitude_key);
    (attr(entity, charges_key) > 0 && magnitude != 0).then_some(magnitude)
}

/// Effect strength for one fire: the template's own scaling by upgrade level,
/// times the `(trigger tier × effect tier)` coefficient. Every shipped cell of
/// that matrix is `1.0`, so tier interaction stays a config edit.
pub fn effect_magnitude(
    settings: &StonesSettings,
    trigger: &TriggerStoneTemplate,
    effect: &EffectStoneTemplate,
    effect_level: i64,
) -> f64 {
    let levels_above_first = (effect_level - 1).max(0) as f64;
    let base = effect.magnitude + effect.magnitude_per_level * levels_above_first;
    base * settings.tier_coefficient(trigger.tier, effect.tier)
}

/// Every passive stat the character's **socketed** stones grant, as
/// `(attribute, value)` pairs ready to fold into an attribute delta map.
///
/// Three properties of this function are the whole feature, and each has a test
/// in `tests/test_stone_stats.rs`:
///
/// * an unsocketed stone contributes nothing — a stone is paid for by putting
///   it in a slot, not by owning it;
/// * `active_side` is never read, so a slot's Real and Fantasy effect stones
///   both contribute at all times and a flip cannot move stats or Power;
/// * a stone's upgrade level scales its stats
///   ([`configs::stones::StoneStat::value_at_level`]), the same shape
///   [`effect_magnitude`] uses.
///
/// Locked sockets need no check here: `StoneInventory::insert` refuses a locked
/// socket, so a socketed stone is by construction in an open one.
///
/// A stone whose template is missing from the config (content pulled from under
/// a live inventory) is skipped and logged, never fatal — same rule as
/// [`crate::game_config_helpers::GameConfigLookup::trigger_stone_template`].
pub fn socketed_stat_bonuses(
    config: &configs::game_config::GameConfig,
    inventory: &StoneInventory,
) -> Vec<(AttributeId, i64)> {
    use crate::game_config_helpers::GameConfigLookup;

    let mut bonuses = Vec::new();
    for (kind, stone) in inventory.all() {
        if !stone.is_socketed() {
            continue;
        }
        let stats = match kind {
            StoneKind::Trigger => config
                .trigger_stone_template(stone.template_id)
                .map(|t| &t.stats),
            StoneKind::Effect => config
                .effect_stone_template(stone.template_id)
                .map(|t| &t.stats),
        };
        let Some(stats) = stats else {
            tracing::warn!(
                "Socketed stone has no {kind} template {} in config — its stats are skipped",
                stone.template_id
            );
            continue;
        };
        for stat in stats {
            bonuses.push((stat.attribute_id, stat.value_at_level(stone.level)));
        }
    }
    bonuses
}

/// Whether a crit streak of `streak` satisfies "`required` crits in a row".
///
/// Fires on every `required`-th crit (2, 4, 6 … for `TR-E04`) rather than
/// resetting a counter, because one counter is shared by every socketed slot:
/// a reset by whichever slot happened to match first would silently starve the
/// others — `TR-L01` (three in a row) would never see a third crit if `TR-E04`
/// zeroed the streak on the second. The global cooldown is what bounds the rate.
pub fn crit_streak_met(streak: i64, required: i64) -> bool {
    let required = required.max(1);
    streak >= required && streak % required == 0
}

/// Whether an event counter of `count` satisfies "every `period`-th".
///
/// Same modulo shape as [`crit_streak_met`] and for the same reason: `TR-C01`
/// (every 5th attack) and a hypothetical every-3rd trigger share one counter,
/// so neither may zero it. What *does* zero it is the rule in acceptance
/// criterion #5 — an activation lost to the global cooldown restarts the
/// sequence, which is [`reset_sequence_counters`]'s job.
pub fn counter_met(count: i64, period: i64) -> bool {
    let period = period.max(1);
    count > 0 && count % period == 0
}

#[cfg(test)]
mod tests {
    use super::*;
    use configs::stones::{EffectStoneAction, TriggerCondition};
    use essences::stones::StoneTier;

    fn trigger(tier: StoneTier) -> TriggerStoneTemplate {
        TriggerStoneTemplate {
            id: uuid::Uuid::from_u128(1),
            name: i18n::I18nString::Translated(String::new()),
            description: i18n::I18nString::Translated(String::new()),
            tier,
            condition: TriggerCondition::OnCrit,
            condition_value: 0,
            condition_window_ticks: 0,
            gauge_gain: 1.0,
            power_proc_rate: 0.75,
            active: true,
            stats: Vec::new(),
            icon_path: String::new(),
        }
    }

    fn effect(tier: StoneTier) -> EffectStoneTemplate {
        EffectStoneTemplate {
            id: uuid::Uuid::from_u128(2),
            name: i18n::I18nString::Translated(String::new()),
            description: i18n::I18nString::Translated(String::new()),
            tier,
            action: EffectStoneAction::InstantDamage,
            magnitude: 30.0,
            magnitude_per_level: 10.0,
            secondary_magnitude: 0.0,
            charges: 0,
            duration_ticks: 0,
            power_q_base_first_rank: 1.1,
            power_q_base_max_rank: 1.3,
            stats: Vec::new(),
            icon_path: String::new(),
        }
    }

    fn settings(multiplier: f64) -> StonesSettings {
        use configs::stones::{
            StoneKillDropSettings, StoneRarityWeight, StoneTierCoefficient, StoneUpgradeStep,
        };
        use strum::IntoEnumIterator;

        StonesSettings {
            global_trigger_cooldown_ticks: 1_000,
            // Not exercised here (these tests cover the tier-coefficient
            // matrix), but the field is required — no serde default.
            rarity_weights: StoneTier::iter()
                .map(|tier| StoneRarityWeight { tier, weight: 1.0 })
                .collect(),
            tier_coefficients: StoneTier::iter()
                .flat_map(|trigger_tier| {
                    StoneTier::iter().map(move |effect_tier| StoneTierCoefficient {
                        trigger_tier,
                        effect_tier,
                        multiplier,
                    })
                })
                .collect(),
            socket_unlocks: Vec::new(),
            upgrade_ladder: vec![StoneUpgradeStep {
                level: 2,
                copies: 2,
            }],
            max_stone_level: 10,
            kill_drop: StoneKillDropSettings {
                chance: 0.0,
                trigger_share: 0.5,
            },
            milestone_grants: vec![],
        }
    }

    /// Acceptance criterion #5, half one: at 1.0 the matrix is the identity, so
    /// strength is exactly the template's own level scaling.
    #[test]
    fn an_all_ones_matrix_is_indistinguishable_from_no_matrix() {
        let settings = settings(1.0);
        let trigger = trigger(StoneTier::Common);
        let effect = effect(StoneTier::Epic);

        assert_eq!(effect_magnitude(&settings, &trigger, &effect, 1), 30.0);
        assert_eq!(effect_magnitude(&settings, &trigger, &effect, 3), 50.0);
    }

    /// Half two: the matrix is genuinely wired to strength, so the chat's
    /// version is a config edit away.
    #[test]
    fn the_matrix_scales_effect_strength() {
        let halved = settings(0.5);
        let trebled = settings(3.0);
        let trigger = trigger(StoneTier::Common);
        let effect = effect(StoneTier::Epic);

        assert_eq!(effect_magnitude(&halved, &trigger, &effect, 1), 15.0);
        assert_eq!(effect_magnitude(&trebled, &trigger, &effect, 1), 90.0);
    }

    /// A missing cell falls back to 1.0 rather than to zero strength — an
    /// incomplete matrix must not silently disable every effect.
    #[test]
    fn a_missing_cell_reads_as_no_modifier() {
        let mut settings = settings(1.0);
        settings.tier_coefficients.clear();
        let trigger = trigger(StoneTier::Rare);
        let effect = effect(StoneTier::Rare);

        assert_eq!(effect_magnitude(&settings, &trigger, &effect, 1), 30.0);
    }

    #[test]
    fn a_streak_trigger_fires_every_nth_crit() {
        let met: Vec<i64> = (0..=6).filter(|n| crit_streak_met(*n, 2)).collect();
        assert_eq!(
            met,
            vec![2, 4, 6],
            "every second crit, not every crit after"
        );

        // A zero/negative `condition_value` must not divide by zero.
        assert!(crit_streak_met(1, 0));
    }

    #[test]
    fn a_counter_trigger_fires_every_nth_event() {
        let met: Vec<i64> = (0..=11).filter(|n| counter_met(*n, 5)).collect();
        assert_eq!(
            met,
            vec![5, 10],
            "every fifth attack, not every attack after"
        );
        assert!(!counter_met(0, 5), "no events is not a fired condition");
        // A zero/negative period must not divide by zero.
        assert!(counter_met(1, 0));
    }

    /// The cooldown is ONE key for the whole build (design v0.2 §2) — there is
    /// no per-slot variant left to accidentally reintroduce.
    #[test]
    fn bookkeeping_keys_are_namespaced_and_the_cooldown_is_global() {
        assert_eq!(GLOBAL_COOLDOWN, "stone.cd");

        let mut keys = vec![
            GLOBAL_COOLDOWN.to_string(),
            CRIT_STREAK.to_string(),
            NEXT_ATTACK_BONUS.to_string(),
            NEXT_ATTACK_BONUS_CHARGES.to_string(),
            NEXT_ATTACK_CRIT.to_string(),
            NEXT_ATTACK_CRIT_CHARGES.to_string(),
            NEXT_ATTACK_EXTRA_HITS.to_string(),
            PREV_HIT_CRIT.to_string(),
            AFTER_SKILL.to_string(),
            LAST_SKILL.to_string(),
            SKILLS_WITHOUT_DAMAGE.to_string(),
            HP_LOW_WATER.to_string(),
            CAST_KIND.to_string(),
            SEQ_STAGE.to_string(),
            SEQ_STAGE_TICK.to_string(),
            SEQ_STAGE_SKILL.to_string(),
            SPELLBOOK_DONE.to_string(),
            CAST_RUN_TICK.to_string(),
            CAST_RUN_SLOT.to_string(),
            CAST_RUN_COUNT.to_string(),
            HIT_REDUCTION.to_string(),
            HIT_REDUCTION_CHARGES.to_string(),
            INCOMING_REDUCTION.to_string(),
            GUARD_CHARGES.to_string(),
            GUARD_RETALIATION.to_string(),
            DAMAGE_FLOOR.to_string(),
            LIFESTEAL.to_string(),
            DAMAGE_BUFF.to_string(),
            SKILL_BUFF.to_string(),
            NEXT_SKILL_BONUS.to_string(),
            NEXT_SKILL_BONUS_CHARGES.to_string(),
            NEXT_SKILL_SPLASH.to_string(),
            NEXT_SKILL_SPLASH_CHARGES.to_string(),
            NEXT_SKILL_SPLIT.to_string(),
            NEXT_SKILL_SPLIT_TARGETS.to_string(),
            NEXT_ATTACK_SPLASH.to_string(),
            NEXT_ATTACK_SPLASH_CHARGES.to_string(),
            NEXT_SKILL_ECHO.to_string(),
            NEXT_SKILL_ECHO_WEAK.to_string(),
            NEXT_SKILL_ECHO_CHARGES.to_string(),
            NEXT_ATTACK_DERIVED.to_string(),
            NEXT_ATTACK_DERIVED_CHARGES.to_string(),
        ];
        keys.extend(SEQUENCE_COUNTERS.iter().map(|k| k.to_string()));
        keys.extend((0..5).map(skill_last_cast_key));
        keys.extend((0..DODGE_RING).map(dodge_tick_key));

        for key in &keys {
            assert!(key.starts_with("stone."), "{key} may collide with a stat");
        }
        let unique: std::collections::HashSet<&String> = keys.iter().collect();
        assert_eq!(unique.len(), keys.len(), "two pieces of state share a key");
    }

    #[test]
    fn an_armed_magnitude_needs_both_a_value_and_a_charge() {
        let mut entity = Entity::default();
        entity.attributes.set(NEXT_ATTACK_BONUS, 6_000);
        assert_eq!(
            armed_magnitude(&entity, NEXT_ATTACK_BONUS, NEXT_ATTACK_BONUS_CHARGES),
            None,
            "a magnitude with no charges is spent"
        );
        entity.attributes.set(NEXT_ATTACK_BONUS_CHARGES, 3);
        assert_eq!(
            armed_magnitude(&entity, NEXT_ATTACK_BONUS, NEXT_ATTACK_BONUS_CHARGES),
            Some(6_000)
        );
    }
}