wowlab_engine_combat/handler/can_cast/

predicates.rs

use wowlab_engine_domain::dbc::{ShapeshiftForm, SpellShapeshiftFormFlags, stance_mask_allows};
use wowlab_types::{
    constants::HUNDRED,
    sim::{ActorId, SimTime},
};

use super::{CastCandidate, CastReject};
use crate::{
    context::{CombatView, HookView},
    state::{CombatInstance, LocalSpellIdx},
    systems::{effective_cast_time_ms, spell_health_cost},
};

/// Reject a spell whose own slot is disabled, before any aura-332 override is resolved.
///
/// An override changes what the requested button casts, never whether the character has it.
fn requested_spell_enabled(
    view: &CombatView<'_>,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    if view
        .instance
        .buffer
        .spell_at(candidate.requested_slot(view.program))
        .is_enabled
        == 0
    {
        return Err(CastReject::Disabled);
    }

    Ok(())
}

fn has_primary_resource(view: &CombatView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;
    let spell = state.buffer.spell_at(candidate.effective_slot(program));
    let profile = candidate.effective_profile(program);

    if spell.cost <= 0.0 {
        return Ok(());
    }

    let cost_bypassed = profile.cost_bypass_aura.is_some_and(|requirement| {
        program
            .rotation
            .aura_active(state, requirement, candidate.target)
    });
    let have = profile
        .primary_resource
        .map(|handle| state.buffer.resource_at(handle).current);
    let available = have.is_none_or(|current| current >= spell.cost);

    if !cost_bypassed && spell.cost > 0.0 && !available {
        return Err(CastReject::PrimaryResource {
            have: have.unwrap_or(0.0),
            cost: spell.cost,
        });
    }

    Ok(())
}

fn has_secondary_resource(
    view: &CombatView<'_>,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;
    let spell = state.buffer.spell_at(candidate.effective_slot(program));
    let profile = candidate.effective_profile(program);

    if spell.secondary_cost <= 0.0 {
        return Ok(());
    }

    let cost_bypassed = profile.cost_bypass_aura.is_some_and(|requirement| {
        program
            .rotation
            .aura_active(state, requirement, candidate.target)
    });
    let have = profile
        .secondary_resource
        .map(|handle| state.buffer.resource_at(handle).current);
    let available = have.is_none_or(|current| current >= spell.secondary_cost);

    if !cost_bypassed && spell.secondary_cost > 0.0 && !available {
        return Err(CastReject::SecondaryResource {
            have: have.unwrap_or(0.0),
            cost: spell.secondary_cost,
        });
    }

    Ok(())
}

fn has_health(view: &CombatView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;
    let spell = candidate.effective(program);
    let profile = candidate.effective_profile(program);

    if spell.cost.health_cost <= 0.0 && spell.cost.health_cost_pct <= 0.0 {
        return Ok(());
    }

    let bypassed = profile.cost_bypass_aura.is_some_and(|requirement| {
        program
            .rotation
            .aura_active(state, requirement, candidate.target)
    });
    let cost = spell_health_cost(
        state,
        ActorId::Player,
        spell.cost.health_cost,
        spell.cost.health_cost_pct,
    );
    let have = state.friendly_actor_health(ActorId::Player).unwrap_or(0.0);

    if !bypassed && cost > 0.0 && have < cost {
        return Err(CastReject::Health { have, cost });
    }

    Ok(())
}

fn cooldown_ready(view: HookView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let HookView {
        program,
        instance: state,
        now,
        ..
    } = view;
    let bypassed = candidate
        .effective_profile(program)
        .cooldown_bypass_aura
        .is_some_and(|requirement| {
            program
                .rotation
                .aura_active(state, requirement, candidate.target)
        });

    if bypassed {
        return Ok(());
    }

    let cooldown = state.buffer.cooldown_at(candidate.cooldown_slot(program));

    category_cooldowns_ready(program, state, candidate, now)?;

    if cooldown.max_charges > 1 && cooldown.current_charges == 0 {
        return Err(CastReject::NoCharges);
    }

    if cooldown.max_charges <= 1 && now.as_secs_f64() < cooldown.ready_at {
        return Err(CastReject::Cooldown {
            ready_at: cooldown.ready_at,
            now: now.as_secs_f64(),
        });
    }

    Ok(())
}

