wowlab_engine_application/audit/

data_values.rs

//! Data-value checks: compare manifest literals (scalars, resource values) against resolved game data.

mod periodic;
mod resources;
mod scalar;

#[cfg(test)]
use periodic::{AuraScalarCheck, check_redundant_aura_scalar};
use periodic::{
    PeriodicCoefficientCheck, check_periodic_aura_values, check_redundant_damage_mult,
    check_redundant_periodic_coefficient,
};
use resources::{check_resource_values, check_secondary_resource_values};
#[cfg(test)]
use scalar::resolved_scalar_value;
use scalar::{check_redundant_resolved_override, check_scalar_literal, warn_if_redundant};
use wowlab_engine_domain::dbc::{PowerModifiers, cast_time_ms, primary_cost};
use wowlab_engine_ports::{DataResolver, DynDataResolver, SpellId};
use wowlab_manifest_schema::{ManifestAuraDef, ScalarField, ScalarRef};
#[cfg(test)]
use wowlab_manifest_schema::{ResourceSection, SecondaryResourceSection};
#[cfg(test)]
use wowlab_types::data::SpellEffect;
use wowlab_types::{constants::MS_PER_SECOND, sim::FastSet};

use super::{AuditCtx, AuditSink};

/// Tolerance for comparing manifest literals against game data (f32 DBC vs f64 literal).
pub(super) const DATA_EPS: f64 = 1e-6;

struct CoreScalarCheck<'a> {
    entity: &'static str,
    name: &'a str,
    owner_id: u32,
    field: &'a str,
    value: Option<&'a ScalarRef>,
    resolved: f64,
}

// #t(fn: rust_max_fn_lines) the audit intentionally traverses aura and spell scalar families in one pass
pub(super) async fn check_data_values(ctx: &mut AuditCtx<'_>) {
    let manifest = ctx.manifest;
    let resolver = ctx.resolver;
    let sink = &mut *ctx.sink;

    for (name, aura) in &manifest.auras {
        if aura.id == 0 {
            continue;
        }

        check_scalar_literal(
            resolver,
            name,
            aura.id,
            "haste_per_stack",
            aura.haste_per_stack.as_ref(),
            sink,
        )
        .await;
        check_scalar_literal(
            resolver,
            name,
            aura.id,
            "crit_per_stack",
            aura.crit_per_stack.as_ref(),
            sink,
        )
        .await;
        check_redundant_damage_mult(resolver, name, aura.id, aura.damage_mult.as_ref(), sink).await;
        check_core_aura_overrides(resolver, name, aura, sink).await;

        if let Some(periodic) = &aura.periodic_damage {
            let source_id = periodic.spell_id.unwrap_or(aura.id);

            check_redundant_periodic_coefficient(
                resolver,
                PeriodicCoefficientCheck {
                    name,
                    spell_id: source_id,
                    field_name: "ap_coef",
                    value: periodic.ap_coef.as_ref(),
                    field: ScalarField::ApCoef,
                },
                sink,
            )
            .await;
            check_redundant_periodic_coefficient(
                resolver,
                PeriodicCoefficientCheck {
                    name,
                    spell_id: source_id,
                    field_name: "sp_coef",
                    value: periodic.sp_coef.as_ref(),
                    field: ScalarField::SpCoef,
                },
                sink,
            )
            .await;
        }

        check_periodic_aura_values(resolver, name, aura, sink).await;
    }

    let power_types = resolver.get_power_types().await.unwrap_or_default();

    check_resource_values(&manifest.resource, &power_types, sink);

    if let Some(sr) = &manifest.secondary_resource {
        check_secondary_resource_values(sr, &power_types, sink);
    }

    let modifiers = PowerModifiers::from_pairs(
        power_types
            .iter()
            .map(|power| (power.power_type_enum, f64::from(power.display_modifier))),
    );

    for (name, spell) in &manifest.spells {
        if spell.id == 0 {
            continue;
        }

        let Ok(data) = resolver
            .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
                spell.id,
            )))
            .await
        else {
            continue;
        };

        check_core_scalar(
            resolver,
            CoreScalarCheck {
                entity: "spell",
                name,
                owner_id: spell.id,
                field: "cost",
                value: spell.cost.as_ref(),
                resolved: primary_cost(
                    &data,
                    i32::from(manifest.resource.type_id),
                    &modifiers,
                    &FastSet::default(),
                )
                .0,
            },
            sink,
        )
        .await;
        check_core_scalar(
            resolver,
            CoreScalarCheck {
                entity: "spell",
                name,
                owner_id: spell.id,
                field: "cooldown",
                value: spell.cooldown.as_ref(),
                resolved: f64::from(data.recovery_time.max(0)) / MS_PER_SECOND,
            },
            sink,
        )
        .await;
        check_core_scalar(
            resolver,
            CoreScalarCheck {
                entity: "spell",
                name,
                owner_id: spell.id,
                field: "cast_time_ms",
                value: spell.cast_time_ms.as_ref(),
                resolved: f64::from(cast_time_ms(&data)),
            },
            sink,
        )
        .await;
        check_core_scalar(
            resolver,
            CoreScalarCheck {
                entity: "spell",
                name,
                owner_id: spell.id,
                field: "charges",
                value: spell.charges.as_ref(),
                resolved: f64::from(data.max_charges),
            },
            sink,
        )
        .await;
        check_core_scalar(
            resolver,
            CoreScalarCheck {
                entity: "spell",
                name,
                owner_id: spell.id,
                field: "charge_cd",
                value: spell.charge_cd.as_ref(),
                resolved: f64::from(data.charge_recovery_time) / MS_PER_SECOND,
            },
            sink,
        )
        .await;
    }
}

async fn check_core_aura_overrides(
    resolver: &DynDataResolver<'_>,
    name: &str,
    aura: &ManifestAuraDef,
    sink: &mut AuditSink,
) {
    let Ok(data) = resolver
        .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
            aura.id,
        )))
        .await
    else {
        return;
    };
    let duration = if data.duration < 0 {
        0.0
    } else {
        f64::from(data.duration)
    };

    check_core_scalar(
        resolver,
        CoreScalarCheck {
            entity: "aura",
            name,
            owner_id: aura.id,
            field: "duration_ms",
            value: aura.duration_ms.as_ref(),
            resolved: duration,
        },
        sink,
    )
    .await;
    check_core_scalar(
        resolver,
        CoreScalarCheck {
            entity: "aura",
            name,
            owner_id: aura.id,
            field: "max_stacks",
            value: aura.max_stacks.as_ref(),
            resolved: f64::from(data.max_stacks),
        },
        sink,
    )
    .await;
}

async fn check_core_scalar(
    resolver: &DynDataResolver<'_>,
    check: CoreScalarCheck<'_>,
    sink: &mut AuditSink,
) {
    let label = format!("{} {} {}", check.entity, check.name, check.field);

    match check.value {
        Some(ScalarRef::Literal(literal)) => {
            warn_if_redundant(*literal, check.resolved, &label, sink);
        }
        Some(value) => {
            check_redundant_resolved_override(
                resolver,
                value,
                check.owner_id,
                check.resolved,
                &label,
                sink,
            )
            .await;
        }
        None => {}
    }
}

#[cfg(test)]
#[path = "data_values/scalar_tests/tests.rs"]
mod scalar_tests;
#[cfg(test)]
mod tests;
#[cfg(test)]
#[path = "data_values/transform_tests/tests.rs"]
mod transform_tests;