wowlab_engine_combat/systems/

guardians.rs

//! Temporary guardian lifecycle and action scheduling.

use wowlab_engine_domain::rotation::DenseBuffer;
use wowlab_engine_ports::Event;
use wowlab_engine_telemetry::TelemetrySink;
use wowlab_types::sim::{ActorId, SimTime};

use super::buffs::current_haste_mult_for;
use crate::{
    DamageFlags,
    context::{ActorView, CombatCtx, HookCtx},
    state::{
        CombatState, GuardianAbilityState, GuardianEvent, GuardianHandle, GuardianInstance,
        GuardianSpec,
    },
};

fn scaled_delay_ms(view: ActorView<'_>, delay_ms: u32, hasted: bool) -> u32 {
    if delay_ms == 0 || !hasted {
        return delay_ms;
    }

    wowlab_types::numeric::f64_to_u32_saturating_round(
        f64::from(delay_ms) / current_haste_mult_for(view),
    )
    .max(1)
}

pub(crate) fn summon_guardian(
    state: &mut CombatState,
    buf: &DenseBuffer,
    spec: GuardianSpec,
    now: SimTime,
) -> GuardianHandle {
    let Some(target) = state.current_target() else {
        return GuardianHandle::new(0, 0);
    };
    let handle = allocate_guardian_handle(state);
    let Some(source) = handle.actor() else {
        return handle;
    };
    let stat_snapshot =
        super::pet_actions::snapshot_owner_stats(state, buf, spec.owner_coefficients);
    let expires_at = now.saturating_add(SimTime::from_millis(spec.duration_ms));
    let abilities = spec
        .abilities
        .iter()
        .map(|ability| {
            let first_delay = scaled_delay_ms(
                ActorView::new(state, buf, source),
                ability.first_action_delay_ms,
                ability.hasted_first_action,
            );

            GuardianAbilityState {
                next_action_at: ability
                    .self_scheduled
                    .then(|| now.saturating_add(SimTime::from_millis(first_delay))),
                actions_executed: 0,
            }
        })
        .collect::<Vec<_>>();
    let tag = spec.tag;

    let guardian = GuardianInstance {
        handle,
        spec,
        spawned_at: now,
        expires_at,
        abilities,
        source,
        target,
        stat_snapshot,
    };
    let slot = handle.0 as usize;

    if slot == state.runtime.companions.guardians.len() {
        state.runtime.companions.guardians.push(Some(guardian));
    } else if let Some(entry) = state.runtime.companions.guardians.get_mut(slot) {
        *entry = Some(guardian);
    }

    super::pet_actions::refresh_pet_stat_snapshots(state, buf);
    // BOUNDS: handle is the index returned immediately before pushing this guardian slot.
    let action_times = state.runtime.companions.guardians[handle.0 as usize]
        .as_ref()
        .into_iter()
        .flat_map(|guardian| guardian.abilities.iter().enumerate())
        .filter_map(|(index, ability)| ability.next_action_at.map(|t| (index, t)))
        .collect::<Vec<_>>();

    for (ability_index, t) in action_times {
        state.schedule(Event::GuardianAction {
            t,
            guardian_id: handle.0,
            guardian_generation: handle.1,
            ability_index,
            source,
            target,
        });
    }

    state.schedule(Event::GuardianExpire {
        t: expires_at,
        guardian_id: handle.0,
        guardian_generation: handle.1,
    });
    tracing::trace!(
        tag,
        slot = handle.0,
        now_ms = now.as_millis(),
        expires_at_ms = expires_at.as_millis(),
        active = active_guardian_count(state, tag),
        "guardian summoned"
    );

    handle
}

