wowlab_engine_combat/systems/damage_pipeline/

api.rs

//! Damage request construction and public dispatch helpers.

use wowlab_engine_gamedata::ResolvedGameData;
use wowlab_engine_telemetry::{DamageEvent, DamageEventFlags, TelemetrySink};
use wowlab_types::sim::{ActorId, EnemyIdx, SpellIdx};

use super::{
    current_spell_power,
    dispatch::{deal_damage, deal_damage_to_target},
    resolve_outgoing_absorbs, typed_attack_power,
    weapon::{WeaponDamageInput, weapon_damage_input},
};
use crate::{
    context::CombatCtx,
    state::{CombatInstance, CombatProgram},
    systems::procs::fire_impact_procs,
};

pub(crate) fn damage_flags_from_data(
    data: &ResolvedGameData,
    spell_id: SpellIdx,
    physical: bool,
) -> DamageFlags {
    let mut flags = if physical {
        DamageFlags::PHYSICAL
    } else {
        DamageFlags::empty()
    };

    if data.cannot_crit(spell_id).unwrap_or(false) {
        flags |= DamageFlags::NO_CRIT;
    }

    if data.treat_as_periodic(spell_id).unwrap_or(false) {
        flags |= DamageFlags::PERIODIC;
    }

    if data.treat_as_area_effect(spell_id).unwrap_or(false) {
        flags |= DamageFlags::AOE;
    }

    if data
        .disable_player_damage_multiplier(spell_id)
        .unwrap_or(false)
    {
        flags |= DamageFlags::IGNORE_PLAYER_MULTIPLIERS;
    }

    if data
        .disable_target_damage_multiplier(spell_id)
        .unwrap_or(false)
    {
        flags |= DamageFlags::IGNORE_TARGET_MULTIPLIERS;
    }

    if data
        .disable_positive_target_damage_multiplier(spell_id)
        .unwrap_or(false)
    {
        flags |= DamageFlags::IGNORE_POSITIVE_TARGET_MULTIPLIERS;
    }

    flags
}

pub(crate) fn damage_flags_from_local(
    program: &CombatProgram,
    action: crate::state::program::LocalDamageActionIdx,
    physical: bool,
) -> DamageFlags {
    let mut flags = program.damage.action_at(action).damage_attribute_flags;

    if physical {
        flags |= DamageFlags::PHYSICAL;
    }

    flags
}

pub(crate) fn damage_flags_from_binding(
    program: &CombatProgram,
    action: crate::DamageActionId,
    physical: bool,
) -> DamageFlags {
    let mut flags = program
        .damage
        .action_id_plan(action)
        .map_or_else(DamageFlags::empty, |plan| plan.damage_attribute_flags);

    if physical {
        flags |= DamageFlags::PHYSICAL;
    }

    flags
}

pub(in crate::systems) fn finalize_damage(
    ctx: &mut CombatCtx<'_>,
    target: EnemyIdx,
    binding: crate::state::program::DamageRequestBinding,
    event: &DamageEvent,
) -> bool {
    finalize_damage_with(ctx, target, binding, event, emit_damage_telemetry);

    !ctx.instance.has_runtime_error()
}

pub(in crate::systems) fn emit_damage_telemetry(
    _source: ActorId,
    _target: EnemyIdx,
    event: &DamageEvent,
    _program: &CombatProgram,
    _state: &CombatInstance,
    sink: &mut TelemetrySink,
) {
    sink.emit_damage(event);
}

