wowlab_engine_content/hooks/enhancement_shaman/

hooks.rs

use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::CooldownOps as _;
use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::GuardianOps as _;
use wowlab_engine_combat::ProcOps as _;
use wowlab_engine_combat::SchedulingOps as _;
use wowlab_engine_combat::{
    DamageFlags, DamageOutcome, GuardianAbility, GuardianEvent, GuardianSpec, HookCtx, MasteryCtx,
    SwingEvent, SwingHand,
};
use wowlab_engine_domain::constants::OFF_HAND_DAMAGE_MULT;
#[cfg(test)]
use wowlab_engine_domain::dbc::{damage_def, spell_attribute_is, DefenseType, SpellAttributeKind};
#[cfg(test)]
use wowlab_engine_gamedata::ResolvedGameData;
use wowlab_engine_rng::{accumulated_proc_chance, proc_chance};
#[cfg(test)]
use wowlab_types::sim::SpellIdx;
use wowlab_types::{combat::DamageSchool, constants::HUNDRED};

#[cfg(test)]
use crate::generated::specs::enhancement_shaman::{AURA, REPORTED_SPELL};
use crate::generated::specs::enhancement_shaman::{
    AURA_AMPLIFICATION_CORE, AURA_BURNING_CORE, AURA_CRACKLING_SURGE, AURA_CRASH_LIGHTNING,
    AURA_DOOM_WINDS, AURA_FLAME_SHOCK, AURA_HOT_HAND, AURA_LASHING_FLAMES, AURA_MAELSTROM_WEAPON,
    AURA_MOLTEN_WEAPON, AURA_SHORT_CIRCUIT, AURA_STORMSURGE, AURA_STORM_UNLEASHED,
    AURA_SURGING_TOTEM, AURA_TOTEMIC_REBOUND, AURA_WHIRLING_AIR, AURA_WHIRLING_EARTH,
    AURA_WHIRLING_FIRE, SPELL, SPELL_LAVA_LASH, SPELL_STORMSTRIKE, TALENT,
};

/// Stormflurry (344357) e1: echo chance.
const STORMFLURRY_CHANCE: f64 = 0.20;
/// Stormflurry (344357) e2: echo damage percent.
const STORMFLURRY_MULT: f64 = 0.40;
/// Doom Winds (466772) e1: +100% Windfury proc chance while active.
const DOOM_WINDS_WF_PROC_MULT: f64 = 2.0;
/// Accumulated RNG base chance for Imbuement Mastery.
const IMBUEMENT_MASTERY_CHANCE: f64 = 0.07;
const LIVELY_TOTEMS_CHANCE: f64 = 0.06;
/// Maelstrom Weapon 187880: 20% melee proc with spell 384149 e2's stack cap.
const MW_CONSUME_CAP: i32 = 10;
/// Maelstrom Weapon talent 187880 e3: +20% damage per stack consumed.
const MW_DMG_PER_STACK: f64 = 0.20;
/// Whirling Air (453409 e3): three guaranteed bolts on the next direct lightning cast.
const WHIRLING_AIR_BOLTS: u32 = 3;
/// Earthsurge e1 multiplier is 150%.
const EARTHSURGE_MULT: f64 = 1.5;
/// Whirling Fire (453405 e1) starts or extends Hot Hand by 8 seconds.
const WHIRLING_FIRE_HOT_HAND_MS: u32 = 8_000;
/// Synthetic guardian tags distinguish elemental wolf actors without using game spell IDs.
const FIRE_WOLF_GUARDIAN_TAG: u32 = 4_693_141;
const LIGHTNING_WOLF_GUARDIAN_TAG: u32 = 4_693_142;
const SEARING_TOTEM_DURATION_MS: u32 = 8_000;
const SEARING_TOTEM_PULSE_MS: u32 = 2_000;
const PRIMORDIAL_FROST_DELAY_MS: u32 = 300;
const PRIMORDIAL_LIGHTNING_DELAY_MS: u32 = 600;
const PRIMORDIAL_LIGHTNING_BOLT_DELAY_MS: u32 = 950;
const PRIMORDIAL_LIGHTNING_BOLT_MULT: f64 = 1.5;
const SURGING_BOLT_DELAY_MS: u32 = 300;
const WHIRLING_AIR_BOLT_SPACING_MS: u32 = 500;
const CRASH_LIGHTNING_UNLEASHED_FIRST_MS: u32 = 1_000;
const CRASH_LIGHTNING_UNLEASHED_SECOND_MS: u32 = 2_000;
/// Ride the Lightning 289874 e2 always unleashes Chain Lightning.
const RIDE_THE_LIGHTNING_MULT: f64 = 1.0;

