wowlab_engine_combat/handler/can_cast/

wait.rs

//! Wait decisions derived from failed cast checks and resource regeneration.

use wowlab_engine_ports::SpecAction;
#[cfg(feature = "rotation-optimizations")]
use wowlab_types::sim::ActorId;
use wowlab_types::{constants::MS_PER_SECOND, sim::SimTime};

use super::{CastCandidate, CastReject};
use crate::{context::CombatView, state::CombatInstance, systems::rune_time_to_regen};

#[cfg(any(not(feature = "rotation-optimizations"), test))]
pub(super) const MIN_WAIT_MS: u32 = 10;

fn resource_ready_at(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    now: SimTime,
    target_cost: Option<f64>,
) -> Option<SimTime> {
    let (current, regen) = if let Some(resource_type) = program.config.base_stats.resource_type {
        program
            .buffer_resource(state, resource_type)
            .map_or((0.0, 0.0), |resource| {
                (resource.current, resource.regen_per_sec)
            })
    } else {
        (0.0, 0.0)
    };

    let cost = match target_cost {
        Some(cost) if cost > 0.0 => cost,
        _ => {
            if program.config.min_primary_cost <= 0.0 || program.config.min_primary_cost >= f64::MAX
            {
                return None;
            }

            program.config.min_primary_cost
        }
    };

    if regen <= 0.0 || current >= cost {
        return None;
    }

    let deficit = cost - current;

    if program.config.base_stats.resource_type == Some(wowlab_types::combat::ResourceType::Runes) {
        let needed = wowlab_types::numeric::f64_to_u32_saturating_ceil(deficit.max(0.0)) as usize;

        if let Some(seconds) = rune_time_to_regen(program, state, needed) {
            let wait_ms =
                wowlab_types::numeric::f64_to_u32_saturating_ceil(seconds * MS_PER_SECOND);

            return Some(
                now.saturating_add(SimTime::from_millis(exact_or_legacy_wait_ms(wait_ms))),
            );
        }
    }

    let wait_ms =
        wowlab_types::numeric::f64_to_u32_saturating_ceil((deficit / regen) * MS_PER_SECOND);

    Some(now.saturating_add(SimTime::from_millis(exact_or_legacy_wait_ms(wait_ms))))
}

