wowlab_engine_content/hooks/unholy_death_knight/

riders.rs

//! Rider of the Apocalypse actors and cross-actor spell overlays.

use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::ResourceOps as _;
use wowlab_engine_combat::GuardianOps as _;
use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::{
    DamageFlags, GuardianAbility, GuardianEvent, GuardianSpec, HookCtx,
};
use wowlab_engine_domain::constants::OFF_HAND_DAMAGE_MULT;
use wowlab_engine_rng::proc_chance;

use super::config::{RiderConfig, UnholyConfig, UnholyRuntime};
use crate::generated::specs::unholy_death_knight::{
    AURA_APOCALYPTIC_CONQUEST, AURA_DREAD_PLAGUE, AURA_MOGRAINES_MIGHT,
    AURA_TROLLBANE_CHAINS, AURA_UNDEATH, AURA_VIRULENT_PLAGUE, EFFECT, HERO,
    REPORTED_SPELL,
};

const RIDER_SWING_MS: u32 = 2_000;
const RIDER_AUTO_ATTACK_MULTIPLIER: f64 = 0.75;
const TROLLBANE_CHAINS_COOLDOWN_MS: u32 = 4_000;
const RANDOM_RIDER_PROC_CHANCE: f64 = 0.20;
const RIDER_DND_EXTENSION_MS: u32 = 1_000;
const RIDER_COUNT: usize = 4;
const TROLLBANE_INDEX: usize = 2;
const WHITEMANE_INDEX: usize = 3;
const TROLLBANE_CODE: u8 = 2;
const WHITEMANE_CODE: u8 = 3;

const MOGRAINE_NPC_ID: u32 = 221_632;
const WHITEMANE_NPC_ID: u32 = 221_633;
const NAZGRIM_NPC_ID: u32 = 221_634;
const TROLLBANE_NPC_ID: u32 = 221_635;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
enum Rider {
    Mograine,
    Nazgrim,
    Trollbane,
    Whitemane,
}

impl Rider {
    const ALL: [Self; 4] = [Self::Mograine, Self::Nazgrim, Self::Trollbane, Self::Whitemane];

    const fn tag(self) -> u32 {
        match self {
            Self::Mograine => HERO::RIDERS::SPELL::MOGRAINE,
            Self::Nazgrim => HERO::RIDERS::SPELL::NAZGRIM,
            Self::Trollbane => HERO::RIDERS::SPELL::TROLLBANE,
            Self::Whitemane => HERO::RIDERS::SPELL::WHITEMANE,
        }
    }

    const fn npc_id(self) -> u32 {
        match self {
            Self::Mograine => MOGRAINE_NPC_ID,
            Self::Nazgrim => NAZGRIM_NPC_ID,
            Self::Trollbane => TROLLBANE_NPC_ID,
            Self::Whitemane => WHITEMANE_NPC_ID,
        }
    }

    const fn index(self) -> usize {
        match self {
            Self::Mograine => 0,
            Self::Nazgrim => 1,
            Self::Trollbane => TROLLBANE_INDEX,
            Self::Whitemane => WHITEMANE_INDEX,
        }
    }

    const fn code(self) -> u8 {
        match self {
            Self::Mograine => 0,
            Self::Nazgrim => 1,
            Self::Trollbane => TROLLBANE_CODE,
            Self::Whitemane => WHITEMANE_CODE,
        }
    }
}

fn rider_config(ctx: &HookCtx<'_>) -> Option<RiderConfig> {
    ctx.spec_config::<UnholyConfig>()?.riders
}

fn rider_auto_attack(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.deal_damage_ap(
        REPORTED_SPELL::AUTO_ATTACK,
        wowlab_engine_domain::damage::pet_swing_ap(RIDER_SWING_MS)
            * RIDER_AUTO_ATTACK_MULTIPLIER,
        DamageFlags::PHYSICAL,
    );
}

fn mograine_off_hand(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.deal_damage_ap(
        REPORTED_SPELL::AUTO_ATTACK,
        wowlab_engine_domain::damage::pet_swing_ap(RIDER_SWING_MS)
            * RIDER_AUTO_ATTACK_MULTIPLIER
            * OFF_HAND_DAMAGE_MULT,
        DamageFlags::PHYSICAL,
    );
}

fn mograine_heart_strike(
    ctx: &mut HookCtx<'_>,
    _event: GuardianEvent,
) {
    ctx.deal_effect_damage_ap_with_geometry(
        EFFECT::MOGRAINE_HEART_STRIKE,
        EFFECT::MOGRAINE_HEART_STRIKE,
        1.0,
        DamageFlags::PHYSICAL,
    );
}