/// Disables DBC damage children that an affected spell's cast hook owns.
pub(crate) const fn hook_owned_damage_trigger_disabled(_ctx: &HookCtx<'_>) -> bool {
    false
}

fn windfury_chance(ctx: &HookCtx<'_>) -> f64 {
    let base = ctx.action_proc_chance(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::WINDFURY_PROC.action(),
    );
    let mastery_bonus = ctx.effect_points(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::WINDFURY_MASTERY,
    ) / HUNDRED;
    let mut chance = base + mastery_bonus;

    if ctx.is_aura_active(AURA_DOOM_WINDS) {
        chance *= DOOM_WINDS_WF_PROC_MULT;
    }

    chance
}

fn stormsurge_chance(ctx: &HookCtx<'_>) -> f64 {
    let base = ctx.action_proc_chance(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::STORMSURGE_DRIVER,
    );

    base + ctx.effect_points(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::STORMSURGE_MASTERY,
    ) / HUNDRED
}

use super::{
    config::{enhancement_config, EnhancementConfig, EnhancementRuntime, WINDFURY_BASE_HITS},
    guardians::summon_feral_spirit,
};

fn searing_totem_pulse(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::SEARING_BOLT_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::SEARING_BOLT,
        coefficient,
        DamageFlags::empty(),
    );
}

fn summon_searing_totem(ctx: &mut HookCtx<'_>) {
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(TALENT::LIVELY_TOTEMS, SEARING_TOTEM_DURATION_MS)
            .ability(
                GuardianAbility::new(SEARING_TOTEM_PULSE_MS, searing_totem_pulse)
                    .first_action_delay(SEARING_TOTEM_PULSE_MS),
            ),
    );
}

fn trigger_searing_volley(ctx: &mut HookCtx<'_>) {
    let count = ctx.active_guardian_count(TALENT::LIVELY_TOTEMS);

    if count == 0 {
        return;
    }

    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::SEARING_VOLLEY_DAMAGE,
    );

    for _ in 0..count {
        ctx.deal_damage_sp(
            crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::SEARING_VOLLEY,
            coefficient,
            DamageFlags::empty(),
        );
    }
}

fn deal_tremor(ctx: &mut HookCtx<'_>, mult: f64) {
    let coefficient = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::TREMOR_DAMAGE,
    );

    ctx.deal_damage_ap(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::TREMOR,
        coefficient * mult,
        DamageFlags::empty(),
    );
}

fn deal_surging_bolt(ctx: &mut HookCtx<'_>) {
    if ctx.active_guardian_count(SPELL::SURGING_TOTEM) == 0 {
        return;
    }

    let coefficient = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::SURGING_BOLT_DAMAGE,
    );

    ctx.deal_damage_ap(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::SURGING_BOLT,
        coefficient,
        DamageFlags::PET,
    );
}

fn trigger_totemic_rebound(ctx: &mut HookCtx<'_>, forced: bool, delay_ms: u32) {
    if ctx.active_guardian_count(SPELL::SURGING_TOTEM) == 0 {
        return;
    }

    if !forced
        && !ctx.roll_system_rppm(
            wowlab_engine_combat::generated_identities::system_rppm::TOTEMIC_REBOUND,
        )
    {
        return;
    }

    ctx.apply_aura(AURA_TOTEMIC_REBOUND);
    ctx.schedule_hook(delay_ms, deal_surging_bolt);
}

fn trigger_direct_lightning_totemic(ctx: &mut HookCtx<'_>) {
    trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);

    if ctx.is_aura_active(AURA_WHIRLING_AIR) {
        for bolt in 0..WHIRLING_AIR_BOLTS {
            let delay_ms = SURGING_BOLT_DELAY_MS + bolt * WHIRLING_AIR_BOLT_SPACING_MS;

            trigger_totemic_rebound(ctx, true, delay_ms);
        }

        ctx.consume_aura(AURA_WHIRLING_AIR);
    }
}

fn roll_stormsurge(ctx: &mut HookCtx<'_>) {
    let chance = stormsurge_chance(ctx);

    apply_stormsurge_roll(ctx, chance, AURA_STORMSURGE, SPELL_STORMSTRIKE);
}