fn exact_or_legacy_wait_ms(wait_ms: u32) -> u32 {
    #[cfg(feature = "rotation-optimizations")]
    {
        wait_ms
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    {
        wait_ms.max(MIN_WAIT_MS)
    }
}

#[cfg(feature = "rotation-optimizations")]
pub(in crate::handler) fn candidate_time_horizon(
    view: &CombatView<'_>,
    candidate: CastCandidate,
    now: SimTime,
    control_ready_at: Option<SimTime>,
    has_school_lockout: bool,
) -> Option<SimTime> {
    let program = view.program;
    let state = view.instance;
    let requested = state.buffer.spell_at(candidate.requested_slot(program));
    let effective = state.buffer.spell_at(candidate.effective_slot(program));

    if requested.is_enabled == 0 || effective.is_enabled == 0 {
        return None;
    }

    let spell = candidate.effective(program);
    let profile = candidate.effective_profile(program);
    let mut ready_at = now;

    if spell.cooldown.start_recovery_category.is_some() {
        let owner = program
            .start_recovery_category_owners
            .get(candidate.effective_local.as_usize())
            .copied()
            .unwrap_or(candidate.effective_local);

        ready_at = ready_at.max(state.runtime.pools.start_recovery_ready_at.ready_at(owner));
    }

    if effective.cost > 0.0 {
        let cost_bypassed = profile.cost_bypass_aura.is_some_and(|requirement| {
            program
                .rotation
                .aura_active(state, requirement, candidate.target)
        });

        if !cost_bypassed
            && let Some(resource_ready_at) =
                resource_ready_at(program, state, now, Some(effective.cost))
        {
            ready_at = ready_at.max(resource_ready_at);
        }
    }

    let cooldown = state.buffer.cooldown_at(candidate.cooldown_slot(program));
    let cooldown_ready_at = SimTime::from_secs_f64(cooldown.ready_at);

    if cooldown_ready_at > now {
        let cooldown_bypassed = profile.cooldown_bypass_aura.is_some_and(|requirement| {
            program
                .rotation
                .aura_active(state, requirement, candidate.target)
        });

        if !cooldown_bypassed {
            ready_at = ready_at.max(cooldown_ready_at);
        }
    }

    if let Some(control_ready_at) = control_ready_at {
        ready_at = ready_at.max(control_ready_at);
    }

    if has_school_lockout
        && let Some(school_ready_at) =
            state.school_lock_ready_at(ActorId::Player, profile.school_mask, now)
    {
        ready_at = ready_at.max(school_ready_at);
    }

    (ready_at > now).then_some(ready_at)
}

#[cfg(any(not(feature = "rotation-optimizations"), test))]
fn resource_wait(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    now: SimTime,
    target_cost: Option<f64>,
) -> SimTime {
    resource_ready_at(program, state, now, target_cost)
        .unwrap_or_else(|| now.saturating_add(SimTime::from_millis(MIN_WAIT_MS)))
}

#[cfg(feature = "rotation-optimizations")]
pub(in crate::handler) fn rejection_ready_at(
    view: &CombatView<'_>,
    candidate: CastCandidate,
    reason: CastReject,
    now: SimTime,
) -> Option<SimTime> {
    match reason {
        CastReject::PrimaryResource { cost, .. } => {
            resource_ready_at(view.program, view.instance, now, Some(cost))
        }
        CastReject::Cooldown { ready_at, .. } => Some(SimTime::from_secs_f64(ready_at)),
        CastReject::CooldownCategory { ready_at, .. }
        | CastReject::ChargeCategory { ready_at, .. }
        | CastReject::StartRecoveryCategory { ready_at, .. }
        | CastReject::SchoolLocked { ready_at } => Some(ready_at),
        CastReject::CrowdControlled { ready_at } => ready_at,
        CastReject::NoCharges => {
            let cooldown = view
                .instance
                .buffer
                .cooldown_at(candidate.cooldown_slot(view.program));

            (cooldown.next_charge_at > now.as_secs_f64())
                .then(|| SimTime::from_secs_f64(cooldown.next_charge_at))
        }
        _ => None,
    }
}

#[cfg(not(feature = "rotation-optimizations"))]
#[expect(
    clippy::unnecessary_wraps,
    reason = "both optimization configurations expose the same optional wait-decision contract"
)]
pub(in crate::handler) fn reject_to_wait(
    view: &CombatView<'_>,
    candidate: CastCandidate,
    reason: Option<CastReject>,
    now: SimTime,
) -> Option<SpecAction> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;

    if let Some(CastReject::StartRecoveryCategory { ready_at, .. }) = reason {
        return Some(SpecAction::Wait { until_ms: ready_at });
    }

    let cost = Some(
        state
            .buffer
            .spell_at(candidate.effective_slot(program))
            .cost,
    )
    .filter(|cost| *cost > 0.0);

    Some(SpecAction::Wait {
        until_ms: resource_wait(program, state, now, cost),
    })
}

#[cfg(feature = "rotation-optimizations")]
pub(in crate::handler) fn reject_to_wait(
    view: &CombatView<'_>,
    candidate: CastCandidate,
    reason: Option<CastReject>,
    now: SimTime,
) -> Option<SpecAction> {
    reason
        .and_then(|reason| rejection_ready_at(view, candidate, reason, now))
        .map(|until_ms| SpecAction::Wait { until_ms })
}

#[cfg(any(not(feature = "rotation-optimizations"), test))]
pub(in crate::handler) fn pool_wait(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    now: SimTime,
) -> SpecAction {
    SpecAction::Wait {
        until_ms: resource_wait(program, state, now, None),
    }
}