fn category_cooldowns_ready(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    candidate: CastCandidate,
    now: SimTime,
) -> Result<(), CastReject> {
    let spell = candidate.effective(program);

    if let Some(category) = spell.cooldown.cooldown_category
        && !state
            .runtime
            .pools
            .cooldown_category_ready_at
            .is_ready(candidate.effective_local, now)
    {
        let ready_at = state
            .runtime
            .pools
            .cooldown_category_ready_at
            .ready_at(candidate.effective_local);

        return Err(CastReject::CooldownCategory {
            category,
            ready_at,
            now,
        });
    }

    if spell.cooldown.max_charges <= 1
        && let Some(category) = spell.cooldown.charge_category
        && !state
            .runtime
            .pools
            .charge_category_ready_at
            .is_ready(candidate.effective_local, now)
    {
        let ready_at = state
            .runtime
            .pools
            .charge_category_ready_at
            .ready_at(candidate.effective_local);

        return Err(CastReject::ChargeCategory {
            category,
            ready_at,
            now,
        });
    }

    Ok(())
}

fn in_execute_range(view: HookView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let HookView {
        program,
        instance: state,
        now,
        ..
    } = view;
    let data = candidate.effective(program);

    if data.requirements.execute_below_pct <= 0.0 {
        return Ok(());
    }

    let bypassed = state
        .runtime
        .pools
        .spell_gates
        .ignores_aura_state(candidate.effective_local);
    let health = state.enemy_health_fraction(program, candidate.target, now);
    let in_execute =
        health.is_some_and(|health| health <= data.requirements.execute_below_pct / HUNDRED);

    if !bypassed && !in_execute {
        return Err(CastReject::ExecuteRange {
            target_health_pct: health.unwrap_or(1.0) * HUNDRED,
            threshold_pct: data.requirements.execute_below_pct,
        });
    }

    Ok(())
}

fn gating_aura_active(view: &CombatView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;
    let Some(requirement) = candidate.effective_profile(program).gating_aura else {
        return Ok(());
    };

    if state
        .runtime
        .pools
        .spell_gates
        .ignores_aura_state(candidate.effective_local)
    {
        return Ok(());
    }

    let active = program
        .rotation
        .aura_active(state, requirement, candidate.target);

    if !active {
        return Err(CastReject::GatingAuraInactive {
            aura_id: requirement.aura_id,
            min_stacks: i32::from(requirement.min_stacks),
        });
    }

    Ok(())
}

fn stealth_requirement_met(
    view: &CombatView<'_>,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    let state = view.instance;

    let profile = candidate.effective_profile(view.program);

    if !profile.requires_stealth {
        return Ok(());
    }

    if state
        .runtime
        .pools
        .spell_gates
        .ignores_aura_state(candidate.effective_local)
    {
        return Ok(());
    }

    if state.buffer.player().stealthed == 0
        && !view
            .program
            .rotation
            .stance_exception_active(state, profile)
    {
        return Err(CastReject::RequiresStealth);
    }

    Ok(())
}

fn position_requirement_met(
    state: &CombatInstance,
    spell_data: &crate::state::SpellData,
) -> Result<(), CastReject> {
    if spell_data.requirements.equipment.requires_behind_target
        && state.attack_position() != crate::state::AttackPosition::Behind
    {
        return Err(CastReject::RequiresBehindTarget);
    }

    Ok(())
}

// #t(fn: rust_cyclomatic_complexity) mirrors the independent allowed/excluded/form-zero rules
fn shapeshift_requirement_met(
    view: &CombatView<'_>,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;
    let profile = candidate.effective_profile(program);

    if profile.shapeshift_required_mask == 0
        && profile.shapeshift_excluded_mask == 0
        && !profile.requires_unshifted
    {
        return Ok(());
    }

    if state
        .runtime
        .pools
        .spell_gates
        .ignores_aura_state(candidate.effective_local)
        || program.rotation.stance_exception_active(state, profile)
    {
        return Ok(());
    }

    let form = i64::from(state.buffer.player().shapeshift_form);
    let current_mask = u32::try_from(form.saturating_sub(1))
        .ok()
        .and_then(|shift| 1_u64.checked_shl(shift))
        .unwrap_or(0);
    let required = profile.shapeshift_required_mask;

    if profile.shapeshift_excluded_mask & current_mask != 0 {
        return Err(CastReject::ShapeshiftExcluded { form });
    }

    // Stance mask is authoritative: a listed current form (or the stealth-stance bridge) grants the cast regardless of the `Not Shapeshifted` attribute (how Moonkin casts Sunfire).

    let form_listed = required & current_mask != 0;
    let stealth_listed = state.buffer.player().stealthed != 0
        && stance_mask_allows(required, ShapeshiftForm::Stealth);

    if form_listed || stealth_listed {
        return Ok(());
    }

    if form == 0 {
        // Unshifted casts require either no form or `Allow While Not Shapeshifted`; `Not Shapeshifted` alone does not grant it (Ambush still needs the stealth stance above).
        if required == 0 || profile.allow_while_unshifted {
            return Ok(());
        }

        return Err(CastReject::ShapeshiftRequired {
            form,
            required_mask: required,
        });
    }

    let Ok(form_index) = u8::try_from(form) else {
        return Ok(());
    };
    let form_flags = program.rotation.shapeshift_form_flags(form_index);

    if form_flags.is_empty() {
        return Ok(());
    }

    if form_flags.acts_as_shifted()
        && (profile.requires_unshifted
            || form_flags.contains(SpellShapeshiftFormFlags::CAN_ONLY_CAST_SHAPESHIFT_SPELLS))
    {
        return Err(CastReject::RequiresUnshifted { form });
    }

    if required != 0 && (form_flags.acts_as_shifted() || !profile.allow_while_unshifted) {
        return Err(CastReject::ShapeshiftRequired {
            form,
            required_mask: required,
        });
    }

    Ok(())
}

