wowlab_engine_content/hooks/havoc_demon_hunter/

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_engine_domain::dbc::ResolvedGameDataEffectExt as _;
use wowlab_types::{constants::HUNDRED, constants::MS_PER_SECOND, sim::SpellIdx};

use wowlab_engine_combat::{DamageFlags, HookCtx, MasteryCtx, SwingEvent};
use wowlab_engine_rng::proc_chance;

use crate::generated::specs::havoc_demon_hunter::{
    AURA_CYCLE_OF_HATRED, AURA_DEMONIC_INTENSITY, AURA_EMPOWERED_EYE_BEAM, AURA_FURIOUS_GAZE,
    AURA_METAMORPHOSIS, AURA_SERRATED_GLAIVE, AURA_STUDENT_OF_SUFFERING, EFFECT, SPELL,
    SPELL_BLADE_DANCE, SPELL_EYE_BEAM, SPELL_THROW_GLAIVE,
};

use super::config::{DemonsurgeAbilities, HavocConfig, HavocRuntime, havoc_config};

/// Metamorphosis base buff duration (162264: 20s), for the Demonic fresh-trigger math.
const META_BASE_MS: u32 = 20_000;

/// Blade Dance deals three 199552-family slashes before the final hit (188499 e2/e3/e4).
const BLADE_DANCE_SLASHES: usize = 3;

const DEMONSURGE_DELAY_MS: u32 = 450;
const DEMONSURGE_DEATH_SWEEP_DELAY_MS: u32 = 700;
// The Fel-Scarred Demonsurge state tracks at most four empowered abilities.
const DEMONSURGE_MAX_STACKS: u8 = 4;

/// Returns Demonic Presence mastery damage.
///
/// 185164 e1 (direct) and e2 (periodic) each ship their own 36-spell affect list.
/// `SimC` reads exactly that list via `parse_affect_flags` (`sc_demon_hunter.cpp:2078`).
/// It applies the direct half at `:2304` and the periodic half at `:2351`.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    ctx.direct_or_periodic_affected_bonus_any(
        &[EFFECT::MASTERY_DIRECT_BONUS.1],
        &[EFFECT::MASTERY_PERIODIC_BONUS.1],
    )
}

fn apply_serrated_glaive(ctx: &mut HookCtx<'_>) {
    if havoc_config(ctx).serrated_glaive {
        ctx.apply_aura(AURA_SERRATED_GLAIVE.raw());
    }
}

pub(crate) fn chaos_strike_hook(ctx: &mut HookCtx<'_>) {
    apply_serrated_glaive(ctx);
    let refund_chance = ctx
        .game_data()
        .proc_chance(SpellIdx::from_raw(EFFECT::CHAOS_STRIKE_REFUND_PROC.0))
        .unwrap_or_default();

    if proc_chance(ctx.rng(), refund_chance) {
        let refund = ctx
            .game_data()
            .effect_base_points(EFFECT::CHAOS_STRIKE_FURY_REFUND);

        ctx.gain_resource(refund);
    }
}

fn demonsurge_damage_hook(ctx: &mut HookCtx<'_>) {
    let cfg = havoc_config(ctx);
    let mult = ctx
        .spec_runtime_mut::<HavocRuntime>()
        .map_or(1.0, |runtime| {
            let mult = 1.0 + cfg.demonsurge_stack_pct * f64::from(runtime.demonsurge_stacks);

            runtime.demonsurge_stacks = runtime
                .demonsurge_stacks
                .saturating_add(1)
                .min(DEMONSURGE_MAX_STACKS);

            mult
        });

    if cfg.demonsurge {
        ctx.deal_effect_damage_ap(EFFECT::DEMONSURGE_DAMAGE, mult, DamageFlags::empty());
    }
}

fn trigger_demonsurge(ctx: &mut HookCtx<'_>, ability: DemonsurgeAbilities, delay_ms: u32) {
    if !havoc_config(ctx).demonsurge {
        return;
    }

    let available = ctx
        .spec_runtime_mut::<HavocRuntime>()
        .is_some_and(|runtime| {
            if !runtime.demonsurge_available.contains(ability) {
                return false;
            }

            runtime.demonsurge_available.remove(ability);

            true
        });

    if available {
        ctx.schedule_hook(delay_ms, demonsurge_damage_hook);
    }
}

/// Annihilation is Chaos Strike's Meta replacement and consumes only its own Demonsurge opportunity.
pub(crate) fn annihilation_hook(ctx: &mut HookCtx<'_>) {
    chaos_strike_hook(ctx);
    trigger_demonsurge(ctx, DemonsurgeAbilities::ANNIHILATION, DEMONSURGE_DELAY_MS);
}