fn apply_stormsurge_roll(
    ctx: &mut HookCtx<'_>,
    chance: f64,
    aura: wowlab_engine_combat::LocalAuraIdx,
    strike: wowlab_engine_combat::LocalSpellIdx,
) {
    let success = proc_chance(ctx.rng(), chance);

    tracing::trace!(chance, success, "STORMSURGE_ROLL");

    if success {
        ctx.apply_aura(aura);
        ctx.reset_cooldown(strike);
    }
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[expect(
    clippy::struct_excessive_bools,
    reason = "each flag preserves one independent landed-melee proc-family capability"
)]
struct LandedMeleeProcFamily {
    windfury: bool,
    flametongue: bool,
    imbuement_mastery: bool,
    maelstrom_weapon: bool,
}

impl LandedMeleeProcFamily {
    const fn player_attack(main_hand: bool) -> Self {
        Self {
            windfury: main_hand,
            flametongue: true,
            imbuement_mastery: false,
            maelstrom_weapon: true,
        }
    }
}

fn spell_landed_melee_proc_family(
    ctx: &HookCtx<'_>,
    action: wowlab_engine_combat::DamageActionId,
) -> LandedMeleeProcFamily {
    let melee = ctx.action_is_melee(action);
    let direct_melee = melee && ctx.action_has_direct_damage(action);
    let main_hand_bound = ctx.action_requires_main_hand(action);
    let weapon_bound = main_hand_bound || ctx.action_requires_off_hand(action);
    let flametongue = direct_melee && weapon_bound;

    LandedMeleeProcFamily {
        // Windfury attacks disable only Windfury self-procs.
        windfury: direct_melee
            && main_hand_bound
            && action != crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::WINDFURY_ATTACK,
        flametongue,
        // trigger_flametongue_weapon only rolls this rider for Windfury attack 25504.
        imbuement_mastery: flametongue
            && action == crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::WINDFURY_ATTACK,
        maelstrom_weapon: melee && !ctx.action_suppresses_caster_procs(action),
    }
}

#[cfg(test)]
fn reference_spell_landed_melee_proc_family(
    game_data: &ResolvedGameData,
    spell_id: u32,
) -> LandedMeleeProcFamily {
    let spell = SpellIdx::from_raw(spell_id);
    let attributes = game_data.spell_attributes(spell).unwrap_or_default();
    let melee = game_data.defense_type(spell) == Some(DefenseType::Melee as i32);
    let direct_melee = melee && damage_def(game_data, spell).is_some();
    let main_hand_bound = spell_attribute_is(attributes, SpellAttributeKind::RequiresMainHand);
    let weapon_bound =
        main_hand_bound || spell_attribute_is(attributes, SpellAttributeKind::RequiresOffHand);
    let flametongue = direct_melee && weapon_bound;

    LandedMeleeProcFamily {
        windfury: direct_melee && main_hand_bound && spell_id != SPELL::WINDFURY_ATTACK,
        flametongue,
        imbuement_mastery: flametongue && spell_id == SPELL::WINDFURY_ATTACK,
        maelstrom_weapon: melee
            && !spell_attribute_is(attributes, SpellAttributeKind::SuppressCasterProcs),
    }
}

fn trigger_flametongue(ctx: &mut HookCtx<'_>, imbuement_mastery_eligible: bool) {
    let ft_coef = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::FLAMETONGUE_ATTACK_DAMAGE,
    );

    ctx.deal_damage_ap(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::FLAMETONGUE_ATTACK,
        ft_coef,
        DamageFlags::empty(),
    );

    let imbuement_mastery = ctx
        .spec_config::<EnhancementConfig>()
        .is_some_and(|config| config.imbuement_mastery);

    let mut failures = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map(|runtime| runtime.imbuement_mastery_failures);
    let imbuement_mastery_proc = imbuement_mastery_eligible
        && imbuement_mastery
        && failures.as_mut().is_some_and(|failures| {
            accumulated_proc_chance(ctx.rng(), IMBUEMENT_MASTERY_CHANCE, failures, 0)
        });

    if let (Some(runtime), Some(failures)) =
        (ctx.spec_runtime_mut::<EnhancementRuntime>(), failures)
    {
        runtime.imbuement_mastery_failures = failures;
    }

    if imbuement_mastery_proc {
        let coef = ctx.effect_ap_coefficient(
            crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::FLAMETONGUE_IMBUEMENT_MASTERY_DAMAGE,
        );

        ctx.deal_damage_ap(
            crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::FLAMETONGUE_ATTACK_IMBUEMENT_MASTERY,
            coef,
            DamageFlags::empty(),
        );
    }
}

