wowlab_engine_combat/systems/

effects.rs

use super::{
    add_aura_stack, apply_aura, deal_profiled_damage_def, expire_aura, extend_aura,
    gain_resource_with_procs, mutate_cooldown,
};
use crate::{
    DamageFlags,
    context::CombatCtx,
    state::{ResourceGain, ResourceGainSource, ResourcePool, SpellEffectData, SpellEffectRange},
};

fn execute_dispel(
    ctx: &mut CombatCtx<'_>,
    profile_spell_id: u32,
    dispel_type: i32,
    steal: bool,
    target: wowlab_types::sim::ActorId,
) {
    let selected = ctx.buf.aura_keys().find(|key| {
        if key.affected() != target {
            return false;
        }

        let active = ctx
            .buf
            .aura(*key)
            .is_some_and(|slot| slot.is_active(ctx.now.as_secs_f64()));

        let matches_family = ctx
            .state
            .aura_local_for_key(*key)
            .map(|local| ctx.state.aura(local).aura_id)
            .is_some_and(|aura_id| {
                ctx.state
                    .config
                    .game_data
                    .dispel_type(wowlab_types::sim::SpellIdx::from_raw(aura_id))
                    == dispel_type
            });

        active && matches_family
    });
    let Some(key) = selected else {
        return;
    };
    let Some(local) = ctx.state.aura_local_for_key(key) else {
        return;
    };
    let resistance = super::buffs::active_spell_modifier_value(
        ctx.view().for_actor(key.source()),
        wowlab_types::sim::SpellIdx::from_raw(ctx.state.aura(local).aura_id),
        wowlab_engine_domain::dbc::ModifierPropertyKind::DispelResistance,
        0.0,
    )
    .clamp(0.0, wowlab_types::constants::HUNDRED);

    if (ctx.rng)() * wowlab_types::constants::HUNDRED < resistance {
        return;
    }

    let stolen_slot = steal.then(|| ctx.buf.aura(key).copied()).flatten();

    {
        let mut aura_ctx = crate::HookCtx::new(
            crate::context::HookCtxServices {
                state: ctx.state,
                buf: ctx.buf,
                sink: ctx.sink,
                rng: ctx.rng,
            },
            crate::context::HookCtxRequest::for_target(ctx.now, ctx.target)
                .with_source(key.source()),
        )
        .with_effect_target(target);

        expire_aura(&mut aura_ctx, local);
    };

    if let Some(slot) = stolen_slot {
        let player_key = wowlab_types::sim::AuraKey::new(
            key.aura(),
            wowlab_types::sim::ActorId::Player,
            wowlab_types::sim::ActorId::Player,
            wowlab_types::sim::AuraOn::Player,
        );

        ctx.buf.ensure_aura_slot(player_key);

        if let Some(destination) = ctx.buf.aura_mut(player_key) {
            *destination = slot;
        }

        crate::systems::auras::emit_aura_apply_event(
            ctx.state,
            ctx.sink,
            player_key,
            key.aura().as_u32(),
            wowlab_types::numeric::i32_to_u8_saturating(slot.stacks),
            ctx.now,
        );
        ctx.state.schedule(wowlab_engine_ports::Event::AuraExpire {
            t: wowlab_types::sim::SimTime::from_secs_f64(slot.expires_at),
            key: player_key,
            target: None,
        });
    }

    super::procs::fire_dispel_procs(ctx, profile_spell_id);
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct EffectExecution {
    pub range: SpellEffectRange,
    pub profile_spell_id: u32,
    pub flags: DamageFlags,
}

fn flags_for_child_profile(
    state: &crate::state::CombatState,
    profile_spell_id: u32,
    inherited: DamageFlags,
) -> DamageFlags {
    let spell = wowlab_types::sim::SpellIdx::from_raw(profile_spell_id);
    let physical = super::damage_pipeline::school_of(state, profile_spell_id).is_physical();
    let profile_flags =
        super::damage_pipeline::damage_flags_from_data(&state.config.game_data, spell, physical);

    flags_with_profile_semantics(inherited, profile_flags)
}

// #t(fn: rust_const_fn_candidate) bitflags operators are not const-stable on this toolchain.
fn flags_with_profile_semantics(inherited: DamageFlags, profile_flags: DamageFlags) -> DamageFlags {
    let profile_bound = DamageFlags::PHYSICAL
        | DamageFlags::PERIODIC
        | DamageFlags::NO_CRIT
        | DamageFlags::IGNORE_PLAYER_MULTIPLIERS
        | DamageFlags::IGNORE_TARGET_MULTIPLIERS
        | DamageFlags::IGNORE_POSITIVE_TARGET_MULTIPLIERS
        | DamageFlags::AOE;

    (inherited & !profile_bound) | profile_flags
}

struct EffectFrame {
    execution: EffectExecution,
    next: usize,
    end: usize,
    reflected: bool,
}

fn effect_is_hostile(
    state: &crate::state::CombatState,
    effect: SpellEffectData,
    remaining_depth: u8,
) -> bool {
    match effect {
        SpellEffectData::Damage { .. }
        | SpellEffectData::InterruptCast { .. }
        | SpellEffectData::Dispel { .. } => true,
        SpellEffectData::ApplyAura { aura_local }
        | SpellEffectData::AddAuraStack { aura_local }
        | SpellEffectData::RemoveAura { aura_local }
        | SpellEffectData::ExtendAura { aura_local, .. } => state
            .defs
            .auras
            .get(aura_local.as_usize())
            .is_some_and(|aura| aura.on == wowlab_types::sim::AuraOn::Target),
        SpellEffectData::Conditional { .. }
        | SpellEffectData::Heal { .. }
        | SpellEffectData::Energize { .. }
        | SpellEffectData::EnergizePercent { .. }
        | SpellEffectData::MutateCooldown { .. } => false,
        SpellEffectData::Delayed { effects, .. } => {
            remaining_depth > 0
                && effect_range_is_hostile_with_depth(state, effects, remaining_depth - 1)
        }
    }
}

fn effect_range_is_hostile_with_depth(
    state: &crate::state::CombatState,
    range: SpellEffectRange,
    remaining_depth: u8,
) -> bool {
    let start = range.start as usize;
    let end = start.saturating_add(usize::from(range.len));
    let Some(effects) = state
        .defs
        .spell_effects
        .get(start..end.min(state.defs.spell_effects.len()))
    else {
        return false;
    };

    effects
        .iter()
        .copied()
        .any(|effect| effect_is_hostile(state, effect, remaining_depth))
}

pub(crate) fn effect_range_is_hostile(
    state: &crate::state::CombatState,
    range: SpellEffectRange,
) -> bool {
    const MAX_NESTED_EFFECT_DEPTH: u8 = 32;

    effect_range_is_hostile_with_depth(state, range, MAX_NESTED_EFFECT_DEPTH)
}

fn effect_hook_ctx<'a>(
    ctx: &'a mut CombatCtx<'_>,
    reflected: bool,
    effect_target: Option<wowlab_types::sim::ActorId>,
) -> crate::HookCtx<'a> {
    let source = ctx.source;
    let hook = ctx.hook_ctx();

    if reflected {
        hook.with_effect_target(source)
    } else if let Some(effect_target) = effect_target {
        hook.with_effect_target(effect_target)
    } else {
        hook
    }
}

