wowlab_engine_content/hooks/arcane_mage/

hooks.rs

use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::CooldownOps as _;
use wowlab_engine_combat::ResourceOps as _;
use wowlab_engine_combat::SchedulingOps as _;
use wowlab_engine_combat::AuraOps as _;
use wowlab_types::constants::HUNDRED;
#[cfg(test)]
use wowlab_types::sim::SpellIdx;

use wowlab_engine_combat::{DamageFlags, GuardianEvent, HookCtx, MasteryCtx};
use wowlab_engine_domain::pool::SpellGate;
use wowlab_engine_rng::proc_chance;

use super::config::{arcane_config, ArcaneRuntime};
#[cfg(test)]
use super::config::ArcaneConfig;

use crate::generated::specs::arcane_mage::{
    AURA_ARCANE_CHARGE, AURA_ARCANE_SALVO, AURA_ARCANE_SURGE, AURA_CLEARCASTING, AURA_INTUITION,
    AURA_OVERPOWERED_MISSILES, EFFECT, SPELL, 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 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.
/// See `sc_mage_live.inc:1591`, `:1701-1702` and `:2113-2118`.
#[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(EFFECT::ARCANE_ASSAULT_DAMAGE);

    ctx.deal_damage_sp(SPELL::ARCANE_ASSAULT, coef, DamageFlags::empty());

    if proc_chance(ctx.rng(), cfg.energized_familiar_chance) {
        let max_mana = ctx
            .buf()
            .resource(wowlab_types::combat::ResourceType::Mana)
            .map_or(0.0, |resource| 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.raw()) {
        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.raw())))
        .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.raw()) < wanted {
        ctx.apply_aura(AURA_ARCANE_CHARGE.raw());
    }

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

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.raw());

    ctx.apply_aura(AURA_CLEARCASTING.raw());

    if !had_clearcasting {
        ctx.set_spell_gate(SPELL_ARCANE_MISSILES.raw(), 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.raw());
    }
}

fn enable_arcane_missiles(ctx: &mut HookCtx<'_>) {
    ctx.set_spell_gate(SPELL_ARCANE_MISSILES.raw(), 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.raw());

    ctx.apply_aura_n(AURA_ARCANE_SALVO.raw(), stacks);

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

/// 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 {
        EFFECT::SAVANT_BARRAGE
    } else {
        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(EFFECT::ARCANE_SPLINTER_DAMAGE);

    ctx.deal_damage_sp(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.raw(), 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.raw()) {
        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 targets = ctx.resolved_spell_effect_targets(
        EFFECT::ARCANE_ORB_TARGETS,
        SPELL::ARCANE_ORB_BOLT,
        None,
    );
    let coef = ctx.effect_sp_coefficient(EFFECT::ARCANE_ORB_BOLT_DAMAGE);

    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 {
        ctx.with_resolved_target(target, |target_ctx| {
            target_ctx.deal_damage_sp_to_target(
                target,
                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(EFFECT::ARCANE_BLAST_DAMAGE);

        ctx.deal_damage_sp(
            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);
}

pub(crate) fn arcane_barrage_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let salvo_stacks = ctx.aura_stacks(AURA_ARCANE_SALVO.raw());
    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.raw()) {
        mult *= cfg.intuition_damage_mult;
    }

    if mult > 1.0 {
        let coef = ctx.effect_sp_coefficient(EFFECT::ARCANE_BARRAGE_DAMAGE);

        ctx.deal_damage_sp(
            SPELL::ARCANE_BARRAGE,
            coef * (mult - 1.0),
            DamageFlags::empty(),
        );
    }

    if cfg.mana_adept_refund_per_charge > 0.0 {
        let max_mana = ctx
            .buf()
            .resource(wowlab_types::combat::ResourceType::Mana)
            .map_or(0.0, |resource| 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.raw());
    ctx.expire_aura(AURA_ARCANE_SALVO.raw());
    ctx.expire_aura(AURA_INTUITION.raw());
    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);
    }
}

pub(crate) fn arcane_missiles_hook(ctx: &mut HookCtx<'_>) {
    let cfg = arcane_config(ctx);
    let overpowered = ctx.is_aura_active(AURA_OVERPOWERED_MISSILES.raw());
    let overpowered_mult = if overpowered {
        OVERPOWERED_MISSILES_MULT
    } else {
        1.0
    };
    let ticks = cfg.arcane_missiles_ticks;
    let coef = ctx.effect_sp_coefficient(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(
            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);
    }

    ctx.consume_aura_stack(AURA_CLEARCASTING.raw());

    if overpowered {
        ctx.expire_aura(AURA_OVERPOWERED_MISSILES.raw());
    }

    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
        .buf()
        .resource(wowlab_types::combat::ResourceType::Mana)
        .map_or(1.0, |res| {
            if res.max > 0.0 {
                res.current / res.max
            } else {
                1.0
            }
        });
    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(EFFECT::ARCANE_SURGE_DAMAGE);

        if coef > 0.0 {
            ctx.deal_damage_sp(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(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(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 super::*;
    use crate::generated::specs::arcane_mage::AURA;
    use wowlab_engine_ports::{CombatStats};
    use wowlab_engine_telemetry::{TelemetrySink};
use wowlab_engine_gamedata::{ResolvedGameData, SpellProps};
    use wowlab_types::sim::{EnemyIdx, SimTime};

    #[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 built = crate::test_combat_builder(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)
        .build(crate::test_support::wait_rotation())
        .or_fail()?;

        built.state.set_spec_config(ArcaneConfig::default());
        built
            .state
            .apply_enemy_damage(
                EnemyIdx(7),
                crate::hooks::shared::test_support::max_health(),
                SimTime::ZERO,
            )
            .or_fail()?;
        let before: Vec<_> = (0..10)
            .map(|raw| {
                built
                    .state
                    .enemy_health(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 { state: &mut built.state, buf: &mut built.buffer, 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
                .state
                .enemy_health(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 super::*;
    use wowlab_engine_ports::{CombatStats};
use wowlab_engine_gamedata::{SpellProps};
    use wowlab_types::sim::{EnemyIdx, SimTime};

    /// 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(CombatStats::default())
            .game_data(data.build())
            .mastery_spell(EFFECT::SAVANT_MASTERY_DAMAGE.0)
            .mastery_hook(mastery)
            .spell("arcane_blast", SPELL::ARCANE_BLAST, Ok)
            .build(crate::test_support::rotation_from_json(SAVANT_TEST_ROTATION))
            .or_fail()?;
        let bonus = |spell_id: u32| {
            mastery(&MasteryCtx {
                state: &built.state,
                buf: &built.buffer,
                spell_id,
                school: wowlab_types::combat::DamageSchool::Arcane,
                mastery: SAVANT_MASTERY_PCT,
                player_crit_pct: 0.0,
                mastery_spell: savant,
                is_periodic: false,
                is_pet: false,
                source: wowlab_types::sim::ActorId::Player,
                target: Some(EnemyIdx::PRIMARY),
                now: SimTime::ZERO,
            })
        };
        let listed = 1.0 + SAVANT_MASTERY_PCT / HUNDRED;

        for spell in [SPELL::ARCANE_ORB_BOLT, SPELL::ARCANE_MISSILES_DAMAGE, SPELL::ARCANE_SPLINTER] {
            verify_that!(bonus(spell), near(listed, 1e-12))?;
        }

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

        for spell in [SPELL::ARCANE_BLAST, SPELL::ARCANE_BARRAGE, SPELL::ARCANE_ASSAULT] {
            verify_that!(bonus(spell), near(1.0, 1e-12))?;
        }

        Ok(())
    }
}