wowlab_engine_domain/dbc/passives/

damage_proc.rs

use super::{
    AuraSubtypeKind, CLASS_FAMILY_FLAGS, HUNDRED, ModifierFilter, ModifierFold, ModifierOperation,
    ModifierPropertyKind, PassiveQuery, RankedPassive, SpellAttributeKind, SpellDataFlat,
    aura_kind, aura_subtype_semantic, effect_targets_spell, fold_flat_pct_modifiers, masks_overlap,
    modified_effect_base_points, modified_effect_value, modifier_property_kind, pct_to_mult,
    spell_attribute_is,
};

/// Static damage multipliers a set of passive auras applies to one spell.
#[derive(Clone, Copy, Debug)]
pub struct PassiveDamageMods {
    pub direct_flat: f64,
    pub direct_flat_mastery_coefficient: f64,
    pub direct: f64,
    pub periodic: f64,
    pub crit_chance: f64,
    pub crit_chance_mult: f64,
    pub crit_damage_bonus: f64,
}

/// Flat percent points and a final multiplier applied to a spell's proc chance.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PassiveProcChanceMods {
    pub flat_pct: f64,
    pub multiplier: f64,
}

/// Resolve passive spell-modifier property 18 while preserving flat-before-percent order.
#[must_use]
pub fn passive_proc_chance_mods(
    passives: &[RankedPassive],
    spell: &SpellDataFlat,
) -> PassiveProcChanceMods {
    let mut mods = PassiveProcChanceMods {
        flat_pct: 0.0,
        multiplier: 1.0,
    };

    for (source, ranks) in passives {
        for modifier in &source.effects {
            if modifier_property_kind(modifier) != Some(ModifierPropertyKind::ProcChance)
                || !effect_targets_spell(modifier, source, spell)
            {
                continue;
            }

            let amount = modified_effect_base_points(
                PassiveQuery {
                    passives,
                    spell: source,
                },
                modifier.index,
                modifier.base_points,
            ) * ranks;

            match aura_subtype_semantic(modifier.aura)
                .and_then(|semantic| semantic.modifier)
                .map(|(operation, _)| operation)
            {
                Some(ModifierOperation::Flat) => mods.flat_pct += amount,
                Some(ModifierOperation::Percent) => mods.multiplier *= pct_to_mult(amount),
                _ => {}
            }
        }
    }

    mods
}

/// Whether `spell` carries any damage-done modifier effect this module models.
#[must_use]
pub fn is_damage_modifier_passive(spell: &SpellDataFlat) -> bool {
    spell.is_passive
        && spell.effects.iter().any(|effect| match aura_kind(effect) {
            Some(
                AuraSubtypeKind::AddPercentModifier
                | AuraSubtypeKind::AddPercentLabelModifier
                | AuraSubtypeKind::ModAutoAttackDamage
                | AuraSubtypeKind::ModPetDamageDone,
            ) => true,
            Some(AuraSubtypeKind::AddFlatModifier | AuraSubtypeKind::AddFlatLabelModifier) => {
                matches!(
                    modifier_property_kind(effect),
                    Some(
                        ModifierPropertyKind::CritChance
                            | ModifierPropertyKind::CritDamage
                            | ModifierPropertyKind::GenericDamage
                            | ModifierPropertyKind::ChainTargets
                    )
                )
            }
            _ => false,
        })
}

/// Returns an effect coefficient after percentage `P_EFFECT_N` modifiers.
#[must_use]
// #t(fn: rust_floating_point_eq) DBC zero means the coefficient field is absent and percentage-only folds cannot make it nonzero.
pub fn modified_effect_coefficient(
    query: PassiveQuery<'_>,
    effect_index: i32,
    coefficient: f64,
) -> f64 {
    if coefficient == 0.0 {
        return 0.0;
    }

    modified_effect_value(query, effect_index, coefficient, false)
}

/// Return an effect's value multiplier after property-27 flat and percentage modifiers.
#[must_use]
pub fn modified_effect_amplitude(query: PassiveQuery<'_>, initial: f64) -> f64 {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;

    fold_flat_pct_modifiers(
        passives,
        initial,
        ModifierFold::FlatAndPercent,
        |source, ranks, modifier| {
            if modifier_property_kind(modifier) != Some(ModifierPropertyKind::Amplitude)
                || !effect_targets_spell(modifier, source, target)
            {
                return None;
            }

            Some(
                modified_effect_base_points(
                    PassiveQuery {
                        passives,
                        spell: source,
                    },
                    modifier.index,
                    modifier.base_points,
                ) * ranks,
            )
        },
    )
}