fn weapon_requirement_met(
    program: &crate::state::CombatProgram,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    let spell = candidate.effective(program);
    let profile = candidate.effective_profile(program);

    if !spell.requirements.equipment.requires_main_hand
        && !spell.requirements.equipment.requires_off_hand
        && spell.requirements.equipped_item_requirement.is_none()
    {
        return Ok(());
    }

    if spell.requirements.equipment.requires_main_hand && !profile.main_hand_available {
        return Err(CastReject::RequiresMainHand);
    }

    if spell.requirements.equipment.requires_off_hand && !profile.off_hand_available {
        return Err(CastReject::RequiresOffHand);
    }

    if spell.requirements.equipped_item_requirement.is_some() && !profile.equipped_item_matches {
        return Err(CastReject::EquippedItemRequirement);
    }

    Ok(())
}

fn start_recovery_ready(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    spell_local: LocalSpellIdx,
    spell_data: &crate::state::SpellData,
    now: SimTime,
) -> Result<(), CastReject> {
    let Some(category) = spell_data.cooldown.start_recovery_category else {
        return Ok(());
    };
    let owner = program
        .start_recovery_category_owners
        .get(spell_local.as_usize())
        .copied()
        .unwrap_or(spell_local);

    if state
        .runtime
        .pools
        .start_recovery_ready_at
        .is_ready(owner, now)
    {
        return Ok(());
    }

    Err(CastReject::StartRecoveryCategory {
        category,
        ready_at: state.runtime.pools.start_recovery_ready_at.ready_at(owner),
        now,
    })
}

fn explicit_target_ready(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    let profile = candidate.effective_profile(program);

    if !profile.requires_hostile_target {
        return Ok(());
    }

    if !state.spell_target_in_range_profile_with_buffs(program, profile, candidate.target) {
        return Err(CastReject::OutOfRange);
    }

    Ok(())
}

fn actor_requirements_met(view: HookView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let HookView {
        program,
        instance: state,
        now,
        ..
    } = view;

    if state.actor_cast_blocked_by_control(ActorId::Player, now) {
        return Err(CastReject::CrowdControlled {
            ready_at: state.actor_control_ready_at(ActorId::Player, now),
        });
    }

    let spell_data = candidate.effective(program);

    stealth_requirement_met(&view.combat(), candidate)?;
    position_requirement_met(state, spell_data)?;
    shapeshift_requirement_met(&view.combat(), candidate)?;

    if state.movement_state(ActorId::Player) == crate::state::MovementState::Moving
        && stationary_cast_required(view, candidate)
        && !crate::systems::can_cast_while_moving(
            &view.combat(),
            candidate.effective_local,
            spell_data.requirements.availability.usable_while_moving,
        )
    {
        return Err(CastReject::Moving);
    }

    school_and_weapon_requirements(program, state, candidate, now)
}

fn stationary_cast_required(view: HookView<'_>, candidate: CastCandidate) -> bool {
    let spell = candidate.effective(view.program);
    let instant_cast_active = candidate
        .effective_profile(view.program)
        .instant_cast_aura
        .is_some_and(|requirement| {
            view.program
                .rotation
                .aura_active(view.instance, requirement, candidate.target)
        });

    spell.channel.behavior.is_channel
        || spell.empower_rank_count > 0
        || (!instant_cast_active
            && effective_cast_time_ms(
                &view.combat(),
                candidate.effective_local,
                spell.cast_time_ms,
            ) > 0)
}

fn school_and_weapon_requirements(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    candidate: CastCandidate,
    now: SimTime,
) -> Result<(), CastReject> {
    if !state
        .runtime
        .control
        .school_lockouts
        .contains_key(ActorId::Player)
    {
        return weapon_requirement_met(program, candidate);
    }

    let schools = candidate.effective_profile(program).school_mask;

    if let Some(ready_at) = state.school_lock_ready_at(ActorId::Player, schools, now) {
        return Err(CastReject::SchoolLocked { ready_at });
    }

    weapon_requirement_met(program, candidate)
}