pub(in crate::systems) fn finalize_damage_with(
    ctx: &mut CombatCtx<'_>,
    target: EnemyIdx,
    binding: crate::state::program::DamageRequestBinding,
    event: &DamageEvent,
    emit: impl FnOnce(
        ActorId,
        EnemyIdx,
        &DamageEvent,
        &CombatProgram,
        &CombatInstance,
        &mut TelemetrySink,
    ),
) {
    if !ctx.instance.is_valid_target(target) {
        return;
    }

    let amount = event.amount;

    emit(
        ctx.source,
        target,
        event,
        ctx.program,
        ctx.instance,
        ctx.sink,
    );

    ctx.instance.runtime.total_damage += amount;
    ctx.instance.refresh_enemy_health(target, ctx.now);
    let before_health = ctx
        .instance
        .enemy_health_fraction(ctx.program, target, ctx.now)
        .unwrap_or(1.0);
    let death = match ctx.instance.apply_enemy_damage(target, amount, ctx.now) {
        Ok(death) => death,
        Err(error) => {
            ctx.instance.record_runtime_error(error);

            return;
        }
    };
    let after_health = ctx
        .instance
        .enemy_health_fraction(ctx.program, target, ctx.now)
        .unwrap_or(before_health);
    let actual_damage = ctx
        .instance
        .enemy_max_health(ctx.program, target)
        .map_or(amount, |maximum| {
            ((before_health - after_health).max(0.0) * maximum).min(amount)
        });

    crate::systems::process_actor_health_change(
        ctx.program,
        ctx.instance,
        ActorId::Enemy(target),
        before_health,
        after_health,
        ctx.now,
    );
    super::leech::apply_leech_healing(ctx, binding, event, actual_damage);

    if let Some(dead) = death {
        ctx.instance.schedule(wowlab_engine_ports::Event::Death {
            t: dead.at,
            target: dead.enemy,
            scope: wowlab_engine_ports::DeathEventScope::Unscoped,
        });

        if matches!(ctx.source, ActorId::Player | ActorId::Pet(_)) {
            crate::systems::procs::fire_kill_procs(ctx, binding.effect_action(), dead.enemy);
        }
    }
}

pub(crate) fn resolve_spell_impact_flags(
    ctx: &mut CombatCtx<'_>,
    profile_action: crate::state::program::LocalDamageActionIdx,
    flags: DamageFlags,
) -> Option<DamageFlags> {
    if flags.contains(DamageFlags::REFLECTION_RESOLVED) {
        return Some(flags);
    }

    if !ctx.program.damage.has_reflection && !ctx.program.damage.has_deflection {
        return Some(flags | DamageFlags::REFLECTION_RESOLVED);
    }

    let school = ctx.program.damage.action_at(profile_action).school;

    match crate::systems::buffs::resolve_incoming_spell_defense(
        ctx.program,
        ctx.instance,
        ctx.target,
        profile_action,
        school,
        ctx.rng,
    ) {
        crate::systems::buffs::IncomingSpellDefense::None => {
            Some(flags | DamageFlags::REFLECTION_RESOLVED)
        }
        crate::systems::buffs::IncomingSpellDefense::Reflected => {
            Some(flags | DamageFlags::REFLECTION_RESOLVED | DamageFlags::REFLECTED)
        }
        crate::systems::buffs::IncomingSpellDefense::Deflected => None,
    }
}
bitflags::bitflags! {
    /// Semantics of a damage impact. Empty is magical, player-sourced, direct, and crit-capable.
    #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
    pub struct DamageFlags: u16 {
        const PHYSICAL = 1 << 0;
        /// Companion-owned impact; guardians carry it for pet scaling, telemetry, and proc suppression.
        const PET = 1 << 1;
        const PERIODIC = 1 << 2;
        const NO_CRIT = 1 << 3;
        /// Temporary-guardian subtype, set with `PET` so target modifiers can distinguish guardians.
        const GUARDIAN = 1 << 4;
        const IGNORE_PLAYER_MULTIPLIERS = 1 << 5;
        const IGNORE_TARGET_MULTIPLIERS = 1 << 6;
        const IGNORE_POSITIVE_TARGET_MULTIPLIERS = 1 << 7;
        const PROC = 1 << 8;
        /// Attribute telemetry to the action while retaining the payload for runtime mechanics.
        const REPORT_AS_PROFILE = 1 << 9;
        /// Area damage, including DBC spells explicitly tagged to use area-effect semantics.
        const AOE = 1 << 10;
        /// The target's reflect/deflect decision has already been resolved for this impact.
        const REFLECTION_RESOLVED = 1 << 11;
        /// Re-execute this impact against its caster without another reflection check.
        const REFLECTED = 1 << 12;
        /// Preserve crit chance while suppressing bonuses beyond the baseline 2x crit damage.
        const IGNORE_CRIT_DAMAGE_BONUSES = 1 << 13;
    }
}

/// Spell identity, scaling coefficient, and semantic flags for one power-scaled hit.
#[derive(Clone, Copy, Debug)]
pub struct DamagePayload {
    pub spell_id: u32,
    pub profile_spell_id: Option<u32>,
    pub coef: f64,
    pub flags: DamageFlags,
}

