overlord_event_system/mechanics/

content_raw_extract.rs

//! Builds [`ContentLookups`] from the typed [`GameConfig`].
//!
//! engine, because `content_raw` carried fields that aren't on the Rust schemas
//! (`q`, `eff`, `fixed_power`, `next_mimic_item_code`, `is_boss`, `is_dungeon`,
//! `is_bossfight`, attribute `base_value`, effect `max_duration_ticks`, ability
//! engine is gone (RHAI_REMOVAL_MIGRATION §9a), so we now source everything we
//! can from the typed config.
//!
//! All former `content_raw`-only fields have since been promoted onto the
//! typed schemas, so every [`ContentLookups`] field is sourced here from the
//! typed [`GameConfig`]; nothing is left to the empty-default fallback.

use std::collections::HashMap;
use std::sync::Arc;

use configs::game_config::GameConfig;

use super::content_lookups::{ContentLookups, EffectTpl};

/// Build [`ContentLookups`] from the typed [`GameConfig`].
///
/// typed schemas (see module docs).
pub fn extract(game_config: &GameConfig) -> ContentLookups {
    // RHAI_REMOVAL_MIGRATION §9a: all of the former `content_raw`-only fields
    // have now been added to the typed config and are sourced here — `q`, `eff`,
    // `fixed_power`, `next_mimic_item_code`, `is_boss`, `is_dungeon`,
    // `is_bossfight`, attribute `base_value`, ability `range`/`target_type`, and
    // effect duration. These are NOT optional niceties: an empty lookup silently
    // breaks combat (e.g. empty `attribute_base_value` zeroes `received_damage`
    // → every hit cancelled; empty `ability_target_type` → no valid targets →
    // entities run through the enemy line) and an empty `item_id_by_mimic_code`
    // degrades quest-directed mimic item grants to the generic per-slot fallback.
    ContentLookups {
        effects_by_code: extract_effects(game_config),
        attribute_by_code: extract_attribute_by_code(game_config),
        attribute_base_value: extract_attribute_base_value(game_config),
        quest_by_code: extract_quest_by_code(game_config),
        ability_range: extract_ability_range(game_config),
        ability_target_type: extract_ability_target_type(game_config),
        item_rarity_q: extract_item_rarity_q(game_config),
        ability_rarity_eff: extract_ability_rarity_eff(game_config),
        item_fixed_power: extract_item_fixed_power(game_config),
        item_id_by_mimic_code: extract_item_id_by_mimic_code(game_config),
        entity_template_is_boss: extract_entity_template_is_boss(game_config),
        fight_template_is_dungeon: extract_fight_template_flag(game_config, |f| f.is_dungeon),
        fight_template_is_bossfight: extract_fight_template_flag(game_config, |f| f.is_bossfight),
        class_counter_role: extract_class_counter_role(game_config),
    }
}

/// Balance v2 (Phase 5): `class.id` → soft 3-cycle combat role, resolved from
/// each class's `main_attribute` code (see `balance::class_counter_role_from_code`).
fn extract_class_counter_role(game_config: &GameConfig) -> HashMap<uuid::Uuid, i8> {
    let code_by_attr: HashMap<uuid::Uuid, &str> = game_config
        .attributes
        .iter()
        .map(|a| (a.id, a.code.as_str()))
        .collect();
    game_config
        .classes
        .iter()
        .filter_map(|c| {
            let code = code_by_attr.get(&c.main_attribute)?;
            Some((
                c.id,
                crate::mechanics::balance::class_counter_role_from_code(code),
            ))
        })
        .collect()
}

/// `item_rarity.q` (rarity power multiplier), from `ItemRarity::q`.
fn extract_item_rarity_q(game_config: &GameConfig) -> HashMap<uuid::Uuid, f64> {
    game_config
        .item_rarities
        .iter()
        .map(|r| (r.id, r.q as f64))
        .collect()
}

/// `ability_rarity.eff` (rarity damage efficiency), from `AbilityRarity::eff`.
fn extract_ability_rarity_eff(game_config: &GameConfig) -> HashMap<uuid::Uuid, f64> {
    game_config
        .ability_rarities
        .iter()
        .map(|r| (r.id, r.eff))
        .collect()
}

/// `item.fixed_power` (overrides random spread), from `ItemTemplate::fixed_power`.
/// Only items that set it are inserted (presence is meaningful in `balance`).
fn extract_item_fixed_power(game_config: &GameConfig) -> HashMap<uuid::Uuid, f64> {
    game_config
        .items
        .iter()
        .filter_map(|i| i.fixed_power.map(|fp| (i.id, fp)))
        .collect()
}

/// `item.next_mimic_item_code` → item template id, from
/// `ItemTemplate::next_mimic_item_code`, for `content::get_item_by_code`.
/// Only items that set a code are inserted. Hidden TECH quests set the
/// character custom value `next_mimic_item_code` so the next chest grants a
/// SPECIFIC item; an empty lookup silently degrades those grants to the
/// generic per-slot fallback in `chest_item_choose`.
fn extract_item_id_by_mimic_code(game_config: &GameConfig) -> HashMap<i64, uuid::Uuid> {
    game_config
        .items
        .iter()
        .filter_map(|i| i.next_mimic_item_code.map(|code| (code, i.id)))
        .collect()
}

