wowlab_engine_combat/handler/can_cast/

predicates.rs

use wowlab_engine_domain::{
    dbc::{ShapeshiftForm, SpellCastTargetFlags, SpellShapeshiftFormFlags, stance_mask_allows},
    rotation::DenseBuffer,
};
use wowlab_types::{
    constants::HUNDRED,
    sim::{ActorId, EnemyIdx, SimTime, SpellIdx},
};

use super::CastReject;
use crate::{
    context::{CombatView, HookView},
    state::CombatState,
    systems::{
        aura_stacks_by_id, bypass_aura_active, effective_cast_time_ms, effective_spell_ids,
        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(buf: &DenseBuffer, requested_spell_id: u32) -> Result<(), CastReject> {
    match buf.spell(SpellIdx(requested_spell_id)) {
        None => Err(CastReject::UnknownSpell),
        Some(spell) if spell.is_enabled == 0 => Err(CastReject::Disabled),
        Some(_) => Ok(()),
    }
}

fn has_primary_resource(
    view: &CombatView<'_>,
    spell_id: u32,
    target: EnemyIdx,
) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;
    let Some(spell) = buf.spell(SpellIdx(spell_id)) else {
        return Err(CastReject::UnknownSpell);
    };
    let cost_bypassed = state.spell_data(spell_id).is_some_and(|(_, data)| {
        bypass_aura_active(
            state,
            buf,
            data.requirements.cost_bypass_aura_id,
            ActorId::Player,
            Some(target),
        )
    });
    let have = state
        .config
        .base_stats
        .resource_type
        .and_then(|resource_type| buf.resource(resource_type))
        .map(|resource| resource.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<'_>,
    spell_id: u32,
    target: EnemyIdx,
) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;
    let Some(spell) = buf.spell(SpellIdx(spell_id)) else {
        return Err(CastReject::UnknownSpell);
    };
    let cost_bypassed = state.spell_data(spell_id).is_some_and(|(_, data)| {
        bypass_aura_active(
            state,
            buf,
            data.requirements.cost_bypass_aura_id,
            ActorId::Player,
            Some(target),
        )
    });
    let have = state
        .config
        .base_stats
        .secondary_resource_type
        .and_then(|resource_type| buf.resource(resource_type))
        .map(|resource| resource.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<'_>, spell_id: u32, target: EnemyIdx) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;
    let Some((_, spell)) = state.spell_data(spell_id) else {
        return Err(CastReject::UnknownSpell);
    };
    let bypassed = bypass_aura_active(
        state,
        buf,
        spell.requirements.cost_bypass_aura_id,
        ActorId::Player,
        Some(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<'_>,
    spell_id: u32,
    cooldown_spell_id: u32,
) -> Result<(), CastReject> {
    let HookView {
        state,
        buf,
        target,
        now,
    } = view;
    let Some(target) = target else {
        return Err(CastReject::NoTarget);
    };
    let bypassed = state.spell_data(spell_id).is_some_and(|(_, data)| {
        bypass_aura_active(
            state,
            buf,
            data.requirements.cooldown_bypass_aura_id,
            ActorId::Player,
            Some(target),
        )
    });
    let Some(cooldown) = (!bypassed)
        .then(|| buf.cooldown(SpellIdx(cooldown_spell_id)))
        .flatten()
    else {
        return Ok(());
    };

    category_cooldowns_ready(state, spell_id, 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(
    state: &CombatState,
    spell_id: u32,
    now: SimTime,
) -> Result<(), CastReject> {
    if let Some(category) = state
        .spell_data(spell_id)
        .and_then(|(_, spell)| spell.cooldown.cooldown_category)
    {
        if !state
            .runtime
            .pools
            .cooldown_category_ready_at
            .is_ready(&category, now)
        {
            let ready_at = state
                .runtime
                .pools
                .cooldown_category_ready_at
                .ready_at(&category);

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

    if let Some(category) = state
        .spell_data(spell_id)
        .filter(|(_, spell)| spell.cooldown.max_charges <= 1)
        .and_then(|(_, spell)| spell.cooldown.charge_category)
    {
        if !state
            .runtime
            .pools
            .charge_category_ready_at
            .is_ready(&category, now)
        {
            let ready_at = state
                .runtime
                .pools
                .charge_category_ready_at
                .ready_at(&category);

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

    Ok(())
}

fn in_execute_range(view: HookView<'_>, spell_id: u32) -> Result<(), CastReject> {
    let HookView {
        state, target, now, ..
    } = view;
    let Some(target) = target else {
        return Err(CastReject::NoTarget);
    };
    let Some((_, data)) = state.spell_data(spell_id) else {
        return Ok(());
    };

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

    let bypassed = crate::systems::ignores_aura_state(state, spell_id);
    let health = state.enemy_health_fraction(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<'_>,
    spell_id: u32,
    target: EnemyIdx,
) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;

    if crate::systems::ignores_aura_state(state, spell_id) {
        return Ok(());
    }

    let Some((_, data)) = state.spell_data(spell_id) else {
        return Ok(());
    };

    if data.requirements.gating_aura_id == 0 {
        return Ok(());
    }

    if !state
        .index
        .aura_by_id
        .contains_key(&data.requirements.gating_aura_id)
    {
        return Err(CastReject::GatingAuraUnknown {
            aura_id: data.requirements.gating_aura_id,
        });
    }

    let active = aura_stacks_by_id(
        state,
        buf,
        data.requirements.gating_aura_id,
        ActorId::Player,
        Some(target),
    ) >= i32::from(data.requirements.gating_aura_min_stacks);

    if !active {
        return Err(CastReject::GatingAuraInactive {
            aura_id: data.requirements.gating_aura_id,
            min_stacks: i32::from(data.requirements.gating_aura_min_stacks),
        });
    }

    Ok(())
}

fn stealth_requirement_met(view: &CombatView<'_>, spell_id: u32) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;

    if crate::systems::ignores_aura_state(state, spell_id) {
        return Ok(());
    }

    let requires_stealth = state
        .spell_data(spell_id)
        .is_some_and(|(_, spell)| spell.requirements.form.requires_stealth);

    if requires_stealth
        && buf.player().stealthed == 0
        && !crate::systems::active_stance_mask_exception(view, spell_id)
    {
        return Err(CastReject::RequiresStealth);
    }

    Ok(())
}

fn position_requirement_met(
    state: &CombatState,
    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<'_>, spell_id: u32) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;

    if crate::systems::ignores_aura_state(state, spell_id) {
        return Ok(());
    }

    let Some((_, spell)) = state.spell_data(spell_id) else {
        return Ok(());
    };

    if crate::systems::active_stance_mask_exception(view, spell_id) {
        return Ok(());
    }

    let form = i64::from(buf.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 = spell.requirements.shapeshift_required_mask;

    if spell.requirements.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 =
        buf.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 || spell.requirements.form.allow_while_unshifted {
            return Ok(());
        }

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

    let form_flags = state
        .defs
        .auras
        .iter()
        .find(|aura| i64::from(aura.shapeshift_form) == form)
        .map(|aura| SpellShapeshiftFormFlags::from_bits_retain(aura.shapeshift_form_flags));
    let Some(form_flags) = form_flags else {
        return Ok(());
    };

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

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

    Ok(())
}

fn weapon_requirement_met(state: &CombatState, spell_id: u32) -> Result<(), CastReject> {
    let Some((_, spell)) = state.spell_data(spell_id) else {
        return Ok(());
    };

    if spell.requirements.equipment.requires_main_hand
        && state.config.game_data.main_hand().speed_ms == 0
    {
        return Err(CastReject::RequiresMainHand);
    }

    if spell.requirements.equipment.requires_off_hand && state.config.game_data.off_hand().is_none()
    {
        return Err(CastReject::RequiresOffHand);
    }

    if spell
        .requirements
        .equipped_item_requirement
        .is_some_and(|requirement| {
            let hand = if spell.requirements.equipment.requires_off_hand {
                wowlab_engine_gamedata::ResolvedDamageWeapon::OffHand
            } else {
                wowlab_engine_gamedata::ResolvedDamageWeapon::MainHand
            };

            !wowlab_engine_domain::dbc::equipped_weapon_matches(
                &state.config.game_data,
                hand,
                requirement,
            )
        })
    {
        return Err(CastReject::EquippedItemRequirement);
    }

    Ok(())
}

fn start_recovery_ready(
    state: &CombatState,
    spell_data: &crate::state::SpellData,
    now: SimTime,
) -> Result<(), CastReject> {
    let Some(category) = spell_data.cooldown.start_recovery_category else {
        return Ok(());
    };

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

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

fn explicit_target_ready(
    state: &CombatState,
    buf: &DenseBuffer,
    spell_data: &crate::state::SpellData,
    idx: SpellIdx,
    target: EnemyIdx,
) -> Result<(), CastReject> {
    let required_targets =
        SpellCastTargetFlags::from_bits_retain(spell_data.targeting.required_explicit_target_mask);

    if required_targets.requires_hostile_unit()
        && !state.spell_target_in_range_with_buffs(buf, idx, target)
    {
        return Err(CastReject::OutOfRange);
    }

    Ok(())
}

fn actor_requirements_met(
    view: HookView<'_>,
    spell_id: u32,
    spell_data: &crate::state::SpellData,
) -> Result<(), CastReject> {
    let HookView {
        state, buf, now, ..
    } = view;

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

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

    let instant_cast_active = spell_data.requirements.instant_cast_aura_id != 0
        && aura_stacks_by_id(
            state,
            buf,
            spell_data.requirements.instant_cast_aura_id,
            ActorId::Player,
            state.current_target(),
        ) > 0;
    let requires_stationary_cast = spell_data.channel.behavior.is_channel
        || spell_data.empower_rank_count > 0
        || (!instant_cast_active
            && effective_cast_time_ms(&view.combat(), spell_id, spell_data.cast_time_ms) > 0);

    if requires_stationary_cast
        && state.movement_state(ActorId::Player) == crate::state::MovementState::Moving
        && !crate::systems::can_cast_while_moving(&view.combat(), spell_id)
    {
        return Err(CastReject::Moving);
    }

    let schools = wowlab_engine_domain::dbc::SpellSchoolMask::from_dbc(
        state
            .config
            .game_data
            .school_mask(SpellIdx::from_raw(spell_id))
            .unwrap_or_default(),
    );

    if state.school_locked(ActorId::Player, schools, now) {
        return Err(CastReject::SchoolLocked);
    }

    weapon_requirement_met(state, spell_id)
}

fn aura_state_requirements_met(
    view: HookView<'_>,
    spell_id: u32,
    spell_data: &crate::state::SpellData,
) -> Result<(), CastReject> {
    let HookView {
        state,
        buf,
        target,
        now,
    } = view;

    let Some(target) = target else {
        return Err(CastReject::NoTarget);
    };

    if crate::systems::ignores_aura_state(state, spell_id) {
        return Ok(());
    }

    let required = [
        (
            ActorId::Player,
            spell_data.requirements.caster_aura_state,
            true,
        ),
        (
            ActorId::Enemy(target),
            spell_data.requirements.target_aura_state,
            true,
        ),
        (
            ActorId::Player,
            spell_data.requirements.exclude_caster_aura_state,
            false,
        ),
        (
            ActorId::Enemy(target),
            spell_data.requirements.exclude_target_aura_state,
            false,
        ),
    ];

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

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

    let required_spells = [
        (
            ActorId::Player,
            spell_data.requirements.caster_aura_spell,
            true,
        ),
        (
            ActorId::Enemy(target),
            spell_data.requirements.target_aura_spell,
            true,
        ),
        (
            ActorId::Player,
            spell_data.requirements.exclude_caster_aura_spell,
            false,
        ),
        (
            ActorId::Enemy(target),
            spell_data.requirements.exclude_target_aura_spell,
            false,
        ),
    ];

    for (actor, raw, must_have) in required_spells {
        if raw <= 0 {
            continue;
        }

        let present = state
            .aura_local(u32::try_from(raw).unwrap_or_default())
            .is_some_and(|local| match actor {
                ActorId::Player if state.aura(local).on == wowlab_types::sim::AuraOn::Player => {
                    crate::systems::is_aura_active(
                        &view.combat(),
                        local,
                        ActorId::Player,
                        Some(target),
                    )
                }
                ActorId::Enemy(enemy)
                    if state.aura(local).on == wowlab_types::sim::AuraOn::Target =>
                {
                    crate::systems::is_aura_active(
                        &view.combat(),
                        local,
                        ActorId::Player,
                        Some(enemy),
                    )
                }
                _ => false,
            });

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

    Ok(())
}

/// Full cast-eligibility check returning the reason a spell cannot be cast, or `Ok(())` when castable.
pub(in crate::handler) fn cast_rejection(
    view: &CombatView<'_>,
    spell_id: u32,
    now: SimTime,
) -> Result<(), CastReject> {
    let CombatView { state, buf, .. } = view;
    let target = state.current_target().ok_or(CastReject::NoTarget)?;
    let hook_view = view.for_hook(now, Some(target));

    requested_spell_enabled(buf, spell_id)?;

    let (spell_id, cooldown_spell_id) = effective_spell_ids(view, spell_id, target);
    let idx = SpellIdx(spell_id);
    let Some(spell) = buf.spell(idx) else {
        return Err(CastReject::UnknownSpell);
    };
    let Some((_, spell_data)) = state.spell_data(spell_id) else {
        return Err(CastReject::UnknownSpell);
    };

    if spell.is_enabled == 0 {
        return Err(CastReject::Disabled);
    }

    start_recovery_ready(state, spell_data, now)?;

    has_primary_resource(view, spell_id, target)?;
    has_secondary_resource(view, spell_id, target)?;
    has_health(view, spell_id, target)?;
    cooldown_ready(hook_view, spell_id, cooldown_spell_id)?;
    in_execute_range(hook_view, spell_id)?;
    gating_aura_active(view, spell_id, target)?;
    aura_state_requirements_met(hook_view, spell_id, spell_data)?;
    actor_requirements_met(hook_view, spell_id, spell_data)?;

    explicit_target_ready(state, buf, spell_data, idx, target)
}

/// Yes/no cast eligibility. Thin wrapper over [`cast_rejection`].
#[cfg(test)]
pub(super) fn can_cast(view: &CombatView<'_>, spell_id: u32, now: SimTime) -> bool {
    cast_rejection(view, spell_id, now).is_ok()
}