fn mograine_death_and_decay(
    ctx: &mut HookCtx<'_>,
    _event: GuardianEvent,
) {
    ctx.apply_owner_aura(AURA_MOGRAINES_MIGHT.raw());
    ctx.deal_effect_damage_ap_with_geometry(
        EFFECT::MOGRAINE_DND,
        EFFECT::MOGRAINE_DND,
        1.0,
        DamageFlags::empty(),
    );
    ctx.extend_aura(AURA_VIRULENT_PLAGUE.raw(), RIDER_DND_EXTENSION_MS);
    ctx.extend_aura(AURA_DREAD_PLAGUE.raw(), RIDER_DND_EXTENSION_MS);
}

fn nazgrim_scourge_strike(
    ctx: &mut HookCtx<'_>,
    _event: GuardianEvent,
) {
    ctx.deal_damage_ap(
        EFFECT::NAZGRIM_SCOURGE_STRIKE.0,
        ctx.effect_ap_coefficient(EFFECT::NAZGRIM_SCOURGE_STRIKE),
        DamageFlags::PHYSICAL,
    );
    ctx.deal_damage_ap(
        REPORTED_SPELL::SCOURGE_STRIKE_SHADOW,
        ctx.effect_ap_coefficient(EFFECT::NAZGRIM_SCOURGE_STRIKE_SHADOW),
        DamageFlags::empty(),
    );
}

fn trollbane_chains(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.apply_owner_aura(AURA_TROLLBANE_CHAINS.raw());
}

fn trollbane_obliterate(
    ctx: &mut HookCtx<'_>,
    _event: GuardianEvent,
) {
    ctx.deal_damage_ap(
        REPORTED_SPELL::OBLITERATE,
        ctx.effect_ap_coefficient(EFFECT::TROLLBANE_OBLITERATE),
        DamageFlags::PHYSICAL,
    );
}

fn whitemane_undeath(ctx: &mut HookCtx<'_>, _event: GuardianEvent) {
    ctx.apply_owner_aura(AURA_UNDEATH.raw());
}

fn whitemane_death_coil(
    ctx: &mut HookCtx<'_>,
    _event: GuardianEvent,
) {
    ctx.deal_damage_ap(
        REPORTED_SPELL::WHITEMANE_DEATH_COIL,
        ctx.effect_ap_coefficient(EFFECT::WHITEMANE_DEATH_COIL),
        DamageFlags::empty(),
    );
}

fn rider_demise(ctx: &mut HookCtx<'_>, event: GuardianEvent) {
    if event.tag == Rider::Mograine.tag() {
        ctx.expire_owner_aura(AURA_MOGRAINES_MIGHT.raw());
    } else if event.tag == Rider::Nazgrim.tag() {
        ctx.expire_owner_aura(AURA_APOCALYPTIC_CONQUEST.raw());
    }
}

fn rider_spec(rider: Rider, duration_ms: u32, config: RiderConfig) -> GuardianSpec {
    let base = GuardianSpec::new_inheriting_owner(rider.tag(), duration_ms)
        .npc_id(rider.npc_id())
        .ability(
            GuardianAbility::new(RIDER_SWING_MS, rider_auto_attack)
                .first_action_delay(RIDER_SWING_MS)
                .hasted_actions(),
        )
        .on_demise(rider_demise);

    match rider {
        Rider::Mograine => base
            .ability(
                GuardianAbility::new(RIDER_SWING_MS, mograine_off_hand)
                    .first_action_delay(RIDER_SWING_MS)
                    .hasted_actions(),
            )
            .ability(GuardianAbility::new(
                config.heart_strike_cooldown_ms,
                mograine_heart_strike,
            ))
            .ability(GuardianAbility::new(
                config.dnd_period_ms,
                mograine_death_and_decay,
            )),
        Rider::Nazgrim => base.ability(GuardianAbility::new(
            config.nazgrim_strike_cooldown_ms,
            nazgrim_scourge_strike,
        )),
        Rider::Trollbane => base
            .ability(
                GuardianAbility::new(TROLLBANE_CHAINS_COOLDOWN_MS, trollbane_chains)
                    .hasted_actions(),
            )
            .ability(GuardianAbility::new(
                config.obliterate_cooldown_ms,
                trollbane_obliterate,
            )),
        Rider::Whitemane => base
            .ability(GuardianAbility::new(
                config.undeath_duration_ms,
                whitemane_undeath,
            ))
            .ability(GuardianAbility::new(
                config.whitemane_death_coil_cooldown_ms,
                whitemane_death_coil,
            )),
    }
}

