wowlab_engine_combat/systems/

auto_attack.rs

//! Auto-attack swing scheduling, damage, and earliest-swing queries.

use wowlab_engine_domain::{constants::OFF_HAND_DAMAGE_MULT, damage::WEAPON_POWER_COEFFICIENT};
use wowlab_engine_ports::Event;
#[cfg(test)]
use wowlab_engine_telemetry::TelemetrySink;
#[cfg(test)]
use wowlab_types::sim::SpellIdx;
use wowlab_types::{
    constants::MS_PER_SECOND,
    sim::{ActorId, EnemyIdx, SimTime},
};

use super::{
    auras::drain_deferred_work,
    buffs::{
        active_auto_attack_replacement, active_form_combat_round_time_ms,
        current_auto_attack_mult_for,
    },
    cooldowns::reduce_cooldown,
    damage_pipeline::{
        ProfiledDamageDef, WeaponDamageInput, deal_bound_profiled_damage_def,
        deal_damage_ap_with_weapon,
    },
};
use crate::{
    DamageFlags,
    context::{CombatCtx, HookCtx},
    state::{CombatInstance, RuntimeDamageDef, SwingEvent, SwingHand},
};

const DUAL_WIELD_WHITE_MISS_CHANCE: f64 = 0.19;
const RAGE_PER_SWING_SECOND: f64 = 1.75;

fn set_player_auto_attacks_active(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    active: bool,
    now: SimTime,
) -> bool {
    let mut changed = false;
    let form_swing_ms = active_form_combat_round_time_ms(program, state);

    for (index, attack) in program.auto_attacks.iter().copied().enumerate() {
        if attack.is_pet {
            continue;
        }

        let weapon_swing_ms = program
            .damage
            .auto_attack_profile(index)
            .and_then(|profile| profile.weapon)
            .map(|weapon| weapon.speed_ms);

        let swing_ms = form_swing_ms
            .or(weapon_swing_ms)
            .filter(|speed| *speed > 0)
            .unwrap_or(attack.swing_ms);
        let is_scheduled = program
            .buffer_swing(state, index)
            .is_some_and(|swing| swing.next_swing_at.is_finite());

        if active {
            if !is_scheduled {
                reschedule_swing(program, state, index, swing_ms, ActorId::Player, now);
                changed = true;
            }
        } else if is_scheduled && let Some(swing) = program.buffer_swing_mut(state, index) {
            swing.next_swing_at = f64::INFINITY;
            changed = true;
        }
    }

    changed
}

/// Apply DBC action attributes that start or cancel the player's shared swing scheduler.
pub(crate) fn apply_auto_attack_action_lifecycle(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    action: crate::state::program::LocalDamageActionIdx,
    source: ActorId,
    target: EnemyIdx,
    now: SimTime,
) {
    if source != ActorId::Player {
        return;
    }

    let action = program.damage.action_at(action);
    let attributes = action.attributes.as_ref();
    let cancels = wowlab_engine_domain::dbc::spell_attribute_is(
        attributes,
        wowlab_engine_domain::dbc::SpellAttributeKind::CancelsAutoAttack,
    );

    if cancels {
        set_player_auto_attacks_active(program, state, false, now);

        return;
    }

    let initiates = wowlab_engine_domain::dbc::spell_attribute_is(
        attributes,
        wowlab_engine_domain::dbc::SpellAttributeKind::InitiatesAutoAttack,
    ) || action.has_attack_effect;

    if initiates
        && set_player_auto_attacks_active(program, state, true, now)
        && let Some(t) = earliest_auto_attack_time(program, state)
    {
        state.schedule(Event::AutoAttack { t, source, target });
    }
}

fn replacement_damage(
    program: &crate::state::CombatProgram,
    _state: &CombatInstance,
    binding: crate::state::program::DamageRequestBinding,
    damage_multiplier: f64,
) -> Option<(u32, Option<f64>, RuntimeDamageDef)> {
    let action = program.damage.action_at(binding.effect_action());
    let spell_id = action.spell.as_u32();

    let (base_points, damage) = program
        .damage
        .resolved_action_damage(binding.effect_action())?;
    let base_points = Some(base_points * damage_multiplier);

    Some((spell_id, base_points, damage.scaled(damage_multiplier)))
}

