wowlab_engine_content/hooks/beast_mastery_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::AuraOps as _;
use wowlab_engine_domain::dbc::ResolvedGameDataEffectExt as _;
use wowlab_types::{constants::HUNDRED, sim::SpellIdx};

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_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, EFFECT, HERO, SPELL_BARBED_SHOT,
    SPELL_KILL_COMMAND, TALENT,
};
use crate::hooks::shared::hunter::{PackLeaderHowl, apply_next_howl_ready, consume_howl};
use wowlab_engine_combat::{DamageFlags, HookCtx, ImpactEvent, MasteryCtx, SwingEvent, SwingHand};
use wowlab_engine_rng::proc_chance;

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

    1.0 + cry * ctx.effect_percent(EFFECT::WYVERNS_CRY_PCT)
}

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

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

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

    if ready_up {
        return;
    }

    apply_next_howl_ready(
        ctx,
        AURA::HOWL_COOLDOWN,
        [AURA_WYVERN_READY, AURA_BOAR_READY, AURA_BEAR_READY],
    );
    ctx.apply_aura(AURA_HOWL_COOLDOWN.raw());
}

/// 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.
///   `SimC` fires `main_hand_attack->execute()` inside `dire_critter_t::summon` and the pet
///   despawns when that window ends (`sc_hunter.cpp:1874-1893`).
///   Guardian autos inherit the owner's haste (`hunter_t::composite_melee_auto_attack_speed`).
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.raw());

    let duration_ms = ctx
        .game_data()
        .aura_duration_ms(SpellIdx::from_raw(AURA::DIRE_BEAST_ACTIVE))
        .unwrap_or_default();
    // 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(HERO::BM_PETS::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.raw());

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

    ctx.expire_aura(AURA_HUNTMASTERS_CALL.raw());
    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(HERO::BM_PETS::SPELL::MELEE, melee);

    if proc_chance(ctx.rng(), FENRYR_CHANCE) {
        let leap = ctx.effect_ap_coefficient(EFFECT::RAVENOUS_LEAP)
            * CALL_PET_AP
            * RAVENOUS_LEAP_TICKS
            * mult;

        ctx.deal_physical_pet_damage_ap(HERO::BM_PETS::SPELL::RAVENOUS_LEAP, leap);
    }
}

fn howl_wyvern(ctx: &mut HookCtx<'_>) {
    let stacks = ctx
        .game_data()
        .effect_base_points(EFFECT::HOWL_WYVERN_STACKS);

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

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

    ctx.deal_damage_ap(
        HERO::PACK_LEADER::SPELL::BOAR_CHARGE,
        ctx.effect_ap_coefficient(EFFECT::BOAR_CHARGE) * mult,
        DamageFlags::PHYSICAL,
    );
    ctx.deal_damage_ap(
        HERO::PACK_LEADER::SPELL::BOAR_CHARGE_CLEAVE,
        ctx.effect_ap_coefficient(EFFECT::BOAR_CHARGE_CLEAVE) * mult,
        DamageFlags::PHYSICAL,
    );
}

fn howl_bear(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_BEAR_ACTIVE.raw());
    ctx.apply_aura(AURA_REND_FLESH.raw());
    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(HERO::BM_PETS::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
        .game_data()
        .effect_base_points(EFFECT::PACK_MENTALITY_BARBED_CDR);

    ctx.reduce_cooldown(
        SPELL_BARBED_SHOT.raw(),
        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.raw())
        || ctx.is_aura_active(AURA_BOAR_READY.raw())
        || ctx.is_aura_active(AURA_BEAR_READY.raw());

    let mut bonus = ctx.effect_percent(EFFECT::ALPHA_PREDATOR_KC_PCT);

    if howl_ready {
        bonus += ctx.effect_percent(EFFECT::PACK_MENTALITY_KC_PCT);
    }

    let kc_coef = ctx.effect_ap_coefficient(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(HERO::BM_PETS::SPELL::KILL_COMMAND_PET, kc_coef);
    }

    let ws_coef = ctx.effect_ap_coefficient(EFFECT::WILDSPEAKER_KC) * DIRE_BEAST_AP * pet_mult(ctx);

    for _ in 0..ctx.aura_stacks(AURA_DIRE_BEAST_ACTIVE.raw()) {
        ctx.deal_physical_pet_damage_ap(HERO::BM_PETS::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(EFFECT::DIRE_COMMAND_PCT);

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

    ctx.expire_aura(AURA_NATURES_ALLY_KILL_COMMAND.raw());
}

pub(crate) fn barbed_shot_hook(ctx: &mut HookCtx<'_>) {
    ctx.apply_aura(AURA_BARBED_SHOT_REGEN.raw());
    ctx.apply_aura(AURA_NATURES_ALLY_KILL_COMMAND.raw());
    let pack_tactics_focus = ctx
        .game_data()
        .effect_base_points(EFFECT::PACK_TACTICS_FOCUS);

    ctx.gain_resource(pack_tactics_focus);
    let stomp = ctx.effect_ap_coefficient(EFFECT::STOMP_DAMAGE) * STABLE_PET_AP * pet_mult(ctx);

    for _ in 0..stable_pets(ctx) {
        ctx.deal_physical_pet_damage_ap(HERO::BM_PETS::SPELL::STOMP, stomp);
    }

    ctx.reduce_cooldown(SPELL_KILL_COMMAND.raw(), WAR_ORDERS_KC_CDR_MS);
}

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

    if ctx.talent_selected(TALENT::BLOODY_FRENZY) {
        ctx.apply_aura(AURA_BLOODY_FRENZY.raw());
    }

    let mult = pet_mult(ctx);
    let bw_hit = ctx.effect_ap_coefficient(EFFECT::PET_BW_DAMAGE) * STABLE_PET_AP * mult;
    let hooves = ctx.effect_ap_coefficient(EFFECT::STOMP_DAMAGE)
        * (1.0 + ctx.effect_percent(EFFECT::THUNDERING_HOOVES_PCT))
        * STABLE_PET_AP
        * mult;

    for _ in 0..stable_pets(ctx) {
        ctx.deal_physical_pet_damage_ap(HERO::BM_PETS::SPELL::PET_BESTIAL_WRATH, bw_hit);
        ctx.deal_physical_pet_damage_ap(HERO::BM_PETS::SPELL::STOMP, hooves);
    }

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

    // Stampede is collapsed to the Bestial Wrath cast.
    ctx.deal_effect_damage_ap_with_geometry(
        EFFECT::STAMPEDE_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
        .resolved_spell_effect_targets(
            EFFECT::WILD_THRASH_DAMAGE,
            EFFECT::WILD_THRASH_DAMAGE.0,
            None,
        )
        .len();
    let damage_mult = wild_thrash_target_multiplier(
        target_count,
        ctx.effect_base_points(EFFECT::WILD_THRASH_THRESHOLD),
        ctx.effect_percent(EFFECT::WILD_THRASH_BONUS),
    );

    for _ in 0..stable_pets(ctx) {
        ctx.deal_effect_damage_ap(
            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(EFFECT::BEAST_CLEAVE_DURATION),
    );

    ctx.apply_aura_with_duration(AURA_BEAST_CLEAVE.raw(), 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.raw(), BARBED_SCALES_CDR_MS);
    ctx.apply_aura(AURA_NATURES_ALLY_KILL_COMMAND.raw());
}

/// 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(HERO::BM_PETS::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(HERO::BM_PETS::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)
        )
    }
}