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_types::{constants::HUNDRED, constants::MS_PER_SECOND};

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_BLADE_DANCE, SPELL_ESSENCE_BREAK, 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;
/// Cycle cross-reduction applies only while the pre-increment stack is below four.
const CYCLE_CROSS_REDUCTION_MAX_STACKS: u32 = 4;

/// Returns Demonic Presence mastery damage.
///
/// 185164 e1 (direct) and e2 (periodic) each ship their own 36-spell affect list.
#[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);
    }
}

pub(crate) fn chaos_strike_hook(ctx: &mut HookCtx<'_>) {
    apply_serrated_glaive(ctx);
    let refund_chance = ctx.action_proc_chance(
        crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::CHAOS_STRIKE_REFUND_PROC
            .action(),
    );

    if proc_chance(ctx.rng(), refund_chance) {
        let refund = ctx.effect_base_points(crate::generated::specs::havoc_demon_hunter::DAMAGE_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(crate::generated::specs::havoc_demon_hunter::DAMAGE_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(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::FURIOUS_THROWS_DAMAGE, 1.0, DamageFlags::PHYSICAL);
    }
}

fn throw_glaive_cd_ready(ctx: &HookCtx<'_>) -> bool {
    ctx.spell_ready(SPELL_THROW_GLAIVE)
}

// 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);
}

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(
            crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::THROW_GLAIVE_DAMAGE,
            cfg.sb_full_pct,
            DamageFlags::PHYSICAL,
        );

        if cfg.furious_throws {
            ctx.deal_effect_damage_ap(
                crate::generated::specs::havoc_demon_hunter::DAMAGE_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(
                crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::THROW_GLAIVE_DAMAGE,
                cfg.sb_slash_pct,
                DamageFlags::PHYSICAL,
            );

            if cfg.furious_throws {
                ctx.deal_effect_damage_ap(
                    crate::generated::specs::havoc_demon_hunter::DAMAGE_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.effect_base_points(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::FIRST_BLOOD_MULT) / HUNDRED;

        for _ in 0..BLADE_DANCE_SLASHES {
            ctx.deal_effect_damage_ap(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::FIRST_BLOOD_HIT, mult, DamageFlags::empty());
        }

        ctx.deal_effect_damage_ap(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::FIRST_BLOOD_FINAL, mult, DamageFlags::empty());
    } else {
        for _ in 0..BLADE_DANCE_SLASHES {
            ctx.deal_effect_damage_ap(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::BLADE_DANCE_HIT, 1.0, DamageFlags::PHYSICAL);
        }

        ctx.deal_effect_damage_ap(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::BLADE_DANCE_FINAL, 1.0, DamageFlags::PHYSICAL);
    }

    trigger_trail_of_ruin(ctx, &cfg);
}

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.effect_base_points(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::FIRST_BLOOD_MULT) / HUNDRED;

        for _ in 0..BLADE_DANCE_SLASHES {
            ctx.deal_effect_damage_ap(
                crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::DEATH_SWEEP_FIRST_BLOOD_HIT,
                mult,
                DamageFlags::empty(),
            );
        }

        ctx.deal_effect_damage_ap(
            crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::DEATH_SWEEP_FIRST_BLOOD_FINAL,
            mult,
            DamageFlags::empty(),
        );
    }

    trigger_trail_of_ruin(ctx, &cfg);

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

fn trigger_trail_of_ruin(ctx: &mut HookCtx<'_>, cfg: &HavocConfig) {
    if cfg.trail_of_ruin {
        ctx.deal_effect_damage_ap(
            crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::TRAIL_OF_RUIN_DAMAGE,
            1.0,
            DamageFlags::empty(),
        );
    }
}

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
        && 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) {
        ctx.extend_aura(AURA_METAMORPHOSIS, total_ms);
    } else {
        ctx.apply_aura(AURA_METAMORPHOSIS);
        ctx.reduce_aura(
            AURA_METAMORPHOSIS,
            META_BASE_MS.saturating_sub(total_ms),
        );
    }
}

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

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

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);
    }

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

        if stacks > 0 {
            let stacks = wowlab_types::numeric::i32_to_u32_nonnegative(stacks);

            ctx.reduce_cooldown(
                SPELL_EYE_BEAM,
                cfg.cycle_of_hatred_cdr_ms * stacks,
            );

            if cfg.mid2_4pc && stacks < CYCLE_CROSS_REDUCTION_MAX_STACKS {
                ctx.reduce_cooldown(SPELL_ESSENCE_BREAK, cfg.cycle_of_hatred_cdr_ms);
            }
        }

        ctx.apply_aura(AURA_CYCLE_OF_HATRED);
    }

    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) {
        // 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 essence_break_hook(ctx: &mut HookCtx<'_>) {
    let cfg = havoc_config(ctx);

    if !cfg.mid2_4pc || !cfg.cycle_of_hatred {
        return;
    }

    // Both reductions use the pre-increment Cycle stack. The cross-reduction
    // stops once the fourth stack exists.

    let stacks = wowlab_types::numeric::i32_to_u32_nonnegative(
        ctx.aura_stacks(AURA_CYCLE_OF_HATRED).max(0),
    );

    if stacks > 0 {
        ctx.reduce_cooldown(
            SPELL_ESSENCE_BREAK,
            cfg.cycle_of_hatred_cdr_ms * stacks,
        );

        if stacks < CYCLE_CROSS_REDUCTION_MAX_STACKS {
            ctx.reduce_cooldown(SPELL_EYE_BEAM, cfg.cycle_of_hatred_cdr_ms);
        }
    }

    ctx.apply_aura(AURA_CYCLE_OF_HATRED);
}

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) {
        // 1271144 e1 (+100% on Eye Beam 1287949) is folded by the generic live-aura path.
        ctx.deal_effect_damage_ap(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::EMPOWERED_EYE_BEAM_DAMAGE, 1.0, DamageFlags::empty());
    } else {
        ctx.deal_effect_damage_ap(crate::generated::specs::havoc_demon_hunter::DAMAGE_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);
    }
}

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

    if cfg.demonsurge
        && 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);
    }

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

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(crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::DEMON_BLADES_DAMAGE, 1.0, DamageFlags::empty());
    let fury = ctx.effect_base_points(crate::generated::specs::havoc_demon_hunter::DAMAGE_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, SpellIdx};

    use crate::generated::specs::havoc_demon_hunter::{REPORTED_SPELL, 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_for(wowlab_engine_combat::generated_identities::specs::havoc_demon_hunter::PROOF, CombatStats::default())
            .game_data(data.build())
            .effect_identities(wowlab_engine_combat::generated_identities::specs::havoc_demon_hunter::damage::ALL)
            .mastery_spell(EFFECT::MASTERY_DIRECT_BONUS.0)
            .mastery_hook(mastery)
            .spell("felblade", SPELL::FELBLADE, Ok)
            .into_draft().expect("valid combat draft").finalize(&crate::test_support::rotation_from_json(MASTERY_TEST_ROTATION))
            .or_fail()?;
        let bonus = |action, is_periodic: bool| {
            mastery(
                &MasteryCtx::new(
                    &built.program,
                    &built.instance,
                    wowlab_engine_combat::MasteryEvent {
                        action,
                        school: wowlab_types::combat::DamageSchool::Chaos,
                        mastery: DEMONIC_PRESENCE_PCT,
                        player_crit_pct: 0.0,
                        mastery_action: crate::generated::specs::havoc_demon_hunter::DAMAGE_EFFECT::MASTERY_DIRECT_BONUS.action(),
                        is_periodic,
                        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 + DEMONIC_PRESENCE_PCT / HUNDRED;

        verify_that!(
            bonus(
                crate::generated::specs::havoc_demon_hunter::DAMAGE_REPORTED::CHAOS_STRIKE_DAMAGE_1,
                false,
            ),
            near(listed, 1e-12)
        )?;
        verify_that!(
            bonus(
                crate::generated::specs::havoc_demon_hunter::DAMAGE_REPORTED::SOULSCAR,
                true,
            ),
            near(listed, 1e-12)
        )?;

        for action in [
            crate::generated::specs::havoc_demon_hunter::DAMAGE_REPORTED::FELBLADE_DAMAGE,
            crate::generated::specs::havoc_demon_hunter::DAMAGE_REPORTED::IMMOLATION_AURA_DAMAGE,
        ] {
            verify_that!(bonus(action, false), near(1.0, 1e-12))?;
        }

        Ok(())
    }
}

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