fn allocate_guardian_handle(state: &mut CombatState) -> GuardianHandle {
    let slot = state
        .runtime
        .companions
        .guardians
        .iter()
        .position(Option::is_none)
        .unwrap_or(state.runtime.companions.guardians.len());

    if slot == state.runtime.companions.guardian_generations.len() {
        state.runtime.companions.guardian_generations.push(1);
    } else if let Some(generation) = state.runtime.companions.guardian_generations.get_mut(slot) {
        *generation = generation.wrapping_add(1).max(1);
    }

    let generation = state
        .runtime
        .companions
        .guardian_generations
        .get(slot)
        .copied()
        .expect("guardian generation was initialized for allocated slot");

    GuardianHandle::new(
        u32::try_from(slot).expect("guardian arena length fits in u32"),
        generation,
    )
}

pub(crate) fn active_guardian_count(state: &CombatState, tag: u32) -> usize {
    state
        .runtime
        .companions
        .guardians
        .iter()
        .flatten()
        .filter(|guardian| guardian.spec.tag == tag)
        .count()
}

/// Drives one `on_demand` ability on every active guardian carrying `tag`, leaving scheduled timelines untouched.
pub(crate) fn command_guardians(ctx: &mut CombatCtx<'_>, tag: u32, ability_index: usize) -> usize {
    let commanded = ctx
        .state
        .runtime
        .companions
        .guardians
        .iter()
        .flatten()
        .filter(|guardian| guardian.spec.tag == tag)
        .filter_map(|guardian| {
            let ability = guardian.spec.abilities.get(ability_index).copied()?;

            Some((
                ability,
                event_for(guardian, ability_index, 0),
                guardian.source,
                guardian.target,
                guardian.spec.npc_id,
            ))
        })
        .collect::<Vec<_>>();
    let count = commanded.len();

    for (ability, event, source, target, npc_id) in commanded {
        let mut hook = HookCtx::new(
            crate::context::HookCtxServices {
                state: ctx.state,
                buf: ctx.buf,
                sink: ctx.sink,
                rng: ctx.rng,
            },
            crate::context::HookCtxRequest::for_target(ctx.now, target).with_source(source),
        )
        .with_source_damage_flags(DamageFlags::PET | DamageFlags::GUARDIAN)
        .with_source_npc_id(npc_id);

        (ability.action)(&mut hook, event);
    }

    count
}

pub(crate) fn guardian_combat_coordinates(
    state: &CombatState,
    handle: GuardianHandle,
) -> Option<(ActorId, wowlab_types::sim::EnemyIdx)> {
    state
        .runtime
        .companions
        .guardians
        .get(handle.0 as usize)?
        .as_ref()
        .filter(|guardian| guardian.handle == handle)
        .map(|guardian| (guardian.source, guardian.target))
}

pub(crate) fn extend_guardians(state: &mut CombatState, tag: u32, amount_ms: u32) {
    let extension = SimTime::from_millis(amount_ms);

    for guardian in state.runtime.companions.guardians.iter_mut().flatten() {
        if guardian.spec.tag == tag {
            guardian.expires_at = guardian.expires_at.saturating_add(extension);
        }
    }
}

/// Remove up to `count` matching actors without firing their natural-demise hook.
pub(crate) fn dismiss_guardians(state: &mut CombatState, tag: u32, count: usize) -> usize {
    let mut removed = 0;

    for index in 0..state.runtime.companions.guardians.len() {
        if removed >= count {
            break;
        }

        let should_remove = state
            .runtime
            .companions
            .guardians
            .get(index)
            .and_then(Option::as_ref)
            .is_some_and(|guardian| guardian.spec.tag == tag);

        if should_remove {
            let guardian = state
                .runtime
                .companions
                .guardians
                .get_mut(index)
                .and_then(Option::take)
                .expect("matching guardian slot");

            let _ = state.deactivate_pet_health(guardian.source);

            removed += 1;
        }
    }

    removed
}

const fn event_for(
    guardian: &GuardianInstance,
    ability_index: usize,
    action_index: u16,
) -> GuardianEvent {
    GuardianEvent {
        handle: guardian.handle,
        tag: guardian.spec.tag,
        ability_index,
        action_index,
        spawned_at: guardian.spawned_at,
        expires_at: guardian.expires_at,
    }
}

