wowlab_engine_combat/systems/

casting.rs

use wowlab_engine_ports::Event;
#[cfg(test)]
use wowlab_types::sim::SpellIdx;
use wowlab_types::{
    constants::HUNDRED,
    sim::{ActorId, SimTime},
};

use crate::{
    context::{ActorView, CombatView},
    state::{BuffEffect, CombatInstance, MovementState, SchoolLockout},
};

const CAST_PUSHBACK_MS: u32 = 500;
const CHANNEL_PUSHBACK_DIVISOR: u32 = 4;
const MAX_PUSHBACKS_PER_CAST: u8 = 2;

#[cfg(test)]
pub(crate) fn set_gcd(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_id: u32,
    now: SimTime,
) {
    let Some(target) = state.current_target() else {
        return;
    };
    let Some(local) = program.spell_local(spell_id) else {
        return;
    };
    let candidate = crate::handler::can_cast::CastCandidate::resolve_planned(
        state,
        program.rotation.local_binding(local),
        target,
    );

    set_gcd_for_candidate(program, state, candidate, now);
}

pub(crate) fn set_gcd_for_candidate(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    candidate: crate::handler::can_cast::CastCandidate,
    now: SimTime,
) {
    let spell = candidate.effective(program);

    if spell.channel.behavior.is_channel && !spell.channel.completion.gcd_on_start {
        return;
    }

    let effective = super::effective_gcd_ms(
        &CombatView::new(program, state),
        candidate.effective_local,
        spell.base_gcd_ms(),
    );
    let gcd_end = now.saturating_add(SimTime::from_millis(effective));

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

        state
            .runtime
            .pools
            .start_recovery_ready_at
            .start(owner, gcd_end);
    }

    if !spell.behavior.off_gcd {
        state.buffer.player_mut().gcd_end = gcd_end.as_secs_f64();
    }
}

#[must_use]
pub(crate) fn can_cast_while_moving(
    view: &CombatView<'_>,
    spell_local: crate::state::LocalSpellIdx,
    inherently_usable: bool,
) -> bool {
    if inherently_usable {
        return true;
    }

    let mut allowed = false;
    let target = view.program.damage.spell_action(spell_local);

    super::buffs::for_each_active_scoped_spell_modifier_for_action(
        ActorView::new(view.program, view.instance, ActorId::Player),
        target,
        |_, effect, binding| {
            let BuffEffect::CastWhileMovingFromEffect { .. } = effect else {
                return;
            };

            allowed |= binding
                .source_effect
                .is_some_and(|source| view.program.damage.effect_affects_action(source, target));
        },
    );

    allowed
}

#[must_use]
pub(crate) fn interrupt_cast(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    actor: ActorId,
    now: SimTime,
    lockout_ms: u32,
) -> bool {
    let Some(active) = state.runtime.casting.active_casts.get(actor).copied() else {
        return false;
    };

    if !active.interruptible || active.ends_at <= now {
        return false;
    }

    state.runtime.casting.active_casts.remove(actor);

    if lockout_ms > 0 {
        let expires_at = now.saturating_add(SimTime::from_millis(lockout_ms));

        state.runtime.control.school_lockouts.insert(
            actor,
            SchoolLockout {
                schools: active.school,
                expires_at,
            },
        );

        if actor == ActorId::Player {
            #[cfg(feature = "rotation-optimizations")]
            state.runtime.rotation_mutations.record_semantic(
                crate::state::runtime::RotationSemanticMutation::ActorState,
                crate::state::runtime::RotationMutationDirection::Fall,
                now,
            );
        }
    }

    if actor == ActorId::Player {
        state.runtime.casting.active_player_candidate = None;
        state.runtime.casting.selected_candidate = None;
        state.buffer.player_mut().cast_end = now.as_secs_f64();
        end_channel(program, state, now);
        state.schedule(Event::PlayerReady { t: now });
    }

    true
}

pub(crate) fn apply_movement_event(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    actor: ActorId,
    moving: bool,
    generation: u64,
    now: SimTime,
) {
    if state.runtime.control.movement_generation.value(actor) != generation {
        return;
    }

    #[cfg(feature = "rotation-optimizations")]
    let before = state.runtime.control.movement.value(actor);
    let after = if moving {
        MovementState::Moving
    } else {
        MovementState::Stationary
    };

    state.runtime.control.movement.set(actor, after);

    #[cfg(feature = "rotation-optimizations")]
    if actor == ActorId::Player && before != after {
        state.runtime.rotation_mutations.record_semantic(
            crate::state::runtime::RotationSemanticMutation::ActorState,
            if moving {
                crate::state::runtime::RotationMutationDirection::Fall
            } else {
                crate::state::runtime::RotationMutationDirection::Rise
            },
            now,
        );
    }

    if !moving || actor != ActorId::Player {
        return;
    }

    let hard_cast_breaks = state
        .runtime
        .casting
        .active_player_candidate
        .is_some_and(|candidate| {
            !can_cast_while_moving(
                &CombatView::new(program, state),
                candidate.effective_local,
                candidate
                    .effective(program)
                    .requirements
                    .availability
                    .usable_while_moving,
            )
        });

    if hard_cast_breaks {
        let _ = interrupt_cast(program, state, actor, now, 0);
    }

    let channel_breaks = state.runtime.casting.active_channel.is_some_and(|channel| {
        let spell = program.spell(channel.local);

        !can_cast_while_moving(
            &CombatView::new(program, state),
            channel.local,
            spell.requirements.availability.usable_while_moving,
        )
    });

    if channel_breaks {
        end_channel(program, state, now);
        state.schedule(Event::PlayerReady { t: now });
    }
}

