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_rng::proc_chance;
use wowlab_types::combat::DamageSchool;

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_FREEZING_TEMPEST,
    AURA_EXTERMINATE, AURA_FROST_FEVER, AURA_FROSTREAPER, AURA_FROZEN_DOMINION_MASTERY,
    AURA_ICY_ONSLAUGHT, AURA_ICY_TALONS, AURA_KILLING_MACHINE, AURA_KILLING_STREAK,
    AURA_PILLAR_OF_FROST, AURA_RAZORICE, AURA_REMORSELESS_WINTER, AURA_RIME, AURA_RUNE_MASTERY,
    EFFECT, SPELL_EMPOWER_RUNE_WEAPON,
};

/// 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(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::MOTFW_ALL_PCT))
        * (1.0 + ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::FROST_DK_SPEC_PCT))
}

fn deal_effect(ctx: &mut HookCtx<'_>, effect: wowlab_engine_combat::DamageEffectId, mult: f64) {
    let coef = ctx.effect_ap_coefficient(effect);

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

/// An effect's AP coefficient scaled by its spell's static passive fold.
fn effect_folded_coef(ctx: &HookCtx<'_>, effect: wowlab_engine_combat::DamageEffectId) -> f64 {
    ctx.effect_ap_coefficient(effect)
        * ctx.action_passive_direct_damage_mult(effect.action())
}

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(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::HYPERPYREXIA_PORTION_PCT);

    ctx.deal_damage_ap(crate::generated::specs::frost_death_knight::DAMAGE_REPORTED::HYPERPYREXIA, coef, DamageFlags::empty());
}

fn roll_dark_talons(ctx: &mut HookCtx<'_>) {
    let chance = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::DARK_TALONS_CHANCE);

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

/// 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(crate::generated::specs::frost_death_knight::DAMAGE_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);

    let chance = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_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) {
        return;
    }

    ctx.apply_aura(AURA_KILLING_MACHINE);

    let chance = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::OBLITERATION_RUNE_PCT);

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

fn trigger_frostreaper(
    ctx: &mut HookCtx<'_>,
    driver: wowlab_engine_combat::SystemRppmBinding,
    aura_local: wowlab_engine_combat::LocalAuraIdx,
) -> bool {
    if !ctx.roll_system_rppm(driver) {
        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, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::OBLITERATE_PHYS, 1.0);
    deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::OBLITERATE_FROST, 1.0);

    if trigger_frostreaper(
        ctx,
        wowlab_engine_combat::generated_identities::system_rppm::FROSTREAPER,
        AURA_FROSTREAPER,
    ) {
        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::FROSTREAPER_DAMAGE, static_frost_mult(ctx));
    }

    ctx.consume_aura(AURA_EMPOWER_RUNE_WEAPON);

    if ctx.consume_aura_stack(AURA_EXTERMINATE) {
        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::EXTERMINATE_HIT, 1.0);
        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::EXTERMINATE_AOE, 1.0);
        ctx.apply_aura(AURA_KILLING_MACHINE);
    }

    let km_stacks = ctx.aura_stacks(AURA_KILLING_MACHINE);

    if km_stacks > 0 {
        ctx.consume_aura(AURA_KILLING_MACHINE);
        ctx.apply_aura_n(AURA_KILLING_STREAK, km_stacks);
        roll_dark_talons(ctx);
        let aa_mult = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::ARCTIC_ASSAULT_PCT)
            * f64::from(km_stacks)
            * static_frost_mult(ctx);

        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::GLACIAL_ADVANCE_DAMAGE, aa_mult);
        ctx.apply_aura(AURA_RAZORICE);

        let chance = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::MURDEROUS_EFFICIENCY_PCT);

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

        ctx.apply_aura(AURA_BONEGRINDER_CRIT);

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

    let chance = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::RIME_PROC_PCT);

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

    ctx.apply_aura(AURA_RUNE_MASTERY);

    roll_hyperpyrexia(ctx, effect_folded_coef(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::OBLITERATE_PHYS));
    roll_hyperpyrexia(ctx, effect_folded_coef(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::OBLITERATE_FROST));
}

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

    ctx.deal_damage_ap(crate::generated::specs::frost_death_knight::DAMAGE_SPELL::FROST_STRIKE, fs_coef * fs_mult, DamageFlags::empty());

    if ctx.consume_aura(AURA_FROSTREAPER) {
        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::FROSTREAPER_DAMAGE, static_frost_mult(ctx));
    }

    ctx.apply_aura(AURA_ICY_TALONS);

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

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

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

    let mut hb_mult = static_frost_mult(ctx) * (1.0 + ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::COF_SPELLS_PCT));

    if ctx.consume_aura(AURA_RIME) {
        roll_dark_talons(ctx);
        let rime_pct = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::RIME_HB_BONUS_PCT)
            + ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::NORTHWINDS_RIME_PCT);

        hb_mult *= (1.0 + rime_pct)
            * (1.0 + ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::ICEBREAKER_PCT))
            * (1.0 + ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::BIND_IN_DARKNESS_HB_PCT));

        let km_chance = ctx.effect_percent(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::HOWLING_BLADES_KM_PCT);

        for blade in [
            crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::HOWLING_BLADES_FIRST,
            crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::HOWLING_BLADES_SECOND,
        ] {
            deal_effect(ctx, blade, 1.0);

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

        let rfc_rp = ctx.effect_base_points(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::RAGE_OF_FROZEN_CHAMPION_RP) / RP_DISPLAY_DIV;

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

    deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::HOWLING_BLAST_DAMAGE, hb_mult);
    obliteration(ctx);
}

