wowlab_engine_domain/dbc/

passives.rs

//! Passive aura modifiers resolved from DBC effects.

#[cfg(test)]
use wowlab_engine_gamedata::SpellProps;
#[cfg(test)]
use wowlab_types::sim::FastSet;
use wowlab_types::{
    constants::HUNDRED,
    data::{SpellDataFlat, SpellEffect},
    game::ClassId,
    numeric::f64_to_i32_saturating_round,
};

use super::decode::power_cost_is_available;
mod combat;
mod crit_scaling;
mod damage_proc;
mod resource;
mod stats;
mod talent;
mod targeting;
mod timing;

pub use combat::{
    PassivePetStatMods, passive_auto_attack_mult, passive_guardian_damage_mult,
    passive_pet_damage_mult, passive_pet_stat_mods, passive_target_armor_mult,
};
pub use crit_scaling::{
    CritChanceScaledAxis, CritChanceScaledCritDamage, crit_chance_scaled_crit_damage,
    crit_chance_scaled_spell_percent,
};
pub use stats::{PassiveStatMods, is_stat_modifier_passive, passive_stat_mods};
pub use timing::{
    apply_passive_cooldowns, passive_cast_time_ms, passive_cooldown_ms, passive_gcd_ms,
    passive_hasted_cooldown, passive_hasted_gcd, passive_max_charges,
};

use super::{
    AttributeMask, AuraSubtypeKind, ModifierFilter, ModifierOperation, ModifierPropertyKind,
    PetStatKind, RatingMultiplierMask, SpellAttributeKind, SpellEffectSemanticExt,
    aura_subtype_kind, aura_subtype_semantic, modifier_property_kind as registered_property_kind,
    pet_stat_kind, spell_attribute_is,
};

/// The fixed cadence used by DBC aura 85 resource-regeneration amounts.
pub const POWER_REGEN_PERIOD_SECONDS: f64 = 5.0;

const CLASS_FAMILY_FLAGS: usize = 4;
pub use damage_proc::{
    ModifiedPowerCoefficients, PassiveDamageMods, PassiveProcChanceMods,
    is_damage_modifier_passive, is_target_damage_taken_debuff, modified_effect_amplitude,
    modified_effect_coefficient, modified_power_coefficients, passive_damage_mods,
    passive_proc_chance_mods,
};

fn aura_kind(effect: &SpellEffect) -> Option<AuraSubtypeKind> {
    aura_subtype_kind(effect.aura)
}

fn modifier_property_kind(effect: &SpellEffect) -> Option<ModifierPropertyKind> {
    registered_property_kind(effect.misc_value_0)
}

const fn masks_overlap(effect: &SpellEffect, target_masks: [i32; CLASS_FAMILY_FLAGS]) -> bool {
    let [m1, m2, m3, m4] = target_masks;

    (effect.effect_class_mask_1 & m1) != 0
        || (effect.effect_class_mask_2 & m2) != 0
        || (effect.effect_class_mask_3 & m3) != 0
        || (effect.effect_class_mask_4 & m4) != 0
}

const fn pct_to_mult(base_points: f64) -> f64 {
    1.0 + base_points / HUNDRED
}

const fn property_effect_index(property: ModifierPropertyKind) -> Option<i32> {
    const EFFECT_INDEX_1: i32 = 0;
    const EFFECT_INDEX_2: i32 = 1;
    const EFFECT_INDEX_3: i32 = 2;
    const EFFECT_INDEX_4: i32 = 3;
    const EFFECT_INDEX_5: i32 = 4;

    match property {
        ModifierPropertyKind::Effect1 => Some(EFFECT_INDEX_1),
        ModifierPropertyKind::Effect2 => Some(EFFECT_INDEX_2),
        ModifierPropertyKind::Effect3 => Some(EFFECT_INDEX_3),
        ModifierPropertyKind::Effect4 => Some(EFFECT_INDEX_4),
        ModifierPropertyKind::Effect5 => Some(EFFECT_INDEX_5),
        _ => None,
    }
}

const fn property_targets_effect(property: ModifierPropertyKind, effect_index: i32) -> bool {
    match property_effect_index(property) {
        Some(index) => index == effect_index,
        None => matches!(property, ModifierPropertyKind::Points),
    }
}

#[derive(Clone, Copy)]
enum ModifierFold {
    PercentOnly,
    FlatAndPercent,
}

impl ModifierFold {
    const fn includes(self, operation: ModifierOperation) -> bool {
        match (self, operation) {
            (Self::FlatAndPercent, _) | (Self::PercentOnly, ModifierOperation::Percent) => true,
            (Self::PercentOnly, ModifierOperation::Flat) => false,
        }
    }
}

/// Flat and multiplicative components of one affected-spell modifier property.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PassiveModifierComponents {
    pub flat: f64,
    pub multiplier: f64,
}

/// Passive selection and the spell whose values are being resolved.
#[derive(Clone, Copy, Debug)]
pub struct PassiveQuery<'a> {
    pub passives: &'a [RankedPassive],
    pub spell: &'a SpellDataFlat,
}

impl PassiveModifierComponents {
    #[must_use]
    pub const fn apply(self, initial: f64) -> f64 {
        (initial + self.flat) * self.multiplier
    }
}

/// Resolve one passive spell-modifier property while retaining flat-before-percent ordering.
#[must_use]
pub fn passive_modifier_components(
    query: PassiveQuery<'_>,
    property: ModifierPropertyKind,
) -> PassiveModifierComponents {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;
    let mut components = PassiveModifierComponents {
        flat: 0.0,
        multiplier: 1.0,
    };

    for (source, ranks) in passives {
        for modifier in &source.effects {
            if modifier_property_kind(modifier) != Some(property)
                || !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) => components.flat += amount,
                Some(ModifierOperation::Percent) => {
                    components.multiplier *= pct_to_mult(amount);
                }
                _ => {}
            }
        }
    }

    components
}