// #t(fn: rust_cyclomatic_complexity) pushback validates actor, finalized candidate, resistance, limits, and typed rescheduling as one atomic cast-state transition.
pub(crate) fn apply_cast_pushback(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    actor: ActorId,
    now: SimTime,
) -> u32 {
    let Some(active) = state.runtime.casting.active_casts.get(actor).copied() else {
        return apply_channel_pushback(program, state, actor, now);
    };

    if active.ends_at <= now || active.pushback_count >= MAX_PUSHBACKS_PER_CAST {
        return 0;
    }

    if !active.damage_pushback {
        return 0;
    }

    let Some(action) = active.action else {
        return 0;
    };
    let resistance = pushback_resistance(ActorView::new(program, state, actor), action);
    let delay = wowlab_types::numeric::f64_to_u32_saturating_round(
        f64::from(CAST_PUSHBACK_MS) * (1.0 - resistance / HUNDRED),
    );

    if delay == 0 {
        return 0;
    }

    let new_end = active.ends_at.saturating_add(SimTime::from_millis(delay));

    if let Some(cast) = state.runtime.casting.active_casts.get_mut(actor) {
        cast.ends_at = new_end;
        cast.pushback_count = cast.pushback_count.saturating_add(1);
    }

    if actor == ActorId::Player
        && let Some(target) = active.target.or_else(|| state.current_target())
        && let Some(candidate) = state.runtime.casting.active_player_candidate
    {
        state.buffer.player_mut().cast_end = new_end.as_secs_f64();
        state.schedule(Event::CastComplete {
            t: new_end,
            spell: program.scheduled_spell(candidate.requested_local),
            empower_rank: active.empower_rank,
            source: actor,
            target,
        });
    }

    delay
}

fn apply_channel_pushback(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    actor: ActorId,
    now: SimTime,
) -> u32 {
    if actor != ActorId::Player
        || state.runtime.casting.active_channel_pushback_count >= MAX_PUSHBACKS_PER_CAST
    {
        return 0;
    }

    let Some(active_channel) = state.runtime.casting.active_channel else {
        return 0;
    };
    let spell = program.spell(active_channel.local);

    if !program
        .rotation
        .cast_profile(active_channel.local)
        .channel_duration_pushback
    {
        return 0;
    }

    let spell = *spell;
    let old_end = SimTime::from_secs_f64(state.buffer.player().channel_end);

    if old_end <= now {
        return 0;
    }

    let resistance = pushback_resistance(
        ActorView::new(program, state, actor),
        program.damage.spell_action(active_channel.local),
    );
    let base_reduction = spell.cast_time_ms / CHANNEL_PUSHBACK_DIVISOR;
    let reduction = wowlab_types::numeric::f64_to_u32_saturating_round(
        f64::from(base_reduction) * (1.0 - resistance / HUNDRED),
    )
    .min(old_end.saturating_sub(now).as_millis());

    if reduction == 0 {
        return 0;
    }

    let new_end = old_end.saturating_sub(SimTime::from_millis(reduction));
    let new_end_secs = new_end.as_secs_f64();

    state.runtime.casting.active_channel_pushback_count = state
        .runtime
        .casting
        .active_channel_pushback_count
        .saturating_add(1);
    state.buffer.player_mut().channel_end = new_end_secs;

    state.buffer.spell_mut_at(active_channel.handle).channel_end = new_end_secs;

    let gcd_end = SimTime::from_secs_f64(state.buffer.player().gcd_end);

    state.schedule(Event::PlayerReady {
        t: gcd_end.max(new_end).saturating_add(SimTime::from_millis(
            u32::from(spell.channel.completion.apply_lag) * program.config.cast_latency.channel_ms,
        )),
    });

    reduction
}

fn pushback_resistance(
    view: ActorView<'_>,
    spell: crate::state::program::LocalDamageActionIdx,
) -> f64 {
    let Some(owner) = super::buffs::spell_modifier_owner(view.actor) else {
        return 0.0;
    };
    let (flat, percent) = super::buffs::data_driven_actor_timing_modifiers(
        view.combat().for_actor(owner),
        spell,
        wowlab_engine_domain::dbc::ModifierPropertyKind::ResistPushback,
        |effect| match effect {
            BuffEffect::ResistPushbackFromEffect {
                value,
                source_spell_id,
                effect_index,
                operation,
            } => Some((*value, *source_spell_id, *effect_index, *operation)),
            _ => None,
        },
    );

    (flat + percent).clamp(0.0, HUNDRED)
}

pub(crate) fn end_channel(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
) {
    state.runtime.casting.channel_generation =
        state.runtime.casting.channel_generation.wrapping_add(1);
    state.runtime.casting.active_channel_target = None;
    let active_channel = state.runtime.casting.active_channel.take();

    state.runtime.casting.active_channel_pushback_count = 0;
    state.runtime.casting.active_channel_ticks_remaining = 0;
    state.runtime.casting.active_channel_on_last_tick = false;
    state.buffer.player_mut().channel_end = now.as_secs_f64();

    if let Some(active) = active_channel {
        debug_assert_eq!(
            program.spell(active.local).spell_id,
            active.spell.as_u32(),
            "active channel identity must match its finalized local spell"
        );
        let slot = state.buffer.spell_mut_at(active.handle);

        slot.is_channeling = 0;
        slot.channel_end = now.as_secs_f64();

        #[cfg(feature = "rotation-optimizations")]
        state.runtime.rotation_mutations.record_semantic(
            crate::state::runtime::RotationSemanticMutation::SpellState,
            crate::state::runtime::RotationMutationDirection::Fall,
            now,
        );
    }
}

#[cfg(test)]
mod tests;