wowlab_engine_domain/dbc/passives/

timing.rs

use wowlab_engine_gamedata::SpellProps;
use wowlab_types::{data::SpellDataFlat, numeric::f64_to_i32_saturating_round};

use super::{
    AuraSubtypeKind, ModifierFold, ModifierPropertyKind, PassiveQuery, RankedPassive,
    SpellEffectSemanticExt, aura_kind, effect_targets_spell, fold_flat_pct_modifiers,
    masks_overlap, modified_effect_base_points, modifier_property_kind, pct_to_mult,
};

/// Maximum spell charges after category-based passive charge modifiers.
#[must_use]
pub fn passive_max_charges(query: PassiveQuery<'_>, initial: i32) -> i32 {
    let PassiveQuery { passives, spell } = query;
    let extra = passives
        .iter()
        .flat_map(|(source, ranks)| {
            source
                .effects
                .iter()
                .filter(|effect| {
                    effect.aura_is(AuraSubtypeKind::ModCooldownChargeCategory)
                        && spell.charge_category_id > 0
                        && effect.misc_value_0 == spell.charge_category_id
                })
                .map(move |effect| {
                    modified_effect_base_points(
                        PassiveQuery {
                            passives,
                            spell: source,
                        },
                        effect.index,
                        effect.base_points,
                    ) * ranks
                })
        })
        .sum::<f64>();

    f64_to_i32_saturating_round((f64::from(initial) + extra).max(0.0))
}

