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, rotation::DenseBuffer,
};
use wowlab_engine_gamedata::ResolvedDamageKind;
use wowlab_engine_ports::Event;
#[cfg(test)]
use wowlab_engine_telemetry::TelemetrySink;
use wowlab_types::{
    constants::MS_PER_SECOND,
    sim::{ActorId, EnemyIdx, SimTime, SpellIdx},
};

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::{WeaponDamageInput, deal_damage_ap_with_weapon, deal_profiled_damage_def},
};
use crate::{
    DamageFlags,
    context::{CombatCtx, HookCtx},
    keys::auto_attack_key,
    state::{
        CombatState, RuntimeDamageDef, SwingEvent, SwingHand, SwingReplacement,
        resolved_damage_base_points,
    },
};

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

fn set_player_auto_attacks_active(
    state: &CombatState,
    buf: &mut DenseBuffer,
    active: bool,
    now: SimTime,
) -> bool {
    let mut changed = false;
    let form_swing_ms = active_form_combat_round_time_ms(state, buf);
    let main_hand = state.config.game_data.main_hand();
    let off_hand = state.config.game_data.off_hand();

    let mut player_index = 0_usize;

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

        let weapon_swing_ms = match player_index {
            0 => Some(main_hand.speed_ms),
            1 => off_hand.map(|weapon| weapon.speed_ms),
            _ => None,
        };

        player_index = player_index.saturating_add(1);

        let swing_ms = form_swing_ms
            .or(weapon_swing_ms)
            .filter(|speed| *speed > 0)
            .unwrap_or(attack.swing_ms);
        let key = auto_attack_key(index);
        let is_scheduled = buf
            .swing(&key)
            .is_some_and(|swing| swing.next_swing_at.is_finite());

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

    changed
}

fn spell_has_attack_effect(state: &CombatState, spell_id: SpellIdx) -> bool {
    let data = &state.config.game_data;

    (1..=data.max_effect_index(spell_id)).any(|effect_index| {
        wowlab_engine_domain::dbc::spell_effect_is(
            data.effect_type(spell_id, effect_index),
            wowlab_engine_domain::dbc::SpellEffectKind::Attack,
        )
    })
}

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

    let spell = SpellIdx::from_raw(spell_id);
    let attributes = state
        .config
        .game_data
        .spell_attributes(spell)
        .unwrap_or_default();
    let cancels = wowlab_engine_domain::dbc::spell_attribute_is(
        attributes,
        wowlab_engine_domain::dbc::SpellAttributeKind::CancelsAutoAttack,
    );

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

        return;
    }

    let initiates = wowlab_engine_domain::dbc::spell_attribute_is(
        attributes,
        wowlab_engine_domain::dbc::SpellAttributeKind::InitiatesAutoAttack,
    ) || spell_has_attack_effect(state, spell);

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

