wowlab_engine_combat/systems/

pet_actions.rs

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

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::{actor_buff_totals, is_aura_active};
use crate::{
    DamageFlags,
    context::{CombatCtx, HookCtx},
    state::{
        CombatInstance, 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(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    coefficients: PetOwnerCoefficients,
) -> PetStatSnapshot {
    let view = crate::CombatView::new(program, state);
    let totals = view.buff_totals();
    let (attack_power, spell_power) =
        super::damage_pipeline::dynamic_base_powers(program, state, &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: state.buffer.player().armor * coefficients.armor,
        health: owner_health * coefficients.health,
    }
}

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

pub(crate) fn refresh_pet_stat_snapshots(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
) {
    for index in program.pet_action_plans.iter().copied().map(usize::from) {
        let Some(bar) = program
            .auto_attacks
            .get(index)
            .expect("bounded auto-attack index")
            .pet_action_bar
        else {
            continue;
        };
        let snapshot = snapshot_owner_stats(program, state, bar.owner_coefficients);

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

    for visit in 0..state.runtime.companions.active_guardian_slots.len() {
        // BOUNDS: `visit` is bounded by the active-slot slice length.
        let index = usize::from(state.runtime.companions.active_guardian_slots[visit]);
        let Some((source, coefficients)) = state
            .runtime
            .companions
            .guardians
            .get(index)
            .and_then(Option::as_ref)
            .map(|guardian| (guardian.source, guardian.spec.owner_coefficients))
        else {
            continue;
        };
        let snapshot = snapshot_owner_stats(program, state, coefficients);

        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(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    source: ActorId,
    _npc_id: Option<u32>,
) -> Option<PetStatSnapshot> {
    let ActorId::Pet(pet) = source else {
        return None;
    };

    if pet.is_primary() {
        let index = usize::from(program.primary_pet_action_auto?);

        return state
            .runtime
            .companions
            .pet_actions
            .get(index)?
            .as_ref()
            .map(|runtime| runtime.stat_snapshot);
    }

    let slot = pet.as_usize().checked_sub(1)?;

    state
        .runtime
        .companions
        .guardians
        .get(slot)?
        .as_ref()
        .filter(|guardian| guardian.source == source)
        .map(|guardian| guardian.stat_snapshot)
}

pub(crate) fn ensure_initial_proc_heartbeat(
    state: &mut CombatInstance,
    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 CombatInstance,
    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 CombatInstance, 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(
    _program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    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(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    condition: PetAbilityCondition,
) -> bool {
    match condition {
        PetAbilityCondition::Always => true,
        PetAbilityCondition::OwnerAuraActive(aura) => is_aura_active(
            &crate::context::CombatView::new(program, state),
            aura,
            ActorId::Player,
            state.current_target(),
        ),
        PetAbilityCondition::OwnerAuraInactive(aura) => !is_aura_active(
            &crate::context::CombatView::new(program, state),
            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(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    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,
        action: program.runtime_events.pet_action(
            // #t(rust_unchecked_indexing) scheduler receives an index from the finalized pet-plan slice.
            program.pet_action_plan_by_auto[auto_attack_index]
                .expect("scheduled auto attack has a finalized pet plan"),
        ),
        source: ActorId::Pet(PetIdx::PRIMARY),
        target,
    });
}

fn pet_regen_per_second(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    base_regen_per_second: f64,
) -> f64 {
    let pet = ActorId::Pet(PetIdx::PRIMARY);
    let buffs = actor_buff_totals(
        crate::context::ActorView::new(program, state, pet),
        state.current_target(),
    );

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

fn next_decision_at(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    bar: crate::state::PetActionBar,
    runtime: PetActionState,
    now: SimTime,
) -> Option<SimTime> {
    let ready_at = bar
        .abilities
        .iter()
        .filter(|ability| condition_matches(program, state, 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(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
) {
    debug_assert_eq!(
        state.runtime.companions.pet_actions.len(),
        program.auto_attacks.len(),
        "pet action runtime length must match the finalized auto-attack plan"
    );

    for index in program.pet_action_plans.iter().copied().map(usize::from) {
        let runtime = program
            .auto_attacks
            .get(index)
            .expect("bounded auto-attack index")
            .pet_action_bar
            .map(|bar| PetActionState {
                resource: bar.resource_initial.min(bar.resource_max),
                regen_per_second: pet_regen_per_second(
                    program,
                    state,
                    bar.resource_regen_per_second,
                ),
                resource_updated_at: SimTime::ZERO,
                gcd_ready_at: SimTime::ZERO,
                next_action_at: None,
                stat_snapshot: snapshot_owner_stats(program, state, bar.owner_coefficients),
            });

        *state
            .runtime
            .companions
            .pet_actions
            .get_mut(index)
            .expect("finalized pet-action index") = runtime;

        if runtime.is_some() {
            schedule_action(program, state, index, SimTime::ZERO);
        }
    }

    refresh_pet_stat_snapshots(program, state);
}

pub(crate) fn refresh_pet_actions_after_aura_change(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
) {
    for index in program.pet_action_plans.iter().copied().map(usize::from) {
        // BOUNDS: index is produced from this same auto_attacks length.
        let Some(bar) = program.auto_attacks[index].pet_action_bar else {
            continue;
        };
        let regen = pet_regen_per_second(program, state, 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(program, state, bar, runtime, now) {
            schedule_action(program, state, index, next);
        }
    }
}

pub(crate) fn gain_pet_resource(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    binding: crate::PetResourceBinding,
    amount: f64,
    now: SimTime,
) -> f64 {
    if amount <= 0.0 {
        return 0.0;
    }

    if !binding.belongs_to(program.spec_identity_brand.unwrap_or(0)) {
        return 0.0;
    }

    let index = usize::from(binding.auto_attack());
    let Some(bar) = program
        .auto_attacks
        .get(index)
        .and_then(|attack| 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(program, state, bar, runtime, now) {
        schedule_action(program, state, index, next);
    }

    gained
}

pub(crate) fn process_pet_action(ctx: &mut CombatCtx<'_>, auto_attack_index: usize) {
    let now = ctx.now;
    let program = ctx.program;
    let state = &mut *ctx.instance;
    let Some(attack) = program.auto_attacks.get(auto_attack_index).copied() else {
        return;
    };
    let Some(bar) = attack.pet_action_bar else {
        return;
    };
    let Some(auto_profile) = program.damage.auto_attack_profile(auto_attack_index) 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(program, state, 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 {
                program,
                instance: state,
                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)
        .with_pet_stat_inheritance(auto_profile.stat_inheritance);

        (ability.action)(&mut hook);
        schedule_action(program, 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(program, state, bar, runtime, now);

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

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