wowlab_engine_content/hooks/beast_mastery_hunter/

hooks.rs

use wowlab_engine_combat::{
    AuraOps as _, CooldownOps as _, DamageFlags, DamageOps as _, HookCtx, ImpactEvent, MasteryCtx,
    ResourceOps as _, SwingEvent, SwingHand,
};
use wowlab_engine_rng::proc_chance;
use wowlab_types::constants::HUNDRED;

use super::config::BeastMasteryConfig;
use crate::{
    generated::specs::beast_mastery_hunter::{
        AURA, AURA_BARBED_SHOT_REGEN, AURA_BEAR_ACTIVE, AURA_BEAR_READY, AURA_BEAST_CLEAVE,
        AURA_BLOODSHED_DOT, AURA_BLOODY_FRENZY, AURA_BOAR_READY, AURA_COBRA_FANG,
        AURA_DIRE_BEAST_ACTIVE, AURA_HOWL_COOLDOWN, AURA_HUNTMASTERS_CALL, AURA_NATURES_ALLY,
        AURA_NATURES_ALLY_KILL_COMMAND, AURA_REND_FLESH, AURA_WYVERN_READY, AURA_WYVERNS_CRY,
        DAMAGE_EFFECT as MID2_DAMAGE_EFFECT, DAMAGE_REPORTED as MID2_DAMAGE_REPORTED, HERO,
        SPELL_BARBED_SHOT, SPELL_KILL_COMMAND,
    },
    hooks::shared::hunter::{PackLeaderHowl, apply_next_howl_ready, consume_howl},
};

/// Stable pets inherit 0.6 owner AP.
const STABLE_PET_AP: f64 = 0.6;

/// Dire beasts inherit 1.0 owner AP.
const DIRE_BEAST_AP: f64 = 1.0;

/// Fenryr and Hati inherit 2.0 owner AP.
const CALL_PET_AP: f64 = 2.0;
const PET_SWING_MS: u32 = 2_000;
const BEAR_SWING_MS: u32 = 1_500;

/// Spell 267116 supplies two permanent pets without a damage penalty.
const PERMANENT_PETS: usize = 2;

/// War Orders 393933 e3 reduces Kill Command cooldown by three seconds.
const WAR_ORDERS_KC_CDR_MS: u32 = 3_000;

/// Fenryr/Hati melee swings over their 10s summon.
const CALL_PET_SWINGS: f64 = 5.0;

/// Fenryr's Ravenous Leap: 8 x 1s ticks (459753).
const RAVENOUS_LEAP_TICKS: f64 = 8.0;

/// Huntmaster's Call 459731 requires three stacks.
const HUNTMASTERS_CALL_CAP: i32 = 3;

/// Huntmaster's Call selects Fenryr or Hati with equal probability.
const FENRYR_CHANCE: f64 = 0.5;

/// Stampede 201594 deals eight ticks of three hits.
const STAMPEDE_HITS: f64 = 24.0;

/// Bear summons deal ten seconds of 1.5-second swings at a 7x multiplier.
const BEAR_SWINGS: f64 = 6.7;
const BEAR_AUTO_MULT: f64 = 7.0;

/// Ursine Fury: bear summon spawns 2 dire beasts (472476 e1).
const URSINE_FURY_DIRE_BEASTS: i64 = 2;

/// Master of Beasts 76657: the "shots and traps" direct and periodic effects.
const MASTERY_SHOTS_DIRECT: u8 = 5;
const MASTERY_SHOTS_PERIODIC: u8 = 6;

/// Returns Master of Beasts mastery damage: 76657 e1 for pets, e5/e6 for the hunter's own shots.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    if ctx.is_pet
        || ctx.spell_id == HERO::BM_PETS::SPELL::BLOODSHED
        || ctx.spell_id == AURA::REND_FLESH
    {
        return ctx.bonus(1);
    }

    // "and the damage of your shots and traps by $s5.1%" — e5/e6 carry their own
    // affect list at half the pet coefficient, and base points of 0, so the static
    // fold resolves them to nothing and only the live mastery value supplies them.

    if ctx.is_periodic {
        ctx.affected_spell_bonus(MASTERY_SHOTS_PERIODIC)
    } else {
        ctx.affected_spell_bonus(MASTERY_SHOTS_DIRECT)
    }
}