pub(crate) fn throw_glaive_hook(ctx: &mut HookCtx<'_>) {
    apply_serrated_glaive(ctx);

    if havoc_config(ctx).furious_throws {
        ctx.deal_effect_damage_ap(EFFECT::FURIOUS_THROWS_DAMAGE, 1.0, DamageFlags::PHYSICAL);
    }
}

fn throw_glaive_cd_ready(ctx: &HookCtx<'_>) -> bool {
    let now = ctx.now().as_secs_f64();

    ctx.buf()
        .cooldown(SpellIdx::from_raw(SPELL::THROW_GLAIVE))
        .is_none_or(|cd| cd.ready_at <= now)
}

// Screaming Brutality shares Throw Glaive's hasted cooldown from spell 212612 e8.
fn consume_throw_glaive_cd(ctx: &mut HookCtx<'_>) {
    ctx.start_cooldown(SPELL_THROW_GLAIVE.raw());
}

fn screaming_brutality_on_blade_dance(ctx: &mut HookCtx<'_>, cfg: &HavocConfig) {
    if !cfg.screaming_brutality {
        return;
    }

    if throw_glaive_cd_ready(ctx) {
        consume_throw_glaive_cd(ctx);
        apply_serrated_glaive(ctx);
        ctx.deal_effect_damage_ap(
            EFFECT::THROW_GLAIVE_DAMAGE,
            cfg.sb_full_pct,
            DamageFlags::PHYSICAL,
        );

        if cfg.furious_throws {
            ctx.deal_effect_damage_ap(
                EFFECT::FURIOUS_THROWS_DAMAGE,
                cfg.sb_full_pct,
                DamageFlags::PHYSICAL,
            );
        }
    }

    for _ in 0..=BLADE_DANCE_SLASHES {
        if proc_chance(ctx.rng(), cfg.sb_slash_chance) {
            apply_serrated_glaive(ctx);
            ctx.deal_effect_damage_ap(
                EFFECT::THROW_GLAIVE_DAMAGE,
                cfg.sb_slash_pct,
                DamageFlags::PHYSICAL,
            );

            if cfg.furious_throws {
                ctx.deal_effect_damage_ap(
                    EFFECT::FURIOUS_THROWS_DAMAGE,
                    cfg.sb_slash_pct,
                    DamageFlags::PHYSICAL,
                );
            }
        }
    }
}

pub(crate) fn blade_dance_hook(ctx: &mut HookCtx<'_>) {
    let cfg = havoc_config(ctx);

    screaming_brutality_on_blade_dance(ctx, &cfg);

    if cfg.first_blood {
        let mult = 1.0 + ctx.game_data().effect_base_points(EFFECT::FIRST_BLOOD_MULT) / HUNDRED;

        for _ in 0..BLADE_DANCE_SLASHES {
            ctx.deal_effect_damage_ap(EFFECT::FIRST_BLOOD_HIT, mult, DamageFlags::empty());
        }

        ctx.deal_effect_damage_ap(EFFECT::FIRST_BLOOD_FINAL, mult, DamageFlags::empty());
    } else {
        for _ in 0..BLADE_DANCE_SLASHES {
            ctx.deal_effect_damage_ap(EFFECT::BLADE_DANCE_HIT, 1.0, DamageFlags::PHYSICAL);
        }

        ctx.deal_effect_damage_ap(EFFECT::BLADE_DANCE_FINAL, 1.0, DamageFlags::PHYSICAL);
    }
}

pub(crate) fn death_sweep_hook(ctx: &mut HookCtx<'_>) {
    let cfg = havoc_config(ctx);

    screaming_brutality_on_blade_dance(ctx, &cfg);

    if cfg.first_blood {
        let mult = 1.0 + ctx.game_data().effect_base_points(EFFECT::FIRST_BLOOD_MULT) / HUNDRED;

        for _ in 0..BLADE_DANCE_SLASHES {
            ctx.deal_effect_damage_ap(
                EFFECT::DEATH_SWEEP_FIRST_BLOOD_HIT,
                mult,
                DamageFlags::empty(),
            );
        }

        ctx.deal_effect_damage_ap(
            EFFECT::DEATH_SWEEP_FIRST_BLOOD_FINAL,
            mult,
            DamageFlags::empty(),
        );
    }

    trigger_demonsurge(
        ctx,
        DemonsurgeAbilities::DEATH_SWEEP,
        DEMONSURGE_DEATH_SWEEP_DELAY_MS,
    );
}

fn eye_beam_channel_ms(ctx: &HookCtx<'_>) -> u32 {
    let remaining_s = (ctx.buf().player().channel_end - ctx.now().as_secs_f64()).max(0.0);

    wowlab_types::numeric::f64_to_u32_saturating_round(remaining_s * MS_PER_SECOND)
}