// #t(fn: rust_unchecked_indexing) i bounded by auto_attacks.len(); target_local from on_crit_reduce_charge validated at build time
// #t(fn: rust_cyclomatic_complexity) inherent auto-attack branching: pet vs MH vs OH, armed vs unarmed, crit procs
// #t(fn: rust_max_fn_lines) the swing pipeline is a single ordered state transition.
pub(crate) fn phase_auto_attacks_for(ctx: &mut CombatCtx<'_>) {
    let source = ctx.source;
    let target = ctx.target;
    let now = ctx.now;
    let program = ctx.program;
    let state = &mut *ctx.instance;
    let sink = &mut *ctx.sink;
    let rng = &mut *ctx.rng;
    let now_secs = now.as_secs_f64();

    for i in 0..program.auto_attacks.len() {
        let aa = program.auto_attacks[i];
        let Some(auto_profile) = program.damage.auto_attack_profile(i) else {
            continue;
        };
        let next_at_secs = match program.buffer_swing(state, i) {
            Some(sw) => sw.next_swing_at,
            None => continue,
        };

        if now_secs < next_at_secs {
            continue;
        }

        let weapon_slot = auto_profile.weapon;
        let hand = auto_profile.hand;
        let hand_mult = if hand == SwingHand::OffHand {
            OFF_HAND_DAMAGE_MULT
        } else {
            1.0
        };
        let auto_binding = auto_profile.request;
        let weapon_multiplier = auto_profile.weapon_multiplier;
        let normalized = auto_profile.normalized;

        // A shifted form replaces the weapon with a beast weapon: its DBC combat round time becomes
        // the swing period, and the weapon's damage range is renormalized to it.
        let form_swing_ms = (!aa.is_pet)
            .then(|| active_form_combat_round_time_ms(program, state))
            .flatten();

        let (mut weapon_input, swing_ms, mut ap_coef) = match weapon_slot {
            Some(w) if w.speed_ms > 0 && w.max_damage > 0.0 => {
                let multiplier = hand_mult * weapon_multiplier;
                let swing_ms = form_swing_ms.unwrap_or(w.speed_ms);
                let normalizing_factor = f64::from(swing_ms) / f64::from(w.speed_ms);
                let speed_s = match form_swing_ms {
                    Some(round_time_ms) => f64::from(round_time_ms) / MS_PER_SECOND,
                    None if normalized => w.normalized_speed_s,
                    None => f64::from(w.speed_ms) / MS_PER_SECOND,
                };

                (
                    WeaponDamageInput {
                        min: w.min_damage * normalizing_factor,
                        max: w.max_damage * normalizing_factor,
                        multiplier,
                        ap_coefficient: speed_s / WEAPON_POWER_COEFFICIENT * multiplier,
                        is_auto_attack: true,
                        swing_hand: Some(hand),
                        swing_speed_ms: swing_ms,
                        miss_chance: 0.0,
                    },
                    swing_ms,
                    0.0,
                )
            }
            Some(w) if w.speed_ms > 0 => (
                WeaponDamageInput::none(),
                form_swing_ms.unwrap_or(w.speed_ms),
                aa.ap_coef,
            ),
            Some(_) => {
                continue;
            }
            None if aa.is_pet => (WeaponDamageInput::none(), aa.swing_ms, aa.ap_coef),
            None => continue,
        };

        weapon_input.is_auto_attack = true;
        weapon_input.swing_hand = Some(hand);
        weapon_input.swing_speed_ms = swing_ms;

        let miss_chance = aa.miss_chance_hook.and_then(|hook| {
            let hook_ctx = HookCtx::new(
                crate::context::HookCtxServices {
                    program,
                    instance: state,
                    sink,
                    rng,
                },
                crate::context::HookCtxRequest::for_target(now, target).with_source(source),
            );

            hook(&hook_ctx, hand)
        });

        weapon_input.miss_chance = if !aa.is_pet && auto_profile.dual_wield {
            miss_chance.unwrap_or(DUAL_WIELD_WHITE_MISS_CHANCE)
        } else {
            miss_chance.unwrap_or(0.0)
        };

        let is_physical = auto_profile.is_physical;
        let mut flags = if is_physical {
            DamageFlags::PHYSICAL
        } else {
            DamageFlags::empty()
        };

        if aa.is_pet {
            flags |= DamageFlags::PET;

            ap_coef *= if aa.uses_spell_power {
                auto_profile.stat_inheritance.spell_power
            } else {
                auto_profile.stat_inheritance.attack_power
            };
        }

        let aura_replacement = (!aa.is_pet && hand == SwingHand::MainHand)
            .then(|| active_auto_attack_replacement(program, state))
            .flatten()
            .map(|binding| (binding, 1.0));
        let selected_replacement = aura_replacement.or_else(|| {
            let hook = aa.replacement_hook?;

            let replacement = hook(
                &mut HookCtx::new(
                    crate::context::HookCtxServices {
                        program,
                        instance: state,
                        sink,
                        rng,
                    },
                    crate::context::HookCtxRequest::for_target(now, target).with_source(source),
                ),
                hand,
            )?;
            let binding = program.damage.action_id_request(replacement.action)?;

            Some((binding, replacement.damage_multiplier))
        });
        let replacement = selected_replacement.and_then(|(binding, multiplier)| {
            replacement_damage(program, state, binding, multiplier).map(|damage| (binding, damage))
        });
        let impact_source = if aa.is_pet {
            ActorId::Pet(wowlab_types::sim::PetIdx::PRIMARY)
        } else {
            source
        };
        let rage_gain = (!aa.is_pet
            && program.config.base_stats.resource_type
                == Some(wowlab_types::combat::ResourceType::Rage))
        .then(|| {
            f64::from(swing_ms) / MS_PER_SECOND
                * RAGE_PER_SWING_SECOND
                * hand_mult
                * program.config.base_stats.swing_resource_gain_mult
        });
        let mut damage_ctx = CombatCtx {
            program,
            instance: state,
            sink,
            now,
            rng,
            source: impact_source,
            target,
        };
        let (final_dmg, is_crit) =
            if let Some((binding, (replacement_id, base_points, damage))) = replacement {
                let effect = crate::state::DamageEffectRef::new(replacement_id, 1);

                deal_bound_profiled_damage_def(
                    &mut damage_ctx,
                    ProfiledDamageDef {
                        binding,
                        effect,
                        geometry_effect: effect,
                        profile_spell_id: replacement_id,
                        base_points,
                        def: damage,
                        flags: DamageFlags::empty(),
                        source_position: None,
                        destination: None,
                    },
                )
            } else if aa.uses_spell_power {
                super::deal_bound_damage_sp(
                    &mut damage_ctx,
                    auto_binding,
                    super::DamagePayload::new(aa.spell_id, ap_coef, flags),
                )
            } else {
                deal_damage_ap_with_weapon(
                    &mut damage_ctx,
                    auto_binding,
                    super::DamagePayload::new(aa.spell_id, ap_coef, flags),
                    weapon_input,
                )
            };

        if final_dmg <= 0.0 {
            reschedule_swing(program, state, i, swing_ms, impact_source, now);
            continue;
        }

        if let Some(rage) = rage_gain {
            // Haste changes swing frequency, not rage per swing.
            super::gain_resource_with_procs(
                &mut damage_ctx,
                crate::state::ResourceGain::modified(
                    rage,
                    crate::state::ResourceGainSource::AutoAttack,
                ),
                false,
            );
        }

        if let Some(hook_fn) = aa.on_swing {
            let source_flags = if aa.is_pet {
                DamageFlags::PET
            } else {
                DamageFlags::empty()
            };
            let mut hook_ctx = HookCtx::new(
                crate::context::HookCtxServices {
                    program,
                    instance: state,
                    sink,
                    rng,
                },
                crate::context::HookCtxRequest::for_target(now, target).with_source(impact_source),
            )
            .with_driver_spell(aa.spell_id)
            .with_source_damage_flags(source_flags)
            .with_source_npc_id(aa.npc_id)
            .with_pet_stat_inheritance(auto_profile.stat_inheritance);

            hook_fn(&mut hook_ctx, SwingEvent { hand, is_crit });
        }

        if is_crit
            && let Some(reduction) = aa.on_crit_reduce_charge
            && wowlab_engine_rng::proc_chance(rng, reduction.chance)
        {
            reduce_cooldown(
                program,
                state,
                reduction.target,
                program.spells[reduction.target.as_usize()]
                    .cooldown
                    .recharge_ms,
                now,
            );
        }

        reschedule_swing(program, state, i, swing_ms, impact_source, now);
    }

    drain_deferred_work(&mut HookCtx::new(
        crate::context::HookCtxServices {
            program,
            instance: state,
            sink,
            rng,
        },
        crate::context::HookCtxRequest::for_target(now, target).with_source(source),
    ));
}

