wowlab_engine_content/hooks/frost_death_knight/

hooks.rs

use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::CooldownOps as _;
use wowlab_engine_combat::ResourceOps as _;
use wowlab_engine_combat::ProcOps as _;
use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::{DamageFlags, HookCtx, MasteryCtx, SwingEvent, SwingHand};
use wowlab_engine_domain::dbc::ResolvedGameDataEffectExt as _;
use wowlab_engine_rng::proc_chance;
use wowlab_types::{combat::DamageSchool, sim::SpellIdx};

use crate::generated::specs::frost_death_knight::{
    AURA_BONEGRINDER_CRIT, AURA_BONEGRINDER_FROST, AURA_BRITTLE, AURA_CHOSEN_OF_FROSTBROOD_HASTE,
    AURA_DARK_TALONS_ICY_TALONS, AURA_EMPOWER_RUNE_WEAPON, AURA_EMPOWERED_STRIKES,
    AURA_EXTERMINATE, AURA_FROST_FEVER, AURA_FROSTREAPER, AURA_FROZEN_DOMINION_MASTERY,
    AURA_ICY_ONSLAUGHT, AURA_ICY_TALONS, AURA_KILLING_MACHINE, AURA_KILLING_STREAK, AURA_MID1_4PC,
    AURA_PILLAR_OF_FROST, AURA_RAZORICE, AURA_REMORSELESS_WINTER, AURA_RIME, AURA_RUNE_MASTERY,
    EFFECT, REPORTED_SPELL, SPELL, SPELL_EMPOWER_RUNE_WEAPON, TALENT,
};

/// Runic-power display divisor (power type 6 `display_modifier`).
const RP_DISPLAY_DIV: f64 = 10.0;

/// Frost Strike RP cost (49143 `power_costs` 350 / 10).
const FROST_STRIKE_RP_COST: f64 = 35.0;

/// Breath of Sindragosa RP cost (1249658 `power_costs` 600 / 10).
const BOS_RP_COST: f64 = 60.0;

/// Runic Empowerment chance uses spell 81229 effect 1 per RP spent.
const RUNIC_EMPOWERMENT_RP_FACTOR: f64 = 0.001;

/// Hyperpyrexia proc chance (spell 456238 proc chance 35%).
const HYPERPYREXIA_PROC_CHANCE: f64 = 0.35;

/// Frostbound Will recharge reduction (spell 1238680 effect 1).
const FROSTBOUND_WILL_ERW_MS: u32 = 6_000;

/// Bonegrinder conversion threshold (spell 377101 max stacks minus one).
const BONEGRINDER_CRIT_MAX: i32 = 5;

const ERW_RECHARGE_MS: u32 = 24_000;

/// Applies Frozen Heart mastery, including Frostreaper's Obliterate conversion.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    if ctx.school == DamageSchool::Frost || ctx.spell_id == EFFECT::OBLITERATE_PHYS.0 {
        ctx.bonus(1)
    } else {
        1.0
    }
}

fn static_frost_mult(ctx: &HookCtx<'_>) -> f64 {
    (1.0 + ctx.effect_percent(EFFECT::MOTFW_ALL_PCT))
        * (1.0 + ctx.effect_percent(EFFECT::FROST_DK_SPEC_PCT))
}

fn deal_effect(ctx: &mut HookCtx<'_>, effect: (u32, u8), mult: f64) {
    let coef = ctx
        .game_data()
        .ap_coef(SpellIdx::from_raw(effect.0), effect.1);

    ctx.deal_damage_ap(effect.0, coef * mult, DamageFlags::empty());
}

/// An effect's AP coefficient scaled by its spell's static passive fold.
fn effect_folded_coef(ctx: &HookCtx<'_>, effect: (u32, u8)) -> f64 {
    let idx = SpellIdx::from_raw(effect.0);

    ctx.game_data().ap_coef(idx, effect.1) * ctx.game_data().passive_damage_mult(idx, false)
}

fn roll_hyperpyrexia(ctx: &mut HookCtx<'_>, trigger_coef: f64) {
    if !proc_chance(ctx.rng(), HYPERPYREXIA_PROC_CHANCE) {
        return;
    }

    let coef = trigger_coef * ctx.effect_percent(EFFECT::HYPERPYREXIA_PORTION_PCT);

    ctx.deal_damage_ap(REPORTED_SPELL::HYPERPYREXIA, coef, DamageFlags::empty());
}