fn hostile_effect_target(
    ctx: &CombatCtx<'_>,
    reflected: bool,
    effect_target: Option<wowlab_types::sim::ActorId>,
) -> wowlab_types::sim::ActorId {
    if reflected {
        ctx.source
    } else {
        match effect_target {
            Some(target) => target,
            None => wowlab_types::sim::ActorId::Enemy(ctx.target),
        }
    }
}

fn execute_percent_energize(
    ctx: &mut CombatCtx<'_>,
    profile_spell_id: u32,
    resource_type: wowlab_types::combat::ResourceType,
    percent: f64,
    effect_index: u8,
) {
    let Some(resource) = ctx.buf.resource(resource_type) else {
        return;
    };
    let percent = super::buffs::active_effect_points(
        ctx.view().for_actor(ctx.source),
        wowlab_types::sim::SpellIdx::from_raw(profile_spell_id),
        effect_index,
        percent,
    );
    let amount = resource.max * percent / wowlab_types::constants::HUNDRED;
    let Some(is_secondary) = super::resources::resource_pool_for_type(ctx.state, resource_type)
    else {
        return;
    };
    let request = ResourceGain::modified(
        amount,
        ResourceGainSource::SpellEffect {
            spell_id: profile_spell_id,
            effect_index,
        },
    );

    gain_resource_with_procs(ctx, request, is_secondary);
}