#[cfg(test)]
fn phase_auto_attacks_fixture(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
    rng: &mut dyn FnMut() -> f64,
    sink: &mut TelemetrySink,
) {
    let Some(target) = state.current_target() else {
        return;
    };
    let mut ctx = CombatCtx {
        program,
        instance: state,
        sink,
        now,
        rng,
        source: ActorId::Player,
        target,
    };

    phase_auto_attacks_for(&mut ctx);
}

fn reschedule_swing(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    index: usize,
    swing_ms: u32,
    source: ActorId,
    now: SimTime,
) {
    let swing_mult =
        current_auto_attack_mult_for(crate::context::ActorView::new(program, state, source));
    let scaled_swing =
        wowlab_types::numeric::f64_to_u32_saturating_trunc(f64::from(swing_ms) / swing_mult);
    let next_swing = now.saturating_add(SimTime::from_millis(scaled_swing));

    if let Some(sw) = program.buffer_swing_mut(state, index) {
        sw.next_swing_at = next_swing.as_secs_f64();
        sw.speed = f64::from(scaled_swing) / MS_PER_SECOND;
        sw.swing_ms = f64::from(swing_ms);
    }
}

/// Preserves elapsed swing progress when live haste, attack speed, or form speed changes.
pub(crate) fn reproject_player_auto_attack_speeds(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
) {
    let speed_multiplier = current_auto_attack_mult_for(crate::context::ActorView::new(
        program,
        state,
        ActorId::Player,
    ));

    if speed_multiplier <= 0.0 {
        return;
    }

    let form_swing_ms = active_form_combat_round_time_ms(program, state);
    let now_secs = now.as_secs_f64();
    let mut changed = false;

    for (index, attack) in program.auto_attacks.iter().enumerate() {
        if attack.is_pet {
            continue;
        }

        let weapon_swing_ms = program
            .damage
            .auto_attack_profile(index)
            .and_then(|profile| profile.weapon)
            .map(|weapon| weapon.speed_ms);

        let Some(base_swing_ms) = form_swing_ms.or(weapon_swing_ms).filter(|speed| *speed > 0)
        else {
            continue;
        };
        let desired_speed = f64::from(base_swing_ms) / MS_PER_SECOND / speed_multiplier;
        let Some(swing) = program.buffer_swing_mut(state, index) else {
            continue;
        };
        let previous_speed = if swing.speed > 0.0 {
            swing.speed
        } else {
            desired_speed
        };

        if swing.next_swing_at.is_finite()
            && swing.next_swing_at > now_secs
            && (desired_speed - previous_speed).abs() > f64::EPSILON
        {
            let remaining = swing.next_swing_at - now_secs;
            let projected_remaining_ms = wowlab_types::numeric::f64_to_u32_saturating_round(
                remaining * desired_speed / previous_speed * MS_PER_SECOND,
            )
            .max(1);

            swing.next_swing_at = now
                .saturating_add(SimTime::from_millis(projected_remaining_ms))
                .as_secs_f64();
            changed = true;
        }

        swing.speed = desired_speed;
        swing.swing_ms = f64::from(base_swing_ms);
    }

    if changed
        && let (Some(next), Some(target)) = (
            earliest_auto_attack_time(program, state),
            state.current_target(),
        )
    {
        state.schedule(Event::AutoAttack {
            t: next,
            source: ActorId::Player,
            target,
        });
    }
}