fn roll_dark_talons(ctx: &mut HookCtx<'_>) {
    let chance = ctx.effect_percent(EFFECT::DARK_TALONS_CHANCE);

    if proc_chance(ctx.rng(), chance) {
        ctx.apply_aura(AURA_DARK_TALONS_ICY_TALONS.raw());
    }
}

/// An RE proc expires Icy Onslaught and suppresses the caster's IO stack gain.
fn runic_empowerment(ctx: &mut HookCtx<'_>, rp_spent: f64) -> bool {
    let chance = ctx.effect_base_points(EFFECT::RUNIC_EMPOWERMENT_PCT)
        * RUNIC_EMPOWERMENT_RP_FACTOR
        * rp_spent;

    if !proc_chance(ctx.rng(), chance) {
        return false;
    }

    ctx.gain_resource(1.0);
    ctx.expire_aura(AURA_ICY_ONSLAUGHT.raw());

    let chance = ctx.effect_percent(EFFECT::FRIGID_EXECUTIONER_PCT);

    if proc_chance(ctx.rng(), chance) {
        ctx.gain_resource(1.0);
    }

    true
}

fn obliteration(ctx: &mut HookCtx<'_>) {
    if !ctx.is_aura_active(AURA_PILLAR_OF_FROST.raw()) {
        return;
    }

    ctx.apply_aura(AURA_KILLING_MACHINE.raw());

    let chance = ctx.effect_percent(EFFECT::OBLITERATION_RUNE_PCT);

    if proc_chance(ctx.rng(), chance) {
        ctx.gain_resource(1.0);
    }
}

fn trigger_frostreaper(ctx: &mut HookCtx<'_>, driver_spell_id: u32, aura_local: u8) -> bool {
    if !ctx.roll_system_rppm(driver_spell_id) {
        return false;
    }

    let refreshed = ctx.is_aura_active(aura_local);

    ctx.apply_aura(aura_local);

    refreshed
}

pub(crate) fn obliterate_hook(ctx: &mut HookCtx<'_>) {
    // Both hits go out under their child ids: the generic static fold already
    // carries MotFW/Frostreaper/spec passives, and Killing Machine's e1/e3
    // affect lists name the children (325461/1264084), never the parent.
    deal_effect(ctx, EFFECT::OBLITERATE_PHYS, 1.0);
    deal_effect(ctx, EFFECT::OBLITERATE_FROST, 1.0);

    if trigger_frostreaper(ctx, TALENT::FROSTREAPER, AURA_FROSTREAPER.raw()) {
        deal_effect(ctx, EFFECT::FROSTREAPER_DAMAGE, static_frost_mult(ctx));
    }

    ctx.consume_aura_stack(AURA_EMPOWERED_STRIKES.raw());
    ctx.consume_aura(AURA_EMPOWER_RUNE_WEAPON.raw());

    if ctx.consume_aura_stack(AURA_EXTERMINATE.raw()) {
        deal_effect(ctx, EFFECT::EXTERMINATE_HIT, 1.0);
        deal_effect(ctx, EFFECT::EXTERMINATE_AOE, 1.0);
        ctx.apply_aura(AURA_KILLING_MACHINE.raw());
    }

    let km_stacks = ctx.aura_stacks(AURA_KILLING_MACHINE.raw());

    if km_stacks > 0 {
        ctx.consume_aura(AURA_KILLING_MACHINE.raw());
        ctx.apply_aura_n(AURA_KILLING_STREAK.raw(), km_stacks);
        roll_dark_talons(ctx);
        let aa_mult = ctx.effect_percent(EFFECT::ARCTIC_ASSAULT_PCT)
            * f64::from(km_stacks)
            * static_frost_mult(ctx);

        deal_effect(ctx, EFFECT::GLACIAL_ADVANCE_DAMAGE, aa_mult);
        ctx.apply_aura(AURA_RAZORICE.raw());

        let chance = ctx.effect_percent(EFFECT::MURDEROUS_EFFICIENCY_PCT);

        if proc_chance(ctx.rng(), chance) {
            ctx.gain_resource(1.0);
        }

        ctx.apply_aura(AURA_BONEGRINDER_CRIT.raw());

        if ctx.aura_stacks(AURA_BONEGRINDER_CRIT.raw()) >= BONEGRINDER_CRIT_MAX {
            ctx.expire_aura(AURA_BONEGRINDER_CRIT.raw());
            ctx.apply_aura(AURA_BONEGRINDER_FROST.raw());
        }
    }

    let chance = ctx.effect_percent(EFFECT::RIME_PROC_PCT);

    if proc_chance(ctx.rng(), chance) {
        ctx.apply_aura(AURA_RIME.raw());
    }

    ctx.apply_aura(AURA_RUNE_MASTERY.raw());

    roll_hyperpyrexia(ctx, effect_folded_coef(ctx, EFFECT::OBLITERATE_PHYS));
    roll_hyperpyrexia(ctx, effect_folded_coef(ctx, EFFECT::OBLITERATE_FROST));
}