fn aura_state_requirements_met(
    view: HookView<'_>,
    candidate: CastCandidate,
) -> Result<(), CastReject> {
    let state = view.instance;
    let profile = candidate.effective_profile(view.program);
    let has_state_requirements = [
        profile.aura_states.required_caster,
        profile.aura_states.required_target,
        profile.aura_states.excluded_caster,
        profile.aura_states.excluded_target,
    ]
    .into_iter()
    .any(|requirement| requirement.is_some());
    let has_spell_requirements = [
        profile.required_caster_aura,
        profile.required_target_aura,
        profile.excluded_caster_aura,
        profile.excluded_target_aura,
    ]
    .into_iter()
    .any(|requirement| requirement.is_some());

    if !has_state_requirements && !has_spell_requirements {
        return Ok(());
    }

    if state
        .runtime
        .pools
        .spell_gates
        .ignores_aura_state(candidate.effective_local)
    {
        return Ok(());
    }

    aura_state_flags_met(view, candidate)?;

    aura_spell_flags_met(view, candidate)
}

fn aura_state_flags_met(view: HookView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let requirements = candidate.effective_profile(view.program).aura_states;
    let required = [
        (ActorId::Player, requirements.required_caster, true),
        (
            ActorId::Enemy(candidate.target),
            requirements.required_target,
            true,
        ),
        (ActorId::Player, requirements.excluded_caster, false),
        (
            ActorId::Enemy(candidate.target),
            requirements.excluded_target,
            false,
        ),
    ];

    for (actor, aura_state, must_have) in required {
        let Some(aura_state) = aura_state else {
            continue;
        };
        let present = view
            .instance
            .has_aura_state(view.program, actor, aura_state, view.now);

        if present != must_have {
            return Err(CastReject::AuraState);
        }
    }

    Ok(())
}

fn aura_spell_flags_met(view: HookView<'_>, candidate: CastCandidate) -> Result<(), CastReject> {
    let profile = candidate.effective_profile(view.program);
    let required_spells = [
        (profile.required_caster_aura, true),
        (profile.required_target_aura, true),
        (profile.excluded_caster_aura, false),
        (profile.excluded_target_aura, false),
    ];

    for (requirement, must_have) in required_spells {
        let Some(requirement) = requirement else {
            continue;
        };
        let present =
            view.program
                .rotation
                .aura_active(view.instance, requirement, candidate.target);

        if present != must_have {
            return Err(CastReject::AuraState);
        }
    }

    Ok(())
}

/// Evaluate one fully resolved candidate and return its first cast-rejection reason.
pub(in crate::handler) fn candidate_rejection(
    view: &CombatView<'_>,
    candidate: CastCandidate,
    now: SimTime,
) -> Result<(), CastReject> {
    let CombatView {
        program,
        instance: state,
        ..
    } = view;
    let hook_view = view.for_hook(now, Some(candidate.target));

    debug_assert_eq!(
        program.spell(candidate.requested_local).spell_id,
        candidate.requested_spell_id(program),
        "candidate requested identity changed after finalization"
    );
    debug_assert_eq!(
        candidate.requested_profile(program).spell_id,
        candidate.requested_spell_id(program),
        "candidate requested cast profile changed after finalization"
    );
    debug_assert_eq!(
        program.buffer_bindings.cooldown(candidate.cooldown_local),
        candidate.cooldown_slot(program),
        "candidate cooldown binding changed after finalization"
    );

    requested_spell_enabled(view, candidate)?;

    if state
        .buffer
        .spell_at(candidate.effective_slot(program))
        .is_enabled
        == 0
    {
        return Err(CastReject::Disabled);
    }

    start_recovery_ready(
        program,
        state,
        candidate.effective_local,
        candidate.effective(program),
        now,
    )?;

    has_primary_resource(view, candidate)?;
    has_secondary_resource(view, candidate)?;
    has_health(view, candidate)?;
    cooldown_ready(hook_view, candidate)?;
    in_execute_range(hook_view, candidate)?;
    gating_aura_active(view, candidate)?;
    aura_state_requirements_met(hook_view, candidate)?;
    actor_requirements_met(hook_view, candidate)?;

    explicit_target_ready(program, state, candidate)
}

/// Yes/no cast eligibility for focused predicate tests.
#[cfg(test)]
pub(super) fn can_cast(view: &CombatView<'_>, spell_id: u32, now: SimTime) -> bool {
    let Some(target) = view.instance.current_target() else {
        return false;
    };
    let Some(local) = view.program.spell_local(spell_id) else {
        return false;
    };
    let binding = view.program.rotation.local_binding(local);
    let candidate = CastCandidate::resolve_planned(view.instance, binding, target);

    candidate_rejection(view, candidate, now).is_ok()
}