/// Brittle rolls spell 374504's proc chance on every disease tick.
pub(crate) fn frost_fever_tick_hook(ctx: &mut HookCtx<'_>) {
    let chance = ctx
        .spec_config::<super::config::FrostDkConfig>()
        .map_or(0.0, |config| config.brittle_proc_chance);

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

pub(crate) fn remorseless_winter_hook(ctx: &mut HookCtx<'_>) {
    if mid2_2pc(ctx) {
        ctx.expire_aura(AURA_FREEZING_TEMPEST);
    }

    ctx.apply_aura(AURA_REMORSELESS_WINTER);
}

pub(crate) fn remorseless_winter_tick_hook(ctx: &mut HookCtx<'_>) {
    if mid2_2pc(ctx) {
        ctx.apply_aura(AURA_FREEZING_TEMPEST);
    }
}

fn trigger_frozen_dominion(
    ctx: &mut HookCtx<'_>,
    talent: wowlab_engine_combat::DamageActionId,
    remorseless_winter_local: wowlab_engine_combat::LocalAuraIdx,
    mastery_local: wowlab_engine_combat::LocalAuraIdx,
) {
    if !ctx.talent_selected(talent) {
        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<'_>) {
    // This activation grants one 377253 stack per distinct enemy hit. The
    // engine currently resolves a single target, and the
    // periodic aura ticks immediately on application.
    trigger_frozen_dominion(
        ctx,
        crate::generated::specs::frost_death_knight::DAMAGE_TALENT::FROZEN_DOMINION,
        AURA_REMORSELESS_WINTER,
        AURA_FROZEN_DOMINION_MASTERY,
    );

}

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

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

}

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

pub(crate) fn breath_of_sindragosa_hook(ctx: &mut HookCtx<'_>) {
    breath_of_sindragosa_damage(ctx);
    ctx.apply_aura(AURA_ICY_TALONS);
    runic_empowerment(ctx, BOS_RP_COST);
    ctx.reduce_cooldown(SPELL_EMPOWER_RUNE_WEAPON, 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(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::BOS_RUNE_REFUND));
}

fn breath_of_sindragosa_damage(ctx: &mut HookCtx<'_>) {
    ctx.deal_effect_damage_ap_with_geometry(
        crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::BOS_DAMAGE,
        crate::generated::specs::frost_death_knight::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(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::COF_FWF_PCT));

    ctx.deal_effect_damage_ap_with_geometry(
        crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::FROSTWYRMS_FURY_DAMAGE,
        crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::FROSTWYRMS_FURY_DAMAGE,
        multiplier,
        DamageFlags::empty(),
    );
    let coef = ctx.effect_ap_coefficient(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::FROSTWYRMS_FURY_DAMAGE) * multiplier;

    ctx.deal_damage_ap(
        crate::generated::specs::frost_death_knight::DAMAGE_REPORTED::CHOSEN_OF_FROSTBROOD_RECALL,
        coef,
        DamageFlags::empty(),
    );
    ctx.apply_aura(AURA_CHOSEN_OF_FROSTBROOD_HASTE);
}

/// Collapses Reaper's Mark's single-target package to cast time.
pub(crate) fn reapers_mark_hook(ctx: &mut HookCtx<'_>) {
    deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::WAVE_OF_SOULS_DAMAGE, 1.0);
    deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_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(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::GRIM_REAPER_MAX_PCT);
    let stacks = ctx.effect_base_points(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::REAPERS_MARK_STACKS);

    deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_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(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::ECHOING_FURY_STACKS),
    ) {
        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::EXTERMINATE_HIT, 1.0);
        deal_effect(ctx, crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::EXTERMINATE_AOE, 1.0);
        ctx.apply_aura(AURA_KILLING_MACHINE);
    }

    ctx.apply_aura_n(
        AURA_EXTERMINATE,
        wowlab_types::numeric::f64_to_i32_saturating_trunc(
            ctx.effect_base_points(crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::EXTERMINATE_STACKS),
        ),
    );

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

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);
        ctx.deal_effect_damage_ap_with_geometry(
            crate::generated::specs::frost_death_knight::DAMAGE_EFFECT::ICY_DEATH_TORRENT_DAMAGE,
            crate::generated::specs::frost_death_knight::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, HookCtx};
    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;
    use crate::generated::specs::frost_death_knight::DAMAGE_TALENT;

    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: wowlab_engine_combat::LocalAuraIdx =
        wowlab_engine_combat::test_support::local_aura(0);
    const MASTERY_LOCAL: wowlab_engine_combat::LocalAuraIdx =
        wowlab_engine_combat::test_support::local_aura(1);

    fn activation_fixture(selected: bool) -> wowlab_engine_combat::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_for(wowlab_engine_combat::generated_identities::specs::frost_death_knight::PROOF, 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))
            })
            .effect_identities(wowlab_engine_combat::generated_identities::specs::frost_death_knight::damage::ALL)
            .talent_spell_ids(&[("Frozen Dominion", FROZEN_DOMINION)])
            .talent_selections(talents.as_slice())
            .into_draft().expect("valid combat draft").finalize(&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 {
                program: &built.program,
                instance: &mut built.instance,
                sink: &mut telemetry,
                rng: &mut rng,
            },
            wowlab_engine_combat::HookCtxRequest::targetless(SimTime::ZERO),
        );

        trigger_frozen_dominion(
            ctx,
            DAMAGE_TALENT::FROZEN_DOMINION,
            REMORSELESS_WINTER_LOCAL,
            MASTERY_LOCAL,
        );

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

        verify_that!(ctx.aura_stacks(MASTERY_LOCAL), 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 {
                program: &built.program,
                instance: &mut built.instance,
                sink: &mut telemetry,
                rng: &mut rng,
            },
            wowlab_engine_combat::HookCtxRequest::targetless(SimTime::ZERO),
        );

        trigger_frozen_dominion(
            ctx,
            DAMAGE_TALENT::FROZEN_DOMINION,
            REMORSELESS_WINTER_LOCAL,
            MASTERY_LOCAL,
        );

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

        verify_that!(ctx.aura_remaining_ms(MASTERY_LOCAL), 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_for(wowlab_engine_combat::generated_identities::specs::frost_death_knight::PROOF, 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)?))
            })
            .into_draft().expect("valid combat draft").finalize(&crate::test_support::wait_rotation())
            .expect("build DBC-backed Frozen Dominion mastery fixture");
        let local = built.program.diagnostic_aura_local(FROZEN_DOMINION_MASTERY).or_fail()?;
        let aura = built.program.aura(local);

        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;