pub(crate) fn frost_strike_hook(ctx: &mut HookCtx<'_>) {
    let fs_mult = static_frost_mult(ctx)
        * (1.0 + ctx.effect_percent(EFFECT::RUNIC_OVERFLOW_FS_PCT))
        * (1.0 + ctx.effect_percent(EFFECT::DEATHLY_BLOWS_FS_PCT))
        * (1.0 + ctx.effect_percent(EFFECT::COF_SPELLS_PCT));
    let fs_coef = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::FROST_STRIKE_2H);

    ctx.deal_damage_ap(SPELL::FROST_STRIKE, fs_coef * fs_mult, DamageFlags::empty());

    if ctx.consume_aura(AURA_FROSTREAPER.raw()) {
        deal_effect(ctx, EFFECT::FROSTREAPER_DAMAGE, static_frost_mult(ctx));
    }

    ctx.apply_aura(AURA_ICY_TALONS.raw());

    if !runic_empowerment(ctx, FROST_STRIKE_RP_COST) {
        ctx.apply_aura(AURA_ICY_ONSLAUGHT.raw());
    }

    obliteration(ctx);
    roll_hyperpyrexia(ctx, fs_coef * fs_mult);
}

pub(crate) fn howling_blast_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_FROST_FEVER.raw());

    let mut hb_mult = static_frost_mult(ctx) * (1.0 + ctx.effect_percent(EFFECT::COF_SPELLS_PCT));

    if ctx.consume_aura(AURA_RIME.raw()) {
        roll_dark_talons(ctx);
        let rime_pct = ctx.effect_percent(EFFECT::RIME_HB_BONUS_PCT)
            + ctx.effect_percent(EFFECT::NORTHWINDS_RIME_PCT);

        hb_mult *= (1.0 + rime_pct)
            * (1.0 + ctx.effect_percent(EFFECT::ICEBREAKER_PCT))
            * (1.0 + ctx.effect_percent(EFFECT::BIND_IN_DARKNESS_HB_PCT));

        let km_chance = ctx.effect_percent(EFFECT::HOWLING_BLADES_KM_PCT);

        for blade in [EFFECT::HOWLING_BLADES_FIRST, EFFECT::HOWLING_BLADES_SECOND] {
            deal_effect(ctx, blade, 1.0);

            if proc_chance(ctx.rng(), km_chance) {
                ctx.apply_aura(AURA_KILLING_MACHINE.raw());
            }
        }

        let rfc_rp = ctx.effect_base_points(EFFECT::RAGE_OF_FROZEN_CHAMPION_RP) / RP_DISPLAY_DIV;

        ctx.gain_secondary_resource(rfc_rp);
        ctx.reduce_cooldown(SPELL_EMPOWER_RUNE_WEAPON.raw(), FROSTBOUND_WILL_ERW_MS);
    } else {
        ctx.apply_aura(AURA_RUNE_MASTERY.raw());
    }

    deal_effect(ctx, EFFECT::HOWLING_BLAST_DAMAGE, hb_mult);
    obliteration(ctx);
}

/// Brittle rolls 374504's proc chance on every disease tick (sc_death_knight.cpp:7769-7775).
pub(crate) fn frost_fever_tick_hook(ctx: &mut HookCtx<'_>) {
    let chance = ctx.selected_talent_proc_chance(TALENT::BRITTLE);

    if proc_chance(ctx.rng(), chance) {
        ctx.apply_aura(AURA_BRITTLE.raw());
    }
}

pub(crate) fn remorseless_winter_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_REMORSELESS_WINTER.raw());
}

