wowlab_engine_domain/dbc/

decode.rs

//! Per-spell DBC decode arithmetic: power-cost scaling and energize-gain matching.

use std::{collections::HashSet, hash::BuildHasher};

use wowlab_types::{
    data::{PowerCostEntry, ResourceCostPercent, SpellDataFlat},
    sim::FastMap,
};

use super::{PowerType, SpellEffectKind, SpellEffectSemanticExt};

/// Power-type sentinel for a costless spell, paired with a `0.0` amount (no real `power_type_enum` is negative).
pub(super) const NO_POWER_COST_TYPE: i32 = -1;
/// `power_type_enum -> display_modifier` divisors used to descale DBC power amounts.
#[derive(Clone, Debug, Default)]
pub struct PowerModifiers {
    by_type: FastMap<i32, f64>,
}

impl PowerModifiers {
    /// Creates an empty modifier table.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Build from the resolved `power_type_enum -> display_modifier` pairs (only positive modifiers).
    pub fn from_pairs(pairs: impl IntoIterator<Item = (i32, f64)>) -> Self {
        Self {
            by_type: pairs.into_iter().filter(|(_, m)| *m > 0.0).collect(),
        }
    }

    fn divisor(&self, power_type: i32) -> f64 {
        self.by_type.get(&power_type).copied().unwrap_or(1.0)
    }
}

/// Descale a raw DBC power amount by its `display_modifier` (or leave it as-is when absent).
#[must_use]
pub fn scale_power_amount(raw: f64, power_type: i32, modifiers: &PowerModifiers) -> f64 {
    raw / modifiers.divisor(power_type)
}