fn execute_damage_effect(
    ctx: &mut CombatCtx<'_>,
    execution: EffectExecution,
    effect_data: SpellEffectData,
) {
    let SpellEffectData::Damage {
        effect,
        damage,
        base_points,
        may_crit,
        attribute_flags,
        requires_main_hand,
        requires_off_hand,
        equipped_item_requirement,
    } = effect_data
    else {
        return;
    };
    let equipment = &ctx.state.config.game_data;
    let missing_required_hand = (requires_main_hand && equipment.main_hand().speed_ms == 0)
        || (requires_off_hand && equipment.off_hand().is_none());
    let item_requirement_unmet = equipped_item_requirement.is_some_and(|requirement| {
        let hand = if requires_off_hand {
            wowlab_engine_gamedata::ResolvedDamageWeapon::OffHand
        } else {
            wowlab_engine_gamedata::ResolvedDamageWeapon::MainHand
        };

        !wowlab_engine_domain::dbc::equipped_weapon_matches(equipment, hand, requirement)
    });

    if missing_required_hand || item_requirement_unmet {
        tracing::trace!(
            spell_id = effect.spell_id,
            effect_index = effect.effect_index,
            requires_main_hand,
            requires_off_hand,
            ?equipped_item_requirement,
            "SPELL_EFFECT_EQUIPMENT_REQUIREMENT_UNMET"
        );

        return;
    }

    let profile_flags = attribute_flags
        | if may_crit {
            DamageFlags::empty()
        } else {
            DamageFlags::NO_CRIT
        };

    deal_profiled_damage_def(
        ctx,
        effect,
        execution.profile_spell_id,
        Some(base_points),
        damage,
        flags_with_profile_semantics(execution.flags, profile_flags),
    );
}

fn execute_heal_effect(
    ctx: &mut CombatCtx<'_>,
    effect_target: Option<wowlab_types::sim::ActorId>,
    effect_data: SpellEffectData,
) {
    let SpellEffectData::Heal {
        effect,
        base,
        ap_coef,
        sp_coef,
        percent_of_max,
        may_crit,
    } = effect_data
    else {
        return;
    };
    let stats = &ctx.state.config.base_stats.stats;
    let (base, percent_of_max) = effect.map_or((base, percent_of_max), |effect| {
        let spell = wowlab_types::sim::SpellIdx::from_raw(effect.spell_id);

        (
            super::buffs::active_effect_points(
                ctx.view().for_actor(ctx.source),
                spell,
                effect.effect_index,
                base,
            ),
            super::buffs::active_effect_points(
                ctx.view().for_actor(ctx.source),
                spell,
                effect.effect_index,
                percent_of_max * wowlab_types::constants::HUNDRED,
            ) / wowlab_types::constants::HUNDRED,
        )
    });
    let amount = base + ap_coef * stats.attack_power + sp_coef * stats.spell_power;

    let _ = super::deal_heal(
        ctx.state,
        ctx.buf,
        ctx.rng,
        super::HealRequest {
            source: ctx.source,
            target: effect_target.unwrap_or(ctx.source),
            base: amount,
            percent_of_max,
            school: wowlab_types::combat::DamageSchool::Holy,
            periodic: false,
            may_crit,
            at: ctx.now,
        },
    );
}