fn trigger_demonic(ctx: &mut HookCtx<'_>, cfg: &HavocConfig) {
    if !cfg.demonic {
        return;
    }

    if cfg.demonsurge {
        if let Some(runtime) = ctx.spec_runtime_mut::<HavocRuntime>() {
            runtime
                .demonsurge_available
                .insert(DemonsurgeAbilities::DEMONIC);
        }
    }

    let total_ms = cfg.demonic_extension_ms + eye_beam_channel_ms(ctx);

    if ctx.is_aura_active(AURA_METAMORPHOSIS.raw()) {
        ctx.extend_aura(AURA_METAMORPHOSIS.raw(), total_ms);
    } else {
        ctx.apply_aura(AURA_METAMORPHOSIS.raw());
        ctx.reduce_aura(
            AURA_METAMORPHOSIS.raw(),
            META_BASE_MS.saturating_sub(total_ms),
        );
    }
}

fn furious_gaze_apply_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_FURIOUS_GAZE.raw());
}

fn empowered_eye_beam_expire_hook(ctx: &mut HookCtx<'_>) {
    ctx.expire_aura(AURA_EMPOWERED_EYE_BEAM.raw());
}

pub(crate) fn eye_beam_hook(ctx: &mut HookCtx<'_>) {
    let cfg = havoc_config(ctx);

    if cfg.student_of_suffering {
        ctx.apply_aura(AURA_STUDENT_OF_SUFFERING.raw());
    }

    trigger_demonic(ctx, &cfg);

    if cfg.cycle_of_hatred {
        // The cooldown starts before the Cycle of Hatred stack increments.
        let stacks = ctx.aura_stacks(AURA_CYCLE_OF_HATRED.raw()).max(0);

        if stacks > 0 {
            ctx.reduce_cooldown(
                SPELL_EYE_BEAM.raw(),
                cfg.cycle_of_hatred_cdr_ms * wowlab_types::numeric::i32_to_u32_nonnegative(stacks),
            );
        }

        ctx.apply_aura(AURA_CYCLE_OF_HATRED.raw());
    }

    if cfg.furious_gaze {
        let channel_ms = eye_beam_channel_ms(ctx);

        ctx.schedule_hook(channel_ms, furious_gaze_apply_hook);
    }

    if cfg.eternal_hunt && ctx.is_aura_active(AURA_EMPOWERED_EYE_BEAM.raw()) {
        // One millisecond past the nominal end keeps the marker active for the
        // final channel tick when both events share the same timestamp.
        ctx.schedule_hook(
            eye_beam_channel_ms(ctx).saturating_add(1),
            empowered_eye_beam_expire_hook,
        );
    }
}

pub(crate) fn abyssal_gaze_hook(ctx: &mut HookCtx<'_>) {
    eye_beam_hook(ctx);
    trigger_demonsurge(ctx, DemonsurgeAbilities::ABYSSAL_GAZE, DEMONSURGE_DELAY_MS);
}

pub(crate) fn eye_beam_tick_hook(ctx: &mut HookCtx<'_>) {
    let per_tick = havoc_config(ctx).blind_fury_per_tick;

    if per_tick > 0.0 {
        ctx.gain_resource(per_tick);
    }

    if ctx.is_aura_active(AURA_EMPOWERED_EYE_BEAM.raw()) {
        // 1271144 e1 (+100% on Eye Beam 1287949) is folded by the generic live-aura path,
        // exactly as SimC's parse_effects( buff.empowered_eye_beam ) (sc_demon_hunter.cpp:2175).
        ctx.deal_effect_damage_ap(EFFECT::EMPOWERED_EYE_BEAM_DAMAGE, 1.0, DamageFlags::empty());
    } else {
        ctx.deal_effect_damage_ap(EFFECT::EYE_BEAM_DAMAGE, 1.0, DamageFlags::empty());
    }
}

pub(crate) fn the_hunt_hook(ctx: &mut HookCtx<'_>) {
    if havoc_config(ctx).eternal_hunt {
        ctx.apply_aura(AURA_EMPOWERED_EYE_BEAM.raw());
    }
}

pub(crate) fn metamorphosis_hook(ctx: &mut HookCtx<'_>) {
    let cfg = havoc_config(ctx);

    if cfg.demonsurge {
        if let Some(runtime) = ctx.spec_runtime_mut::<HavocRuntime>() {
            runtime.demonsurge_available = DemonsurgeAbilities::ALL_HARDCAST;
            runtime.demonsurge_stacks = 0;
        }
    }

    if cfg.demonic_intensity {
        ctx.apply_aura(AURA_DEMONIC_INTENSITY.raw());
    }

    if cfg.chaotic_transformation {
        ctx.reset_cooldown(SPELL_EYE_BEAM.raw());
        ctx.reset_cooldown(SPELL_BLADE_DANCE.raw());
    }
}

