wowlab_engine_combat/systems/

pet_actions.rs

//! Persistent-pet resource, priority-list, and global-cooldown scheduling.

use wowlab_engine_domain::rotation::DenseBuffer;
use wowlab_engine_ports::Event;
#[cfg(test)]
use wowlab_engine_telemetry::TelemetrySink;
use wowlab_types::{
    constants::{HUNDRED, MS_PER_SECOND},
    sim::{ActorId, PetIdx, SimTime},
};

use super::{accumulate_actor_buffs, is_aura_active};
use crate::{
    DamageFlags,
    context::{CombatCtx, HookCtx},
    state::{
        CombatState, PetAbilityCondition, PetActionState, PetOwnerCoefficients, PetStatSnapshot,
    },
};

pub(crate) const PROC_HEARTBEAT_INITIAL_MIN_MS: u32 = 1;
pub(crate) const PROC_HEARTBEAT_INITIAL_MAX_EXCLUSIVE_MS: u32 = 5_249;
pub(crate) const PROC_HEARTBEAT_MEAN_MS: f64 = 5_250.0;
pub(crate) const PROC_HEARTBEAT_STANDARD_DEVIATION_MS: f64 = 25.0;

pub(crate) fn snapshot_owner_stats(
    state: &CombatState,
    buf: &DenseBuffer,
    coefficients: PetOwnerCoefficients,
) -> PetStatSnapshot {
    let view = crate::CombatView::new(state, buf);
    let totals = view.buff_totals();
    let (attack_power, spell_power) =
        super::damage_pipeline::dynamic_base_powers(state, buf, totals);
    let owner_health = state
        .friendly_actor_max_health(ActorId::Player)
        .unwrap_or(0.0);

    PetStatSnapshot {
        attack_power: attack_power * coefficients.attack_power_from_attack_power
            + spell_power * coefficients.attack_power_from_spell_power,
        spell_power: attack_power * coefficients.spell_power_from_attack_power
            + spell_power * coefficients.spell_power_from_spell_power,
        armor: buf.player().armor * coefficients.armor,
        health: owner_health * coefficients.health,
    }
}

fn apply_snapshot_health(state: &mut CombatState, actor: ActorId, snapshot: PetStatSnapshot) {
    let _ = state.activate_pet_health(actor, snapshot.health);
}

pub(crate) fn refresh_pet_stat_snapshots(state: &mut CombatState, buf: &DenseBuffer) {
    let persistent = state
        .defs
        .auto_attacks
        .iter()
        .enumerate()
        .filter_map(|(index, attack)| {
            let bar = attack.pet_action_bar?;

            Some((
                index,
                snapshot_owner_stats(state, buf, bar.owner_coefficients),
            ))
        })
        .collect::<Vec<_>>();

    for (index, snapshot) in persistent {
        if let Some(runtime) = state
            .runtime
            .companions
            .pet_actions
            .get_mut(index)
            .and_then(Option::as_mut)
        {
            runtime.stat_snapshot = snapshot;
        }

        apply_snapshot_health(state, ActorId::Pet(PetIdx::PRIMARY), snapshot);
    }

    let guardian_snapshots = state
        .runtime
        .companions
        .guardians
        .iter()
        .enumerate()
        .filter_map(|(index, guardian)| {
            let guardian = guardian.as_ref()?;

            Some((
                index,
                guardian.source,
                snapshot_owner_stats(state, buf, guardian.spec.owner_coefficients),
            ))
        })
        .collect::<Vec<_>>();

    for (index, source, snapshot) in guardian_snapshots {
        if let Some(guardian) = state
            .runtime
            .companions
            .guardians
            .get_mut(index)
            .and_then(Option::as_mut)
        {
            guardian.stat_snapshot = snapshot;
        }

        apply_snapshot_health(state, source, snapshot);
    }
}

pub(crate) fn pet_stat_snapshot(
    state: &CombatState,
    source: ActorId,
    npc_id: Option<u32>,
) -> Option<PetStatSnapshot> {
    if let Some(snapshot) = state
        .runtime
        .companions
        .guardians
        .iter()
        .flatten()
        .find_map(|guardian| {
            (guardian.source == source && guardian.spec.npc_id == npc_id)
                .then_some(guardian.stat_snapshot)
        })
    {
        return Some(snapshot);
    }

    state
        .defs
        .auto_attacks
        .iter()
        .zip(&state.runtime.companions.pet_actions)
        .find_map(|(attack, runtime)| {
            (attack.npc_id == npc_id && attack.pet_action_bar.is_some())
                .then(|| runtime.as_ref().map(|runtime| runtime.stat_snapshot))
                .flatten()
        })
}

pub(crate) fn ensure_initial_proc_heartbeat(
    state: &mut CombatState,
    now: SimTime,
    rng: &mut wowlab_engine_rng::SimRng,
) {
    if state.runtime.procs.proc_heartbeat_scheduled_at.is_some() {
        return;
    }

    let delay = rng.range_u32(
        PROC_HEARTBEAT_INITIAL_MIN_MS,
        PROC_HEARTBEAT_INITIAL_MAX_EXCLUSIVE_MS,
    );

    schedule_proc_heartbeat(state, now, delay);
}

