overlord_event_system/behaviors/

validate.rs

//! Deploy-time validation of every script-ref field in the game config.
//!
//! A config field referencing a native fn is a plain string; a typo'd name
//! makes the runtime lookup return `None` mid-gameplay (silently skipped slot
//! or failed event). [`validate_game_config_refs`] walks every ref-bearing
//! field and checks the name resolves to a callable registered for that exact
//! slot, so the admin deploy step / config validator fails loudly instead.

use configs::game_config::GameConfig;
use uuid::Uuid;

use crate::behaviors::{BehaviorKind, BehaviorRegistry, quests};

/// Validate every script-ref field in `config` against `registry`.
///
/// Returns all failures, one message per bad ref, each naming the config slot
/// (entity id + field) and listing the registered names for the category.
pub fn validate_game_config_refs(
    config: &GameConfig,
    registry: &BehaviorRegistry,
) -> Result<(), Vec<String>> {
    let mut checker = RefChecker {
        registry,
        errors: Vec::new(),
    };

    for effect in &config.effects {
        if let Some(name) = effect.behavior.as_deref() {
            checker.check(
                format!("effects[{}].script", effect.id),
                BehaviorKind::Event,
                name,
                registry.event_fn(name).is_some(),
            );
        }
    }

    for quest in &config.quests {
        if let Some(name) = quest.progress_behavior.as_deref() {
            checker.check(
                format!("quests[{}].progress_behavior", quest.id),
                BehaviorKind::ConditionalProgress,
                name,
                registry.conditional_progress_fn(name).is_some(),
            );
            checker.check_required_content(
                config,
                format!("quests[{}].progress_behavior", quest.id),
                name,
            );
        }
        if let Some(name) = quest.additional_quests_behavior.as_deref() {
            checker.check(
                format!("quests[{}].additional_quests_behavior", quest.id),
                BehaviorKind::AdditionalQuests,
                name,
                registry.additional_quests_fn(name).is_some(),
            );
            checker.check_required_content(
                config,
                format!("quests[{}].additional_quests_behavior", quest.id),
                name,
            );
        }
    }

    for bundle in &config.bundles {
        for (i, step) in bundle.steps.iter().enumerate() {
            if let Some(name) = step.behavior.as_deref() {
                checker.check(
                    format!("bundles[{}].steps[{i}].script", bundle.id),
                    BehaviorKind::Currencies,
                    name,
                    registry.currencies_fn(name).is_some(),
                );
            }
        }
    }

    for ability in &config.abilities {
        if let Some(name) = ability.start_behavior.as_deref() {
            checker.check(
                format!("abilities[{}].start_behavior", ability.id),
                BehaviorKind::StartCastAbility,
                name,
                registry.start_cast_ability_fn(name).is_some(),
            );
        }
        if let Some(name) = ability.behavior.as_deref() {
            checker.check(
                format!("abilities[{}].script", ability.id),
                BehaviorKind::CastAbility,
                name,
                registry.cast_ability_fn(name).is_some(),
            );
        }
    }

    for projectile in &config.projectiles {
        if let Some(name) = projectile.start_behavior.as_deref() {
            checker.check(
                format!("projectiles[{}].start_behavior", projectile.id),
                BehaviorKind::StartCastProjectile,
                name,
                registry.start_cast_projectile_fn(name).is_some(),
            );
        }
        if let Some(name) = projectile.behavior.as_deref() {
            checker.check(
                format!("projectiles[{}].script", projectile.id),
                BehaviorKind::CastProjectile,
                name,
                registry.cast_projectile_fn(name).is_some(),
            );
        }
    }

    for fight_template in &config.fight_templates {
        if let Some(name) = fight_template.start_behavior.as_deref() {
            checker.check(
                format!("fight_templates[{}].start_behavior", fight_template.id),
                BehaviorKind::FightStart,
                name,
                registry.fight_start_fn(name).is_some(),
            );
        }
    }

    for attribute in &config.attributes {
        if let Some(name) = attribute.calculation_behavior.as_deref() {
            checker.check(
                format!("attributes[{}].calculation_behavior", attribute.id),
                BehaviorKind::ItemAttribute,
                name,
                registry.item_attribute_fn(name).is_some(),
            );
        }
    }

    checker.check(
        "game_settings.default_loop_task_behavior".to_string(),
        BehaviorKind::DefaultLoopTask,
        &config.game_settings.default_loop_task_behavior,
        registry
            .default_loop_task_fn(&config.game_settings.default_loop_task_behavior)
            .is_some(),
    );

    let vassals = &config.vassals_settings;
    checker.check(
        "vassals_settings.suzerain_reward_fn".to_string(),
        BehaviorKind::VassalReward,
        &vassals.suzerain_reward_fn,
        registry
            .vassal_reward_fn(&vassals.suzerain_reward_fn)
            .is_some(),
    );
    checker.check(
        "vassals_settings.vassal_reward_fn".to_string(),
        BehaviorKind::VassalReward,
        &vassals.vassal_reward_fn,
        registry
            .vassal_reward_fn(&vassals.vassal_reward_fn)
            .is_some(),
    );

    for task in &config.vassal_tasks {
        checker.check(
            format!("vassal_tasks[{}].reward_fn", task.id),
            BehaviorKind::VassalReward,
            &task.reward_fn,
            registry.vassal_reward_fn(&task.reward_fn).is_some(),
        );
        checker.check(
            format!("vassal_tasks[{}].loyalty_fn", task.id),
            BehaviorKind::VassalLoyalty,
            &task.loyalty_fn,
            registry.vassal_loyalty_fn(&task.loyalty_fn).is_some(),
        );
    }

    if checker.errors.is_empty() {
        Ok(())
    } else {
        Err(checker.errors)
    }
}

