wowlab_engine_content/hooks/arcane_mage/

hooks.rs

use wowlab_engine_combat::{
    AuraOps as _, CooldownOps as _, DamageFlags, DamageOps as _, GuardianEvent, HookCtx,
    MasteryCtx, ResourceOps as _, SchedulingOps as _,
};
use wowlab_engine_domain::pool::SpellGate;
use wowlab_engine_rng::proc_chance;
use wowlab_types::constants::HUNDRED;
#[cfg(test)]
use wowlab_types::sim::SpellIdx;

#[cfg(test)]
use super::config::ArcaneConfig;
use super::config::{ArcaneRuntime, arcane_config};
#[cfg(test)]
use crate::generated::specs::arcane_mage::SPELL;
use crate::generated::specs::arcane_mage::{
    AURA_ARCANE_CHARGE, AURA_ARCANE_SALVO, AURA_ARCANE_SURGE, AURA_CLEARCASTING,
    AURA_CUMULATIVE_POWER, AURA_INTUITION, AURA_OVERPOWERED_MISSILES, EFFECT,
    AURA_PRISMATIC_BOLT, SPELL_ARCANE_MISSILES, SPELL_ARCANE_ORB,
};

/// 5143: 2.5s channel, 0.625s period (4 ticks) + tick zero.
const ARCANE_MISSILES_TICKS: u32 = 5;
/// Orb Barrage 384858 e1: 4% chance per Arcane Salvo stack.
const ORB_BARRAGE_CHANCE_PER_SALVO_STACK: f64 = 0.04;
const ORB_MASTERY_STAGGER_MS: u32 = 150;
/// Arcane Salvo cap; reaching it triggers Intuition.
const SALVO_MAX_STACKS: i32 = 20;
/// Arcane Surge 365350 e2 (2x), scaled by Mana Bomb 457521 e1 (+50%).
const SURGE_MAX_MANA_MULT: f64 = 2.0;
const MANA_BOMB_BONUS: f64 = 0.50;
/// Touch of the Magi 210824 e1: 20% of damage dealt during the window.
const TOUCH_OF_THE_MAGI_CAPTURE: f64 = 0.20;
const TOUCH_OF_THE_ARCHMAGE_DAMAGE: f64 = 0.75;
const TOUCH_OF_THE_ARCHMAGE_PRIMARY_BONUS: f64 = 0.50;
/// Clearcasting has an undocumented two-percentage-point bonus.
pub(super) const CLEARCASTING_UNDOCUMENTED_BONUS: f64 = 0.02;
/// Clearcasting PRD uses the historical 13-attempt cap despite an uncapped tracker.
pub(super) const CLEARCASTING_CONSTANT_CAP: u32 = 13;
const CLEARCASTING_REACTION_MS: u32 = 50;
const OVERPOWERED_MISSILES_CHANCE: f64 = 0.25;
const OVERPOWERED_MISSILES_MULT: f64 = 2.0;
/// High Voltage 461248 e1 (50%) grants 461524 e1 (1) Arcane Charge per tick.
const HIGH_VOLTAGE_CHANCE: f64 = 0.50;
/// Expanded Mind 1243557 e1 (Blast) / e2 (Arcane Orb): +2 Salvo stacks.
const EXPANDED_MIND_BLAST_STACKS: i32 = 2;
const EXPANDED_MIND_ORB_STACKS: i32 = 2;
const PRISMATIC_BOLT_SALVO_MULTIPLIER: i32 = 2;
const MISSILES_SALVO_STACKS_PER_TICK: i32 = 1;
const OVERPOWERED_SALVO_STACKS_PER_TICK: i32 = 2;
/// Infused Splinters 1261080 e1 (25%) / e3 (1): Salvo per splinter impact.
const INFUSED_SPLINTERS_SALVO_CHANCE: f64 = 0.25;
const INFUSED_SPLINTERS_SALVO_STACKS: i32 = 1;
/// Spellfrost Teachings 444986 e1: -250ms Arcane Orb cooldown per splinter.
const SPELLFROST_TEACHINGS_ORB_CDR_MS: u32 = 250;
/// Splintering Orbs 444256 e4: 2 splinters per Arcane Orb impact.
const SPLINTERING_ORBS_SPLINTERS: i32 = 2;
/// Augury Abounds 1280165: 1.5% per attempt, 0.5-second ICD, eight splinters.
const AUGURY_ABOUNDS_BASE_CHANCE: f64 = 0.015;
const AUGURY_ABOUNDS_SPLINTERS: i32 = 8;
const AUGURY_ABOUNDS_ICD_MS: u32 = 500;
const SPLINTERS_PER_TRIGGER: i32 = 1;
/// Splinterstorm 443783 e2 (100%): 2 splinters per trigger during Arcane Surge.
const SPLINTERSTORM_SPLINTERS_PER_TRIGGER: i32 = 2;
/// Splinterstorm 443783 e1: 8 splinters on Arcane Surge cast.
const SPLINTERSTORM_ARCANE_SURGE_SPLINTERS: i32 = 8;
/// Touch of the Magi 321507: grants 4 Arcane Charges.
const TOUCH_OF_THE_MAGI_CHARGES: f64 = 4.0;