pub(crate) fn reproject_pet_auto_attack_speeds(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
) {
    let source = ActorId::Pet(wowlab_types::sim::PetIdx::PRIMARY);
    let multiplier =
        current_auto_attack_mult_for(crate::context::ActorView::new(program, state, source));

    if multiplier <= 0.0 {
        return;
    }

    let now_secs = now.as_secs_f64();
    let mut earliest = None::<SimTime>;

    for index in program.pet_auto_attacks.iter().copied().map(usize::from) {
        // BOUNDS: finalization derives this slice from the same auto-attack plan.
        let attack = &program.auto_attacks[index];

        let desired = f64::from(attack.swing_ms) / MS_PER_SECOND / multiplier;
        let Some(swing) = program.buffer_swing_mut(state, index) else {
            continue;
        };
        let previous = if swing.speed > 0.0 {
            swing.speed
        } else {
            desired
        };

        if swing.next_swing_at.is_finite()
            && swing.next_swing_at > now_secs
            && (desired - previous).abs() > f64::EPSILON
        {
            let remaining = swing.next_swing_at - now_secs;
            let remaining_ms = wowlab_types::numeric::f64_to_u32_saturating_round(
                remaining * desired / previous * MS_PER_SECOND,
            )
            .max(1);

            swing.next_swing_at = now
                .saturating_add(SimTime::from_millis(remaining_ms))
                .as_secs_f64();
        }

        swing.speed = desired;
        swing.swing_ms = f64::from(attack.swing_ms);

        if swing.next_swing_at.is_finite() {
            let next = SimTime::from_secs_f64(swing.next_swing_at);

            earliest = Some(earliest.map_or(next, |current| current.min(next)));
        }
    }

    if let (Some(t), Some(target)) = (earliest, state.current_target()) {
        state.schedule(Event::AutoAttack { t, source, target });
    }
}

pub(crate) fn earliest_auto_attack_time(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
) -> Option<SimTime> {
    if program.auto_attacks.is_empty() {
        return None;
    }

    let mut min_time: Option<SimTime> = None;

    for i in 0..program.auto_attacks.len() {
        if let Some(sw) = program.buffer_swing(state, i) {
            if !sw.next_swing_at.is_finite() {
                continue;
            }

            let t = SimTime::from_secs_f64(sw.next_swing_at);

            min_time = Some(match min_time {
                Some(prev) => prev.min(t),
                None => t,
            });
        }
    }

    min_time
}

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