fn summon_rider(ctx: &mut HookCtx<'_>, rider: Rider, duration_ms: u32, extend_existing: bool) {
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if ctx.active_guardian_count(rider.tag()) > 0 {
        if extend_existing {
            ctx.extend_guardians(rider.tag(), duration_ms);
        }

        return;
    }

    if rider == Rider::Mograine {
        ctx.apply_aura(AURA_MOGRAINES_MIGHT.raw());
    } else if rider == Rider::Nazgrim {
        let stacks = wowlab_types::numeric::f64_to_i32_saturating_round(
            ctx.effect_base_points(EFFECT::NAZGRIM_CONQUEST_BASE_PCT)
                .max(0.0),
        );

        ctx.apply_aura_n(AURA_APOCALYPTIC_CONQUEST.raw(), stacks);
    }

    if let Some(runtime) = ctx
        .spec_runtime_mut::<UnholyRuntime>()
        .and_then(|runtime| runtime.riders.as_mut())
    {
        let index = rider.index();
        // BOUNDS: Rider::index maps the four variants onto the four rider-state slots.

        runtime.fury_pools[index] = 0.0;
        // BOUNDS: Rider::index maps the four variants onto the four rider-state slots.
        runtime.fury_rp_spent[index] = 0.0;
    }

    let _ = ctx.summon_guardian(rider_spec(rider, duration_ms, config));
}

pub(super) fn resource_spend(ctx: &mut HookCtx<'_>) {
    let runes = wowlab_types::numeric::f64_to_i32_saturating_trunc(ctx.last_primary_spent().max(0.0).floor());
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if runes > 0
        && config.nazgrims_conquest
        && ctx.active_guardian_count(Rider::Nazgrim.tag()) > 0
    {
        ctx.apply_aura_n(AURA_APOCALYPTIC_CONQUEST.raw(), runes);
    }

    extend_riders_from_rp(ctx, ctx.last_secondary_spent());
}

pub(super) fn extend_riders_from_rp(ctx: &mut HookCtx<'_>, rp_spent: f64) {
    if rp_spent <= 0.0 {
        return;
    }

    let active = Rider::ALL.map(|rider| ctx.active_guardian_count(rider.tag()) > 0);
    let mut extend = [false; RIDER_COUNT];
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if config.fury_rp_threshold <= 0.0 {
        return;
    }

    let limit = config.fury_rp_threshold
        * (f64::from(config.fury_max_extension_ms) / f64::from(config.fury_extension_ms));

    if let Some(runtime) = ctx
        .spec_runtime_mut::<UnholyRuntime>()
        .and_then(|runtime| runtime.riders.as_mut())
    {
        for (index, is_active) in active.into_iter().enumerate() {
            if !is_active {
                continue;
            }
            // BOUNDS: index comes from enumerating Rider::ALL and all rider-state arrays have RIDER_COUNT slots.

            extend[index] = accumulate_fury(
                // BOUNDS: index comes from enumerating Rider::ALL and fury_pools has RIDER_COUNT slots.
                &mut runtime.fury_pools[index],
                // BOUNDS: index comes from enumerating Rider::ALL and fury_rp_spent has RIDER_COUNT slots.
                &mut runtime.fury_rp_spent[index],
                rp_spent,
                config.fury_rp_threshold,
                limit,
            );
        }
    }

    let extension_ms = config.fury_extension_ms;

    for (index, should_extend) in extend.into_iter().enumerate() {
        if should_extend {
            // BOUNDS: index comes from enumerating an array with the same length as Rider::ALL.
            ctx.extend_guardians(Rider::ALL[index].tag(), extension_ms);
        }
    }
}

const fn accumulate_fury(
    pool: &mut f64,
    spent: &mut f64,
    amount: f64,
    threshold: f64,
    limit: f64,
) -> bool {
    if amount <= 0.0 || threshold <= 0.0 || *spent >= limit {
        return false;
    }

    *spent += amount;
    *pool += amount;

    if *pool < threshold {
        return false;
    }

    *pool -= threshold;

    true
}

pub(super) fn summon_apocalypse_riders(ctx: &mut HookCtx<'_>) {
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if !config.apocalypse_now {
        return;
    }

    for rider in Rider::ALL {
        summon_rider(ctx, rider, config.apocalypse_duration_ms, true);
    }
}