pub(super) const ARCANE_FAMILIAR_PERIOD_MS: u32 = 3_000;
const ENERGIZED_FAMILIAR_STAGGER_MS: u32 = 75;

/// Savant 190740 e5 lists Missiles, Orb, Supernova, Touch of the Magi and Surge; e6 is label 3408.
/// Arcane Blast and Barrage are in neither, taking Savant through the per-charge terms e2/e3.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    ctx.affected_bonus_any(&[
        EFFECT::SAVANT_MASTERY_DAMAGE.1,
        EFFECT::SAVANT_SPLINTER_DAMAGE.1,
    ])
}

fn arcane_assault(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let coef = ctx.effect_sp_coefficient(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_ASSAULT_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_ASSAULT,
        coef,
        DamageFlags::empty(),
    );

    if proc_chance(ctx.rng(), cfg.energized_familiar_chance) {
        let max_mana = ctx.primary_resource_max();

        ctx.gain_resource(max_mana * cfg.energized_familiar_gain_fraction);
    }

    if proc_chance(ctx.rng(), cfg.attuned_familiar_chance) {
        trigger_splinter(ctx, 1);
    }
}

fn delayed_arcane_assault(ctx: &mut HookCtx<'_>) {
    arcane_assault(ctx);
}

pub(super) fn arcane_familiar_action(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    arcane_assault(ctx);
    let cfg = arcane_config(ctx);

    if ctx.is_aura_active(AURA_ARCANE_SURGE) {
        for assault in 1..=cfg.arcane_familiar_extra_assaults {
            ctx.schedule_hook(
                ENERGIZED_FAMILIAR_STAGGER_MS.saturating_mul(assault),
                delayed_arcane_assault,
            );
        }
    }
}

fn charges(ctx: &HookCtx<'_>) -> f64 {
    ctx.secondary_resource()
        .max(f64::from(ctx.aura_stacks(AURA_ARCANE_CHARGE)))
        .max(ctx.last_secondary_spent())
}

fn sync_charge_aura(ctx: &mut HookCtx<'_>) {
    let wanted = wowlab_types::numeric::f64_to_i32_saturating_round(ctx.secondary_resource());

    while ctx.aura_stacks(AURA_ARCANE_CHARGE) < wanted {
        ctx.apply_aura(AURA_ARCANE_CHARGE);
    }

    while ctx.aura_stacks(AURA_ARCANE_CHARGE) > wanted {
        ctx.consume_aura_stack(AURA_ARCANE_CHARGE);
    }
}

fn trigger_clearcasting(ctx: &mut HookCtx<'_>) {
    if roll_clearcasting(ctx) {
        grant_clearcasting(ctx);
    }
}

fn roll_clearcasting(ctx: &mut HookCtx<'_>) -> bool {
    let cfg = arcane_config(ctx);
    let attempts = ctx
        .spec_runtime::<ArcaneRuntime>()
        .map(|runtime| runtime.clearcasting_attempts)
        .unwrap_or_default();
    let attempt = attempts.saturating_add(1);
    let prd_chance = cfg.clearcasting_prd_constant * f64::from(attempt);
    let success = proc_chance(ctx.rng(), prd_chance);

    tracing::trace!(attempt, prd_chance, success, "CLEARCASTING_ROLL");

    if !success {
        if let Some(runtime) = ctx.spec_runtime_mut::<ArcaneRuntime>() {
            runtime.clearcasting_attempts = attempts.saturating_add(1);
        }

        return false;
    }

    if let Some(runtime) = ctx.spec_runtime_mut::<ArcaneRuntime>() {
        runtime.clearcasting_attempts = 0;
    }

    true
}

fn grant_clearcasting(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let had_clearcasting = ctx.is_aura_active(AURA_CLEARCASTING);

    ctx.apply_aura(AURA_CLEARCASTING);

    if !had_clearcasting {
        ctx.set_spell_gate(SPELL_ARCANE_MISSILES, SpellGate::ReactionDelay, false);
        ctx.schedule_hook(CLEARCASTING_REACTION_MS, enable_arcane_missiles);
    }

    if cfg.overpowered_missiles && proc_chance(ctx.rng(), OVERPOWERED_MISSILES_CHANCE) {
        ctx.apply_aura(AURA_OVERPOWERED_MISSILES);
    }
}