fn fire_demise(ctx: &mut HookCtx<'_>, guardian: &GuardianInstance) {
    let Some(hook) = guardian.spec.on_demise else {
        return;
    };

    hook(ctx, event_for(guardian, 0, 0));
}

struct PreparedGuardianAction {
    ability: crate::state::GuardianAbility,
    event: GuardianEvent,
    source: ActorId,
    target: wowlab_types::sim::EnemyIdx,
    npc_id: Option<u32>,
}

#[derive(Clone, Copy)]
struct GuardianActionKey {
    handle: GuardianHandle,
    ability_index: usize,
    now: SimTime,
}

fn restore_guardian(state: &mut CombatState, guardian: GuardianInstance) {
    let handle = guardian.handle;
    let generation_is_current = state
        .runtime
        .companions
        .guardian_generations
        .get(handle.0 as usize)
        .is_some_and(|generation| *generation == handle.1);

    if generation_is_current
        && let Some(slot) = state
            .runtime
            .companions
            .guardians
            .get_mut(handle.0 as usize)
        && slot.is_none()
    {
        *slot = Some(guardian);
    }
}

fn prepare_guardian_action(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    handle: GuardianHandle,
    ability_index: usize,
    now: SimTime,
) -> Option<PreparedGuardianAction> {
    let slot = state
        .runtime
        .companions
        .guardians
        .get_mut(handle.0 as usize)?;

    if slot.as_ref()?.handle != handle {
        return None;
    }

    let mut guardian = slot.take()?;
    let Some(ability) = guardian.spec.abilities.get(ability_index).copied() else {
        restore_guardian(state, guardian);

        return None;
    };

    if guardian
        .abilities
        .get(ability_index)
        .is_none_or(|ability| ability.next_action_at != Some(now))
        || now > guardian.expires_at
    {
        restore_guardian(state, guardian);

        return None;
    }

    let target = if state.is_valid_target(guardian.target) {
        guardian.target
    } else {
        state.retarget();
        crate::builder::buffer_init::project_encounter(state, buf, now);
        let Some(target) = state.current_target() else {
            restore_guardian(state, guardian);

            return None;
        };

        target
    };

    guardian.target = target;
    let Some(ability_state) = guardian.abilities.get_mut(ability_index) else {
        restore_guardian(state, guardian);

        return None;
    };

    ability_state.next_action_at = None;
    ability_state.actions_executed = ability_state.actions_executed.saturating_add(1);
    let action_index = ability_state.actions_executed - 1;
    let prepared = PreparedGuardianAction {
        ability,
        event: event_for(&guardian, ability_index, action_index),
        source: guardian.source,
        target,
        npc_id: guardian.spec.npc_id,
    };

    restore_guardian(state, guardian);

    Some(prepared)
}

fn finish_guardian_action(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    key: GuardianActionKey,
    ability: crate::state::GuardianAbility,
    rng: &mut dyn FnMut() -> f64,
    sink: &mut TelemetrySink,
) {
    let GuardianActionKey {
        handle,
        ability_index,
        now,
    } = key;
    let Some(slot) = state
        .runtime
        .companions
        .guardians
        .get_mut(handle.0 as usize)
    else {
        return;
    };

    if slot
        .as_ref()
        .is_none_or(|guardian| guardian.handle != handle)
    {
        return;
    }

    let Some(mut guardian) = slot.take() else {
        return;
    };
    let Some(actions_executed) = guardian
        .abilities
        .get(ability_index)
        .map(|ability| ability.actions_executed)
    else {
        restore_guardian(state, guardian);

        return;
    };

    if ability.max_actions > 0 && actions_executed >= ability.max_actions {
        if ability.ends_guardian {
            let _ = state.deactivate_pet_health(guardian.source);
            let mut ctx = HookCtx::new(
                crate::context::HookCtxServices {
                    state,
                    buf,
                    sink,
                    rng,
                },
                crate::context::HookCtxRequest::for_target(now, guardian.target)
                    .with_source(guardian.source),
            )
            .with_source_damage_flags(DamageFlags::PET | DamageFlags::GUARDIAN)
            .with_source_npc_id(guardian.spec.npc_id);

            fire_demise(&mut ctx, &guardian);
        } else {
            restore_guardian(state, guardian);
        }

        return;
    }

    let delay = scaled_delay_ms(
        ActorView::new(state, buf, guardian.source),
        ability.action_interval_ms,
        ability.hasted_action_interval,
    )
    .max(1);
    let next = now.saturating_add(SimTime::from_millis(delay));
    let Some(ability_state) = guardian.abilities.get_mut(ability_index) else {
        restore_guardian(state, guardian);

        return;
    };

    if next > guardian.expires_at {
        restore_guardian(state, guardian);

        return;
    }

    ability_state.next_action_at = Some(next);
    let source = guardian.source;
    let target = guardian.target;

    restore_guardian(state, guardian);
    state.schedule(Event::GuardianAction {
        t: next,
        guardian_id: handle.0,
        guardian_generation: handle.1,
        ability_index,
        source,
        target,
    });
}