fn trigger_maelstrom_weapon(ctx: &mut HookCtx<'_>) {
    let chance = ctx.action_proc_chance(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::MAELSTROM_WEAPON_DRIVER,
    );

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

fn landed_melee_riders(ctx: &mut HookCtx<'_>, family: LandedMeleeProcFamily) {
    if family.flametongue {
        trigger_flametongue(ctx, family.imbuement_mastery);
    }

    if family.maelstrom_weapon {
        trigger_maelstrom_weapon(ctx);
    }
}

fn landed_melee_spell_procs(
    ctx: &mut HookCtx<'_>,
    action: wowlab_engine_combat::DamageActionId,
    outcome: DamageOutcome,
) {
    if outcome.amount <= 0.0 {
        return;
    }

    let family = spell_landed_melee_proc_family(ctx, action);

    landed_melee_procs(ctx, family);
}

fn landed_melee_procs(ctx: &mut HookCtx<'_>, family: LandedMeleeProcFamily) {
    let windfury_procced = if family.windfury {
        let chance = windfury_chance(ctx);
        let success = proc_chance(ctx.rng(), chance);

        tracing::trace!(chance, success, "WINDFURY_ROLL");

        success
    } else {
        false
    };

    if windfury_procced {
        let coef = ctx.effect_ap_coefficient(
            crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::WINDFURY_ATTACK_DAMAGE,
        );
        let hits = ctx
            .spec_config::<EnhancementConfig>()
            .map_or(WINDFURY_BASE_HITS, |config| config.windfury_hits);
        let child_family = spell_landed_melee_proc_family(
            ctx,
            crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::WINDFURY_ATTACK,
        );

        for _ in 0..hits {
            let outcome = ctx.deal_damage_ap_result(
                crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::WINDFURY_ATTACK,
                coef,
                DamageFlags::PHYSICAL,
            );

            if outcome.amount > 0.0 {
                landed_melee_riders(ctx, child_family);
            }
        }
    }

    landed_melee_riders(ctx, family);
}

fn melee_hit_procs(ctx: &mut HookCtx<'_>, main_hand: bool) {
    landed_melee_procs(ctx, LandedMeleeProcFamily::player_attack(main_hand));
}

fn trigger_crash_lightning_proc(
    ctx: &mut HookCtx<'_>,
    effect: wowlab_engine_combat::DamageEffectId,
    multiplier: f64,
) {
    let snapshot = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map_or(0.0, mid2_crash_snapshot_average);

    if ctx.deal_triggered_damage(effect, multiplier * (1.0 + snapshot), DamageFlags::empty()) {
        let family = spell_landed_melee_proc_family(
            ctx,
            crate::generated::specs::enhancement_shaman::DAMAGE_REPORTED::CRASH_LIGHTNING_PROC,
        );

        landed_melee_procs(ctx, family);
    }
}

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

    let mh = matches!(hand, SwingHand::MainHand);

    melee_hit_procs(ctx, mh);

    let hh_chance = ctx.action_proc_chance(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::HOT_HAND_DRIVER,
    );

    if proc_chance(ctx.rng(), hh_chance) {
        ctx.apply_aura(AURA_HOT_HAND);
    }
}

fn stormstrike_hits(ctx: &mut HookCtx<'_>, mult: f64, stormblast_mult: f64) {
    let mh_coef = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::STORMSTRIKE_MH_DAMAGE,
    );
    let oh_coef = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::STORMSTRIKE_OH_DAMAGE,
    );
    let main_hand = ctx.deal_damage_ap_result(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::STORMSTRIKE_MH,
        mh_coef * mult,
        DamageFlags::PHYSICAL,
    );

    if stormblast_mult > 0.0 {
        let _ = ctx.deal_damage_from_result(
            crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::STORMBLAST,
            main_hand,
            stormblast_mult,
            DamageFlags::empty(),
        );
    }

    roll_stormsurge(ctx);
    melee_hit_procs(ctx, true);
    let off_hand = ctx.deal_damage_ap_result(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::STORMSTRIKE_OFFHAND,
        oh_coef * mult * OFF_HAND_DAMAGE_MULT,
        DamageFlags::PHYSICAL,
    );

    if stormblast_mult > 0.0 {
        let _ = ctx.deal_damage_from_result(
            crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::STORMBLAST,
            off_hand,
            stormblast_mult,
            DamageFlags::empty(),
        );
    }

    roll_stormsurge(ctx);
    melee_hit_procs(ctx, false);

    // Crash Lightning procs once per Stormstrike variant, including echoes.

    if ctx.is_aura_active(AURA_CRASH_LIGHTNING) {
        let stacks = f64::from(ctx.aura_stacks(AURA_CRASH_LIGHTNING));

        trigger_crash_lightning_proc(
            ctx,
            crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::CRASH_LIGHTNING_DAMAGE,
            mult * stacks,
        );
    }

    ride_the_lightning(ctx);
}