fn enable_arcane_missiles(ctx: &mut HookCtx<'_>) {
    ctx.set_spell_gate(SPELL_ARCANE_MISSILES, SpellGate::ReactionDelay, true);
}

fn trigger_salvo(ctx: &mut HookCtx<'_>, stacks: i32) {
    if !arcane_config(ctx).arcane_salvo {
        return;
    }

    let old_stacks = ctx.aura_stacks(AURA_ARCANE_SALVO);

    ctx.apply_aura_n(AURA_ARCANE_SALVO, stacks);

    if old_stacks < SALVO_MAX_STACKS && ctx.aura_stacks(AURA_ARCANE_SALVO) >= SALVO_MAX_STACKS {
        ctx.apply_aura(AURA_INTUITION);
    }
}

/// Arcane Charge uses 36032 e1/e2 and Savant 190740 e2/e3 per charge.
fn arcane_charge_multiplier(ctx: &HookCtx<'_>, charge_count: f64, barrage: bool) -> f64 {
    let cfg = arcane_config(ctx);
    let base = if barrage {
        cfg.arcane_charge_barrage_fraction
    } else {
        cfg.arcane_charge_blast_fraction
    };
    let savant_points = ctx.effect_points(if barrage {
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::SAVANT_BARRAGE
    } else {
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::SAVANT_BLAST
    });

    resolved_arcane_charge_multiplier(charge_count, base, savant_points)
}

const fn resolved_arcane_charge_multiplier(
    charge_count: f64,
    base_fraction: f64,
    savant_points: f64,
) -> f64 {
    let savant = savant_points / HUNDRED;

    1.0 + charge_count * (base_fraction + savant)
}

pub(super) fn arcane_missiles_ticks(extra_waves: f64) -> u32 {
    ARCANE_MISSILES_TICKS.saturating_add(wowlab_types::numeric::f64_to_u32_saturating_round(
        extra_waves.max(0.0),
    ))
}

const fn force_of_will_barrage_splinters(salvo_stacks: i32, stacks_per_splinter: i32) -> i32 {
    if stacks_per_splinter > 0 {
        salvo_stacks / stacks_per_splinter
    } else {
        0
    }
}

fn roll_augury_abounds(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);

    if !cfg.augury_abounds {
        return;
    }

    let now = ctx.now().as_millis();
    let runtime = ctx
        .spec_runtime::<ArcaneRuntime>()
        .copied()
        .unwrap_or_default();

    if now < runtime.augury_icd_until_ms {
        return;
    }

    let attempts = runtime.augury_attempts.saturating_add(1);
    let success = proc_chance(ctx.rng(), AUGURY_ABOUNDS_BASE_CHANCE * f64::from(attempts));

    if let Some(runtime) = ctx.spec_runtime_mut::<ArcaneRuntime>() {
        runtime.augury_icd_until_ms = now.saturating_add(AUGURY_ABOUNDS_ICD_MS);
        runtime.augury_attempts = if success { 0 } else { attempts };
    }

    if success {
        trigger_splinter_inner(ctx, AUGURY_ABOUNDS_SPLINTERS, false);
    }
}

fn fire_splinter(ctx: &mut HookCtx<'_>, allow_augury: bool) {
    let cfg = arcane_config(ctx);
    let coef = ctx.effect_sp_coefficient(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_SPLINTER_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_SPLINTER,
        coef,
        DamageFlags::empty(),
    );

    if cfg.infused_splinters && proc_chance(ctx.rng(), INFUSED_SPLINTERS_SALVO_CHANCE) {
        trigger_salvo(ctx, INFUSED_SPLINTERS_SALVO_STACKS);
    }

    if cfg.spellfrost_teachings {
        ctx.reduce_cooldown(SPELL_ARCANE_ORB, SPELLFROST_TEACHINGS_ORB_CDR_MS);
    }

    if allow_augury {
        roll_augury_abounds(ctx);
    }
}

fn trigger_splinter_inner(ctx: &mut HookCtx<'_>, count: i32, allow_augury: bool) {
    let cfg = arcane_config(ctx);

    if !cfg.splintering_sorcery {
        return;
    }

    let per_trigger = if cfg.splinterstorm && ctx.is_aura_active(AURA_ARCANE_SURGE) {
        SPLINTERSTORM_SPLINTERS_PER_TRIGGER
    } else {
        SPLINTERS_PER_TRIGGER
    };

    for _ in 0..(count.max(0) * per_trigger) {
        fire_splinter(ctx, allow_augury);
    }
}

fn trigger_splinter(ctx: &mut HookCtx<'_>, count: i32) {
    trigger_splinter_inner(ctx, count, true);
}