fn trigger_frozen_dominion(
    ctx: &mut HookCtx<'_>,
    talent_id: u32,
    remorseless_winter_local: u8,
    mastery_local: u8,
) {
    if !ctx.talent_selected(talent_id) {
        return;
    }

    ctx.apply_aura(remorseless_winter_local);
    ctx.apply_aura(mastery_local);
}

/// Applies Frozen Dominion's Remorseless Winter.
pub(crate) fn pillar_of_frost_hook(ctx: &mut HookCtx<'_>) {
    // SimC grants one 377253 stack per distinct enemy hit by this 1233152
    // activation. The engine currently resolves a single target, and the
    // periodic aura ticks immediately on application.
    trigger_frozen_dominion(
        ctx,
        TALENT::FROZEN_DOMINION,
        AURA_REMORSELESS_WINTER.raw(),
        AURA_FROZEN_DOMINION_MASTERY.raw(),
    );

    if mid1_4pc(ctx) {
        ctx.apply_aura(AURA_MID1_4PC.raw());
    }
}

pub(crate) fn empower_rune_weapon_hook(ctx: &mut HookCtx<'_>) {
    let rp = ctx.effect_base_points(EFFECT::ERW_RP) / RP_DISPLAY_DIV;

    ctx.gain_secondary_resource(rp);
    ctx.apply_aura(AURA_EMPOWER_RUNE_WEAPON.raw());
    ctx.apply_aura(AURA_KILLING_MACHINE.raw());

    if mid1_2pc(ctx) {
        ctx.apply_aura(AURA_EMPOWERED_STRIKES.raw());
    }
}

fn mid1_2pc(ctx: &HookCtx<'_>) -> bool {
    ctx.state()
        .spec_config::<super::config::FrostDkConfig>()
        .is_some_and(|config| config.mid1_2pc)
}

fn mid1_4pc(ctx: &HookCtx<'_>) -> bool {
    ctx.state()
        .spec_config::<super::config::FrostDkConfig>()
        .is_some_and(|config| config.mid1_4pc)
}

pub(crate) fn breath_of_sindragosa_hook(ctx: &mut HookCtx<'_>) {
    breath_of_sindragosa_damage(ctx);
    ctx.apply_aura(AURA_ICY_TALONS.raw());
    runic_empowerment(ctx, BOS_RP_COST);
    ctx.reduce_cooldown(SPELL_EMPOWER_RUNE_WEAPON.raw(), ERW_RECHARGE_MS);
}

pub(crate) fn breath_of_sindragosa_tick_hook(ctx: &mut HookCtx<'_>) {
    breath_of_sindragosa_damage(ctx);
}

pub(crate) fn breath_of_sindragosa_expire_hook(ctx: &mut HookCtx<'_>) {
    ctx.gain_resource(ctx.effect_base_points(EFFECT::BOS_RUNE_REFUND));
}

fn breath_of_sindragosa_damage(ctx: &mut HookCtx<'_>) {
    ctx.deal_effect_damage_ap_with_geometry(
        EFFECT::BOS_DAMAGE,
        EFFECT::BOS_DAMAGE,
        1.0,
        DamageFlags::empty(),
    );
}

pub(crate) fn frostwyrms_fury_hook(ctx: &mut HookCtx<'_>) {
    let multiplier = static_frost_mult(ctx) * (1.0 + ctx.effect_percent(EFFECT::COF_FWF_PCT));

    ctx.deal_effect_damage_ap_with_geometry(
        EFFECT::FROSTWYRMS_FURY_DAMAGE,
        EFFECT::FROSTWYRMS_FURY_DAMAGE,
        multiplier,
        DamageFlags::empty(),
    );
    let coef = ctx.effect_ap_coefficient(EFFECT::FROSTWYRMS_FURY_DAMAGE) * multiplier;

    ctx.deal_damage_ap(
        REPORTED_SPELL::CHOSEN_OF_FROSTBROOD_RECALL,
        coef,
        DamageFlags::empty(),
    );
    ctx.apply_aura(AURA_CHOSEN_OF_FROSTBROOD_HASTE.raw());
}