pub(crate) fn stormstrike_hook(ctx: &mut HookCtx<'_>) {
    let stormblast_mult = if ctx.is_aura_active(AURA_STORMSURGE) {
        ctx.spec_config::<EnhancementConfig>()
            .map_or(0.0, |config| config.stormblast_mult)
    } else {
        0.0
    };
    // Consume the prior proc before the child hits roll fresh Stormsurges;
    // new procs must survive for the next Stormstrike.

    ctx.consume_aura(AURA_STORMSURGE);
    stormstrike_hits(ctx, 1.0, stormblast_mult);

    // Doom Winds' direct lightning does not consume Maelstrom Weapon stacks.
    let mw_stacks = ctx.aura_stacks(AURA_MAELSTROM_WEAPON).min(MW_CONSUME_CAP);

    if ctx.is_aura_active(AURA_DOOM_WINDS) && mw_stacks > 0 {
        let coefficient = ctx.effect_sp_coefficient(
            crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::LIGHTNING_BOLT_DAMAGE,
        );

        ctx.deal_damage_sp(
            crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::LIGHTNING_BOLT,
            coefficient * (1.0 + MW_DMG_PER_STACK * f64::from(mw_stacks)),
            DamageFlags::empty(),
        );
        trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);
    }

    if proc_chance(ctx.rng(), STORMFLURRY_CHANCE) {
        stormstrike_hits(ctx, STORMFLURRY_MULT, stormblast_mult);
    }

    ctx.apply_aura(AURA_MAELSTROM_WEAPON);
}

fn ride_the_lightning(ctx: &mut HookCtx<'_>) {
    let coef = ctx.effect_sp_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::CHAIN_LIGHTNING_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::CHAIN_LIGHTNING,
        coef * RIDE_THE_LIGHTNING_MULT,
        DamageFlags::empty(),
    );
    // Triggered Chain Lightning variants do not consume Whirling Air.
    trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);
}

fn trigger_splitstream(ctx: &mut HookCtx<'_>) {
    let splitstream_mult = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0.0, |config| config.splitstream_mult);

    if splitstream_mult <= 0.0 {
        return;
    }

    let splitstream = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::SUNDERING_SPLITSTREAM_DAMAGE,
    );

    ctx.deal_damage_ap(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::SUNDERING_SPLITSTREAM,
        splitstream * splitstream_mult,
        DamageFlags::PHYSICAL,
    );
    melee_hit_procs(ctx, true);

    if ctx.is_aura_active(AURA_SURGING_TOTEM) {
        deal_tremor(ctx, EARTHSURGE_MULT * splitstream_mult);
    }
}

/// Applies Lava Lash hook effects.
pub(crate) fn lava_lash_hook(ctx: &mut HookCtx<'_>) {
    let ashen_catalyst_cdr_ms = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0, |config| config.ashen_catalyst_cdr_ms);

    if ashen_catalyst_cdr_ms > 0 && ctx.is_aura_active(AURA_FLAME_SHOCK) {
        ctx.reduce_cooldown(SPELL_LAVA_LASH, ashen_catalyst_cdr_ms);
    }

    if ctx.is_aura_active(AURA_HOT_HAND) {
        trigger_splitstream(ctx);
    }

    // An already-active Hot Hand fires a second Splitstream before extension.

    if ctx.is_aura_active(AURA_WHIRLING_FIRE) {
        let hot_hand_active = ctx.is_aura_active(AURA_HOT_HAND);

        if hot_hand_active {
            trigger_splitstream(ctx);
        }

        ctx.consume_aura(AURA_WHIRLING_FIRE);

        if hot_hand_active {
            ctx.extend_aura(AURA_HOT_HAND, WHIRLING_FIRE_HOT_HAND_MS);
        } else {
            ctx.apply_aura(AURA_HOT_HAND);
        }
    }

    // Lava Lash applies Lashing Flames 334168 e1 but does not benefit from it.

    ctx.apply_aura(AURA_LASHING_FLAMES);

    if ctx.is_aura_active(AURA_CRASH_LIGHTNING) {
        let stacks = f64::from(ctx.aura_stacks(AURA_CRASH_LIGHTNING));

        trigger_crash_lightning_proc(
            ctx,
            crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::CRASH_LIGHTNING_DAMAGE,
            stacks,
        );
    }

    // A newly spawned Searing Totem participates in the same Lava Lash volley.

    let lively_totems = ctx
        .spec_config::<EnhancementConfig>()
        .is_some_and(|config| config.lively_totems);
    let mut failures = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map(|runtime| runtime.lively_totems_failures);
    let lively_totems_proc = lively_totems
        && failures.as_mut().is_some_and(|failures| {
            accumulated_proc_chance(ctx.rng(), LIVELY_TOTEMS_CHANCE, failures, 0)
        });

    if let (Some(runtime), Some(failures)) =
        (ctx.spec_runtime_mut::<EnhancementRuntime>(), failures)
    {
        runtime.lively_totems_failures = failures;
    }

    if lively_totems_proc {
        summon_searing_totem(ctx);
    }

    trigger_searing_volley(ctx);

    ride_the_lightning(ctx);
    melee_hit_procs(ctx, false);
}