fn fire_arcane_orb(ctx: &mut HookCtx<'_>, damage_fraction: f64) {
    let cfg = arcane_config(ctx);
    let coef = ctx.effect_sp_coefficient(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_ORB_BOLT_DAMAGE,
    );

    ctx.with_resolved_spell_effect_targets(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_ORB_TARGETS,
        crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_ORB_BOLT,
        None,
        |ctx, targets| {
            ctx.gain_secondary_resource(1.0);
            sync_charge_aura(ctx);

            if cfg.expanded_mind {
                trigger_salvo(ctx, EXPANDED_MIND_ORB_STACKS);
            }

            for target in targets.iter().copied() {
                ctx.with_resolved_target(target, |target_ctx| {
                    target_ctx.deal_damage_sp_to_target(
                        target,
                        crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_ORB_BOLT,
                        coef * damage_fraction,
                        DamageFlags::empty(),
                    );
                    target_ctx.gain_secondary_resource(1.0);
                    sync_charge_aura(target_ctx);

                    if cfg.splintering_orbs {
                        trigger_splinter(target_ctx, SPLINTERING_ORBS_SPLINTERS);
                    }
                });
            }
        },
    );
}

fn fire_orb_mastery(ctx: &mut HookCtx<'_>) {
    let damage_fraction = arcane_config(ctx).orb_mastery_damage_fraction;

    if damage_fraction <= 0.0 {
        return;
    }

    fire_arcane_orb(ctx, damage_fraction);
}

pub(crate) fn arcane_blast_hook(ctx: &mut HookCtx<'_>) {
    let charge_count = charges(ctx);
    let mult = arcane_charge_multiplier(ctx, charge_count, false);

    if mult > 1.0 {
        let coef = ctx.effect_sp_coefficient(
            crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_BLAST_DAMAGE,
        );

        ctx.deal_damage_sp(
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_BLAST,
            coef * (mult - 1.0),
            DamageFlags::empty(),
        );
    }

    sync_charge_aura(ctx);

    if arcane_config(ctx).expanded_mind {
        trigger_salvo(ctx, EXPANDED_MIND_BLAST_STACKS);
    }

    trigger_splinter(ctx, 1);
    trigger_clearcasting(ctx);
    ctx.expire_aura(AURA_CUMULATIVE_POWER);
}

pub(crate) fn arcane_barrage_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let salvo_stacks = ctx.aura_stacks(AURA_ARCANE_SALVO);
    let orb_barrage_proc = cfg.orb_barrage
        && salvo_stacks > 0
        && proc_chance(
            ctx.rng(),
            f64::from(salvo_stacks) * ORB_BARRAGE_CHANCE_PER_SALVO_STACK,
        );

    if orb_barrage_proc {
        fire_arcane_orb(ctx, 1.0);
    }

    let charge_count = charges(ctx);
    let mut mult = arcane_charge_multiplier(ctx, charge_count, true);

    mult *= 1.0 + f64::from(salvo_stacks) * cfg.arcane_salvo_fraction_per_stack;

    if ctx.is_aura_active(AURA_INTUITION) {
        mult *= cfg.intuition_damage_mult;
    }

    if mult > 1.0 {
        let coef = ctx.effect_sp_coefficient(
            crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_BARRAGE_DAMAGE,
        );

        ctx.deal_damage_sp(
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_BARRAGE,
            coef * (mult - 1.0),
            DamageFlags::empty(),
        );
    }

    if cfg.mana_adept_refund_per_charge > 0.0 {
        let max_mana = ctx.primary_resource_max();

        ctx.gain_resource(max_mana * charge_count * cfg.mana_adept_refund_per_charge);
    }

    ctx.spend_all_secondary_resource(0.0);
    ctx.expire_aura(AURA_ARCANE_CHARGE);
    ctx.expire_aura(AURA_ARCANE_SALVO);
    ctx.expire_aura(AURA_INTUITION);
    trigger_splinter(
        ctx,
        force_of_will_barrage_splinters(salvo_stacks, cfg.force_of_will_salvo_per_splinter),
    );
    // A triggered Orb Barrage suppresses this Barrage's Clearcasting roll and BLP advance.

    if !orb_barrage_proc {
        trigger_clearcasting(ctx);
    }

    if cfg.prismatic_bolt
        && salvo_stacks > 0
        && proc_chance(
            ctx.rng(),
            f64::from(salvo_stacks) * cfg.prismatic_bolt_proc_per_salvo,
        )
    {
        ctx.apply_aura(AURA_PRISMATIC_BOLT);
    }
}