fn replacement_damage(
    state: &CombatState,
    replacement: SwingReplacement,
) -> Option<(u32, Option<f64>, RuntimeDamageDef)> {
    if let Some((_, spell)) = state.spell_data(replacement.spell_id) {
        return Some((
            replacement.spell_id,
            Some(spell.base_points * replacement.damage_multiplier),
            spell.damage.scaled(replacement.damage_multiplier),
        ));
    }

    let resolved = wowlab_engine_domain::dbc::damage_def(
        &state.config.game_data,
        SpellIdx::from_raw(replacement.spell_id),
    )?;
    let damage = crate::builder::lower_resolved_damage(resolved, 1.0)?;
    let base_points = Some(resolved_damage_base_points(
        resolved,
        replacement.damage_multiplier,
    ));

    Some((
        replacement.spell_id,
        base_points,
        damage.scaled(replacement.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 state = &mut *ctx.state;
    let buf = &mut *ctx.buf;
    let sink = &mut *ctx.sink;
    let rng = &mut *ctx.rng;
    let now_secs = now.as_secs_f64();

    let mh = state.config.game_data.main_hand();
    let oh = state.config.game_data.off_hand();

    let mut player_aa_index: u32 = 0;

    for i in 0..state.defs.auto_attacks.len() {
        let aa = state.defs.auto_attacks[i];
        let assigned_player_index = if aa.is_pet {
            None
        } else {
            let index = player_aa_index;

            player_aa_index = player_aa_index.saturating_add(1);

            Some(index)
        };
        let key = auto_attack_key(i);

        let next_at_secs = match buf.swing(&key) {
            Some(sw) => sw.next_swing_at,
            None => continue,
        };

        if now_secs < next_at_secs {
            continue;
        }

        let weapon_slot = match assigned_player_index {
            Some(0) => Some(mh),
            Some(1) => oh,
            None | Some(_) => None,
        };

        let hand = match assigned_player_index {
            Some(1) => SwingHand::OffHand,
            _ => SwingHand::MainHand,
        };
        let hand_mult = if hand == SwingHand::OffHand {
            OFF_HAND_DAMAGE_MULT
        } else {
            1.0
        };
        let weapon_payload = (!aa.is_pet)
            .then(|| {
                wowlab_engine_domain::dbc::damage_def(
                    &state.config.game_data,
                    SpellIdx::from_raw(aa.spell_id),
                )
            })
            .flatten()
            .filter(|def| {
                matches!(
                    def.kind,
                    ResolvedDamageKind::Weapon
                        | ResolvedDamageKind::WeaponPercent
                        | ResolvedDamageKind::NormalizedWeapon
                )
            });
        let weapon_multiplier = weapon_payload.map_or(1.0, |def| def.coefficient);
        let normalized = weapon_payload
            .is_some_and(|def| matches!(def.kind, ResolvedDamageKind::NormalizedWeapon));

        // 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 (sc_druid.cpp:13793-13815).
        let form_swing_ms = (!aa.is_pet)
            .then(|| active_form_combat_round_time_ms(state, buf))
            .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 {
                    state,
                    buf,
                    sink,
                    rng,
                },
                crate::context::HookCtxRequest::for_target(now, target).with_source(source),
            );

            hook(&hook_ctx, hand)
        });

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

        let is_physical = weapon_payload.map_or(aa.is_physical, |def| def.is_physical);
        let mut flags = if is_physical {
            DamageFlags::PHYSICAL
        } else {
            DamageFlags::empty()
        };

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

            if let Some(npc_id) = aa.npc_id {
                let inheritance_mult = if aa.uses_spell_power {
                    state
                        .config
                        .game_data
                        .pet_spell_power_inheritance_mult(npc_id)
                } else {
                    state
                        .config
                        .game_data
                        .pet_attack_power_inheritance_mult(npc_id)
                };

                ap_coef *= inheritance_mult;
            }
        }

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

            hook(
                &mut HookCtx::new(
                    crate::context::HookCtxServices {
                        state,
                        buf,
                        sink,
                        rng,
                    },
                    crate::context::HookCtxRequest::for_target(now, target).with_source(source),
                ),
                hand,
            )
        });
        let replacement =
            selected_replacement.and_then(|selected| replacement_damage(state, selected));
        let impact_source = if aa.is_pet {
            ActorId::Pet(wowlab_types::sim::PetIdx::PRIMARY)
        } else {
            source
        };
        let rage_gain = (!aa.is_pet
            && state.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
                * state.config.base_stats.swing_resource_gain_mult
        });
        let mut damage_ctx = CombatCtx {
            state,
            buf,
            sink,
            now,
            rng,
            source: impact_source,
            target,
        };
        let (final_dmg, is_crit) = if let Some((replacement_id, base_points, damage)) = replacement
        {
            deal_profiled_damage_def(
                &mut damage_ctx,
                crate::state::DamageEffectRef::new(replacement_id, 1),
                replacement_id,
                base_points,
                damage,
                DamageFlags::empty(),
            )
        } else if aa.uses_spell_power {
            super::deal_damage_sp(
                &mut damage_ctx,
                super::DamagePayload::new(aa.spell_id, ap_coef, flags),
            )
        } else {
            deal_damage_ap_with_weapon(
                &mut damage_ctx,
                super::DamagePayload::new(aa.spell_id, ap_coef, flags),
                weapon_input,
            )
        };

        if final_dmg <= 0.0 {
            reschedule_swing(state, buf, &key, 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 {
                    state,
                    buf,
                    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);

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

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

        reschedule_swing(state, buf, &key, swing_ms, impact_source, now);
    }

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

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

    phase_auto_attacks_for(&mut ctx);
}

fn reschedule_swing(
    state: &CombatState,
    buf: &mut DenseBuffer,
    key: &str,
    swing_ms: u32,
    source: ActorId,
    now: SimTime,
) {
    let swing_mult =
        current_auto_attack_mult_for(crate::context::ActorView::new(state, buf, 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) = buf.swing_mut(key) {
        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(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    now: SimTime,
) {
    let speed_multiplier =
        current_auto_attack_mult_for(crate::context::ActorView::new(state, buf, ActorId::Player));

    if speed_multiplier <= 0.0 {
        return;
    }

    let form_swing_ms = active_form_combat_round_time_ms(state, buf);
    let main_hand = state.config.game_data.main_hand();
    let off_hand = state.config.game_data.off_hand();
    let now_secs = now.as_secs_f64();
    let mut player_index = 0_usize;
    let mut changed = false;

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

        let weapon_swing_ms = match player_index {
            0 => Some(main_hand.speed_ms),
            1 => off_hand.map(|weapon| weapon.speed_ms),
            _ => None,
        };

        player_index = player_index.saturating_add(1);

        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 key = auto_attack_key(index);
        let Some(swing) = buf.swing_mut(&key) 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(state, buf),
            state.current_target(),
        )
    {
        state.schedule(Event::AutoAttack {
            t: next,
            source: ActorId::Player,
            target,
        });
    }
}

pub(crate) fn earliest_auto_attack_time(state: &CombatState, buf: &DenseBuffer) -> Option<SimTime> {
    if state.defs.auto_attacks.is_empty() {
        return None;
    }

    let mut min_time: Option<SimTime> = None;

    for i in 0..state.defs.auto_attacks.len() {
        let key = auto_attack_key(i);

        if let Some(sw) = buf.swing(&key) {
            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;