pub(crate) fn ensure_recurring_proc_heartbeat(
    state: &mut CombatState,
    now: SimTime,
    rng: &mut wowlab_engine_rng::SimRng,
) {
    if state.runtime.procs.proc_heartbeat_scheduled_at.is_some() {
        return;
    }

    let sampled = rng.gaussian(PROC_HEARTBEAT_MEAN_MS, PROC_HEARTBEAT_STANDARD_DEVIATION_MS);
    let delay = wowlab_types::numeric::f64_to_u32_saturating_round(sampled).max(1);

    schedule_proc_heartbeat(state, now, delay);
}

fn schedule_proc_heartbeat(state: &mut CombatState, now: SimTime, delay_ms: u32) {
    let at = now.saturating_add(SimTime::from_millis(delay_ms));

    state.runtime.procs.proc_heartbeat_scheduled_at = Some(at);
    state.schedule(Event::ProcHeartbeat { t: at });
}

pub(crate) fn begin_proc_heartbeat(state: &mut CombatState, now: SimTime) -> bool {
    if state.runtime.procs.proc_heartbeat_scheduled_at != Some(now) {
        return false;
    }

    state.runtime.procs.proc_heartbeat_scheduled_at = None;

    true
}

fn condition_matches(
    state: &CombatState,
    buf: &DenseBuffer,
    condition: PetAbilityCondition,
) -> bool {
    match condition {
        PetAbilityCondition::Always => true,
        PetAbilityCondition::OwnerAuraActive(aura) => is_aura_active(
            &crate::context::CombatView::new(state, buf),
            aura,
            ActorId::Player,
            state.current_target(),
        ),
        PetAbilityCondition::OwnerAuraInactive(aura) => !is_aura_active(
            &crate::context::CombatView::new(state, buf),
            aura,
            ActorId::Player,
            state.current_target(),
        ),
    }
}

fn sync_resource(runtime: &mut PetActionState, resource_max: f64, now: SimTime) {
    let elapsed = now
        .as_secs_f64()
        .max(runtime.resource_updated_at.as_secs_f64())
        - runtime.resource_updated_at.as_secs_f64();

    runtime.resource = (runtime.resource + elapsed * runtime.regen_per_second).min(resource_max);
    runtime.resource_updated_at = now;
}

fn resource_ready_at(now: SimTime, current: f64, required: f64, regen: f64) -> Option<SimTime> {
    if current >= required {
        return Some(now);
    }

    if regen <= 0.0 {
        return None;
    }

    let wait_ms = wowlab_types::numeric::f64_to_u32_saturating_ceil(
        (required - current) / regen * MS_PER_SECOND,
    );

    Some(now.saturating_add(SimTime::from_millis(wait_ms.max(1))))
}

fn schedule_action(state: &mut CombatState, auto_attack_index: usize, at: SimTime) {
    let Some(target) = state.current_target() else {
        return;
    };
    let Some(runtime) = state
        .runtime
        .companions
        .pet_actions
        .get_mut(auto_attack_index)
    else {
        return;
    };
    let Some(runtime) = runtime.as_mut() else {
        return;
    };
    let at = at.max(runtime.gcd_ready_at);

    if runtime.next_action_at == Some(at) {
        return;
    }

    runtime.next_action_at = Some(at);
    state.schedule(Event::PetAction {
        t: at,
        auto_attack_index,
        source: ActorId::Pet(PetIdx::PRIMARY),
        target,
    });
}

fn pet_regen_per_second(state: &CombatState, buf: &DenseBuffer, base_regen_per_second: f64) -> f64 {
    let pet = ActorId::Pet(PetIdx::PRIMARY);
    let buffs = accumulate_actor_buffs(
        crate::context::ActorView::new(state, buf, pet),
        state.current_target(),
    );

    base_regen_per_second * (1.0 + buffs.regen_pct / HUNDRED).max(0.0)
}

fn next_decision_at(
    state: &CombatState,
    buf: &DenseBuffer,
    bar: crate::state::PetActionBar,
    runtime: PetActionState,
    now: SimTime,
) -> Option<SimTime> {
    let ready_at = bar
        .abilities
        .iter()
        .filter(|ability| condition_matches(state, buf, ability.condition))
        .filter_map(|ability| {
            resource_ready_at(
                now,
                runtime.resource,
                ability.minimum_resource,
                runtime.regen_per_second,
            )
        })
        .min()?;

    Some(ready_at.max(runtime.gcd_ready_at))
}

pub(crate) fn initialize_pet_actions(state: &mut CombatState, buf: &DenseBuffer) {
    state.runtime.companions.pet_actions = state
        .defs
        .auto_attacks
        .iter()
        .map(|attack| {
            attack.pet_action_bar.map(|bar| PetActionState {
                resource: bar.resource_initial.min(bar.resource_max),
                regen_per_second: pet_regen_per_second(state, buf, bar.resource_regen_per_second),
                resource_updated_at: SimTime::ZERO,
                gcd_ready_at: SimTime::ZERO,
                next_action_at: None,
                stat_snapshot: snapshot_owner_stats(state, buf, bar.owner_coefficients),
            })
        })
        .collect();

    let indices = state
        .runtime
        .companions
        .pet_actions
        .iter()
        .enumerate()
        .filter_map(|(index, runtime)| runtime.is_some().then_some(index))
        .collect::<Vec<_>>();

    for index in indices {
        schedule_action(state, index, SimTime::ZERO);
    }

    refresh_pet_stat_snapshots(state, buf);
}