pub(crate) fn prismatic_bolt_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let primary_effect =
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::PRISMATIC_BOLT_DAMAGE;

    ctx.deal_damage_sp(
        crate::generated::specs::arcane_mage::DAMAGE_REPORTED::PRISMATIC_BOLT,
        ctx.effect_sp_coefficient(primary_effect),
        DamageFlags::empty(),
    );
    let effect = crate::generated::specs::arcane_mage::DAMAGE_EFFECT::PRISMATIC_BOLT_AOE_DAMAGE;
    let coefficient = ctx.effect_sp_coefficient(effect);
    let primary = ctx.target();

    ctx.with_resolved_spell_effect_targets(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::PRISMATIC_BOLT_AOE_TARGETS,
        crate::generated::specs::arcane_mage::DAMAGE_REPORTED::PRISMATIC_BOLT_AOE,
        None,
        |ctx, targets| {
            let secondary_count = targets
                .iter()
                .filter(|target| Some(**target) != primary)
                .count();
            let reduced_aoe = if cfg.prismatic_bolt_reduced_targets > 0
                && secondary_count > cfg.prismatic_bolt_reduced_targets
            {
                (wowlab_types::numeric::usize_to_f64(cfg.prismatic_bolt_reduced_targets)
                    / wowlab_types::numeric::usize_to_f64(secondary_count))
                .sqrt()
            } else {
                1.0
            };

            for target in targets
                .iter()
                .copied()
                .filter(|target| Some(*target) != primary)
            {
                ctx.deal_damage_sp_to_target(
                    target,
                    crate::generated::specs::arcane_mage::DAMAGE_REPORTED::PRISMATIC_BOLT_AOE,
                    coefficient * reduced_aoe,
                    DamageFlags::AOE,
                );
            }
        },
    );
    ctx.expire_aura(AURA_PRISMATIC_BOLT);
    ctx.expire_aura(AURA_CUMULATIVE_POWER);
    ctx.gain_secondary_resource(cfg.prismatic_bolt_charges);
    sync_charge_aura(ctx);
    trigger_salvo(
        ctx,
        EXPANDED_MIND_BLAST_STACKS * PRISMATIC_BOLT_SALVO_MULTIPLIER,
    );

    if cfg.prismatic_bolt_clearcasting_chance > 0.0
        && proc_chance(ctx.rng(), cfg.prismatic_bolt_clearcasting_chance)
    {
        grant_clearcasting(ctx);
    }
}

pub(crate) fn arcane_pulse_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_PULSE_DAMAGE,
    );
    let target_count = ctx.with_resolved_spell_effect_targets(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_PULSE_DAMAGE,
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_PULSE_DAMAGE.action(),
        None,
        |ctx, targets| {
            let reduced_aoe = if cfg.arcane_pulse_reduced_targets > 0
                && targets.len() > cfg.arcane_pulse_reduced_targets
            {
                (wowlab_types::numeric::usize_to_f64(cfg.arcane_pulse_reduced_targets)
                    / wowlab_types::numeric::usize_to_f64(targets.len()))
                .sqrt()
            } else {
                1.0
            };

            for target in targets.iter().copied() {
                ctx.deal_damage_sp_to_target(
                    target,
                    crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_PULSE_DAMAGE
                        .action(),
                    coefficient * reduced_aoe,
                    DamageFlags::AOE,
                );
            }

            targets.len()
        },
    );

    ctx.gain_secondary_resource(
        cfg.arcane_pulse_charges_per_target
            * wowlab_types::numeric::usize_to_f64(target_count),
    );
    sync_charge_aura(ctx);
    ctx.expire_aura(AURA_CUMULATIVE_POWER);

    if cfg.expanded_mind {
        trigger_salvo(ctx, EXPANDED_MIND_BLAST_STACKS);
    }

    trigger_splinter(ctx, 1);
    trigger_clearcasting(ctx);
}

pub(crate) fn arcane_missiles_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let overpowered = ctx.is_aura_active(AURA_OVERPOWERED_MISSILES);
    let overpowered_mult = if overpowered {
        OVERPOWERED_MISSILES_MULT
    } else {
        1.0
    };
    let ticks = cfg.arcane_missiles_ticks;
    let coef = ctx.effect_sp_coefficient(
        crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_MISSILES_DAMAGE,
    );

    for _ in 0..ticks {
        let charged = ctx.secondary_resource() > 0.0;
        let charged_mult = if charged {
            1.0 + cfg.charged_missiles_fraction
        } else {
            1.0
        };

        ctx.deal_damage_sp(
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_MISSILES_DAMAGE,
            coef * overpowered_mult * charged_mult,
            DamageFlags::empty(),
        );
        trigger_salvo(ctx, MISSILES_SALVO_STACKS_PER_TICK);

        if overpowered {
            trigger_salvo(ctx, OVERPOWERED_SALVO_STACKS_PER_TICK);
        }

        if arcane_config(ctx).high_voltage && proc_chance(ctx.rng(), HIGH_VOLTAGE_CHANCE) {
            ctx.gain_secondary_resource(1.0);
            sync_charge_aura(ctx);
        }

        if cfg.charged_missiles_fraction > 0.0 {
            ctx.spend_secondary_resource(1.0);
            sync_charge_aura(ctx);
        }

        trigger_splinter(ctx, 1);

        if cfg.mid2_cumulative_power {
            ctx.apply_aura(AURA_CUMULATIVE_POWER);
        }
    }

    ctx.consume_aura_stack(AURA_CLEARCASTING);

    if overpowered {
        ctx.expire_aura(AURA_OVERPOWERED_MISSILES);
    }

    trigger_clearcasting(ctx);
}