/// Spell-power and attack-power coefficients after property-24 modifiers.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ModifiedPowerCoefficients {
    pub spell_power: f64,
    pub attack_power: f64,
    /// Additive coefficient per live mastery point from attribute-285 flat modifiers.
    pub mastery_add: f64,
}

/// Resolve property 24 against the first populated coefficient field, preserving flat-before-percent order.
#[must_use]
// #t(fn: rust_floating_point_eq) DBC zero marks an absent AP/SP coefficient field; only populated fields require a passive fold.
pub fn modified_power_coefficients(
    query: PassiveQuery<'_>,
    effect_index: i32,
    spell_power: f64,
    attack_power: f64,
) -> ModifiedPowerCoefficients {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;
    let spell_power = if spell_power == 0.0 {
        0.0
    } else {
        modified_effect_coefficient(query, effect_index, spell_power)
    };
    let attack_power = if attack_power == 0.0 {
        0.0
    } else {
        modified_effect_coefficient(query, effect_index, attack_power)
    };
    let (initial, modifies_spell_power) = if spell_power.abs() > f64::EPSILON {
        (spell_power, true)
    } else if attack_power.abs() > f64::EPSILON {
        (attack_power, false)
    } else {
        return ModifiedPowerCoefficients {
            spell_power,
            attack_power,
            mastery_add: 0.0,
        };
    };
    let mut flat = 0.0;
    let mut flat_mastery = 0.0;
    let mut percent = 1.0;

    for (source, ranks) in passives {
        for modifier in &source.effects {
            if modifier_property_kind(modifier) != Some(ModifierPropertyKind::Coefficient)
                || !effect_targets_spell(modifier, source, target)
            {
                continue;
            }

            let amount = modified_effect_base_points(
                PassiveQuery {
                    passives,
                    spell: source,
                },
                modifier.index,
                modifier.base_points,
            ) * ranks;

            match aura_subtype_semantic(modifier.aura)
                .and_then(|semantic| semantic.modifier)
                .map(|(operation, _)| operation)
            {
                Some(ModifierOperation::Flat) => {
                    flat += amount / HUNDRED;

                    if spell_attribute_is(
                        &source.attributes,
                        SpellAttributeKind::MasteryAffectsPoints,
                    ) {
                        flat_mastery += modified_effect_coefficient(
                            PassiveQuery {
                                passives,
                                spell: source,
                            },
                            modifier.index,
                            modifier.bonus_coefficient,
                        ) * ranks
                            / HUNDRED;
                    }
                }
                Some(ModifierOperation::Percent) => percent *= pct_to_mult(amount),
                None => {}
            }
        }
    }

    let modified = (initial + flat) * percent;

    ModifiedPowerCoefficients {
        spell_power: if modifies_spell_power {
            modified
        } else {
            spell_power
        },
        attack_power: if modifies_spell_power {
            attack_power
        } else {
            modified
        },
        mastery_add: flat_mastery * percent,
    }
}