fn pet_mult(ctx: &HookCtx<'_>) -> f64 {
    let cry = f64::from(ctx.aura_stacks(AURA_WYVERNS_CRY));

    1.0 + cry
        * ctx.effect_percent(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WYVERNS_CRY_PCT,
        )
}

fn stable_pets(ctx: &HookCtx<'_>) -> usize {
    if ctx.is_aura_active(AURA_NATURES_ALLY) {
        PERMANENT_PETS + 1
    } else {
        PERMANENT_PETS
    }
}

fn advance_howl_cycle(ctx: &mut HookCtx<'_>) {
    if ctx.is_aura_active(AURA_HOWL_COOLDOWN) {
        return;
    }

    let ready_up = ctx.is_aura_active(AURA_WYVERN_READY)
        || ctx.is_aura_active(AURA_BOAR_READY)
        || ctx.is_aura_active(AURA_BEAR_READY);

    if ready_up {
        return;
    }

    apply_next_howl_ready(
        ctx,
        wowlab_engine_combat::generated_identities::proc_counter::BEAST_MASTERY_HOWL,
        [AURA_WYVERN_READY, AURA_BOAR_READY, AURA_BEAR_READY],
    );
    ctx.apply_aura(AURA_HOWL_COOLDOWN);
}

/// Whole melee swings a temporary beast lands over `duration_ms`, counting the one it opens with.
///
/// A summon lands one opening swing plus every whole hasted swing period that fits in its window.
/// Guardian autos inherit the owner's haste.
fn temporary_pet_swings(ctx: &HookCtx<'_>, duration_ms: u32, swing_ms: u32) -> f64 {
    let hasted_swing_ms = f64::from(swing_ms) / (1.0 + ctx.buf().player().haste / HUNDRED);

    if hasted_swing_ms <= 0.0 {
        return 1.0;
    }

    1.0 + (f64::from(duration_ms) / hasted_swing_ms).floor()
}

fn summon_dire_beast(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_DIRE_BEAST_ACTIVE);

    let duration_ms = ctx.action_aura_duration_ms(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_AURA::DIRE_BEAST_ACTIVE,
    );
    // Temporary-pet melee is collapsed to summon time.
    let melee = DIRE_BEAST_AP
        * wowlab_engine_domain::damage::pet_swing_ap(PET_SWING_MS)
        * temporary_pet_swings(ctx, duration_ms, PET_SWING_MS)
        * pet_mult(ctx);

    ctx.deal_physical_pet_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::MELEE,
        melee,
    );
    trigger_huntmasters_call(ctx);
}

pub(crate) fn dire_beast_proc(ctx: &mut HookCtx<'_>, _impact: ImpactEvent) {
    summon_dire_beast(ctx);
}

// Temporary-pet melee and Ravenous Leap are collapsed to summon time.
fn trigger_huntmasters_call(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_HUNTMASTERS_CALL);

    if ctx.aura_stacks(AURA_HUNTMASTERS_CALL) < HUNTMASTERS_CALL_CAP {
        return;
    }

    ctx.expire_aura(AURA_HUNTMASTERS_CALL);
    let mult = pet_mult(ctx);
    let melee = CALL_PET_AP
        * wowlab_engine_domain::damage::pet_swing_ap(PET_SWING_MS)
        * CALL_PET_SWINGS
        * mult;

    ctx.deal_physical_pet_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::MELEE,
        melee,
    );

    if proc_chance(ctx.rng(), FENRYR_CHANCE) {
        let leap = ctx.effect_ap_coefficient(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::RAVENOUS_LEAP,
        ) * CALL_PET_AP
            * RAVENOUS_LEAP_TICKS
            * mult;

        ctx.deal_physical_pet_damage_ap(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::RAVENOUS_LEAP,
            leap,
        );
    }
}