pub(crate) fn arcane_orb_hook(ctx: &mut HookCtx<'_>) {
    sync_charge_aura(ctx);
    let cfg = arcane_config(ctx);

    fire_arcane_orb(ctx, 1.0);

    if cfg.orb_mastery_damage_fraction > 0.0 {
        for orb in 1..=cfg.orb_mastery_extra_orbs {
            ctx.schedule_hook(orb.saturating_mul(ORB_MASTERY_STAGGER_MS), fire_orb_mastery);
        }
    }

    trigger_clearcasting(ctx);
}

pub(crate) fn arcane_surge_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let mana_pct = ctx.primary_resource_fraction();
    let max_mana_mult = SURGE_MAX_MANA_MULT
        * if cfg.mana_bomb {
            1.0 + MANA_BOMB_BONUS
        } else {
            1.0
        };
    let extra = mana_pct * (max_mana_mult - 1.0);

    if extra > 0.0 {
        let coef = ctx.effect_sp_coefficient(
            crate::generated::specs::arcane_mage::DAMAGE_EFFECT::ARCANE_SURGE_DAMAGE,
        );

        if coef > 0.0 {
            ctx.deal_damage_sp(
                crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_SURGE,
                coef * extra,
                DamageFlags::empty(),
            );
        }
    }

    if cfg.splinterstorm {
        trigger_splinter(ctx, SPLINTERSTORM_ARCANE_SURGE_SPLINTERS);
    }

    grant_clearcasting(ctx);
}

pub(crate) fn touch_of_the_magi_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let start_damage = ctx.total_damage();

    if let Some(runtime) = ctx.spec_runtime_mut::<ArcaneRuntime>() {
        runtime.touch_of_the_magi_start_damage = start_damage;
    }

    ctx.gain_secondary_resource(TOUCH_OF_THE_MAGI_CHARGES);
    sync_charge_aura(ctx);
    trigger_splinter(ctx, 1);
    trigger_clearcasting(ctx);

    if cfg.aegwynns_technique {
        grant_clearcasting(ctx);
    }
}