impl DamagePayload {
    #[must_use]
    pub const fn new(spell_id: u32, coef: f64, flags: DamageFlags) -> Self {
        Self {
            spell_id,
            profile_spell_id: None,
            coef,
            flags,
        }
    }

    #[must_use]
    pub const fn profiled(
        spell_id: u32,
        profile_spell_id: u32,
        coef: f64,
        flags: DamageFlags,
    ) -> Self {
        Self {
            spell_id,
            profile_spell_id: Some(profile_spell_id),
            coef,
            flags,
        }
    }

    pub(super) const fn resolved_profile_spell_id(self) -> u32 {
        match self.profile_spell_id {
            Some(profile_spell_id) => profile_spell_id,
            None => self.spell_id,
        }
    }
}

#[inline]
pub(in crate::systems) const fn reported_damage_spell_id(request: &DamageRequest) -> u32 {
    if request.flags.contains(DamageFlags::REPORT_AS_PROFILE) {
        request.profile_spell_id
    } else {
        request.effect.spell_id
    }
}

#[derive(Clone, Copy, Debug)]
pub(in crate::systems) struct DamageRequest {
    pub effect: crate::state::DamageEffectRef,
    pub geometry_effect: crate::state::DamageEffectRef,
    pub source_position: Option<wowlab_types::sim::SpatialTransform>,
    pub destination: Option<wowlab_types::sim::SpatialTransform>,
    pub profile_spell_id: u32,
    pub base_points: Option<f64>,
    pub coef: f64,
    pub power: f64,
    pub weapon: WeaponDamageInput,
    pub flags: DamageFlags,
}

impl DamageRequest {
    const fn new(payload: DamagePayload, power: f64) -> Self {
        let effect = crate::state::DamageEffectRef::new(payload.spell_id, 1);

        Self {
            effect,
            geometry_effect: effect,
            source_position: None,
            destination: None,
            profile_spell_id: payload.resolved_profile_spell_id(),
            base_points: None,
            coef: payload.coef,
            power,
            weapon: WeaponDamageInput::none(),
            flags: payload.flags,
        }
    }

    const fn profile(mut self, spell_id: u32) -> Self {
        self.profile_spell_id = spell_id;

        self
    }

    const fn effect(mut self, effect: crate::state::DamageEffectRef) -> Self {
        self.effect = effect;
        self.geometry_effect = effect;

        self
    }

    const fn geometry(
        mut self,
        effect: crate::state::DamageEffectRef,
        source_position: Option<wowlab_types::sim::SpatialTransform>,
        destination: Option<wowlab_types::sim::SpatialTransform>,
    ) -> Self {
        self.geometry_effect = effect;
        self.source_position = source_position;
        self.destination = destination;

        self
    }

    const fn weapon(mut self, weapon: WeaponDamageInput) -> Self {
        self.weapon = weapon;

        self
    }

    const fn base_points(mut self, base_points: f64) -> Self {
        self.base_points = Some(base_points);

        self
    }

    const fn optional_base_points(mut self, base_points: Option<f64>) -> Self {
        self.base_points = base_points;

        self
    }
}

/// Executable damage input after all external identities have been resolved once.
#[derive(Clone, Copy, Debug)]
pub(in crate::systems) struct BoundDamageRequest {
    pub binding: crate::state::program::DamageRequestBinding,
    input: DamageRequest,
}

impl BoundDamageRequest {
    pub(super) const fn new(
        input: DamageRequest,
        binding: crate::state::program::DamageRequestBinding,
    ) -> Self {
        Self { binding, input }
    }
}

impl std::ops::Deref for BoundDamageRequest {
    type Target = DamageRequest;

    fn deref(&self) -> &Self::Target {
        &self.input
    }
}

impl std::ops::DerefMut for BoundDamageRequest {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.input
    }
}

/// Emit already-resolved residual damage without a second multiplier pass.
pub(crate) fn deal_residual_damage(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    spell_id: u32,
    amount: f64,
) {
    deal_bound_resolved_damage(ctx, binding, spell_id, amount, DamageFlags::PERIODIC);
}

