wowlab_parsers/parsers/transform/

creature.rs

use wowlab_types::data::{
    ContentTuningFlat, ContentTuningXDifficultyFlat, ContentTuningXExpectedFlat,
    CreatureDifficultyFlat, CreatureFlat,
};

use crate::parsers::dbc::DbcData;

/// Flatten every `Creature` row in the DBC dataset into `CreatureFlat` records.
#[must_use]
pub fn transform_all_creatures(dbc: &DbcData) -> Vec<CreatureFlat> {
    dbc.creature
        .values()
        .map(|row| CreatureFlat {
            id: row.ID,
            name: row.Name_lang.clone().unwrap_or_default(),
            classification: row.Classification,
            creature_type: row.CreatureType,
            creature_family: row.CreatureFamily,
        })
        .collect()
}

/// Flatten every `CreatureDifficulty` row in the DBC dataset into `CreatureDifficultyFlat` records.
#[must_use]
pub fn transform_all_creature_difficulties(dbc: &DbcData) -> Vec<CreatureDifficultyFlat> {
    dbc.creature_difficulty
        .values()
        .flatten()
        .map(|row| CreatureDifficultyFlat {
            id: row.ID,
            creature_id: row.CreatureID,
            content_tuning_id: row.ContentTuningID,
            faction_template_id: row.FactionTemplateID,
            field_9_0_1_35522_003_min: row.Field_9_0_1_35522_003Min,
            field_9_0_1_35522_003_max: row.Field_9_0_1_35522_003Max,
            flags_0: row.Flags_0,
            flags_1: row.Flags_1,
            flags_2: row.Flags_2,
            flags_3: row.Flags_3,
            flags_4: row.Flags_4,
            flags_5: row.Flags_5,
            flags_6: row.Flags_6,
            flags_7: row.Flags_7,
            flags_8: row.Flags_8,
        })
        .collect()
}

/// Flatten every `ContentTuning` row in the DBC dataset into `ContentTuningFlat` records.
#[must_use]
pub fn transform_all_content_tunings(dbc: &DbcData) -> Vec<ContentTuningFlat> {
    dbc.content_tuning
        .values()
        .map(|row| ContentTuningFlat {
            id: row.ID,
            flags: row.Flags,
            expansion_id: row.ExpansionID,
            hp_scaling_curve_id: row.HPScalingCurveID,
            dmg_scaling_curve_id: row.DMGScalingCurveID,
            hp_primary_stat_scaling_curve_id: row.HPPrimaryStatScalingCurveID,
            dmg_primary_stat_scaling_curve_id: row.DMGPrimaryStatScalingCurveID,
            primary_stat_scaling_mod_player_data_element_character_id: row
                .PrimaryStatScalingModPlayerDataElementCharacterID,
            primary_stat_scaling_mod_player_data_element_character_multiplier: row
                .PrimaryStatScalingModPlayerDataElementCharacterMultiplier,
            min_level_squish: row.MinLevelSquish,
            max_level_squish: row.MaxLevelSquish,
            min_level_scaling_offset: row.MinLevelScalingOffset,
            max_level_scaling_offset: row.MaxLevelScalingOffset,
            allowed_min_offset: row.AllowedMinOffset,
            allowed_max_offset: row.AllowedMaxOffset,
            lfg_min_level: row.LfgMinLevel,
            lfg_max_level: row.LfgMaxLevel,
            ilevel: row.ILevel,
            xp_mult_quest: row.XpMultQuest,
        })
        .collect()
}

/// Flatten every `ContentTuningXDifficulty` row in the DBC dataset into `ContentTuningXDifficultyFlat` records.
#[must_use]
pub fn transform_all_content_tuning_x_difficulty(
    dbc: &DbcData,
) -> Vec<ContentTuningXDifficultyFlat> {
    dbc.content_tuning_x_difficulty
        .values()
        .flatten()
        .map(|row| ContentTuningXDifficultyFlat {
            id: row.ID,
            content_tuning_id: row.ContentTuningID,
            difficulty_id: row.DifficultyID,
        })
        .collect()
}