pub(crate) fn touch_of_the_magi_expire_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let start_damage = ctx
        .spec_runtime::<ArcaneRuntime>()
        .map_or(0.0, |runtime| runtime.touch_of_the_magi_start_damage);
    let captured = (ctx.total_damage() - start_damage).max(0.0);
    let explosion = captured * TOUCH_OF_THE_MAGI_CAPTURE;

    if explosion <= 0.0 {
        return;
    }

    ctx.deal_damage_flat(
        crate::generated::specs::arcane_mage::DAMAGE_SPELL::TOUCH_OF_THE_MAGI_EXPLOSION,
        explosion,
    );

    if cfg.touch_of_the_archmage {
        let archmage =
            explosion * TOUCH_OF_THE_ARCHMAGE_DAMAGE * (1.0 + TOUCH_OF_THE_ARCHMAGE_PRIMARY_BONUS);

        ctx.deal_damage_flat(
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::TOUCH_OF_THE_ARCHMAGE,
            archmage,
        );
    }
}

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

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use wowlab_engine_gamedata::{ResolvedGameData, SpellProps};
    use wowlab_engine_ports::CombatStats;
    use wowlab_engine_telemetry::TelemetrySink;
    use wowlab_types::sim::{EnemyIdx, SimTime};

    use super::*;
    use crate::generated::specs::arcane_mage::AURA;

    #[gtest]
    fn arcane_charge_multiplier_combines_resolved_base_and_mastery_values() -> Result<()> {
        let multiplier = resolved_arcane_charge_multiplier(4.0, 1.20, 33.13 * 0.84);
        let expected = 1.0 + 4.0 * (1.20 + 0.3313 * 0.84);

        verify_that!(multiplier, near(expected, 1e-12))
    }

    #[gtest]
    fn amplification_adds_its_resolved_extra_waves() -> Result<()> {
        verify_that!(arcane_missiles_ticks(2.0), eq(7))
    }

    #[gtest]
    fn force_of_will_converts_complete_salvo_groups_to_splinters() -> Result<()> {
        verify_that!(force_of_will_barrage_splinters(19, 5), eq(3))
    }

    #[gtest]
    fn arcane_orb_damages_each_spatially_eligible_identity_once() -> Result<()> {
        let encounter = crate::hooks::shared::test_support::spatial_hook_encounter()?;
        let mut data = ResolvedGameData::builder();

        data.set_creature_armor(0.0);
        data.set_armor_constant(1.0);
        data.set_level(80);
        data.insert_spell_props(
            SpellIdx::from_raw(SPELL::ARCANE_ORB),
            SpellProps {
                hostile_max_range: 40.0,
                radius: 40.0,
                ..SpellProps::default()
            },
        );
        data.insert_effect_type(
            wowlab_types::sim::EffectRef::new(
                SpellIdx::from_raw(EFFECT::ARCANE_ORB_TARGETS.0),
                EFFECT::ARCANE_ORB_TARGETS.1,
            ),
            2,
        );
        data.insert_implicit_targets(
            wowlab_types::sim::EffectRef::new(
                SpellIdx::from_raw(EFFECT::ARCANE_ORB_TARGETS.0),
                EFFECT::ARCANE_ORB_TARGETS.1,
            ),
            18,
            16,
        );
        data.insert_spell_props(
            SpellIdx::from_raw(SPELL::ARCANE_ORB_BOLT),
            SpellProps {
                ignores_line_of_sight: true,
                treat_as_area_effect: true,
                ..SpellProps::default()
            },
        );
        data.insert_sp_coef(
            SpellIdx::from_raw(EFFECT::ARCANE_ORB_BOLT_DAMAGE.0),
            EFFECT::ARCANE_ORB_BOLT_DAMAGE.1,
            1.0,
        );
        data.insert_school_mask(SpellIdx::from_raw(SPELL::ARCANE_ORB_BOLT), 0x40);
        let mut draft = crate::test_combat_builder_for(
            wowlab_engine_combat::generated_identities::specs::arcane_mage::PROOF,
            CombatStats {
                spell_power: 100.0,
                ..CombatStats::default()
            },
        )
        .secondary_resource("arcane_charges", 4.0)
        .secondary_resource_type_id(16)
        .game_data(data.build())
        .encounter(encounter)
        .aura("arcane_charge", AURA::ARCANE_CHARGE, |a| {
            Ok(a.on_player().max_stacks(4))
        })
        .spell("arcane_orb", SPELL::ARCANE_ORB, Ok)
        .spell("arcane_orb_bolt", SPELL::ARCANE_ORB_BOLT, Ok)
        .into_draft()
        .or_fail()?;

        draft.set_spec_config(ArcaneConfig::default());
        let mut built = draft
            .finalize(&crate::test_support::wait_rotation())
            .or_fail()?;

        built
            .instance
            .apply_enemy_damage(
                EnemyIdx(7),
                crate::hooks::shared::test_support::max_health(),
                SimTime::ZERO,
            )
            .or_fail()?;
        let before: Vec<_> = (0..10)
            .map(|raw| {
                built
                    .instance
                    .enemy_health(&built.program, EnemyIdx(raw), SimTime::ZERO)
                    .or_fail()
            })
            .collect::<Result<Vec<_>>>()?;
        let mut sink = TelemetrySink::default();
        let mut rng = || 1.0;
        let mut ctx = HookCtx::new(
            wowlab_engine_combat::HookCtxServices {
                program: &built.program,
                instance: &mut built.instance,
                sink: &mut sink,
                rng: &mut rng,
            },
            wowlab_engine_combat::HookCtxRequest::for_target(SimTime::ZERO, EnemyIdx::PRIMARY),
        );

        arcane_orb_hook(&mut ctx);
        verify_that!(ctx.secondary_resource(), eq(4.0))?;
        drop(ctx);

        let hit_ids = [0_u16, 1, 2, 3, 4, 8];

        for raw in 0..10 {
            let after = built
                .instance
                .enemy_health(&built.program, EnemyIdx(raw), SimTime::ZERO)
                .or_fail()?;

            if hit_ids.contains(&raw) {
                verify_that!(after, lt(before[usize::from(raw)]))?;
            } else {
                verify_that!(after, eq(before[usize::from(raw)]))?;
            }
        }

        verify_that!(sink.damage, len(eq(hit_ids.len())))?;

        verify_true!(
            sink.damage
                .iter()
                .all(|event| event.spell_id == SPELL::ARCANE_ORB_BOLT)
        )
    }
}

#[cfg(test)]
mod savant_mastery_tests {
    use googletest::prelude::*;
    use wowlab_engine_gamedata::SpellProps;
    use wowlab_engine_ports::CombatStats;
    use wowlab_types::sim::{EnemyIdx, SimTime};

    use super::*;