fn execute_resource_effect(
    ctx: &mut CombatCtx<'_>,
    profile_spell_id: u32,
    effect_data: SpellEffectData,
) -> bool {
    match effect_data {
        SpellEffectData::Energize {
            effect,
            pool,
            amount,
        } => {
            let amount = effect.map_or(amount, |effect| {
                super::buffs::active_effect_points(
                    ctx.view().for_actor(ctx.source),
                    wowlab_types::sim::SpellIdx::from_raw(effect.spell_id),
                    effect.effect_index,
                    amount,
                )
            });
            let is_secondary = matches!(pool, ResourcePool::Secondary);
            let request =
                ResourceGain::modified(amount, ResourceGainSource::Spell(profile_spell_id));

            gain_resource_with_procs(ctx, request, is_secondary);

            true
        }
        SpellEffectData::EnergizePercent {
            resource_type,
            percent,
            effect_index,
        } => {
            execute_percent_energize(ctx, profile_spell_id, resource_type, percent, effect_index);

            true
        }
        SpellEffectData::MutateCooldown {
            spell_local,
            operation,
        } => {
            mutate_cooldown(ctx.state, ctx.buf, spell_local, operation, ctx.now);

            true
        }
        _ => false,
    }
}

pub(crate) fn execute_effect_range(ctx: &mut CombatCtx<'_>, execution: EffectExecution) {
    execute_effect_range_for_actor(ctx, execution, None);
}

fn effect_frame(ctx: &mut CombatCtx<'_>, execution: EffectExecution) -> Option<EffectFrame> {
    let hostile = effect_range_is_hostile(ctx.state, execution.range);
    let flags = if hostile {
        super::damage_pipeline::resolve_spell_impact_flags(
            ctx,
            execution.profile_spell_id,
            execution.flags,
        )?
    } else {
        execution.flags
    };
    let execution = EffectExecution { flags, ..execution };
    let next = execution.range.start as usize;
    let end = next.saturating_add(usize::from(execution.range.len));

    Some(EffectFrame {
        execution,
        next,
        end,
        reflected: flags.contains(DamageFlags::REFLECTED),
    })
}

const fn effect_driver_spell_id(execution: EffectExecution, proc_driver_spell_id: u32) -> u32 {
    if proc_driver_spell_id == 0 {
        execution.profile_spell_id
    } else {
        proc_driver_spell_id
    }
}

pub(crate) fn execute_effect_range_for_actor(
    ctx: &mut CombatCtx<'_>,
    execution: EffectExecution,
    effect_target: Option<wowlab_types::sim::ActorId>,
) {
    execute_effect_range_for_actor_with_proc_driver(ctx, execution, effect_target, 0);
}

pub(crate) fn execute_proc_effect_range_for_actor(
    ctx: &mut CombatCtx<'_>,
    execution: EffectExecution,
    effect_target: Option<wowlab_types::sim::ActorId>,
    proc_driver_spell_id: u32,
) {
    execute_effect_range_for_actor_with_proc_driver(
        ctx,
        execution,
        effect_target,
        proc_driver_spell_id,
    );
}