/// Collapses Reaper's Mark's single-target package to cast time.
pub(crate) fn reapers_mark_hook(ctx: &mut HookCtx<'_>) {
    deal_effect(ctx, EFFECT::WAVE_OF_SOULS_DAMAGE, 1.0);
    deal_effect(ctx, EFFECT::WAVE_OF_SOULS_DAMAGE, 1.0);

    let hp_pct = ctx.target_health_fraction();
    let grim_reaper = 1.0 + (1.0 - hp_pct) * ctx.effect_percent(EFFECT::GRIM_REAPER_MAX_PCT);
    let stacks = ctx.effect_base_points(EFFECT::REAPERS_MARK_STACKS);

    deal_effect(ctx, EFFECT::REAPERS_MARK_EXPLOSION, stacks * grim_reaper);

    // Echoing Fury's cast-time charge is consumed before the delayed explosion.

    for _ in 0..wowlab_types::numeric::f64_to_i64_saturating_trunc(
        ctx.effect_base_points(EFFECT::ECHOING_FURY_STACKS),
    ) {
        deal_effect(ctx, EFFECT::EXTERMINATE_HIT, 1.0);
        deal_effect(ctx, EFFECT::EXTERMINATE_AOE, 1.0);
        ctx.apply_aura(AURA_KILLING_MACHINE.raw());
    }

    ctx.apply_aura_n(
        AURA_EXTERMINATE.raw(),
        wowlab_types::numeric::f64_to_i32_saturating_trunc(
            ctx.effect_base_points(EFFECT::EXTERMINATE_STACKS),
        ),
    );

    ctx.apply_aura(AURA_KILLING_MACHINE.raw());
    ctx.apply_aura(AURA_FROST_FEVER.raw());
    ctx.apply_aura(AURA_RUNE_MASTERY.raw());
}