/// Emit resolved damage without reapplying stats, buffs, mastery, mitigation, or crit.
pub(crate) fn deal_bound_resolved_damage(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    spell_id: u32,
    amount: f64,
    flags: DamageFlags,
) {
    if amount <= 0.0 {
        return;
    }

    if !ctx.instance.is_valid_target(ctx.target) {
        return;
    }

    let Some(scope) = ctx.program.telemetry_scope(ctx.source, ctx.target) else {
        return;
    };

    let resolved = resolve_outgoing_absorbs(
        ctx.instance,
        ctx.target,
        ctx.program.damage.action_at(binding.effect_action()).school,
        amount,
        wowlab_types::combat::HitResult::Hit,
    );

    if resolved.amount > f64::EPSILON
        && !finalize_damage(
            ctx,
            ctx.target,
            binding,
            &DamageEvent::new(
                wowlab_engine_telemetry::DamageObservation {
                    spell_id,
                    amount: resolved.amount,
                    flags: DamageEventFlags::default()
                        .with_periodic(flags.contains(DamageFlags::PERIODIC))
                        .with_pet(flags.contains(DamageFlags::PET)),
                },
                ctx.now.as_millis(),
                scope,
            ),
        )
    {
        return;
    }

    fire_impact_procs(
        ctx,
        crate::ImpactEvent {
            kind: crate::state::ProcEventKind::Spell,
            phase: crate::state::ProcPhaseMask::HIT,
            hit_mask: resolved.hit_mask,
            spell_id,
            action: Some(binding.effect_action()),
            amount: resolved.amount,
            is_periodic: flags.contains(DamageFlags::PERIODIC),
            is_physical: ctx.program.damage.action_at(binding.effect_action()).school
                == wowlab_types::combat::DamageSchool::Physical,
            swing_hand: None,
            swing_speed_ms: 0,
            source: ctx.source,
            target: ctx.target,
            provenance: crate::state::ProcProvenance {
                trigger_spell_id: spell_id,
                policy: crate::ProcPolicy::from_attributes(
                    ctx.program
                        .damage
                        .action_at(binding.effect_action())
                        .attributes
                        .as_ref(),
                ),
                kind: if flags.contains(DamageFlags::PROC) {
                    crate::state::ProcSourceKind::Proc
                } else {
                    crate::state::ProcSourceKind::Action
                },
            },
        },
    );
}

/// Deal attack-power-based damage with the default main-hand weapon-AP composite.
pub(crate) fn deal_bound_damage_ap(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    payload: DamagePayload,
) -> (f64, bool) {
    deal_damage_ap_typed(ctx, binding, payload, crate::state::WeaponApType::MainHand)
}

pub(crate) fn deal_damage_ap_at(
    ctx: &mut CombatCtx<'_>,
    target: EnemyIdx,
    binding: crate::state::program::DamageRequestBinding,
    payload: DamagePayload,
) -> (f64, bool) {
    let power = typed_attack_power(
        ctx.program,
        ctx.instance,
        crate::state::WeaponApType::MainHand,
    );

    deal_damage_to_target(
        ctx,
        target,
        BoundDamageRequest::new(DamageRequest::new(payload, power), binding),
    )
}

/// Deal attack-power-based damage with an explicit weapon-AP composite.
pub(super) fn deal_damage_ap_typed(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    payload: DamagePayload,
    ap_type: crate::state::WeaponApType,
) -> (f64, bool) {
    let power = typed_attack_power(ctx.program, ctx.instance, ap_type);

    deal_damage(
        ctx,
        BoundDamageRequest::new(DamageRequest::new(payload, power), binding),
    )
}

pub(crate) fn deal_effect_damage_ap(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    effect: crate::state::DamageEffectRef,
    coef: f64,
    flags: DamageFlags,
) -> (f64, bool) {
    let power = typed_attack_power(
        ctx.program,
        ctx.instance,
        crate::state::WeaponApType::MainHand,
    );

    deal_damage(
        ctx,
        BoundDamageRequest::new(
            DamageRequest::new(DamagePayload::new(effect.spell_id, coef, flags), power)
                .effect(effect),
            binding,
        ),
    )
}

pub(crate) fn deal_bound_effect_damage_ap_with_geometry(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    effect: crate::state::DamageEffectRef,
    geometry_effect: crate::state::DamageEffectRef,
    coef: f64,
    flags: DamageFlags,
) -> (f64, bool) {
    let destination = ctx.instance.actor_transform(ActorId::Enemy(ctx.target));
    let power = typed_attack_power(
        ctx.program,
        ctx.instance,
        crate::state::WeaponApType::MainHand,
    );

    deal_damage(
        ctx,
        BoundDamageRequest::new(
            DamageRequest::new(DamagePayload::new(effect.spell_id, coef, flags), power)
                .effect(effect)
                .geometry(geometry_effect, None, destination),
            binding,
        ),
    )
}