/// Flatten every `ContentTuningXExpected` row in the DBC dataset into `ContentTuningXExpectedFlat` records.
#[must_use]
pub fn transform_all_content_tuning_x_expected(dbc: &DbcData) -> Vec<ContentTuningXExpectedFlat> {
    dbc.content_tuning_x_expected
        .values()
        .flatten()
        .map(|row| ContentTuningXExpectedFlat {
            id: row.ID,
            content_tuning_id: row.ContentTuningID,
            expected_stat_mod_id: row.ExpectedStatModID,
            min_mythic_plus_season_id: row.MinMythicPlusSeasonID,
            max_mythic_plus_season_id: row.MaxMythicPlusSeasonID,
        })
        .collect()
}

#[cfg(test)]
mod creature_tests {
    use googletest::prelude::*;

    use super::*;
    use crate::parsers::{
        dbc::rows::{CreatureDifficultyRow, CreatureRow},
        transform::fixtures::dbc,
    };

    const fn creature_difficulty_row(
        id: i32,
        creature_id: i32,
        content_tuning_id: i32,
    ) -> CreatureDifficultyRow {
        CreatureDifficultyRow {
            ID: id,
            Field_9_0_1_35522_003Min: 0,
            Field_9_0_1_35522_003Max: 0,
            FactionTemplateID: 16,
            ContentTuningID: content_tuning_id,
            Flags_0: 268_959_756,
            Flags_1: 0,
            Flags_2: 0,
            Flags_3: 0,
            Flags_4: 16_777_216,
            Flags_5: 0,
            Flags_6: 0,
            Flags_7: 0,
            Flags_8: 0,
            CreatureID: creature_id,
        }
    }

    #[gtest]
    fn creatures_map_identity_and_classification() -> Result<()> {
        let mut dbc = dbc();

        dbc.creature.insert(
            220_586,
            CreatureRow {
                ID: 220_586,
                Name_lang: Some("Queen Ansurek".to_string()),
                Classification: 1,
                CreatureType: 7,
                CreatureFamily: 0,
            },
        );
        dbc.creature.insert(
            3,
            CreatureRow {
                ID: 3,
                Name_lang: None,
                Classification: 0,
                CreatureType: 6,
                CreatureFamily: 0,
            },
        );

        let result = transform_all_creatures(&dbc);

        verify_that!(result, len(eq(2)))?;
        verify_that!(
            result,
            contains(matches_pattern!(CreatureFlat {
                id: eq(&220_586),
                name: eq("Queen Ansurek"),
                classification: eq(&1),
                creature_type: eq(&7),
                creature_family: eq(&0),
            }))
        )?;

        verify_that!(
            result,
            contains(matches_pattern!(CreatureFlat {
                id: eq(&3),
                name: eq(""),
                ..
            }))
        )
    }

    #[gtest]
    fn creature_difficulties_flatten_grouped_rows() -> Result<()> {
        let mut dbc = dbc();

        dbc.creature_difficulty.insert(
            220_586,
            vec![creature_difficulty_row(270_199, 220_586, 719)],
        );
        dbc.creature_difficulty.insert(
            3,
            vec![
                creature_difficulty_row(2, 3, 13),
                creature_difficulty_row(4, 3, 14),
            ],
        );

        let result = transform_all_creature_difficulties(&dbc);

        verify_that!(result, len(eq(3)))?;

        verify_that!(
            result,
            contains(matches_pattern!(CreatureDifficultyFlat {
                id: eq(&270_199),
                creature_id: eq(&220_586),
                content_tuning_id: eq(&719),
                faction_template_id: eq(&16),
                flags_0: eq(&268_959_756),
                flags_4: eq(&16_777_216),
                ..
            }))
        )
    }
}

#[cfg(test)]
mod content_tuning_tests {
    use googletest::prelude::*;