/// Returns compound damage and critical-strike modifiers.
#[must_use]
pub fn passive_damage_mods(
    passives: &[RankedPassive],
    target_class_set: i32,
    target_class_masks: [i32; CLASS_FAMILY_FLAGS],
    target_labels: &[i32],
) -> PassiveDamageMods {
    let mut crit_damage_flat = 0.0;
    let mut crit_damage_mult = 1.0;
    let mut mods = PassiveDamageMods {
        direct_flat: 0.0,
        direct_flat_mastery_coefficient: 0.0,
        direct: 1.0,
        periodic: 1.0,
        crit_chance: 0.0,
        crit_chance_mult: 1.0,
        crit_damage_bonus: 0.0,
    };

    for (aura, ranks) in passives {
        for effect in &aura.effects {
            let base_points = modified_effect_base_points(
                PassiveQuery {
                    passives,
                    spell: aura,
                },
                effect.index,
                effect.base_points,
            );
            let matched = match aura_subtype_semantic(effect.aura)
                .and_then(|semantic| semantic.modifier)
                .map(|(_, filter)| filter)
            {
                Some(ModifierFilter::ClassFamilyMask) => {
                    aura.spell_class_set == target_class_set
                        && masks_overlap(effect, target_class_masks)
                }
                Some(ModifierFilter::Label) => target_labels.contains(&effect.misc_value_1),
                _ => false,
            };

            if !matched {
                continue;
            }

            let operation = aura_subtype_semantic(effect.aura)
                .and_then(|semantic| semantic.modifier)
                .map(|(operation, _)| operation);

            match (operation, modifier_property_kind(effect)) {
                (Some(ModifierOperation::Flat), Some(ModifierPropertyKind::GenericDamage)) => {
                    mods.direct_flat += base_points * ranks;

                    if spell_attribute_is(
                        &aura.attributes,
                        SpellAttributeKind::MasteryAffectsPoints,
                    ) {
                        mods.direct_flat_mastery_coefficient += modified_effect_coefficient(
                            PassiveQuery {
                                passives,
                                spell: aura,
                            },
                            effect.index,
                            effect.bonus_coefficient,
                        ) * ranks;
                    }
                }
                (Some(ModifierOperation::Percent), Some(ModifierPropertyKind::GenericDamage)) => {
                    mods.direct *= pct_to_mult(base_points * ranks);
                    // #t(rust_log_in_loop) each contributing passive is a distinct identity needed in trace diagnostics.
                    tracing::trace!(
                        source_spell_id = aura.id,
                        source_spell_name = aura.name.as_str(),
                        effect_index = effect.index,
                        percent = base_points * ranks,
                        running_direct = mods.direct,
                        "static passive direct-damage contribution"
                    );
                }
                (Some(ModifierOperation::Percent), Some(ModifierPropertyKind::PeriodicAmount)) => {
                    mods.periodic *= pct_to_mult(base_points * ranks);
                    // #t(rust_log_in_loop) each contributing passive is a distinct identity needed in trace diagnostics.
                    tracing::trace!(
                        source_spell_id = aura.id,
                        source_spell_name = aura.name.as_str(),
                        effect_index = effect.index,
                        percent = base_points * ranks,
                        running_periodic = mods.periodic,
                        "static passive periodic-damage contribution"
                    );
                }
                (Some(ModifierOperation::Percent), Some(ModifierPropertyKind::CritDamage)) => {
                    crit_damage_mult *= pct_to_mult(base_points * ranks);
                }
                (Some(ModifierOperation::Flat), Some(ModifierPropertyKind::CritDamage)) => {
                    crit_damage_flat += base_points * ranks / HUNDRED;
                }
                (Some(ModifierOperation::Flat), Some(ModifierPropertyKind::CritChance)) => {
                    mods.crit_chance += base_points * ranks;
                }
                (Some(ModifierOperation::Percent), Some(ModifierPropertyKind::CritChance)) => {
                    mods.crit_chance_mult *= pct_to_mult(base_points * ranks);
                }
                _ => {}
            }
        }
    }

    mods.crit_damage_bonus = ((1.0 + crit_damage_flat) * crit_damage_mult - 1.0) * HUNDRED;

    mods
}

/// Whether `spell` is a damage-taken debuff the caster maintains on its own target.
///
/// Mystic Touch 113746 and Chaos Brand 1490 are the live shapes.
/// Each is a school-filtered aura-87 (`ModDamageTakenPercent`) aimed at the caster's own enemy.
/// Their parent class passives (8647, 255260) carry only a dummy effect and name them in text.
/// This predicate therefore qualifies the *referenced* spell, never the passive that names it.
#[must_use]
pub fn is_target_damage_taken_debuff(spell: &SpellDataFlat) -> bool {
    spell.effects.iter().any(|effect| {
        aura_kind(effect) == Some(AuraSubtypeKind::ModDamageTakenPercent)
            && effect_targets_current_enemy(effect)
    })
}

fn effect_targets_current_enemy(effect: &wowlab_types::data::SpellEffect) -> bool {
    crate::dbc::implicit_target_semantic(effect.implicit_target_a).is_some_and(|semantic| {
        semantic.object == crate::dbc::ImplicitTargetObject::Unit
            && semantic.reference == crate::dbc::ImplicitTargetReference::Target
            && semantic.check == crate::dbc::ImplicitTargetCheck::Enemy
    })
}