pub(crate) fn process_guardian_action(
    ctx: &mut CombatCtx<'_>,
    handle: GuardianHandle,
    ability_index: usize,
) {
    let Some(prepared) =
        prepare_guardian_action(ctx.state, ctx.buf, handle, ability_index, ctx.now)
    else {
        return;
    };
    let mut hook = HookCtx::new(
        crate::context::HookCtxServices {
            state: ctx.state,
            buf: ctx.buf,
            sink: ctx.sink,
            rng: ctx.rng,
        },
        crate::context::HookCtxRequest::for_target(ctx.now, prepared.target)
            .with_source(prepared.source),
    )
    .with_source_damage_flags(DamageFlags::PET | DamageFlags::GUARDIAN)
    .with_source_npc_id(prepared.npc_id);

    (prepared.ability.action)(&mut hook, prepared.event);
    finish_guardian_action(
        ctx.state,
        ctx.buf,
        GuardianActionKey {
            handle,
            ability_index,
            now: ctx.now,
        },
        prepared.ability,
        ctx.rng,
        ctx.sink,
    );
}

pub(crate) fn process_guardian_expire(ctx: &mut CombatCtx<'_>, handle: GuardianHandle) {
    let guardian_id = handle.0;
    let guardian_generation = handle.1;

    let Some(slot) = ctx
        .state
        .runtime
        .companions
        .guardians
        .get_mut(guardian_id as usize)
    else {
        return;
    };

    if slot
        .as_ref()
        .is_none_or(|guardian| guardian.handle != handle)
    {
        return;
    }

    let Some(guardian) = slot.take() else {
        return;
    };

    if ctx.now < guardian.expires_at {
        let expires_at = guardian.expires_at;

        *slot = Some(guardian);
        ctx.state.schedule(Event::GuardianExpire {
            t: expires_at,
            guardian_id,
            guardian_generation,
        });

        return;
    }

    if guardian
        .abilities
        .iter()
        .any(|ability| ability.next_action_at == Some(ctx.now))
    {
        *slot = Some(guardian);
        ctx.state.schedule(Event::GuardianExpire {
            t: ctx.now.saturating_add(SimTime::from_millis(1)),
            guardian_id,
            guardian_generation,
        });

        return;
    }

    let _ = ctx.state.deactivate_pet_health(guardian.source);
    let mut hook = HookCtx::new(
        crate::context::HookCtxServices {
            state: ctx.state,
            buf: ctx.buf,
            sink: ctx.sink,
            rng: ctx.rng,
        },
        crate::context::HookCtxRequest::for_target(ctx.now, guardian.target)
            .with_source(guardian.source),
    )
    .with_source_damage_flags(DamageFlags::PET | DamageFlags::GUARDIAN)
    .with_source_npc_id(guardian.spec.npc_id);

    fire_demise(&mut hook, &guardian);
}

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