    /// 190740 e6 targets by `SpellLabel` 3408 (Frost Splinter 443722, Arcane Splinter 443763).
    const SPLINTER_LABEL: i32 = 3408;
    /// `Apply Percent Modifier w/ Label`, the aura subtype 190740 e6 carries.
    const ADD_PERCENT_LABEL_MODIFIER: i32 = 218;
    const MAGE_SPELL_FAMILY: i32 = 3;
    const SAVANT_MASTERY_PCT: f64 = 33.0;
    const SAVANT_TEST_ROTATION: &str = r#"{"version":1,"name":"savant","variables":{},"actions":[{"type":"wait","seconds":1.0}],"lists":{}}"#;

    #[gtest]
    fn savant_mastery_applies_only_to_its_dbc_affect_list() -> Result<()> {
        let savant = SpellIdx::from_raw(EFFECT::SAVANT_MASTERY_DAMAGE.0);
        let (list, label) = (
            EFFECT::SAVANT_MASTERY_DAMAGE.1,
            EFFECT::SAVANT_SPLINTER_DAMAGE.1,
        );
        let mut data = wowlab_engine_gamedata::ResolvedGameData::builder();
        let props = SpellProps {
            mastery_affects_points: true,
            ..SpellProps::default()
        };

        data.insert_spell_props(savant, props);
        data.insert_sp_coef(savant, list, 1.0);
        data.insert_sp_coef(savant, label, 1.0);
        data.insert_spell_class_flags(savant, MAGE_SPELL_FAMILY, [0, 0, 0, 0]);
        data.insert_effect_class_mask(savant, list, [1, 0, 0, 0]);
        data.insert_effect_aura(
            wowlab_types::sim::EffectRef::new(savant, label),
            ADD_PERCENT_LABEL_MODIFIER,
        );
        data.insert_effect_misc_value_1(
            wowlab_types::sim::EffectRef::new(savant, label),
            SPLINTER_LABEL,
        );
        data.insert_spell_labels(
            SpellIdx::from_raw(SPELL::ARCANE_SPLINTER),
            vec![SPLINTER_LABEL],
        );

        for (spells, mask) in [
            (
                [SPELL::ARCANE_ORB_BOLT, SPELL::ARCANE_MISSILES_DAMAGE],
                [1, 0, 0, 0],
            ),
            ([SPELL::ARCANE_BLAST, SPELL::ARCANE_BARRAGE], [2, 0, 0, 0]),
        ] {
            for spell in spells {
                data.insert_spell_class_flags(SpellIdx::from_raw(spell), MAGE_SPELL_FAMILY, mask);
            }
        }

        let built = crate::test_combat_builder_for(
            wowlab_engine_combat::generated_identities::specs::arcane_mage::PROOF,
            CombatStats::default(),
        )
        .game_data(data.build())
        .effect_identities(
            wowlab_engine_combat::generated_identities::specs::arcane_mage::damage::ALL,
        )
        .mastery_spell(EFFECT::SAVANT_MASTERY_DAMAGE.0)
        .mastery_hook(mastery)
        .spell("arcane_blast", SPELL::ARCANE_BLAST, Ok)
        .into_draft()
        .expect("valid combat draft")
        .finalize(&crate::test_support::rotation_from_json(
            SAVANT_TEST_ROTATION,
        ))
        .or_fail()?;
        let bonus = |action| {
            mastery(
                &MasteryCtx::new(
                    &built.program,
                    &built.instance,
                    wowlab_engine_combat::MasteryEvent {
                        action,
                        school: wowlab_types::combat::DamageSchool::Arcane,
                        mastery: SAVANT_MASTERY_PCT,
                        player_crit_pct: 0.0,
                        mastery_action: crate::generated::specs::arcane_mage::DAMAGE_EFFECT::SAVANT_MASTERY_DAMAGE.action(),
                        is_periodic: false,
                        is_pet: false,
                        source: wowlab_types::sim::ActorId::Player,
                        target: Some(EnemyIdx::PRIMARY),
                        now: SimTime::ZERO,
                    },
                )
                .expect("mastery fixture coordinates are finalized"),
            )
        };
        let listed = 1.0 + SAVANT_MASTERY_PCT / HUNDRED;

        for action in [
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_ORB_BOLT,
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_MISSILES_DAMAGE,
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_SPLINTER,
        ] {
            verify_that!(bonus(action), near(listed, 1e-12))?;
        }

        // Arcane Blast, Barrage and Assault are Arcane but in neither affect list.

        for action in [
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_BLAST,
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_BARRAGE,
            crate::generated::specs::arcane_mage::DAMAGE_SPELL::ARCANE_ASSAULT,
        ] {
            verify_that!(bonus(action), near(1.0, 1e-12))?;
        }

        Ok(())
    }
}