/// What kind of config content a behavior's baked-in uuid must resolve to.
#[derive(Clone, Copy)]
enum ContentKind {
    Dungeon,
    Currency,
    ItemRarity,
    Quest,
}

/// Behaviors that carry a content uuid as a const parameter: when a quest
/// references one of these names, the named content must exist in the same
/// config, otherwise the behavior silently never matches (or errors) at
/// runtime.
const REQUIRED_CONTENT: &[(&str, ContentKind, u128)] = &[
    (
        "raid_dungeon_1",
        ContentKind::Dungeon,
        quests::progress::DUNGEON_1,
    ),
    (
        "raid_dungeon_2",
        ContentKind::Dungeon,
        quests::progress::DUNGEON_2,
    ),
    (
        "raid_dungeon_3",
        ContentKind::Dungeon,
        quests::progress::DUNGEON_3,
    ),
    (
        "loop_task_raid_dungeon_1",
        ContentKind::Dungeon,
        quests::progress::DUNGEON_1,
    ),
    (
        "loop_task_raid_dungeon_2",
        ContentKind::Dungeon,
        quests::progress::DUNGEON_2,
    ),
    (
        "loop_task_raid_dungeon_3",
        ContentKind::Dungeon,
        quests::progress::DUNGEON_3,
    ),
    (
        "loop_task_collect_currency",
        ContentKind::Currency,
        quests::progress::COLLECT_CURRENCY,
    ),
    (
        "count_equipped_rarity_a",
        ContentKind::ItemRarity,
        quests::progress::RARITY_A,
    ),
    (
        "count_equipped_rarity_b",
        ContentKind::ItemRarity,
        quests::progress::RARITY_B,
    ),
    (
        "count_equipped_rarity_c",
        ContentKind::ItemRarity,
        quests::progress::RARITY_C,
    ),
    (
        "log_in_today",
        ContentKind::Quest,
        quests::progress::LOG_IN_QUEST,
    ),
    (
        "aq_redirect_to_kill_3_enemies",
        ContentKind::Quest,
        quests::loop_tasks::REDIRECT_KILL_3_ENEMIES,
    ),
    (
        "aq_redirect_to_open_chest_6",
        ContentKind::Quest,
        quests::loop_tasks::REDIRECT_OPEN_CHEST_6,
    ),
    (
        "aq_redirect_to_sell_5_gear",
        ContentKind::Quest,
        quests::loop_tasks::REDIRECT_SELL_5_GEAR,
    ),
    (
        "aq_redirect_to_reach_level_3",
        ContentKind::Quest,
        quests::loop_tasks::REDIRECT_REACH_LEVEL_3,
    ),
];