pub(crate) fn deal_effect_damage_sp_with_geometry(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    effect: crate::state::DamageEffectRef,
    geometry_effect: crate::state::DamageEffectRef,
    coef: f64,
    flags: DamageFlags,
) -> (f64, bool) {
    let destination = ctx.instance.actor_transform(ActorId::Enemy(ctx.target));

    deal_damage(
        ctx,
        BoundDamageRequest::new(
            DamageRequest::new(
                DamagePayload::new(effect.spell_id, coef, flags),
                current_spell_power(ctx.program, ctx.instance),
            )
            .effect(effect)
            .geometry(geometry_effect, None, destination),
            binding,
        ),
    )
}

pub(crate) fn deal_effect_damage_sp(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    effect: crate::state::DamageEffectRef,
    coef: f64,
    flags: DamageFlags,
) -> (f64, bool) {
    deal_damage(
        ctx,
        BoundDamageRequest::new(
            DamageRequest::new(
                DamagePayload::new(effect.spell_id, coef, flags),
                current_spell_power(ctx.program, ctx.instance),
            )
            .effect(effect),
            binding,
        ),
    )
}

pub(in crate::systems) fn deal_damage_ap_with_weapon(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    payload: DamagePayload,
    weapon: WeaponDamageInput,
) -> (f64, bool) {
    let ap_type = if weapon.max > 0.0 {
        crate::state::WeaponApType::None
    } else {
        crate::state::WeaponApType::MainHand
    };
    let power = typed_attack_power(ctx.program, ctx.instance, ap_type);

    deal_damage(
        ctx,
        BoundDamageRequest::new(DamageRequest::new(payload, power).weapon(weapon), binding),
    )
}

pub(crate) fn deal_bound_damage_sp(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    payload: DamagePayload,
) -> (f64, bool) {
    let power = current_spell_power(ctx.program, ctx.instance);

    deal_damage(
        ctx,
        BoundDamageRequest::new(DamageRequest::new(payload, power), binding),
    )
}

pub(crate) fn deal_damage_sp_at(
    ctx: &mut CombatCtx<'_>,
    target: EnemyIdx,
    binding: crate::state::program::DamageRequestBinding,
    payload: DamagePayload,
) -> (f64, bool) {
    let power = current_spell_power(ctx.program, ctx.instance);

    deal_damage_to_target(
        ctx,
        target,
        BoundDamageRequest::new(DamageRequest::new(payload, power), binding),
    )
}

/// Deal damage from an already-resolved base amount.
pub(crate) fn deal_damage_base(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    spell_id: u32,
    amount: f64,
    flags: DamageFlags,
) -> (f64, bool) {
    deal_damage(
        ctx,
        BoundDamageRequest::new(
            DamageRequest::new(DamagePayload::new(spell_id, 0.0, flags), 0.0).base_points(amount),
            binding,
        ),
    )
}

/// Deal an already-resolved amount while retaining its exact DBC effect coordinate.
pub(crate) fn deal_effect_damage_base(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    effect: crate::state::DamageEffectRef,
    profile_spell_id: u32,
    amount: f64,
    flags: DamageFlags,
) -> (f64, bool) {
    deal_damage(
        ctx,
        BoundDamageRequest::new(
            DamageRequest::new(DamagePayload::new(effect.spell_id, 0.0, flags), 0.0)
                .profile(profile_spell_id)
                .effect(effect)
                .base_points(amount),
            binding,
        ),
    )
}

pub(crate) fn deal_damage_def(
    ctx: &mut CombatCtx<'_>,
    binding: crate::state::program::DamageRequestBinding,
    spell_id: u32,
    def: crate::state::RuntimeDamageDef,
    flags: DamageFlags,
) {
    deal_bound_profiled_damage_def(
        ctx,
        ProfiledDamageDef {
            binding,
            effect: crate::state::DamageEffectRef::new(spell_id, 1),
            geometry_effect: crate::state::DamageEffectRef::new(spell_id, 1),
            profile_spell_id: spell_id,
            base_points: None,
            def,
            flags,
            source_position: None,
            destination: None,
        },
    );
}