fn crash_lightning_unleashed(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx.effect_ap_coefficient(crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::CRASH_LIGHTNING_UNLEASHED_DAMAGE);
    let snapshot = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map_or(0.0, |runtime| runtime.mid2_storm_unleashed_snapshot);

    ctx.deal_damage_ap(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::CRASH_LIGHTNING_UNLEASHED,
        coefficient * (1.0 + snapshot),
        DamageFlags::empty(),
    );
}

pub(crate) fn crash_lightning_hook(ctx: &mut HookCtx<'_>) {
    melee_hit_procs(ctx, true);
    let config = ctx.spec_config::<EnhancementConfig>().copied().unwrap_or_default();
    let snapshot = f64::from(ctx.aura_stacks(AURA_SHORT_CIRCUIT).max(0))
        * config.mid2_short_circuit_per_stack;

    if let Some(runtime) = ctx.spec_runtime_mut::<EnhancementRuntime>() {
        push_mid2_crash_snapshot(runtime, snapshot);
        runtime.mid2_storm_unleashed_snapshot = snapshot;
    }

    if config.storm_unleashed_repeats {
        ctx.schedule_hook(
            CRASH_LIGHTNING_UNLEASHED_FIRST_MS,
            crash_lightning_unleashed,
        );
        ctx.schedule_hook(
            CRASH_LIGHTNING_UNLEASHED_SECOND_MS,
            crash_lightning_unleashed,
        );
    }

    ctx.consume_aura(AURA_SHORT_CIRCUIT);
}

pub(crate) fn crash_lightning_expire_hook(ctx: &mut HookCtx<'_>) {
    if let Some(runtime) = ctx.spec_runtime_mut::<EnhancementRuntime>()
        && runtime.mid2_crash_snapshot_count > 0
    {
        runtime.mid2_crash_snapshot_head =
            (runtime.mid2_crash_snapshot_head + 1) % runtime.mid2_crash_snapshots.len();
        runtime.mid2_crash_snapshot_count -= 1;
    }
}

fn push_mid2_crash_snapshot(runtime: &mut EnhancementRuntime, snapshot: f64) {
    let capacity = runtime.mid2_crash_snapshots.len();
    let index = (runtime.mid2_crash_snapshot_head + runtime.mid2_crash_snapshot_count) % capacity;
    let Some(slot) = runtime.mid2_crash_snapshots.get_mut(index) else {
        return;
    };

    *slot = snapshot;

    if runtime.mid2_crash_snapshot_count < capacity {
        runtime.mid2_crash_snapshot_count += 1;
    } else {
        runtime.mid2_crash_snapshot_head = (runtime.mid2_crash_snapshot_head + 1) % capacity;
    }
}

fn mid2_crash_snapshot_average(runtime: &EnhancementRuntime) -> f64 {
    if runtime.mid2_crash_snapshot_count == 0 {
        return 0.0;
    }

    let total = (0..runtime.mid2_crash_snapshot_count)
        .map(|offset| {
            runtime.mid2_crash_snapshots
                .get(
                    (runtime.mid2_crash_snapshot_head + offset)
                        % runtime.mid2_crash_snapshots.len(),
                )
                .copied()
                .unwrap_or_default()
        })
        .sum::<f64>();

    total / wowlab_types::numeric::usize_to_f64(runtime.mid2_crash_snapshot_count)
}

fn primordial_storm_damage_mult(ctx: &HookCtx<'_>) -> f64 {
    let stacks = ctx
        .spec_runtime::<EnhancementRuntime>()
        .map_or(0, |runtime| runtime.primordial_storm_mw_stacks);

    1.0 + MW_DMG_PER_STACK * f64::from(stacks)
}