fn howl_wyvern(ctx: &mut HookCtx<'_>) {
    let stacks = ctx.effect_base_points(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::HOWL_WYVERN_STACKS,
    );

    ctx.apply_aura_n(
        AURA_WYVERNS_CRY,
        wowlab_types::numeric::f64_to_i32_saturating_trunc(stacks),
    );
}

fn howl_boar(ctx: &mut HookCtx<'_>) {
    let mult = pet_mult(ctx);

    ctx.deal_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::BOAR_CHARGE,
        ctx.effect_ap_coefficient(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::BOAR_CHARGE,
        ) * mult,
        DamageFlags::PHYSICAL,
    );
    ctx.deal_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::BOAR_CHARGE_CLEAVE,
        ctx.effect_ap_coefficient(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::BOAR_CHARGE_CLEAVE,
        ) * mult,
        DamageFlags::PHYSICAL,
    );
}

fn howl_bear(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_BEAR_ACTIVE);
    ctx.apply_aura(AURA_REND_FLESH);
    let bear_melee = STABLE_PET_AP
        * wowlab_engine_domain::damage::pet_swing_ap(BEAR_SWING_MS)
        * BEAR_AUTO_MULT
        * BEAR_SWINGS
        * pet_mult(ctx);

    ctx.deal_physical_pet_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::MELEE,
        bear_melee,
    );

    for _ in 0..URSINE_FURY_DIRE_BEASTS {
        summon_dire_beast(ctx);
    }
}

fn howl_consumed(ctx: &mut HookCtx<'_>) {
    let cdr_ms = ctx.effect_base_points(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::PACK_MENTALITY_BARBED_CDR,
    );

    ctx.reduce_cooldown(
        SPELL_BARBED_SHOT,
        wowlab_types::numeric::f64_to_u32_saturating_trunc(cdr_ms),
    );
}

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

    let howl_ready = ctx.is_aura_active(AURA_WYVERN_READY)
        || ctx.is_aura_active(AURA_BOAR_READY)
        || ctx.is_aura_active(AURA_BEAR_READY);

    let mut bonus = ctx.effect_percent(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::ALPHA_PREDATOR_KC_PCT,
    );

    if howl_ready {
        bonus += ctx.effect_percent(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::PACK_MENTALITY_KC_PCT,
        );
    }

    let kc_coef = ctx.effect_ap_coefficient(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::KC_PET_DAMAGE,
    ) * STABLE_PET_AP
        * (1.0 + bonus)
        * pet_mult(ctx);

    for _ in 0..stable_pets(ctx) {
        ctx.deal_physical_pet_damage_ap(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::KILL_COMMAND_PET,
            kc_coef,
        );
    }

    let ws_coef = ctx.effect_ap_coefficient(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WILDSPEAKER_KC,
    ) * DIRE_BEAST_AP
        * pet_mult(ctx);

    for _ in 0..ctx.aura_stacks(AURA_DIRE_BEAST_ACTIVE) {
        ctx.deal_physical_pet_damage_ap(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::WILDSPEAKER_KILL_COMMAND,
            ws_coef,
        );
    }

    consume_howl(
        ctx,
        PackLeaderHowl {
            wyvern_ready: AURA_WYVERN_READY,
            boar_ready: AURA_BOAR_READY,
            bear_ready: AURA_BEAR_READY,
            on_wyvern: howl_wyvern,
            on_boar: howl_boar,
            on_bear: howl_bear,
            on_consumed: howl_consumed,
            consume_all: false,
        },
    );

    let dire_command_chance = ctx.effect_percent(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::DIRE_COMMAND_PCT,
    );

    if proc_chance(ctx.rng(), dire_command_chance) {
        summon_dire_beast(ctx);
    }

    ctx.expire_aura(AURA_NATURES_ALLY_KILL_COMMAND);
}