pub(super) fn maybe_summon_random_rider(
    ctx: &mut HookCtx<'_>,
) {
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if !proc_chance(ctx.rng(), RANDOM_RIDER_PROC_CHANCE) {
        return;
    }

    let last_random_rider = ctx
        .spec_runtime::<UnholyRuntime>()
        .and_then(|runtime| runtime.riders)
        .and_then(|runtime| runtime.last_random_rider);
    let mut candidates = Rider::ALL;
    let mut candidate_count = 0;

    for rider in Rider::ALL {
        if Some(rider.code()) != last_random_rider {
            // BOUNDS: at most Rider::ALL.len() candidates are inserted into this same-sized array.
            candidates[candidate_count] = rider;
            candidate_count += 1;
        }
    }

    let index = wowlab_types::numeric::f64_to_usize_saturating_trunc(
        ctx.rng()() * wowlab_types::numeric::usize_to_f64(candidate_count),
    )
    .min(candidate_count - 1);
    // BOUNDS: index is clamped to the populated candidate prefix.
    let rider = candidates[index];

    if let Some(runtime) = ctx
        .spec_runtime_mut::<UnholyRuntime>()
        .and_then(|runtime| runtime.riders.as_mut())
    {
        runtime.last_random_rider = Some(rider.code());
    }

    summon_rider(ctx, rider, config.random_duration_ms, false);
}

pub(super) fn trigger_icy_fury(ctx: &mut HookCtx<'_>) {
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if !config.icy_fury
        || ctx.active_guardian_count(Rider::Trollbane.tag()) == 0
        || !ctx.is_aura_active(AURA_TROLLBANE_CHAINS.raw())
    {
        return;
    }

    ctx.expire_aura(AURA_TROLLBANE_CHAINS.raw());
    ctx.deal_effect_damage_ap_with_geometry(
        EFFECT::ICY_FURY_DAMAGE,
        EFFECT::ICY_FURY_DAMAGE,
        1.0,
        DamageFlags::empty(),
    );
}

pub(super) fn trigger_whitemane_famine(ctx: &mut HookCtx<'_>) {
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if config.whitemanes_famine
        && ctx.active_guardian_count(Rider::Whitemane.tag()) > 0
        && ctx.is_aura_active(AURA_UNDEATH.raw())
    {
        ctx.add_aura_stack(AURA_UNDEATH.raw());
    }
}

pub(super) fn trigger_let_terror_reign(
    ctx: &mut HookCtx<'_>,
) {
    let Some(config) = rider_config(ctx) else {
        return;
    };

    if !config.let_terror_reign || ctx.active_guardian_count(Rider::Whitemane.tag()) == 0 {
        return;
    }

    let coefficient = ctx.effect_ap_coefficient(EFFECT::WHITEMANE_DEATH_COIL)
        * ctx.effect_percent(EFFECT::LET_TERROR_REIGN_UNHOLY_PCT);

    ctx.deal_pet_damage_ap_for_npc(
        WHITEMANE_NPC_ID,
        REPORTED_SPELL::DEATH_COIL_LET_TERROR_REIGN,
        coefficient,
    );
}

pub(crate) fn undeath_tick_hook(ctx: &mut HookCtx<'_>) {
    ctx.add_aura_stack(AURA_UNDEATH.raw());
}

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

    use super::{accumulate_fury, Rider};

    #[gtest]
    #[rstest]
    #[case(Rider::Mograine, 444_248, 221_632)]
    #[case(Rider::Nazgrim, 444_252, 221_634)]
    #[case(Rider::Trollbane, 444_254, 221_635)]
    #[case(Rider::Whitemane, 444_251, 221_633)]
    fn rider_identity_preserves_summon_and_creature_ids(
        #[case] rider: Rider,
        #[case] tag: u32,
        #[case] npc_id: u32,
    ) -> Result<()> {
        verify_that!(rider.tag(), eq(tag))?;

        verify_that!(rider.npc_id(), eq(npc_id))
    }

    #[gtest]
    #[rstest]
    #[case::below_threshold(20.0, 20.0, false)]
    #[case::reaches_threshold(50.0, 0.0, true)]
    #[case::carries_remainder(80.0, 30.0, true)]
    fn fury_extends_once_per_threshold(
        #[case] amount: f64,
        #[case] expected_pool: f64,
        #[case] expected_extension: bool,
    ) -> Result<()> {
        let (mut pool, mut spent) = (0.0, 0.0);

        verify_that!(
            accumulate_fury(&mut pool, &mut spent, amount, 50.0, 250.0),
            eq(expected_extension)
        )?;
        verify_that!(pool, eq(expected_pool))?;

        verify_that!(spent, eq(amount))
    }

    #[gtest]
    fn fury_stops_at_its_extension_budget() -> Result<()> {
        let (mut pool, mut spent) = (0.0, 250.0);

        verify_that!(
            accumulate_fury(&mut pool, &mut spent, 50.0, 50.0, 250.0),
            eq(false)
        )?;

        verify_that!((pool, spent), eq((0.0, 250.0)))
    }
}