wowlab_engine_combat/context/

damage.rs

//! Damage operations exposed to combat hooks.

use wowlab_types::sim::{ActorId, EnemyIdx, PetIdx};

use super::{DamageOps, HookCtx};
use crate::{
    DamageActionId, DamageEffectId,
    state::{RuntimeDamageDef, SwingHand},
    systems,
};

/// Resolved outcome of one hook-owned damage impact.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
#[must_use]
pub struct DamageOutcome {
    pub amount: f64,
    pub is_crit: bool,
}

impl From<(f64, bool)> for DamageOutcome {
    fn from((amount, is_crit): (f64, bool)) -> Self {
        Self { amount, is_crit }
    }
}

impl DamageOps for HookCtx<'_> {
    fn deal_damage_ap(&mut self, action: DamageActionId, coef: f64, flags: systems::DamageFlags) {
        let _ = self.deal_damage_ap_result(action, coef, flags);
    }

    /// Deal one attack-power hit and return its post-mitigation outcome.
    fn deal_damage_ap_result(
        &mut self,
        action: DamageActionId,
        coef: f64,
        flags: systems::DamageFlags,
    ) -> DamageOutcome {
        let Some(target) = self.target else {
            return DamageOutcome::default();
        };
        let flags = self.source_flags(flags);
        let coef = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::AttackPowerInheritance,
            coef,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return DamageOutcome::default();
        };

        systems::deal_bound_damage_ap(
            &mut ctx,
            binding,
            systems::DamagePayload::new(spell_id, coef, flags),
        )
        .into()
    }

    /// Derive a non-crit child hit from a parent's final amount under the child's own modifiers.
    ///
    /// The parent amount already contains player-wide damage and versatility multipliers.
    ///
    /// The child retains its spell-scoped and target modifiers.
    /// Those inherited terms are not applied a second time.
    fn deal_damage_from_result(
        &mut self,
        action: DamageActionId,
        parent: DamageOutcome,
        multiplier: f64,
        flags: systems::DamageFlags,
    ) -> DamageOutcome {
        if parent.amount <= 0.0 || multiplier <= 0.0 {
            return DamageOutcome::default();
        }

        let Some(target) = self.target else {
            return DamageOutcome::default();
        };
        let flags = self.source_flags(
            flags | systems::DamageFlags::NO_CRIT | systems::DamageFlags::IGNORE_PLAYER_MULTIPLIERS,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return DamageOutcome::default();
        };

        systems::deal_damage_base(
            &mut ctx,
            binding,
            spell_id,
            parent.amount * multiplier,
            flags,
        )
        .into()
    }

    /// Deal an AP hit under one spell's formula while reporting a distinct combat-log identity.
    fn deal_profiled_damage_ap(
        &mut self,
        action: DamageActionId,
        profile: DamageActionId,
        coef: f64,
        flags: systems::DamageFlags,
    ) {
        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(flags);
        let coef = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::AttackPowerInheritance,
            coef,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let profile_spell_id = profile.spell_id();
        let Some(binding) = ctx
            .program
            .damage
            .profiled_action_id_request(action, profile)
        else {
            return;
        };

        systems::deal_bound_damage_ap(
            &mut ctx,
            binding,
            systems::DamagePayload::profiled(spell_id, profile_spell_id, coef, flags),
        );
    }

    /// Current outgoing spell/melee haste multiplier (`1.0` means unmodified cadence).
    fn haste_multiplier(&self) -> f64 {
        systems::current_haste_mult(&self.view().combat())
    }

    /// Deal exactly one attack-power hit to a previously resolved enemy identity.
    fn deal_damage_ap_to_target(
        &mut self,
        target: EnemyIdx,
        action: DamageActionId,
        coef: f64,
        flags: systems::DamageFlags,
    ) {
        let flags = self.source_flags(flags);
        let coef = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::AttackPowerInheritance,
            coef,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return;
        };

        systems::deal_damage_ap_at(
            &mut ctx,
            target,
            binding,
            systems::DamagePayload::new(spell_id, coef, flags),
        );
    }

    fn deal_damage_ap_if_positive(
        &mut self,
        action: DamageActionId,
        coefficient: f64,
        flags: systems::DamageFlags,
    ) {
        if coefficient > 0.0 {
            self.deal_damage_ap(action, coefficient, flags);
        }
    }

    fn deal_effect_damage_ap(
        &mut self,
        effect: DamageEffectId,
        multiplier: f64,
        flags: systems::DamageFlags,
    ) {
        let coefficient = self.effect_ap_coefficient(effect) * multiplier;

        if coefficient <= 0.0 {
            return;
        }

        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(flags);
        let coefficient = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::AttackPowerInheritance,
            coefficient,
        );
        let mut ctx = self.combat_ctx(target);
        let effect_ref =
            crate::state::DamageEffectRef::new(effect.action().spell_id(), effect.effect_index());
        let Some(binding) = ctx
            .program
            .damage
            .effect_id_request(effect, effect, effect.action())
        else {
            return;
        };

        systems::deal_effect_damage_ap(&mut ctx, binding, effect_ref, coefficient, flags);
    }

    fn deal_effect_damage_ap_with_geometry(
        &mut self,
        effect: DamageEffectId,
        geometry_effect: DamageEffectId,
        multiplier: f64,
        flags: systems::DamageFlags,
    ) {
        let coefficient = self.effect_ap_coefficient(effect) * multiplier;

        if coefficient <= 0.0 {
            return;
        }

        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(flags);
        let coefficient = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::AttackPowerInheritance,
            coefficient,
        );
        let mut ctx = self.combat_ctx(target);
        let effect_ref =
            crate::state::DamageEffectRef::new(effect.action().spell_id(), effect.effect_index());
        let geometry_ref = crate::state::DamageEffectRef::new(
            geometry_effect.action().spell_id(),
            geometry_effect.effect_index(),
        );
        let Some(binding) =
            ctx.program
                .damage
                .effect_id_request(effect, geometry_effect, effect.action())
        else {
            return;
        };

        systems::deal_bound_effect_damage_ap_with_geometry(
            &mut ctx,
            binding,
            effect_ref,
            geometry_ref,
            coefficient,
            flags,
        );
    }

    fn deal_effect_damage_sp_with_geometry(
        &mut self,
        effect: DamageEffectId,
        geometry_effect: DamageEffectId,
        multiplier: f64,
        flags: systems::DamageFlags,
    ) {
        let coefficient = self.effect_sp_coefficient(effect) * multiplier;

        if coefficient <= 0.0 {
            return;
        }

        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(flags);
        let coefficient = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::SpellPowerInheritance,
            coefficient,
        );
        let mut ctx = self.combat_ctx(target);
        let effect_ref =
            crate::state::DamageEffectRef::new(effect.action().spell_id(), effect.effect_index());
        let geometry_ref = crate::state::DamageEffectRef::new(
            geometry_effect.action().spell_id(),
            geometry_effect.effect_index(),
        );
        let Some(binding) =
            ctx.program
                .damage
                .effect_id_request(effect, geometry_effect, effect.action())
        else {
            return;
        };

        systems::deal_effect_damage_sp_with_geometry(
            &mut ctx,
            binding,
            effect_ref,
            geometry_ref,
            coefficient,
            flags,
        );
    }

    fn deal_physical_damage_ap_if_positive(&mut self, action: DamageActionId, coefficient: f64) {
        self.deal_damage_ap_if_positive(action, coefficient, systems::DamageFlags::PHYSICAL);
    }

    fn deal_pet_damage_ap(&mut self, action: DamageActionId, coefficient: f64) {
        self.deal_damage_ap(action, coefficient, systems::DamageFlags::PET);
    }

    /// Deal pet AP damage using a construction-resolved NPC inheritance scalar.
    fn deal_pet_damage_ap_with_inheritance(
        &mut self,
        action: DamageActionId,
        coefficient: f64,
        inheritance_multiplier: f64,
    ) {
        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(systems::DamageFlags::PET);
        let coefficient = coefficient * inheritance_multiplier;
        let mut ctx = self.combat_ctx_with_source(ActorId::Pet(PetIdx::PRIMARY), target);
        let spell_id = action.spell_id();
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return;
        };

        systems::deal_bound_damage_ap(
            &mut ctx,
            binding,
            systems::DamagePayload::new(spell_id, coefficient, flags),
        );
    }

    fn deal_physical_pet_damage_ap(&mut self, action: DamageActionId, coefficient: f64) {
        self.deal_damage_ap(
            action,
            coefficient,
            systems::DamageFlags::PHYSICAL | systems::DamageFlags::PET,
        );
    }

    fn deal_damage_sp(&mut self, action: DamageActionId, coef: f64, flags: systems::DamageFlags) {
        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(flags);
        let coef = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::SpellPowerInheritance,
            coef,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return;
        };

        systems::deal_bound_damage_sp(
            &mut ctx,
            binding,
            systems::DamagePayload::new(spell_id, coef, flags),
        );
    }

    /// Deal exactly one spell-power hit to a previously resolved enemy identity.
    fn deal_damage_sp_to_target(
        &mut self,
        target: EnemyIdx,
        action: DamageActionId,
        coef: f64,
        flags: systems::DamageFlags,
    ) {
        let flags = self.source_flags(flags);
        let coef = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::SpellPowerInheritance,
            coef,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return;
        };

        systems::deal_damage_sp_at(
            &mut ctx,
            target,
            binding,
            systems::DamagePayload::new(spell_id, coef, flags),
        );
    }

    fn deal_profiled_damage_sp(
        &mut self,
        action: DamageActionId,
        profile: DamageActionId,
        coef: f64,
        flags: systems::DamageFlags,
    ) {
        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(flags);
        let coef = self.resolved_pet_coefficient(
            flags,
            wowlab_engine_domain::dbc::PetStatKind::SpellPowerInheritance,
            coef,
        );
        let mut ctx = self.combat_ctx(target);
        let spell_id = action.spell_id();
        let profile_spell_id = profile.spell_id();
        let Some(binding) = ctx
            .program
            .damage
            .profiled_action_id_request(action, profile)
        else {
            return;
        };

        systems::deal_bound_damage_sp(
            &mut ctx,
            binding,
            systems::DamagePayload::profiled(spell_id, profile_spell_id, coef, flags),
        );
    }

    fn deal_damage_flat(&mut self, action: DamageActionId, amount: f64) {
        let Some(target) = self.target else {
            return;
        };
        let spell_id = action.spell_id();
        let flags = systems::damage_flags_from_binding(self.program, action, false);
        let flags = self.source_flags(flags);
        let mut ctx = self.combat_ctx(target);
        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return;
        };

        systems::deal_damage_def(
            &mut ctx,
            binding,
            spell_id,
            RuntimeDamageDef::Flat(amount),
            flags,
        );
    }

    /// Deal a post-mitigation redirected amount without a second modifier pass.
    fn deal_resolved_damage(&mut self, action: DamageActionId, amount: f64) {
        let Some(target) = self.target else {
            return;
        };
        let flags = self.source_flags(systems::DamageFlags::empty());
        let mut ctx = self.combat_ctx(target);

        let Some(binding) = ctx.program.damage.action_id_request(action) else {
            return;
        };

        systems::deal_bound_resolved_damage(&mut ctx, binding, action.spell_id(), amount, flags);
    }

    /// Follow one resolved DBC trigger edge and deal its terminal child damage.
    fn deal_triggered_damage(
        &mut self,
        effect: DamageEffectId,
        multiplier: f64,
        flags: systems::DamageFlags,
    ) -> bool {
        let Some(target) = self.target else {
            return false;
        };
        let Some((binding, planned)) = self.program.damage.triggered_effect_id_request(effect)
        else {
            tracing::warn!(
                source_spell_id = effect.action().spell_id(),
                effect_index = effect.effect_index(),
                "TRIGGER_DAMAGE_UNRESOLVED"
            );

            return false;
        };
        let Some(damage) = planned
            .resolved_damage
            .map(|damage| damage.scaled(multiplier))
        else {
            return false;
        };
        let base_points = Some(planned.resolved_damage_base_points * multiplier);
        let flags = self.source_flags(flags);
        let mut ctx = self.combat_ctx(target);
        let geometry = crate::state::DamageEffectRef::new(
            planned.geometry.spell.as_u32(),
            planned.geometry.effect_index,
        );

        systems::deal_bound_profiled_damage_def(
            &mut ctx,
            systems::ProfiledDamageDef {
                binding,
                effect: geometry,
                geometry_effect: geometry,
                profile_spell_id: effect.action().spell_id(),
                base_points,
                def: damage,
                flags,
                source_position: None,
                destination: None,
            },
        );

        true
    }

    /// Deal an item's spell-power damage, reading its effect-1 SP coefficient from game data.
    fn deal_item_damage_sp(&mut self, action: DamageActionId) {
        let coef = self
            .program
            .damage
            .action_id_request(action)
            .map(|binding| self.program.damage.effect_at(binding.effect))
            .map_or(0.0, |effect| effect.sp_coefficient);

        self.deal_damage_sp(action, coef, systems::DamageFlags::empty());
    }

    fn deal_hook_flat_damage(&mut self, action: DamageActionId) -> bool {
        let Some(amount) = self
            .program
            .damage
            .action_id_plan(action)
            .and_then(|planned| planned.hook_flat_damage)
        else {
            return false;
        };

        self.deal_damage_flat(action, amount);

        true
    }

    fn player_swing_period_ms(&self, hand: SwingHand) -> Option<u32> {
        systems::active_form_combat_round_time_ms(self.program, self.instance)
            .or_else(|| match hand {
                SwingHand::MainHand => Some(self.program.damage.main_hand.speed_ms),
                SwingHand::OffHand => self.program.damage.off_hand.map(|weapon| weapon.speed_ms),
            })
            .filter(|period_ms| *period_ms > 0)
    }

    fn effect_base_points(&self, effect: DamageEffectId) -> f64 {
        self.program
            .damage
            .effect_id_plan(effect)
            .map(|(_, planned)| planned)
            .map_or(0.0, |planned| planned.base_points)
    }

    fn effect_points(&self, effect: DamageEffectId) -> f64 {
        let Some(planned) = self
            .program
            .damage
            .effect_id_plan(effect)
            .map(|(_, planned)| planned)
        else {
            return 0.0;
        };
        let mastery_affects_points = self
            .program
            .damage
            .action_id_plan(effect.action())
            .is_some_and(|action| action.mastery_affects_points);
        let mastery = if mastery_affects_points {
            systems::current_mastery_points(&self.view().combat())
        } else {
            0.0
        };

        planned.base_points + mastery * planned.sp_coefficient
    }

    fn effect_percent(&self, effect: DamageEffectId) -> f64 {
        self.effect_base_points(effect) / wowlab_types::constants::HUNDRED
    }

    fn effect_ap_coefficient(&self, effect: DamageEffectId) -> f64 {
        self.program
            .damage
            .effect_id_plan(effect)
            .map(|(_, planned)| planned)
            .map_or(0.0, |planned| planned.ap_coefficient)
    }

    fn effect_sp_coefficient(&self, effect: DamageEffectId) -> f64 {
        self.program
            .damage
            .effect_id_plan(effect)
            .map(|(_, planned)| planned)
            .map_or(0.0, |planned| planned.sp_coefficient)
    }

    fn effect_period_ms(&self, effect: DamageEffectId) -> u32 {
        self.program
            .damage
            .effect_id_plan(effect)
            .map(|(_, planned)| planned.period)
            .filter(|period| period.is_finite() && *period > 0.0)
            .map_or(0, wowlab_types::numeric::f64_to_u32_saturating_round)
    }

    fn action_proc_chance(&self, action: DamageActionId) -> f64 {
        self.program
            .damage
            .action_id_plan(action)
            .map_or(0.0, |planned| planned.proc_chance)
    }

    fn action_gcd_ms(&self, action: DamageActionId) -> u32 {
        self.program
            .damage
            .action_id_plan(action)
            .map_or(0, |planned| planned.gcd_ms)
    }

    fn action_aura_duration_ms(&self, action: DamageActionId) -> u32 {
        self.program
            .damage
            .action_id_plan(action)
            .map_or(0, |planned| planned.aura_duration_ms)
    }

    fn action_aura_tick_ms(&self, action: DamageActionId) -> u32 {
        self.program
            .damage
            .action_id_plan(action)
            .map_or(0, |planned| planned.aura_tick_ms)
    }

    fn action_secondary_gain(&self, action: DamageActionId) -> f64 {
        self.program
            .damage
            .action_id_plan(action)
            .map_or(0.0, |planned| planned.secondary_gain)
    }

    fn action_hook_scalar(&self, action: DamageActionId) -> Option<f64> {
        self.program
            .damage
            .action_id_plan(action)
            .and_then(|planned| planned.hook_scalar)
    }

    fn action_passive_direct_damage_mult(&self, action: DamageActionId) -> f64 {
        self.program
            .damage
            .action_id_plan(action)
            .map_or(1.0, |planned| planned.passive.direct_damage_mult)
    }

    fn action_is_melee(&self, action: DamageActionId) -> bool {
        self.program
            .damage
            .action_id_plan(action)
            .is_some_and(|planned| {
                planned.defense_type == wowlab_engine_domain::dbc::DefenseType::Melee as i32
            })
    }

    fn action_has_direct_damage(&self, action: DamageActionId) -> bool {
        self.program
            .damage
            .action_id_plan(action)
            .is_some_and(|planned| planned.has_direct_damage)
    }

    fn action_requires_main_hand(&self, action: DamageActionId) -> bool {
        self.program
            .damage
            .action_id_plan(action)
            .is_some_and(|planned| {
                wowlab_engine_domain::dbc::spell_attribute_is(
                    &planned.attributes,
                    wowlab_engine_domain::dbc::SpellAttributeKind::RequiresMainHand,
                )
            })
    }

    fn action_requires_off_hand(&self, action: DamageActionId) -> bool {
        self.program
            .damage
            .action_id_plan(action)
            .is_some_and(|planned| {
                wowlab_engine_domain::dbc::spell_attribute_is(
                    &planned.attributes,
                    wowlab_engine_domain::dbc::SpellAttributeKind::RequiresOffHand,
                )
            })
    }

    fn action_suppresses_caster_procs(&self, action: DamageActionId) -> bool {
        self.program
            .damage
            .action_id_plan(action)
            .is_some_and(|planned| {
                wowlab_engine_domain::dbc::spell_attribute_is(
                    &planned.attributes,
                    wowlab_engine_domain::dbc::SpellAttributeKind::SuppressCasterProcs,
                )
            })
    }

    fn impact_has_label(&self, impact: crate::ImpactEvent, label: i32) -> bool {
        impact.action.is_some_and(|action| {
            self.program
                .damage
                .action_at(action)
                .labels
                .contains(&label)
        })
    }

    fn impact_is_physical(&self, impact: crate::ImpactEvent) -> bool {
        impact.action.is_some_and(|action| {
            self.program
                .damage
                .action_at(action)
                .school_mask
                .contains(wowlab_engine_domain::dbc::SpellSchoolMask::PHYSICAL)
        })
    }

    fn impact_is_nature(&self, impact: crate::ImpactEvent) -> bool {
        impact.action.is_some_and(|action| {
            self.program.damage.action_at(action).school
                == wowlab_types::combat::DamageSchool::Nature
        })
    }

    fn impact_generates_primary_resource(&self, impact: crate::ImpactEvent) -> bool {
        impact
            .action
            .is_some_and(|action| self.program.damage.action_at(action).primary_resource_gain > 0.0)
    }

    fn effect_affects_impact(&self, effect: DamageEffectId, impact: crate::ImpactEvent) -> bool {
        let Some(action) = impact.action else {
            return false;
        };
        let Some((effect, _)) = self.program.damage.effect_id_plan(effect) else {
            return false;
        };

        self.program.damage.effect_affects_action(effect, action)
    }

    fn target_health_fraction(&self) -> f64 {
        self.target
            .filter(|target| self.instance.is_valid_target(*target))
            .and_then(|target| {
                self.instance
                    .enemy_health_fraction(self.program, target, self.now)
            })
            .unwrap_or(1.0)
    }
}