pub(crate) fn barbed_shot_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_BARBED_SHOT_REGEN);
    ctx.apply_aura(AURA_NATURES_ALLY_KILL_COMMAND);
    let pack_tactics_focus = ctx.effect_base_points(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::PACK_TACTICS_FOCUS,
    );

    ctx.gain_resource(pack_tactics_focus);
    let stomp = ctx.effect_ap_coefficient(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::STOMP_DAMAGE,
    ) * STABLE_PET_AP
        * pet_mult(ctx);

    let cfg = ctx
        .spec_config::<BeastMasteryConfig>()
        .copied()
        .unwrap_or_default();

    for _ in 0..stable_pets(ctx) {
        trigger_stomp(ctx, stomp, cfg.mid2_cobra_fang);

        if cfg.mid2_extra_stomp_mult > 0.0 {
            trigger_stomp(ctx, stomp * cfg.mid2_extra_stomp_mult, cfg.mid2_cobra_fang);
        }
    }

    ctx.reduce_cooldown(SPELL_KILL_COMMAND, WAR_ORDERS_KC_CDR_MS);
}

pub(crate) fn bestial_wrath_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_NATURES_ALLY);

    if ctx.talent_selected(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_TALENT::BLOODY_FRENZY,
    ) {
        ctx.apply_aura(AURA_BLOODY_FRENZY);
    }

    let mult = pet_mult(ctx);
    let bw_hit = ctx.effect_ap_coefficient(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::PET_BW_DAMAGE,
    ) * STABLE_PET_AP
        * mult;
    let hooves = ctx.effect_ap_coefficient(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::STOMP_DAMAGE,
    ) * (1.0
        + ctx.effect_percent(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::THUNDERING_HOOVES_PCT,
        ))
        * STABLE_PET_AP
        * mult;

    for _ in 0..stable_pets(ctx) {
        ctx.deal_physical_pet_damage_ap(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::PET_BESTIAL_WRATH,
            bw_hit,
        );

        let cobra_fang = ctx
            .spec_config::<BeastMasteryConfig>()
            .is_some_and(|cfg| cfg.mid2_cobra_fang);

        trigger_stomp(ctx, hooves, cobra_fang);
    }

    ctx.apply_aura(AURA_BLOODSHED_DOT);
    ctx.grant_charges(SPELL_BARBED_SHOT, 1);

    // Stampede is collapsed to the Bestial Wrath cast.
    ctx.deal_effect_damage_ap_with_geometry(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::STAMPEDE_DAMAGE,
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::STAMPEDE_GEOMETRY,
        STAMPEDE_HITS,
        DamageFlags::PHYSICAL,
    );
}

/// Executes each stable pet's Wild Thrash and enables Beast Cleave.
pub(crate) fn wild_thrash_hook(ctx: &mut HookCtx<'_>) {
    let target_count = ctx.with_resolved_spell_effect_targets(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WILD_THRASH_DAMAGE,
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WILD_THRASH_DAMAGE.action(),
        None,
        |_ctx, targets| targets.len(),
    );
    let damage_mult = wild_thrash_target_multiplier(
        target_count,
        ctx.effect_base_points(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WILD_THRASH_THRESHOLD,
        ),
        ctx.effect_percent(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WILD_THRASH_BONUS,
        ),
    );

    for _ in 0..stable_pets(ctx) {
        ctx.deal_effect_damage_ap(
            crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::WILD_THRASH_DAMAGE,
            STABLE_PET_AP * pet_mult(ctx) * damage_mult,
            DamageFlags::PHYSICAL | DamageFlags::PET,
        );
    }

    let duration_ms = wowlab_types::numeric::f64_to_u32_saturating_trunc(ctx.effect_base_points(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_EFFECT::BEAST_CLEAVE_DURATION,
    ));

    ctx.apply_aura_with_duration(AURA_BEAST_CLEAVE, duration_ms);
}

fn wild_thrash_target_multiplier(target_count: usize, threshold: f64, bonus: f64) -> f64 {
    let target_count = f64::from(u32::try_from(target_count).unwrap_or(u32::MAX));

    if target_count >= threshold {
        1.0 + bonus
    } else {
        1.0
    }
}