fn consume_maelstrom_weapon(ctx: &mut HookCtx<'_>) -> i32 {
    let stacks = ctx.aura_stacks(AURA_MAELSTROM_WEAPON).min(MW_CONSUME_CAP);

    ctx.consume_aura(AURA_MAELSTROM_WEAPON);
    let cdr_per_stack = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0, |config| config.elemental_tempo_cdr_per_stack_ms);
    let stack_count = wowlab_types::numeric::i32_to_u32_nonnegative(stacks);
    let cdr_ms = cdr_per_stack.saturating_mul(stack_count);

    if cdr_ms > 0 {
        ctx.reduce_cooldown(SPELL_STORMSTRIKE, cdr_ms);
        ctx.reduce_cooldown(SPELL_LAVA_LASH, cdr_ms);
    }

    let hot_hand_per_stack = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0, |config| config.totemic_momentum_hot_hand_ms);

    if hot_hand_per_stack > 0 && ctx.is_aura_active(AURA_HOT_HAND) {
        ctx.extend_aura(
            AURA_HOT_HAND,
            hot_hand_per_stack.saturating_mul(stack_count),
        );
    }

    let storm_unleashed_chance = ctx
        .spec_config::<EnhancementConfig>()
        .map_or(0.0, |config| config.storm_unleashed_chance_per_stack);

    if (0..stacks).any(|_| proc_chance(ctx.rng(), storm_unleashed_chance)) {
        ctx.apply_aura(AURA_STORM_UNLEASHED);
    }

    stacks
}

fn primordial_fire(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::PRIMORDIAL_FIRE_DAMAGE,
    );

    let outcome = ctx.deal_damage_ap_result(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::PRIMORDIAL_FIRE,
        coefficient * primordial_storm_damage_mult(ctx),
        DamageFlags::empty(),
    );

    landed_melee_spell_procs(
        ctx,
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::PRIMORDIAL_FIRE,
        outcome,
    );
}

fn primordial_frost(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::PRIMORDIAL_FROST_DAMAGE,
    );

    let outcome = ctx.deal_damage_ap_result(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::PRIMORDIAL_FROST,
        coefficient * primordial_storm_damage_mult(ctx),
        DamageFlags::empty(),
    );

    landed_melee_spell_procs(
        ctx,
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::PRIMORDIAL_FROST,
        outcome,
    );
}

fn primordial_lightning(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx.effect_ap_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::PRIMORDIAL_LIGHTNING_DAMAGE,
    );

    let outcome = ctx.deal_damage_ap_result(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::PRIMORDIAL_LIGHTNING,
        coefficient * primordial_storm_damage_mult(ctx),
        DamageFlags::empty(),
    );

    landed_melee_spell_procs(
        ctx,
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::PRIMORDIAL_LIGHTNING,
        outcome,
    );
}

fn primordial_lightning_bolt(ctx: &mut HookCtx<'_>) {
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::LIGHTNING_BOLT_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::LIGHTNING_BOLT,
        coefficient * primordial_storm_damage_mult(ctx) * PRIMORDIAL_LIGHTNING_BOLT_MULT,
        DamageFlags::empty(),
    );
    trigger_totemic_rebound(ctx, false, SURGING_BOLT_DELAY_MS);
}

pub(crate) fn primordial_storm_hook(ctx: &mut HookCtx<'_>) {
    let stacks = consume_maelstrom_weapon(ctx);

    if let Some(runtime) = ctx.spec_runtime_mut::<EnhancementRuntime>() {
        runtime.primordial_storm_mw_stacks = stacks;
    }

    primordial_fire(ctx);
    ctx.schedule_hook(PRIMORDIAL_FROST_DELAY_MS, primordial_frost);
    ctx.schedule_hook(PRIMORDIAL_LIGHTNING_DELAY_MS, primordial_lightning);
    ctx.schedule_hook(
        PRIMORDIAL_LIGHTNING_BOLT_DELAY_MS,
        primordial_lightning_bolt,
    );
}

pub(crate) fn lightning_bolt_hook(ctx: &mut HookCtx<'_>) {
    let stacks = consume_maelstrom_weapon(ctx);

    let coef = ctx.effect_sp_coefficient(
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::LIGHTNING_BOLT_DAMAGE,
    );
    let mult = 1.0 + MW_DMG_PER_STACK * f64::from(stacks);

    ctx.deal_damage_sp(
        crate::generated::specs::enhancement_shaman::DAMAGE_SPELL::LIGHTNING_BOLT,
        coef * mult,
        DamageFlags::empty(),
    );
    trigger_direct_lightning_totemic(ctx);
}

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

pub(crate) fn surging_totem_hook(ctx: &mut HookCtx<'_>) {
    let config = enhancement_config(ctx);
    let _ = ctx.summon_guardian(
        GuardianSpec::new_inheriting_owner(SPELL::SURGING_TOTEM, config.surging_totem_duration_ms)
            .npc_id(config.surging_totem_npc_id)
            .stat_inheritance(wowlab_engine_combat::PetStatInheritance::new(
                config.surging_totem_ap_inheritance,
                config.surging_totem_sp_inheritance,
            ))
            .on_demise(surging_totem_demise),
    );

    ctx.apply_aura(AURA_AMPLIFICATION_CORE);
    ctx.apply_aura(AURA_WHIRLING_AIR);
    ctx.apply_aura(AURA_WHIRLING_FIRE);
    ctx.apply_aura(AURA_WHIRLING_EARTH);
    deal_tremor(ctx, 1.0);
}