// #t(fn: rust_cyclomatic_complexity) one interpreter loop exhaustively dispatches the typed effect vocabulary
fn execute_effect_range_for_actor_with_proc_driver(
    ctx: &mut CombatCtx<'_>,
    execution: EffectExecution,
    effect_target: Option<wowlab_types::sim::ActorId>,
    proc_driver_spell_id: u32,
) {
    let Some(frame) = effect_frame(ctx, execution) else {
        return;
    };

    let mut frames = vec![frame];

    while let Some(mut frame) = frames.pop() {
        if frame.next >= frame.end {
            continue;
        }

        let Some(effect) = ctx.state.defs.spell_effects.get(frame.next).copied() else {
            continue;
        };

        frame.next = frame.next.saturating_add(1);
        let execution = frame.execution;
        let reflected = frame.reflected;

        frames.push(frame);

        if execute_resource_effect(ctx, execution.profile_spell_id, effect) {
            continue;
        }

        match effect {
            SpellEffectData::Conditional { predicate, effects } => {
                let enabled = {
                    let hook = effect_hook_ctx(ctx, reflected, effect_target);

                    predicate(&hook)
                };

                if enabled {
                    if let Some(frame) = effect_frame(
                        ctx,
                        EffectExecution {
                            range: effects,
                            ..execution
                        },
                    ) {
                        frames.push(frame);
                    }
                }
            }
            SpellEffectData::ApplyAura { aura_local } => {
                let mut hook = effect_hook_ctx(ctx, reflected, effect_target)
                    .with_driver_spell(effect_driver_spell_id(execution, proc_driver_spell_id))
                    .with_source_damage_flags(execution.flags);

                apply_aura(&mut hook, aura_local);
            }
            SpellEffectData::AddAuraStack { aura_local } => {
                let mut hook = effect_hook_ctx(ctx, reflected, effect_target)
                    .with_driver_spell(effect_driver_spell_id(execution, proc_driver_spell_id))
                    .with_source_damage_flags(execution.flags);

                add_aura_stack(&mut hook, aura_local);
            }
            SpellEffectData::RemoveAura { aura_local } => {
                expire_aura(
                    &mut effect_hook_ctx(ctx, reflected, effect_target),
                    aura_local,
                );
            }
            SpellEffectData::InterruptCast { lockout_ms } => {
                let _ = super::interrupt_cast(
                    ctx.state,
                    ctx.buf,
                    hostile_effect_target(ctx, reflected, effect_target),
                    ctx.now,
                    lockout_ms,
                );
            }
            SpellEffectData::Dispel { dispel_type, steal } => {
                let target = hostile_effect_target(ctx, reflected, effect_target);

                execute_dispel(ctx, execution.profile_spell_id, dispel_type, steal, target);
            }
            effect @ SpellEffectData::Damage { .. } => {
                execute_damage_effect(ctx, execution, effect);
            }
            effect @ SpellEffectData::Heal { .. } => {
                let target = if reflected {
                    Some(ctx.source)
                } else {
                    effect_target
                };

                execute_heal_effect(ctx, target, effect);
            }
            SpellEffectData::Energize { .. }
            | SpellEffectData::EnergizePercent { .. }
            | SpellEffectData::MutateCooldown { .. } => {}
            SpellEffectData::ExtendAura {
                aura_local,
                amount_ms,
            } => extend_aura(
                &mut effect_hook_ctx(ctx, reflected, effect_target),
                aura_local,
                amount_ms,
            ),
            SpellEffectData::Delayed {
                delay_ms,
                profile_spell_id,
                effects,
            } => {
                let flags = flags_for_child_profile(ctx.state, profile_spell_id, execution.flags);

                if delay_ms == 0 {
                    if let Some(frame) = effect_frame(
                        ctx,
                        EffectExecution {
                            range: effects,
                            profile_spell_id,
                            flags,
                        },
                    ) {
                        frames.push(frame);
                    }

                    continue;
                }

                let source = ctx.source;
                let hook = ctx.hook_ctx();
                let mut hook = if reflected {
                    hook.with_effect_target(source)
                } else if let Some(effect_target) = effect_target {
                    hook.with_effect_target(effect_target)
                } else {
                    hook
                };

                hook.schedule_effect_program(
                    delay_ms,
                    effects,
                    profile_spell_id,
                    flags,
                    proc_driver_spell_id,
                );
            }
        }
    }
}

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