    use super::*;
    use crate::parsers::{
        dbc::rows::{ContentTuningRow, ContentTuningXDifficultyRow, ContentTuningXExpectedRow},
        transform::fixtures::dbc,
    };

    #[gtest]
    fn content_tunings_map_all_scaling_fields() -> Result<()> {
        let mut dbc = dbc();

        dbc.content_tuning.insert(
            719,
            ContentTuningRow {
                ID: 719,
                Flags: 32,
                ExpansionID: 7,
                HPScalingCurveID: 0,
                DMGScalingCurveID: 0,
                HPPrimaryStatScalingCurveID: 0,
                DMGPrimaryStatScalingCurveID: 0,
                PrimaryStatScalingModPlayerDataElementCharacterID: 0,
                PrimaryStatScalingModPlayerDataElementCharacterMultiplier: 0.0,
                MinLevelSquish: 50,
                MaxLevelSquish: 50,
                MinLevelScalingOffset: 0,
                MaxLevelScalingOffset: 0,
                AllowedMinOffset: 0,
                AllowedMaxOffset: 0,
                LfgMinLevel: 0,
                LfgMaxLevel: 0,
                ILevel: 0,
                XpMultQuest: 1.0,
            },
        );

        let result = transform_all_content_tunings(&dbc);

        verify_that!(
            result,
            elements_are![matches_pattern!(ContentTuningFlat {
                id: eq(&719),
                flags: eq(&32),
                expansion_id: eq(&7),
                hp_scaling_curve_id: eq(&0),
                dmg_scaling_curve_id: eq(&0),
                min_level_squish: eq(&50),
                max_level_squish: eq(&50),
                ..
            })]
        )?;

        verify_that!(f64::from(result[0].xp_mult_quest), near(1.0, 1e-6))
    }

    #[gtest]
    fn content_tuning_x_difficulty_flattens_mapping() -> Result<()> {
        let mut dbc = dbc();

        dbc.content_tuning_x_difficulty.insert(
            719,
            vec![ContentTuningXDifficultyRow {
                ID: 4135,
                DifficultyID: 14,
                ContentTuningID: 719,
            }],
        );

        let result = transform_all_content_tuning_x_difficulty(&dbc);

        verify_that!(
            result,
            elements_are![matches_pattern!(ContentTuningXDifficultyFlat {
                id: eq(&4135),
                content_tuning_id: eq(&719),
                difficulty_id: eq(&14),
            })]
        )
    }

    #[gtest]
    fn content_tuning_x_expected_keeps_season_bounds() -> Result<()> {
        let mut dbc = dbc();

        dbc.content_tuning_x_expected.insert(
            1279,
            vec![
                ContentTuningXExpectedRow {
                    ID: 3032,
                    ExpectedStatModID: 391,
                    MinMythicPlusSeasonID: 117,
                    MaxMythicPlusSeasonID: 0,
                    ContentTuningID: 1279,
                },
                ContentTuningXExpectedRow {
                    ID: 449,
                    ExpectedStatModID: 14,
                    MinMythicPlusSeasonID: 0,
                    MaxMythicPlusSeasonID: 100,
                    ContentTuningID: 1279,
                },
            ],
        );

        let result = transform_all_content_tuning_x_expected(&dbc);

        verify_that!(result, len(eq(2)))?;
        verify_that!(
            result,
            contains(matches_pattern!(ContentTuningXExpectedFlat {
                id: eq(&3032),
                content_tuning_id: eq(&1279),
                expected_stat_mod_id: eq(&391),
                min_mythic_plus_season_id: eq(&117),
                max_mythic_plus_season_id: eq(&0),
            }))
        )?;

        verify_that!(
            result,
            contains(matches_pattern!(ContentTuningXExpectedFlat {
                id: eq(&449),
                min_mythic_plus_season_id: eq(&0),
                max_mythic_plus_season_id: eq(&100),
                ..
            }))
        )
    }
}