pub(crate) fn swing_hook(ctx: &mut HookCtx<'_>, event: SwingEvent) {
    let hand = event.hand;
    let is_crit = event.is_crit;

    if hand == SwingHand::OffHand {
        return;
    }

    if is_crit {
        ctx.apply_aura(AURA_KILLING_MACHINE.raw());
        ctx.deal_effect_damage_ap_with_geometry(
            EFFECT::ICY_DEATH_TORRENT_DAMAGE,
            EFFECT::ICY_DEATH_TORRENT_DAMAGE,
            1.0,
            DamageFlags::empty(),
        );
    }
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use wowlab_engine_combat::AuraOps as _;
    use wowlab_engine_combat::{BuffEffect, BuiltCombatSystem, HookCtx, LocalAuraIdx};
    use wowlab_engine_domain::dbc::{AuraSubtypeKind, SpellEffectKind};
    use wowlab_engine_ports::{CombatStats, TalentSelection};
    use wowlab_engine_telemetry::{TelemetrySink};
use wowlab_engine_gamedata::{AuraProps, ResolvedGameData, SpellProps};
    use wowlab_types::sim::{SimTime, SpellIdx};

    use super::trigger_frozen_dominion;

    const FROZEN_DOMINION: u32 = 377_226;
    const FROZEN_DOMINION_MASTERY: u32 = 377_253;
    const FROZEN_DOMINION_MASTERY_PER_STACK: f64 = 4.0;
    const REMORSELESS_WINTER: u32 = 1_233_152;
    const REMORSELESS_WINTER_LOCAL: LocalAuraIdx = LocalAuraIdx::new(0);
    const MASTERY_LOCAL: LocalAuraIdx = LocalAuraIdx::new(1);

    fn activation_fixture(selected: bool) -> BuiltCombatSystem {
        let talents = selected.then_some(TalentSelection {
            spell_id: FROZEN_DOMINION,
            override_spell_id: 0,
            replaces_spell_id: 0,
            ranks: 1,
            precombat_aura: false,
            hero_tree: None,
            effect_overrides: Vec::new(),
        });

        crate::test_combat_builder(CombatStats::default())
            .aura("remorseless_winter", REMORSELESS_WINTER, |a| {
                Ok(a.on_player().duration_ms(12_000))
            })
            .aura("frozen_dominion_mastery", FROZEN_DOMINION_MASTERY, |a| {
                Ok(a.on_player().duration_ms(15_000).max_stacks(5))
            })
            .talent_spell_ids(&[("Frozen Dominion", FROZEN_DOMINION)])
            .talent_selections(talents.as_slice())
            .build(crate::test_support::wait_rotation())
            .expect("build Frozen Dominion activation fixture")
    }

    #[gtest]
    fn frozen_dominion_activation_requires_selected_talent() -> Result<()> {
        let mut built = activation_fixture(false);
        let mut telemetry = TelemetrySink::default();
        let mut rng = || 0.5;
        let ctx = &mut HookCtx::new(
            wowlab_engine_combat::HookCtxServices {
                state: &mut built.state,
                buf: &mut built.buffer,
                sink: &mut telemetry,
                rng: &mut rng,
            },
            wowlab_engine_combat::HookCtxRequest::targetless(SimTime::ZERO),
        );

        trigger_frozen_dominion(
            ctx,
            FROZEN_DOMINION,
            REMORSELESS_WINTER_LOCAL.raw(),
            MASTERY_LOCAL.raw(),
        );

        verify_that!(ctx.aura_stacks(REMORSELESS_WINTER_LOCAL.raw()), eq(0))?;

        verify_that!(ctx.aura_stacks(MASTERY_LOCAL.raw()), eq(0))
    }

    #[gtest]
    fn selected_frozen_dominion_activates_winter_and_one_mastery_stack() -> Result<()> {
        let mut built = activation_fixture(true);
        let mut telemetry = TelemetrySink::default();
        let mut rng = || 0.5;
        let ctx = &mut HookCtx::new(
            wowlab_engine_combat::HookCtxServices {
                state: &mut built.state,
                buf: &mut built.buffer,
                sink: &mut telemetry,
                rng: &mut rng,
            },
            wowlab_engine_combat::HookCtxRequest::targetless(SimTime::ZERO),
        );

        trigger_frozen_dominion(
            ctx,
            FROZEN_DOMINION,
            REMORSELESS_WINTER_LOCAL.raw(),
            MASTERY_LOCAL.raw(),
        );

        verify_that!(ctx.aura_stacks(REMORSELESS_WINTER_LOCAL.raw()), eq(1))?;
        verify_that!(ctx.aura_stacks(MASTERY_LOCAL.raw()), eq(1))?;
        verify_that!(
            ctx.aura_remaining_ms(REMORSELESS_WINTER_LOCAL.raw()),
            some(eq(12_000))
        )?;

        verify_that!(ctx.aura_remaining_ms(MASTERY_LOCAL.raw()), some(eq(15_000)))
    }

    #[gtest]
    fn frozen_dominion_mastery_definition_is_lowered_from_dbc() -> Result<()> {
        let spell = SpellIdx::from_raw(FROZEN_DOMINION_MASTERY);
        let mut data = ResolvedGameData::builder();

        data.insert_spell_props(spell, SpellProps::default());
        data.insert_aura_props(
            spell,
            AuraProps {
                duration_ms: 15_000,
                doses: 1,
                max_stacks: 5,
                tick_period_ms: 0,
                pandemic: false,
            },
        );
        data.insert_effect_type(
            wowlab_types::sim::EffectRef::new(spell, 1),
            SpellEffectKind::ApplyAura as i32,
        );
        data.insert_effect_aura(
            wowlab_types::sim::EffectRef::new(spell, 1),
            AuraSubtypeKind::ModMasteryPercent as i32,
        );
        data.insert_base_points(spell, 1, FROZEN_DOMINION_MASTERY_PER_STACK);
        let data = data.build();
        let built = crate::test_combat_builder(CombatStats::default())
            .game_data(data.clone())
            .aura("frozen_dominion_mastery", FROZEN_DOMINION_MASTERY, |a| {
                Ok(a.on_player()
                    .apply_base_from_data(&data, FROZEN_DOMINION_MASTERY)?
                    .max_stacks(data.require_aura_max_stacks(spell)?))
            })
            .build(crate::test_support::wait_rotation())
            .expect("build DBC-backed Frozen Dominion mastery fixture");
        let local = built.state.aura_local(FROZEN_DOMINION_MASTERY).or_fail()?;
        let aura = built.aura(local).or_fail()?;

        verify_that!(aura.base_duration_ms, eq(15_000))?;
        verify_that!(aura.max_stacks, eq(5))?;

        verify_true!(aura.effects.iter().flatten().any(|effect| {
            matches!(
                effect,
                BuffEffect::Mastery(value)
                    if (*value - FROZEN_DOMINION_MASTERY_PER_STACK).abs() <= f64::EPSILON
            )
        }))
    }
}

#[cfg(test)]
#[path = "hooks/bonegrinder_tests.rs"]
mod bonegrinder_tests;

#[cfg(test)]
#[path = "hooks/frostreaper_tests.rs"]
mod frostreaper_tests;

#[cfg(test)]
#[path = "hooks/icy_talons_tests.rs"]
mod icy_talons_tests;