pub(crate) fn refresh_pet_actions_after_aura_change(
    state: &mut CombatState,
    buf: &DenseBuffer,
    now: SimTime,
) {
    for index in 0..state.defs.auto_attacks.len() {
        // BOUNDS: index is produced from this same auto_attacks length.
        let Some(bar) = state.defs.auto_attacks[index].pet_action_bar else {
            continue;
        };
        let regen = pet_regen_per_second(state, buf, bar.resource_regen_per_second);
        let Some(runtime) = state
            .runtime
            .companions
            .pet_actions
            .get_mut(index)
            .and_then(Option::as_mut)
        else {
            continue;
        };

        sync_resource(runtime, bar.resource_max, now);
        runtime.regen_per_second = regen;
        runtime.next_action_at = None;
        let runtime = *runtime;

        if let Some(next) = next_decision_at(state, buf, bar, runtime, now) {
            schedule_action(state, index, next);
        }
    }
}

pub(crate) fn gain_pet_resource(
    state: &mut CombatState,
    buf: &DenseBuffer,
    npc_id: u32,
    amount: f64,
    now: SimTime,
) -> f64 {
    if amount <= 0.0 {
        return 0.0;
    }

    let Some((index, bar)) =
        state
            .defs
            .auto_attacks
            .iter()
            .enumerate()
            .find_map(|(index, attack)| {
                (attack.npc_id == Some(npc_id)).then_some((index, attack.pet_action_bar?))
            })
    else {
        return 0.0;
    };
    let Some(runtime) = state
        .runtime
        .companions
        .pet_actions
        .get_mut(index)
        .and_then(Option::as_mut)
    else {
        return 0.0;
    };

    sync_resource(runtime, bar.resource_max, now);
    let before = runtime.resource;

    runtime.resource = (runtime.resource + amount).min(bar.resource_max);
    runtime.next_action_at = None;

    let gained = runtime.resource - before;
    let runtime = *runtime;

    if let Some(next) = next_decision_at(state, buf, bar, runtime, now) {
        schedule_action(state, index, next);
    }

    gained
}

pub(crate) fn process_pet_action(ctx: &mut CombatCtx<'_>, auto_attack_index: usize) {
    let now = ctx.now;
    let state = &mut *ctx.state;
    let buf = &mut *ctx.buf;
    let Some(attack) = state.defs.auto_attacks.get(auto_attack_index).copied() else {
        return;
    };
    let Some(bar) = attack.pet_action_bar else {
        return;
    };
    let Some(runtime) = state
        .runtime
        .companions
        .pet_actions
        .get_mut(auto_attack_index)
        .and_then(Option::as_mut)
    else {
        return;
    };

    if runtime.next_action_at != Some(now) {
        return;
    }

    runtime.next_action_at = None;
    sync_resource(runtime, bar.resource_max, now);
    let resource = runtime.resource;

    let selected = bar.abilities.iter().position(|ability| {
        resource >= ability.minimum_resource && condition_matches(state, buf, ability.condition)
    });

    if let Some(ability_index) = selected {
        // BOUNDS: ability_index comes from position() over bar.abilities.
        let ability = bar.abilities[ability_index];

        if let Some(runtime) = state
            .runtime
            .companions
            .pet_actions
            .get_mut(auto_attack_index)
            .and_then(Option::as_mut)
        {
            runtime.resource = (runtime.resource - ability.cost).max(0.0);
            let gcd_ms = ability.gcd_ms.unwrap_or(bar.gcd_ms);

            runtime.gcd_ready_at = now.saturating_add(SimTime::from_millis(gcd_ms.max(1)));
        }

        let mut hook = HookCtx::new(
            crate::context::HookCtxServices {
                state,
                buf,
                sink: ctx.sink,
                rng: ctx.rng,
            },
            crate::context::HookCtxRequest::for_target(now, ctx.target)
                .with_source(ActorId::Pet(PetIdx::PRIMARY)),
        )
        .with_source_damage_flags(DamageFlags::PET)
        .with_source_npc_id(attack.npc_id);

        (ability.action)(&mut hook);
        schedule_action(state, auto_attack_index, now);

        return;
    }

    // BOUNDS: auto_attack_index was validated against the corresponding auto-attack definition and runtime table above.

    let runtime = state.runtime.companions.pet_actions[auto_attack_index]
        .expect("configured pet action bar has runtime state");
    let next = next_decision_at(state, buf, bar, runtime, now);

    if let Some(next) = next {
        schedule_action(state, auto_attack_index, next);
    }
}

#[cfg(test)]
#[path = "pet_actions/tests.rs"]
mod tests;