fn surging_totem_demise(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.expire_aura(AURA_AMPLIFICATION_CORE);
    ctx.expire_aura(AURA_SURGING_TOTEM);
    ctx.expire_aura(AURA_TOTEMIC_REBOUND);
    ctx.expire_aura(AURA_WHIRLING_AIR);
    ctx.expire_aura(AURA_WHIRLING_EARTH);
    ctx.expire_aura(AURA_WHIRLING_FIRE);
}

pub(crate) fn surging_totem_pulse_hook(ctx: &mut HookCtx<'_>) {
    deal_tremor(ctx, 1.0);
}

pub(crate) fn sundering_hook(ctx: &mut HookCtx<'_>) {
    melee_hit_procs(ctx, true);
    summon_feral_spirit(ctx, FIRE_WOLF_GUARDIAN_TAG, AURA_MOLTEN_WEAPON);

    if ctx.active_guardian_count(SPELL::SURGING_TOTEM) > 0 {
        deal_tremor(ctx, EARTHSURGE_MULT);
    }

    // 453406 e1 (+100% direct on Sundering) is folded by the generic live-aura path;
    // only the Searing Totem half of the buff is content.

    if ctx.is_aura_active(AURA_WHIRLING_EARTH) {
        ctx.consume_aura(AURA_WHIRLING_EARTH);
        summon_searing_totem(ctx);
    }
}

pub(crate) fn doom_winds_hook(ctx: &mut HookCtx<'_>) {
    summon_feral_spirit(ctx, LIGHTNING_WOLF_GUARDIAN_TAG, AURA_CRACKLING_SURGE);
}

pub(crate) fn voltaic_blaze_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura_n(
        AURA_MAELSTROM_WEAPON,
        enhancement_config(ctx).voltaic_blaze_maelstrom_stacks,
    );

    if enhancement_config(ctx).mid2_2pc {
        ctx.apply_aura(AURA_BURNING_CORE);
    }

    trigger_searing_volley(ctx);
}

pub(crate) fn burning_core_tick_hook(ctx: &mut HookCtx<'_>) {
    let config = enhancement_config(ctx);
    let primary_target = ctx.target();
    let effect = crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::FIRE_NOVA_DAMAGE;
    let coefficient = ctx.effect_ap_coefficient(effect);

    ctx.with_resolved_spell_effect_targets(effect, effect.action(), None, |ctx, targets| {
        for target in targets.iter().copied() {
            let multiplier = if Some(target) == primary_target {
                config.mid2_fire_nova_primary_mult
            } else {
                1.0
            };

            ctx.with_resolved_target(target, |target_ctx| {
                target_ctx.deal_damage_ap_to_target(
                    target,
                    effect.action(),
                    coefficient * multiplier,
                    DamageFlags::AOE,
                );
            });
        }
    });

    if config.mid2_fire_nova_crash_cdr_ms > 0 {
        ctx.reduce_cooldown(
            crate::generated::specs::enhancement_shaman::SPELL_CRASH_LIGHTNING,
            config.mid2_fire_nova_crash_cdr_ms,
        );
        ctx.apply_aura(AURA_SHORT_CIRCUIT);
    }
}

pub(crate) fn ascendance_hook(ctx: &mut HookCtx<'_>) {
    ctx.reset_cooldown(SPELL_STORMSTRIKE);
}

/// Returns Enhanced Elements mastery damage from effect 1.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    let enhanced_elements = if [
        DamageSchool::Fire,
        DamageSchool::Frost,
        DamageSchool::Nature,
    ]
    .into_iter()
    .any(|school| ctx.has_school(school))
    {
        ctx.bonus(1)
    } else {
        1.0
    };

    let elemental_weapons_per_imbue = ctx
        .program
        .spec_config::<EnhancementConfig>()
        .map_or(0.0, |config| config.elemental_weapons_per_imbue);
    let modifier_effect = if ctx.is_periodic {
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::ELEMENTAL_WEAPONS_PERIODIC
    } else {
        crate::generated::specs::enhancement_shaman::DAMAGE_EFFECT::ELEMENTAL_WEAPONS_DIRECT
    };
    let affected = ctx.effect_affects_spell(modifier_effect) || ctx.spell_id == SPELL::STORMBLAST;
    let active_imbues = ctx.active_weapon_imbue_count();
    let elemental_weapons = if affected {
        1.0 + elemental_weapons_per_imbue * wowlab_types::numeric::usize_to_f64(active_imbues)
    } else {
        1.0
    };

    enhanced_elements * elemental_weapons
}

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