pub(crate) fn cobra_shot_hook(ctx: &mut HookCtx<'_>) {
    const BARBED_SCALES_CDR_MS: u32 = 2_000;
    ctx.reduce_cooldown(SPELL_BARBED_SHOT, BARBED_SCALES_CDR_MS);
    ctx.apply_aura(AURA_NATURES_ALLY_KILL_COMMAND);

    let cfg = ctx
        .spec_config::<BeastMasteryConfig>()
        .copied()
        .unwrap_or_default();
    let coefficient = ctx.effect_ap_coefficient(MID2_DAMAGE_EFFECT::COBRA_SHOT_DAMAGE);
    let stacks = ctx.aura_stacks(AURA_COBRA_FANG);

    ctx.deal_damage_ap(
        MID2_DAMAGE_EFFECT::COBRA_SHOT_DAMAGE.action(),
        if stacks > 0 && !ctx.is_aura_active(AURA_BEAST_CLEAVE) {
            coefficient * (1.0 + f64::from(stacks) * cfg.cobra_fang_primary_per_stack)
        } else {
            coefficient
        },
        DamageFlags::empty(),
    );

    if stacks <= 0 {
        return;
    }

    let stacks = f64::from(stacks);

    if ctx.is_aura_active(AURA_BEAST_CLEAVE) {
        let primary = ctx.target();

        ctx.with_resolved_spell_effect_targets(
            MID2_DAMAGE_EFFECT::COBRA_CLEAVE_GEOMETRY,
            MID2_DAMAGE_REPORTED::COBRA_CLEAVE,
            None,
            |ctx, targets| {
                for target in targets
                    .iter()
                    .copied()
                    .filter(|target| Some(*target) != primary)
                {
                    ctx.deal_damage_ap_to_target(
                        target,
                        MID2_DAMAGE_REPORTED::COBRA_CLEAVE,
                        coefficient * stacks * cfg.cobra_fang_cleave_per_stack,
                        DamageFlags::empty(),
                    );
                }
            },
        );
    }

    ctx.expire_aura(AURA_COBRA_FANG);
}

fn trigger_stomp(ctx: &mut HookCtx<'_>, coefficient: f64, cobra_fang: bool) {
    ctx.deal_physical_pet_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::STOMP,
        coefficient,
    );

    if cobra_fang {
        ctx.apply_aura(AURA_COBRA_FANG);
    }
}

/// Claw 16827 uses 0.75 pet AP at 0.88 casts per two-second swing window.
const CLAW_COEF: f64 = 0.75;
const CLAWS_PER_SWING: f64 = 0.88;

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

    if hand == SwingHand::OffHand {
        return;
    }

    let mult = pet_mult(ctx);
    let extra_pets = stable_pets(ctx) - 1;
    let swing = STABLE_PET_AP
        * wowlab_engine_domain::damage::pet_swing_ap(PET_SWING_MS)
        * mult
        * wowlab_types::numeric::usize_to_f64(extra_pets);

    ctx.deal_physical_pet_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::MELEE,
        swing,
    );

    let claw = STABLE_PET_AP
        * CLAW_COEF
        * CLAWS_PER_SWING
        * mult
        * wowlab_types::numeric::usize_to_f64(stable_pets(ctx));

    ctx.deal_physical_pet_damage_ap(
        crate::generated::specs::beast_mastery_hunter::DAMAGE_SPELL::CLAW,
        claw,
    );
}

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

    use super::wild_thrash_target_multiplier;

    #[gtest]
    #[rstest::rstest]
    #[case::below_threshold(1, 2.0, 2.0, 1.0)]
    #[case::at_threshold(2, 2.0, 2.0, 3.0)]
    #[case::above_threshold(5, 2.0, 2.0, 3.0)]
    fn wild_thrash_bonus_uses_resolved_target_count(
        #[case] target_count: usize,
        #[case] threshold: f64,
        #[case] bonus: f64,
        #[case] expected: f64,
    ) -> Result<()> {
        verify_that!(
            wild_thrash_target_multiplier(target_count, threshold, bonus),
            eq(expected)
        )
    }
}