/// `entity.is_boss`, from `EntityTemplate::is_boss`.
fn extract_entity_template_is_boss(game_config: &GameConfig) -> HashMap<uuid::Uuid, bool> {
    game_config
        .entities
        .iter()
        .map(|e| (e.id, e.is_boss))
        .collect()
}

/// A per-`FightTemplate` boolean flag (`is_dungeon` / `is_bossfight`).
fn extract_fight_template_flag(
    game_config: &GameConfig,
    flag: impl Fn(&essences::fighting::FightTemplate) -> bool,
) -> HashMap<uuid::Uuid, bool> {
    game_config
        .fight_templates
        .iter()
        .map(|f| (f.id, flag(f)))
        .collect()
}

/// `attribute.base_value` (the stat's starting value before bonuses), from
/// `Attribute::base_value`. Only attributes with a non-null base are inserted.
/// Critically `received_damage`'s base of 10000 (= 100% damage taken) lives
/// here: an empty map makes `get_entity_stat("received_damage")` resolve to 0,
/// and `damage_entity` then cancels every hit (`received_damage_k <= 0`).
fn extract_attribute_base_value(game_config: &GameConfig) -> HashMap<uuid::Uuid, f64> {
    game_config
        .attributes
        .iter()
        .filter_map(|a| a.base_value.map(|base| (a.id, base as f64)))
        .collect()
}

/// Per-ability cast `range` (in cells), from `AbilityTemplate::range`.
fn extract_ability_range(game_config: &GameConfig) -> HashMap<uuid::Uuid, i64> {
    game_config
        .abilities
        .iter()
        .map(|a| (a.id, a.range))
        .collect()
}

/// Per-ability `target_type` ("Enemy" / "Ally" / "Self"), from
/// `AbilityTemplate::target_type`.
fn extract_ability_target_type(game_config: &GameConfig) -> HashMap<uuid::Uuid, String> {
    game_config
        .abilities
        .iter()
        .map(|a| (a.id, a.target_type.as_str().to_string()))
        .collect()
}

/// Effect templates keyed by their `code`, from `GameConfig::effects`.
/// `max_duration_ticks` (ms) is sourced from `Effect::duration` (seconds):
/// `duration * 1000`. `None` falls back to the 5000 ms default in
/// `change_entity_effect_duration`.
fn extract_effects(game_config: &GameConfig) -> HashMap<String, Arc<EffectTpl>> {
    let mut out = HashMap::new();
    for effect in &game_config.effects {
        out.insert(
            effect.code.clone(),
            Arc::new(EffectTpl {
                id: effect.id,
                code: effect.code.clone(),
                max_duration_ticks: effect.duration.map(|d| d * 1000),
            }),
        );
    }
    out
}

/// `attribute.code` → `AttributeId`, from `GameConfig::attributes`.
fn extract_attribute_by_code(game_config: &GameConfig) -> HashMap<String, uuid::Uuid> {
    let mut out = HashMap::new();
    for attribute in &game_config.attributes {
        out.insert(attribute.code.clone(), attribute.id);
    }
    out
}

/// Quest `code` → quest UUID, from `GameConfig::quests`. Quests without a `code`
/// are skipped (the field is `Option<String>` on the schema).
fn extract_quest_by_code(game_config: &GameConfig) -> HashMap<String, uuid::Uuid> {
    let mut out = HashMap::new();
    for quest in &game_config.quests {
        if let Some(code) = &quest.code {
            out.insert(code.clone(), quest.id);
        }
    }
    out
}

#[cfg(test)]
mod mimic_code_tests {
    //! Regression: `item_id_by_mimic_code` used to stay empty (the field was
    //! never promoted from `content_raw` onto the typed `ItemTemplate`), so
    //! `content::get_item_by_code` always returned `None` and quest-directed
    //! mimic grants silently degraded to the generic per-slot chest fallback.

    use super::*;
    use crate::mechanics::content;

    #[test]
    fn next_mimic_item_code_is_extracted_and_resolves_via_get_item_by_code() {
        let mut cfg = configs::tests_game_config::generate_game_config_for_tests();
        let item_id = cfg.items[0].id;
        cfg.items[0].next_mimic_item_code = Some(1002);

        let lookups = extract(&cfg);
        assert_eq!(
            lookups.item_id_by_mimic_code.get(&1002).copied(),
            Some(item_id),
            "extract must source item_id_by_mimic_code from ItemTemplate::next_mimic_item_code"
        );
        // Items without a code must not be inserted.
        assert_eq!(lookups.item_id_by_mimic_code.len(), 1);

        let item = content::get_item_by_code(&cfg, &lookups, 1002)
            .expect("mimic code must resolve to the configured item template");
        assert_eq!(item.id, item_id);
        assert!(content::get_item_by_code(&cfg, &lookups, 9999).is_none());
    }
}