pub(crate) fn deal_bound_profiled_damage_def(
    ctx: &mut CombatCtx<'_>,
    request: ProfiledDamageDef,
) -> (f64, bool) {
    deal_profiled_damage_def_at(ctx, &request)
}

#[derive(Clone, Copy)]
pub(crate) struct ProfiledDamageDef {
    pub(crate) binding: crate::state::program::DamageRequestBinding,
    pub(crate) effect: crate::state::DamageEffectRef,
    pub(crate) geometry_effect: crate::state::DamageEffectRef,
    pub(crate) profile_spell_id: u32,
    pub(crate) base_points: Option<f64>,
    pub(crate) def: crate::state::RuntimeDamageDef,
    pub(crate) flags: DamageFlags,
    pub(crate) source_position: Option<wowlab_types::sim::SpatialTransform>,
    pub(crate) destination: Option<wowlab_types::sim::SpatialTransform>,
}

pub(crate) fn deal_profiled_damage_def_at(
    ctx: &mut CombatCtx<'_>,
    request: &ProfiledDamageDef,
) -> (f64, bool) {
    let ProfiledDamageDef {
        binding,
        effect,
        mut geometry_effect,
        profile_spell_id,
        base_points,
        def,
        flags,
        source_position,
        destination,
    } = *request;

    if geometry_effect == effect {
        geometry_effect = ctx.program.damage.effect_ref(binding.geometry_effect);
    }

    match def {
        crate::state::RuntimeDamageDef::None => {
            tracing::trace!(
                spell_id = effect.spell_id,
                is_periodic = flags.contains(DamageFlags::PERIODIC),
                "damage dispatch with no damage defined"
            );

            (0.0, false)
        }
        crate::state::RuntimeDamageDef::Flat(amount) => deal_damage(
            ctx,
            BoundDamageRequest::new(
                DamageRequest::new(
                    DamagePayload::profiled(effect.spell_id, profile_spell_id, 0.0, flags),
                    0.0,
                )
                .effect(effect)
                .geometry(geometry_effect, source_position, destination)
                .base_points(amount),
                binding,
            ),
        ),
        crate::state::RuntimeDamageDef::ApCoefficient {
            coef,
            is_physical,
            ap_type,
        } => {
            let power = typed_attack_power(ctx.program, ctx.instance, ap_type);

            deal_damage(
                ctx,
                BoundDamageRequest::new(
                    DamageRequest::new(
                        DamagePayload::profiled(
                            effect.spell_id,
                            profile_spell_id,
                            coef,
                            if is_physical {
                                flags | DamageFlags::PHYSICAL
                            } else {
                                flags
                            },
                        ),
                        power,
                    )
                    .effect(effect)
                    .geometry(geometry_effect, source_position, destination)
                    .optional_base_points(base_points),
                    binding,
                ),
            )
        }
        crate::state::RuntimeDamageDef::SpCoefficient { coef, is_physical } => {
            let power = current_spell_power(ctx.program, ctx.instance);

            deal_damage(
                ctx,
                BoundDamageRequest::new(
                    DamageRequest::new(
                        DamagePayload::profiled(
                            effect.spell_id,
                            profile_spell_id,
                            coef,
                            if is_physical {
                                flags | DamageFlags::PHYSICAL
                            } else {
                                flags
                            },
                        ),
                        power,
                    )
                    .effect(effect)
                    .geometry(geometry_effect, source_position, destination)
                    .optional_base_points(base_points),
                    binding,
                ),
            )
        }
        crate::state::RuntimeDamageDef::Weapon {
            multiplier,
            flat_bonus,
            normalized,
            is_physical,
            hand,
        } => {
            let power =
                typed_attack_power(ctx.program, ctx.instance, crate::state::WeaponApType::None);
            let weapon =
                weapon_damage_input(ctx.program, ctx.instance, hand, multiplier, normalized);

            deal_damage(
                ctx,
                BoundDamageRequest::new(
                    DamageRequest::new(
                        DamagePayload::profiled(
                            effect.spell_id,
                            profile_spell_id,
                            0.0,
                            if is_physical {
                                flags | DamageFlags::PHYSICAL
                            } else {
                                flags
                            },
                        ),
                        power,
                    )
                    .effect(effect)
                    .geometry(geometry_effect, source_position, destination)
                    .weapon(weapon)
                    .base_points(flat_bonus),
                    binding,
                ),
            )
        }
    }
}