pub(super) fn power_cost_is_available<S>(
    cost: &PowerCostEntry,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> bool
where
    S: BuildHasher,
{
    cost.required_aura_spell_id == 0 || active_aura_spell_ids.contains(&cost.required_aura_spell_id)
}

fn power_cost_row<'a, S>(
    spell: &'a SpellDataFlat,
    resource_type: i32,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> Option<&'a PowerCostEntry>
where
    S: BuildHasher,
{
    spell.power_costs.iter().find(|cost| {
        cost.power_type == resource_type && power_cost_is_available(cost, active_aura_spell_ids)
    })
}

/// Primary power cost (descaled) and its power type, matched by resource type; -1 when absent.
#[must_use]
pub fn primary_cost<S>(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    modifiers: &PowerModifiers,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> (f64, i32)
where
    S: BuildHasher,
{
    power_cost_row(spell, primary_resource_type, active_aura_spell_ids).map_or(
        (0.0, NO_POWER_COST_TYPE),
        |p| {
            (
                scale_power_amount(f64::from(p.cost), p.power_type, modifiers),
                p.power_type,
            )
        },
    )
}

#[must_use]
pub fn primary_cost_pct<S>(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> ResourceCostPercent
where
    S: BuildHasher,
{
    ResourceCostPercent::base(
        power_cost_row(spell, primary_resource_type, active_aura_spell_ids)
            .map_or(0.0, |p| p.cost_pct),
    )
}

#[must_use]
pub fn primary_max_cost_pct<S>(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> ResourceCostPercent
where
    S: BuildHasher,
{
    ResourceCostPercent::maximum(
        power_cost_row(spell, primary_resource_type, active_aura_spell_ids)
            .map_or(0.0, |p| p.max_cost_pct),
    )
}

#[must_use]
pub fn primary_optional_cost_pct<S>(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> ResourceCostPercent
where
    S: BuildHasher,
{
    ResourceCostPercent::base(
        power_cost_row(spell, primary_resource_type, active_aura_spell_ids)
            .map_or(0.0, |p| p.optional_cost_pct),
    )
}

#[must_use]
pub fn primary_optional_cost<S>(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    modifiers: &PowerModifiers,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> f64
where
    S: BuildHasher,
{
    power_cost_row(spell, primary_resource_type, active_aura_spell_ids).map_or(0.0, |p| {
        scale_power_amount(f64::from(p.optional_cost), p.power_type, modifiers)
    })
}

/// Health costs decoded from the active health-power row.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HealthCosts {
    pub cost: f64,
    pub cost_pct: f64,
    pub max_cost_pct: f64,
    pub optional_cost: f64,
    pub optional_cost_pct: ResourceCostPercent,
}

impl Default for HealthCosts {
    fn default() -> Self {
        Self {
            cost: 0.0,
            cost_pct: 0.0,
            max_cost_pct: 0.0,
            optional_cost: 0.0,
            optional_cost_pct: ResourceCostPercent::maximum(0.0),
        }
    }
}

/// Flat, percentage, and optional health costs from the active health-power row.
#[must_use]
pub fn health_cost<S>(spell: &SpellDataFlat, active_aura_spell_ids: &HashSet<i32, S>) -> HealthCosts
where
    S: BuildHasher,
{
    power_cost_row(spell, PowerType::Health as i32, active_aura_spell_ids).map_or_else(
        HealthCosts::default,
        |cost| HealthCosts {
            cost: f64::from(cost.cost).max(0.0),
            cost_pct: cost.cost_pct.max(0.0),
            max_cost_pct: cost.max_cost_pct.max(0.0),
            optional_cost: f64::from(cost.optional_cost).max(0.0),
            optional_cost_pct: ResourceCostPercent::maximum(cost.optional_cost_pct.max(0.0)),
        },
    )
}

/// Optional primary-resource spend encoded as a Power Burn spell effect.
#[must_use]
pub fn primary_power_burn_cost(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    modifiers: &PowerModifiers,
) -> f64 {
    spell
        .effects
        .iter()
        .find(|effect| {
            effect.effect_is(SpellEffectKind::PowerBurn)
                && effect.misc_value_0 == primary_resource_type
        })
        .map_or(0.0, |effect| {
            scale_power_amount(effect.base_points, effect.misc_value_0, modifiers).max(0.0)
        })
}

/// Minimum secondary power cost from the row matching the spec's secondary resource type.
#[must_use]
pub fn secondary_cost<S>(
    spell: &SpellDataFlat,
    secondary_resource_type: Option<i32>,
    modifiers: &PowerModifiers,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> f64
where
    S: BuildHasher,
{
    secondary_resource_type
        .and_then(|st| {
            power_cost_row(spell, st, active_aura_spell_ids)
                .map(|p| scale_power_amount(f64::from(p.cost), p.power_type, modifiers))
        })
        .unwrap_or(0.0)
}

/// 1-based DBC power-cost entry index for the resource type's cost; 0 when absent.
#[must_use]
pub fn cost_entry_index<S>(
    spell: &SpellDataFlat,
    resource_type: Option<i32>,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> u8
where
    S: BuildHasher,
{
    let Some(resource_type) = resource_type else {
        return 0;
    };

    spell
        .power_costs
        .iter()
        .position(|cost| {
            cost.power_type == resource_type && power_cost_is_available(cost, active_aura_spell_ids)
        })
        .and_then(|index| u8::try_from(index + 1).ok())
        .unwrap_or(0)
}

/// Optional secondary power cost above the minimum (for variable-point finishers).
#[must_use]
pub fn secondary_optional_cost<S>(
    spell: &SpellDataFlat,
    secondary_resource_type: Option<i32>,
    modifiers: &PowerModifiers,
    active_aura_spell_ids: &HashSet<i32, S>,
) -> f64
where
    S: BuildHasher,
{
    secondary_resource_type
        .and_then(|st| {
            power_cost_row(spell, st, active_aura_spell_ids)
                .map(|p| scale_power_amount(f64::from(p.optional_cost), p.power_type, modifiers))
        })
        .unwrap_or(0.0)
}

/// Resource gain from the first ENERGIZE effect granting the primary resource type, descaled.
#[must_use]
pub fn primary_resource_gain(
    spell: &SpellDataFlat,
    primary_resource_type: i32,
    modifiers: &PowerModifiers,
) -> f64 {
    spell
        .effects
        .iter()
        .find(|e| e.effect_is(SpellEffectKind::Energize) && e.misc_value_0 == primary_resource_type)
        .map_or(0.0, |e| {
            scale_power_amount(e.base_points, e.misc_value_0, modifiers)
        })
}

/// Resource gain from the first ENERGIZE effect granting the secondary resource type, descaled.
#[must_use]
pub fn secondary_resource_gain(
    spell: &SpellDataFlat,
    secondary_resource_type: Option<i32>,
    modifiers: &PowerModifiers,
) -> f64 {
    secondary_resource_type
        .and_then(|st| {
            spell
                .effects
                .iter()
                .find(|e| e.effect_is(SpellEffectKind::Energize) && e.misc_value_0 == st)
                .map(|e| scale_power_amount(e.base_points, e.misc_value_0, modifiers))
        })
        .unwrap_or(0.0)
}

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

    use super::{
        NO_POWER_COST_TYPE, PowerModifiers, primary_cost, primary_power_burn_cost,
        scale_power_amount, secondary_cost, secondary_optional_cost,
    };

    #[gtest]
    fn power_cost_divided_by_display_modifier() {
        let modifiers = PowerModifiers::from_pairs([(8_i32, 10.0_f64), (13_i32, 100.0_f64)]);

        expect_that!(scale_power_amount(400.0, 8, &modifiers), eq(40.0));
        expect_that!(scale_power_amount(5000.0, 13, &modifiers), eq(50.0));
    }

    #[gtest]
    fn required_aura_filters_other_specializations_power_rows() {
        let spell = SpellDataFlat {
            power_costs: vec![
                PowerCostEntry {
                    power_type: 12,
                    cost: 2,
                    cost_pct: 0.0,
                    max_cost_pct: 0.0,
                    optional_cost: 0,
                    optional_cost_pct: 0.0,
                    required_aura_spell_id: 137_025,
                },
                PowerCostEntry {
                    power_type: 3,
                    cost: 40,
                    cost_pct: 0.0,
                    max_cost_pct: 0.0,
                    optional_cost: 0,
                    optional_cost_pct: 0.0,
                    required_aura_spell_id: 137_023,
                },
            ],
            ..Default::default()
        };
        let active = FastSet::from_iter([137_025]);
        let modifiers = PowerModifiers::default();

        expect_that!(primary_cost(&spell, 3, &modifiers, &active).0, eq(0.0));
        expect_that!(
            secondary_cost(&spell, Some(12), &modifiers, &active),
            eq(2.0)
        );
    }

    #[gtest]
    fn secondary_cost_keeps_optional_spend_separate() {
        let spell = SpellDataFlat {
            power_costs: vec![PowerCostEntry {
                power_type: 4,
                cost: 1,
                cost_pct: 0.0,
                max_cost_pct: 0.0,
                optional_cost: 4,
                optional_cost_pct: 0.0,
                required_aura_spell_id: 0,
            }],
            ..Default::default()
        };
        let active = FastSet::default();
        let modifiers = PowerModifiers::default();

        expect_that!(
            secondary_cost(&spell, Some(4), &modifiers, &active),
            eq(1.0)
        );
        expect_that!(
            secondary_optional_cost(&spell, Some(4), &modifiers, &active),
            eq(4.0)
        );
    }

    #[gtest]
    fn power_burn_is_optional_primary_resource_spend() {
        let spell = SpellDataFlat {
            effects: vec![SpellEffect {
                effect: 62,
                base_points: 25.0,
                misc_value_0: 3,
                ..Default::default()
            }],
            ..Default::default()
        };
        let modifiers = PowerModifiers::default();

        expect_that!(primary_power_burn_cost(&spell, 3, &modifiers), eq(25.0));
        expect_that!(primary_power_burn_cost(&spell, 0, &modifiers), eq(0.0));
    }

    #[gtest]
    fn power_amount_unscaled_when_modifier_absent() {
        let modifiers = PowerModifiers::from_pairs([(8_i32, 10.0_f64)]);

        expect_that!(scale_power_amount(40.0, 3, &modifiers), eq(40.0));
        expect_that!(
            scale_power_amount(0.0, NO_POWER_COST_TYPE, &modifiers),
            eq(0.0)
        );
    }

    #[gtest]
    fn primary_gain_data_scaled_for_match_literal_preserved_for_absent() {
        use wowlab_engine_gamedata::SpellProps;
        use wowlab_types::{data::PowerTypeFlat, sim::SpellIdx};

        let power_types = [PowerTypeFlat {
            power_type_enum: 8,
            display_modifier: 10.0,
            ..Default::default()
        }];
        let modifiers = PowerModifiers::from_pairs(
            power_types
                .iter()
                .map(|p| (p.power_type_enum, f64::from(p.display_modifier))),
        );

        let starfire_gain = scale_power_amount(80.0, 8, &modifiers);

        expect_that!(starfire_gain, eq(8.0));

        let mut builder = wowlab_engine_gamedata::ResolvedGameData::builder();

        builder.insert_spell_props(
            SpellIdx::from_raw(194_153),
            SpellProps {
                gain: starfire_gain,
                ..Default::default()
            },
        );
        builder.insert_spell_props(
            SpellIdx::from_raw(190_984),
            SpellProps {
                gain: 8.0,
                ..Default::default()
            },
        );
        let data = builder.build();

        expect_that!(data.gain(SpellIdx::from_raw(194_153)), eq(Some(8.0)));
        expect_that!(data.gain(SpellIdx::from_raw(190_984)), eq(Some(8.0)));
    }
}