/// Returns the cooldown after passive modifiers targeting `spell`.
#[must_use]
pub fn passive_cooldown_ms(query: PassiveQuery<'_>, base_cooldown_ms: i32) -> i32 {
    let PassiveQuery { passives, spell } = query;

    f64_to_i32_saturating_round(
        fold_flat_pct_modifiers(
            passives,
            f64::from(base_cooldown_ms),
            ModifierFold::FlatAndPercent,
            |source, ranks, modifier| {
                if modifier_property_kind(modifier) != Some(ModifierPropertyKind::Cooldown)
                    || !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),
    )
}

/// Applies passive modifiers to every spell-owned cooldown clock.
pub fn apply_passive_cooldowns(query: PassiveQuery<'_>, props: &mut SpellProps) {
    let PassiveQuery { passives, spell } = query;

    props.cooldown_ms = passive_cooldown_ms(query, props.cooldown_ms);
    props.charge_cd_ms = passive_cooldown_ms(query, props.charge_cd_ms);
    props.category_cooldown_ms = passive_cooldown_ms(query, props.category_cooldown_ms);

    if spell.category_id > 0 {
        let category_delta = passives
            .iter()
            .flat_map(|(source, ranks)| {
                source.effects.iter().filter_map(move |effect| {
                    (effect.aura_is(AuraSubtypeKind::ModCooldownTimeCategory)
                        && effect.misc_value_0 == spell.category_id)
                        .then_some(effect.base_points * ranks)
                })
            })
            .sum::<f64>();

        props.category_cooldown_ms = f64_to_i32_saturating_round(
            (f64::from(props.category_cooldown_ms) + category_delta).max(0.0),
        );
    }

    let mut charge_cooldown = f64::from(props.charge_cd_ms);

    for (source, ranks) in passives {
        for modifier in &source.effects {
            if spell.charge_category_id == 0 || modifier.misc_value_0 != spell.charge_category_id {
                continue;
            }

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

            match aura_kind(modifier) {
                Some(AuraSubtypeKind::ModRechargeTimeCategory) => charge_cooldown += amount,
                Some(AuraSubtypeKind::ModRechargeTimePercentCategory) => {
                    charge_cooldown *= pct_to_mult(amount);
                }
                _ => {}
            }
        }
    }

    props.charge_cd_ms = f64_to_i32_saturating_round(charge_cooldown.max(0.0));
}

/// Whether a passive aura marks this spell's cooldown as haste-scaled.
#[must_use]
pub fn passive_hasted_cooldown(passives: &[RankedPassive], target: &SpellDataFlat) -> bool {
    passives.iter().any(|(aura, _)| {
        aura.is_passive
            && aura.effects.iter().any(|effect| match aura_kind(effect) {
                Some(AuraSubtypeKind::HastedCooldown) => {
                    aura.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(AuraSubtypeKind::HastedCooldownCategory) => {
                    target.charge_category_id != 0
                        && effect.misc_value_0 == target.charge_category_id
                }
                _ => false,
            })
    })
}

/// Whether the spell's global cooldown scales with the actor's haste.
#[must_use]
pub fn passive_hasted_gcd(passives: &[RankedPassive], target: &SpellDataFlat) -> bool {
    let is_ability = crate::dbc::spell_attribute_is_any(
        &target.attributes,
        &[
            crate::dbc::SpellAttributeKind::RangedAbility,
            crate::dbc::SpellAttributeKind::Ability,
        ],
    );

    !is_ability
        || passives.iter().any(|(aura, _)| {
            aura.is_passive
                && aura.effects.iter().any(|effect| match aura_kind(effect) {
                    Some(AuraSubtypeKind::HastedGlobalCooldown) => {
                        aura.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(AuraSubtypeKind::ApplyHastedGcdLabel) => target
                        .labels
                        .iter()
                        .any(|label| label.0 == effect.misc_value_0),
                    _ => false,
                })
        })
}

macro_rules! passive_timing_wrappers {
    ($($(#[$meta:meta])* $method:ident => $property:ident),+ $(,)?) => {
        $(
            $(#[$meta])*
            #[must_use]
            pub fn $method(query: PassiveQuery<'_>, initial: i32) -> i32 {
                super::passive_integral_value(
                    query,
                    initial,
                    ModifierPropertyKind::$property,
                )
            }
        )+
    };
}

passive_timing_wrappers! {
    /// Cast time after selected passive flat and percentage modifiers.
    passive_cast_time_ms => CastTime,
    /// Global cooldown after selected passive flat and percentage modifiers.
    passive_gcd_ms => GlobalCooldown,
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use wowlab_types::data::{SpellEffect, SpellLabel};

    use super::*;

    const CLASS_SET: i32 = 11;

    fn ability() -> SpellDataFlat {
        let mut attributes = vec![0; 1];

        attributes[crate::dbc::SpellAttributeKind::Ability.block()] |=
            crate::dbc::SpellAttributeKind::Ability.mask();

        SpellDataFlat {
            attributes,
            spell_class_set: CLASS_SET,
            spell_class_mask_1: 1,
            ..Default::default()
        }
    }

    fn passive(effect: SpellEffect) -> SpellDataFlat {
        SpellDataFlat {
            is_passive: true,
            spell_class_set: CLASS_SET,
            effects: vec![effect],
            ..Default::default()
        }
    }

    #[gtest]
    fn hasted_gcd_combines_ability_flags_with_mask_and_label_passives() -> Result<()> {
        let mut target = ability();

        verify_that!(passive_hasted_gcd(&[], &target), eq(false))?;

        let masked = SpellEffect {
            aura: AuraSubtypeKind::HastedGlobalCooldown as i32,
            effect_class_mask_1: 1,
            ..Default::default()
        };

        verify_that!(
            passive_hasted_gcd(&[(passive(masked), 1.0)], &target),
            eq(true)
        )?;

        let label = 640;

        target.labels = vec![SpellLabel(label)];
        let labeled = SpellEffect {
            aura: AuraSubtypeKind::ApplyHastedGcdLabel as i32,
            misc_value_0: label,
            ..Default::default()
        };

        verify_that!(
            passive_hasted_gcd(&[(passive(labeled), 1.0)], &target),
            eq(true)
        )?;

        verify_that!(passive_hasted_gcd(&[], &SpellDataFlat::default()), eq(true))
    }
}