pub(crate) fn consuming_fire_hook(ctx: &mut HookCtx<'_>) {
    trigger_demonsurge(
        ctx,
        DemonsurgeAbilities::CONSUMING_FIRE,
        DEMONSURGE_DELAY_MS,
    );
}

pub(crate) fn swing_hook(ctx: &mut HookCtx<'_>, _event: SwingEvent) {
    ctx.deal_effect_damage_ap(EFFECT::DEMON_BLADES_DAMAGE, 1.0, DamageFlags::empty());
    let fury = ctx
        .game_data()
        .effect_base_points(EFFECT::DEMON_BLADES_FURY);

    ctx.gain_resource(fury);
}

#[cfg(test)]
mod demonic_presence_mastery_tests {
    use googletest::prelude::*;

    use super::*;
    use wowlab_engine_ports::{CombatStats};
use wowlab_engine_gamedata::{SpellProps};
    use wowlab_types::sim::{EnemyIdx, SimTime};

    use crate::generated::specs::havoc_demon_hunter::REPORTED_SPELL;

    const DEMON_HUNTER_SPELL_FAMILY: i32 = 107;
    const DEMONIC_PRESENCE_PCT: f64 = 34.07;
    const MASTERY_TEST_ROTATION: &str = r#"{"version":1,"name":"presence","variables":{},"actions":[{"type":"wait","seconds":1.0}],"lists":{}}"#;

    /// 185164 e1/e2 list Chaos Strike and Soulscar but not Felblade or Immolation Aura, which are
    /// Chaos and Fire school hits the deleted school match used to give the full mastery bonus.
    #[gtest]
    fn demonic_presence_applies_only_to_its_dbc_affect_list() -> Result<()> {
        let presence = SpellIdx::from_raw(EFFECT::MASTERY_DIRECT_BONUS.0);
        let direct = EFFECT::MASTERY_DIRECT_BONUS.1;
        let periodic = EFFECT::MASTERY_PERIODIC_BONUS.1;
        let mut data = wowlab_engine_gamedata::ResolvedGameData::builder();

        data.insert_spell_props(
            presence,
            SpellProps {
                mastery_affects_points: true,
                ..SpellProps::default()
            },
        );
        data.insert_sp_coef(presence, direct, 1.0);
        data.insert_sp_coef(presence, periodic, 1.0);
        data.insert_spell_class_flags(presence, DEMON_HUNTER_SPELL_FAMILY, [0, 0, 0, 0]);
        data.insert_effect_class_mask(presence, direct, [1, 0, 0, 0]);
        data.insert_effect_class_mask(presence, periodic, [1, 0, 0, 0]);

        for (spells, mask) in [
            (
                [
                    REPORTED_SPELL::CHAOS_STRIKE_DAMAGE_1,
                    REPORTED_SPELL::SOULSCAR,
                ],
                [1, 0, 0, 0],
            ),
            (
                [
                    REPORTED_SPELL::FELBLADE_DAMAGE,
                    REPORTED_SPELL::IMMOLATION_AURA_DAMAGE,
                ],
                [2, 0, 0, 0],
            ),
        ] {
            for spell in spells {
                data.insert_spell_class_flags(
                    SpellIdx::from_raw(spell),
                    DEMON_HUNTER_SPELL_FAMILY,
                    mask,
                );
            }
        }

        let built = crate::test_combat_builder(CombatStats::default())
            .game_data(data.build())
            .mastery_spell(EFFECT::MASTERY_DIRECT_BONUS.0)
            .mastery_hook(mastery)
            .spell("felblade", SPELL::FELBLADE, Ok)
            .build(crate::test_support::rotation_from_json(MASTERY_TEST_ROTATION))
            .or_fail()?;
        let bonus = |spell_id: u32, is_periodic: bool| {
            mastery(&MasteryCtx {
                state: &built.state,
                buf: &built.buffer,
                spell_id,
                school: wowlab_types::combat::DamageSchool::Chaos,
                mastery: DEMONIC_PRESENCE_PCT,
                player_crit_pct: 0.0,
                mastery_spell: presence,
                is_periodic,
                is_pet: false,
                source: wowlab_types::sim::ActorId::Player,
                target: Some(EnemyIdx::PRIMARY),
                now: SimTime::ZERO,
            })
        };
        let listed = 1.0 + DEMONIC_PRESENCE_PCT / HUNDRED;

        verify_that!(
            bonus(REPORTED_SPELL::CHAOS_STRIKE_DAMAGE_1, false),
            near(listed, 1e-12)
        )?;
        verify_that!(bonus(REPORTED_SPELL::SOULSCAR, true), near(listed, 1e-12))?;

        for spell in [
            REPORTED_SPELL::FELBLADE_DAMAGE,
            REPORTED_SPELL::IMMOLATION_AURA_DAMAGE,
        ] {
            verify_that!(bonus(spell, false), near(1.0, 1e-12))?;
        }

        Ok(())
    }
}

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