fn effect_targets_spell(
    effect: &SpellEffect,
    source: &SpellDataFlat,
    target: &SpellDataFlat,
) -> bool {
    match aura_subtype_semantic(effect.aura).and_then(|semantic| semantic.modifier) {
        Some((_, ModifierFilter::ClassFamilyMask)) => {
            source.spell_class_set == target.spell_class_set
                && masks_overlap(
                    effect,
                    [
                        target.spell_class_mask_1,
                        target.spell_class_mask_2,
                        target.spell_class_mask_3,
                        target.spell_class_mask_4,
                    ],
                )
        }
        Some((_, ModifierFilter::Label)) => target
            .labels
            .iter()
            .any(|label| label.0 == effect.misc_value_1),
        _ => false,
    }
}

fn fold_flat_pct_modifiers(
    passives: &[RankedPassive],
    initial: f64,
    operations: ModifierFold,
    mut amount_for: impl FnMut(&SpellDataFlat, f64, &SpellEffect) -> Option<f64>,
) -> f64 {
    let mut flat = 0.0;
    let mut pct_mult = 1.0;

    for (source, ranks) in passives {
        for modifier in &source.effects {
            let Some(amount) = amount_for(source, *ranks, modifier) else {
                continue;
            };
            let operation = aura_subtype_semantic(modifier.aura)
                .and_then(|semantic| semantic.modifier)
                .map(|(operation, _)| operation);

            match operation.filter(|operation| operations.includes(*operation)) {
                Some(ModifierOperation::Flat) => flat += amount,
                Some(ModifierOperation::Percent) => pct_mult *= pct_to_mult(amount),
                _ => {}
            }
        }
    }
    // Flat adjusts the base before percent scales it, independent of passive iteration order.

    (initial + flat) * pct_mult
}

fn passive_integral_value(
    query: PassiveQuery<'_>,
    initial: i32,
    property: ModifierPropertyKind,
) -> i32 {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;

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

                Some(modifier.base_points * ranks)
            },
        )
        .max(0.0),
    )
}

fn modified_effect_value(
    query: PassiveQuery<'_>,
    effect_index: i32,
    initial: f64,
    include_flat: bool,
) -> f64 {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;

    fold_flat_pct_modifiers(
        passives,
        initial,
        if include_flat {
            ModifierFold::FlatAndPercent
        } else {
            ModifierFold::PercentOnly
        },
        |source, ranks, modifier| {
            if !modifier_property_kind(modifier)
                .is_some_and(|property| property_targets_effect(property, effect_index))
                || !effect_targets_spell(modifier, source, target)
            {
                return None;
            }

            tracing::trace!(
                source_spell_id = source.id,
                source_spell_name = %source.name,
                modifier_index = modifier.index,
                target_spell_id = target.id,
                effect_index,
                ranks,
                value = modifier.base_points * ranks,
                "passive effect-value modifier applied"
            );

            Some(modifier.base_points * ranks)
        },
    )
}

/// Return effective effect base points after selected `P_EFFECT_N` passives apply.
#[must_use]
pub fn modified_effect_base_points(
    query: PassiveQuery<'_>,
    effect_index: i32,
    base_points: f64,
) -> f64 {
    modified_effect_value(query, effect_index, base_points, true)
}

/// Resolves an aura's maximum stack count after passive modifiers.
#[must_use]
pub fn passive_max_stacks(query: PassiveQuery<'_>, initial: i32) -> i32 {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;

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

                Some(modifier.base_points * ranks)
            },
        )
        .max(1.0),
    )
}

/// Resolves `SpellAuraOptions.ProcCharges` after passive property-31 modifiers.
#[must_use]
pub fn passive_doses(passives: &[RankedPassive], target: &SpellDataFlat) -> i32 {
    f64_to_i32_saturating_round(fold_flat_pct_modifiers(
        passives,
        f64::from(target.proc_charges),
        ModifierFold::FlatAndPercent,
        |source, ranks, modifier| {
            if modifier_property_kind(modifier) != Some(ModifierPropertyKind::Doses)
                || !effect_targets_spell(modifier, source, target)
            {
                return None;
            }

            Some(modifier.base_points * ranks)
        },
    ))
}

/// Returns a periodic effect's interval after flat and percentage tick-time modifiers.
#[must_use]
pub fn passive_period_ms(query: PassiveQuery<'_>, initial: i32) -> i32 {
    let PassiveQuery {
        passives,
        spell: target,
    } = query;

    if initial <= 0 {
        return 0;
    }

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

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

pub use targeting::{
    passive_chain_multiplier, passive_chain_target_range, passive_chain_targets,
    passive_hostile_max_range, passive_max_targets, passive_radius,
};

/// Aura duration after selected passive flat/percent modifiers targeting `spell`.
#[must_use]
pub fn passive_duration_ms(query: PassiveQuery<'_>, base_duration_ms: i32) -> i32 {
    let PassiveQuery { passives, spell } = query;

    if spell.is_passive && base_duration_ms == 0 {
        return 0;
    }

    f64_to_i32_saturating_round(
        fold_flat_pct_modifiers(
            passives,
            f64::from(base_duration_ms),
            ModifierFold::FlatAndPercent,
            |source, ranks, modifier| {
                if modifier_property_kind(modifier) != Some(ModifierPropertyKind::Duration)
                    || !effect_targets_spell(modifier, source, spell)
                {
                    return None;
                }

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

pub use resource::{RankedPassive, passive_mana_regen_multiplier, passive_resource_cost};
pub use talent::{ResourcePassive, class_passive_spell_ids, talent_resource_passives};

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