struct RefChecker<'a> {
    registry: &'a BehaviorRegistry,
    errors: Vec<String>,
}

impl RefChecker<'_> {
    /// Record an error for `slot` unless the name resolved to a callable.
    ///
    /// `callable` is the result of the exact typed lookup the runtime performs
    /// for this slot — some categories hold more than one callable map (e.g.
    /// `item_ids` has chest and bundle scopes), so category membership alone
    /// is not enough.
    fn check(&mut self, slot: String, category: BehaviorKind, name: &str, callable: bool) {
        if callable {
            return;
        }
        let detail = match self.registry.validate_ref(category, name) {
            Err(e) => e,
            Ok(()) => format!(
                "script_ref names `{name}`, which is registered under category `{}` \
                 but not callable for this slot's input scope",
                category.as_str()
            ),
        };
        self.errors.push(format!("{slot}: {detail}"));
    }

    /// If `name` is a behavior with a baked-in content uuid, assert that
    /// content exists in `config`.
    fn check_required_content(&mut self, config: &GameConfig, slot: String, name: &str) {
        for (behavior, kind, raw_id) in REQUIRED_CONTENT {
            if *behavior != name {
                continue;
            }
            let id = Uuid::from_u128(*raw_id);
            let (exists, kind_name) = match kind {
                ContentKind::Dungeon => (
                    config.dungeon_templates.iter().any(|d| d.id == id),
                    "dungeon",
                ),
                ContentKind::Currency => (config.currencies.iter().any(|c| c.id == id), "currency"),
                ContentKind::ItemRarity => (
                    config.item_rarities.iter().any(|r| r.id == id),
                    "item rarity",
                ),
                ContentKind::Quest => (config.quests.iter().any(|q| q.id == id), "quest"),
            };
            if !exists {
                self.errors.push(format!(
                    "{slot}: behavior `{name}` requires {kind_name} `{id}` which is not in \
                     the config"
                ));
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::behaviors::build_registry;

    #[test]
    fn test_fixture_config_passes_validation() {
        let config = configs::tests_game_config::generate_game_config_for_tests();
        let registry = build_registry();
        let result = validate_game_config_refs(&config, &registry);
        assert!(
            result.is_ok(),
            "test fixture config has invalid script refs:\n{}",
            result.unwrap_err().join("\n")
        );
    }

    #[test]
    fn typoed_quest_progress_ref_is_reported_with_slot_and_names() {
        let mut config = configs::tests_game_config::generate_game_config_for_tests();
        let quest = config.quests.first_mut().expect("fixture has quests");
        quest.progress_behavior = Some("definitely_not_registered".to_string());
        let quest_id = quest.id;

        let errors = validate_game_config_refs(&config, &build_registry()).unwrap_err();
        let err = errors
            .iter()
            .find(|e| e.contains(&quest_id.to_string()))
            .expect("error names the quest");
        assert!(err.contains("progress_behavior"), "{err}");
        assert!(err.contains("conditional_progress"), "{err}");
    }

    #[test]
    fn wrong_category_name_is_rejected() {
        // `vassal_task_loyalty_const` is registered under `vassal_loyalty`,
        // not `item_attribute` — referencing it from an attribute slot must
        // fail with the category's available names listed.
        let mut config = configs::tests_game_config::generate_game_config_for_tests();
        let attribute = config
            .attributes
            .first_mut()
            .expect("fixture has attributes");
        attribute.calculation_behavior = Some("vassal_task_loyalty_const".to_string());

        let errors = validate_game_config_refs(&config, &build_registry()).unwrap_err();
        assert!(
            errors.iter().any(|e| e.contains("calculation_behavior")
                && e.contains("vassal_task_loyalty_const")
                && e.contains("item_attribute")),
            "expected a wrong-category error, got: {errors:?}"
        );
    }
}