overlord_event_system/mechanics/

content.rs

//! Native `content` script-module dispatchers plus the per-ability
//! `ability_info(level)` composition for the `content_raw`-style ability map.
//!
//! These are `pub` Rust fns that the native script ports
//! (`behaviors::description_values`, `behaviors::expression`'s
//! `chest_item_choose`) call. The balance primitives they use
//! (`balance::ability_damage_from_id`, `balance::effect_duration`, consts
//! `AOE_COEF`/`OT_COEF`/`HEAL_COEF`) live in [`crate::mechanics::balance`].

use configs::game_config::GameConfig;
use essences::items::ItemTemplate;
use uuid::Uuid;

use crate::game_config_helpers::GameConfigLookup;
use crate::mechanics::balance;
use crate::mechanics::content_lookups::ContentLookups;

/// The typed result of the per-ability `ability_info(level)` closures. Each
/// struct holds every key that appears across the 18 bespoke ability infos, with
/// `None` for keys a given ability does not set.
///
/// `PartialEq + Serialize` so it can be diffed/logged if ever surfaced directly.
/// The downstream `description_values` fn reads individual fields, computing
/// `floor(ability_info.<field> * 100)`.
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
pub struct AbilityInfo {
    /// `damage` — instant damage component. Present on all damage abilities.
    pub damage: Option<f64>,
    /// `dot` — damage-over-time component.
    pub dot: Option<f64>,
    /// `hot` — heal-over-time component.
    pub hot: Option<f64>,
    /// `effect_duration` — buff/debuff duration (seconds), from
    /// `balance::effect_duration`.
    pub effect_duration: Option<f64>,
    /// `duration` — integer tick/second duration literal.
    pub duration: Option<i64>,
    /// `crit_chance_bonus` — added crit chance (fraction).
    pub crit_chance_bonus: Option<f64>,
    /// `vampiric` — life-steal fraction.
    pub vampiric: Option<f64>,
    /// `projectiles` — projectile count (integer).
    pub projectiles: Option<i64>,
    /// `max_targets` — AoE cap (from the ability template config field). `None`
    /// = unlimited; the band/cone AoE behaviors take the first N band-eligible
    /// targets in deterministic order.
    pub max_targets: Option<i64>,
}

impl AbilityInfo {
    /// Rescales the ability's numbers by the stones active on it. Damage-like
    /// keys share one multiplier, applied-effect durations share another, and
    /// the AoE cap grows by the socketed target bonus. The multipliers are
    /// identity when nothing is socketed, so a stoneless character reads exactly
    /// the config numbers.
    pub fn apply_stone_mods(&mut self, mods: &essences::ability_stones::AbilityStoneMods) {
        if mods.is_identity() {
            return;
        }
        // Condense folds the ability's own copies (Arcane Missiles' projectiles,
        // Thousand Cuts' flurry) into one hit that carries their whole budget,
        // BEFORE the payload multipliers — the collapsed hit is then multiplied
        // like any other payload.
        if mods.condense
            && let Some(copies) = self.projectiles.filter(|c| *c > 1)
        {
            for value in [&mut self.damage, &mut self.dot, &mut self.hot]
                .into_iter()
                .flatten()
            {
                *value *= copies as f64;
            }
            self.projectiles = Some(1);
        }
        for value in [&mut self.damage, &mut self.dot, &mut self.hot]
            .into_iter()
            .flatten()
        {
            *value *= mods.damage_mult;
        }
        if let Some(duration) = &mut self.effect_duration {
            *duration *= mods.effect_duration_mult;
        }
        if let Some(duration) = &mut self.duration {
            *duration = ((*duration as f64) * mods.effect_duration_mult).round() as i64;
        }
        self.max_targets = mods.apply_coverage(self.max_targets);
    }

    /// All-`None` base; closures set the keys they produce.
    pub fn none() -> Self {
        Self::empty()
    }

    /// All-`None` base; closures set the keys they produce.
    fn empty() -> Self {
        AbilityInfo {
            damage: None,
            dot: None,
            hot: None,
            effect_duration: None,
            duration: None,
            crit_chance_bonus: None,
            vampiric: None,
            projectiles: None,
            max_targets: None,
        }
    }
}

/// Native port of the `content` module's `get_ability_info(id, level)`:
/// dispatch to the per-ability `ability_info(level)` closure baked into the
/// ability map. Returns `None` for ability ids that have no `ability_info`
///
/// Faithfully mirrors each of the 18 closures'
/// arithmetic; the per-ability constants are ported verbatim from
pub fn ability_info(
    config: &GameConfig,
    lookups: &ContentLookups,
    ability_id: Uuid,
    level: i64,
) -> anyhow::Result<AbilityInfo> {
    // `balance::ability_damage(uuid(id), level)` in every closure.
    let dmg = |id: Uuid| -> anyhow::Result<f64> {
        balance::ability_damage_from_id(config, lookups, id, level)
            .map_err(|e| anyhow::anyhow!("balance::ability_damage({id}): {e}"))
    };

    let id_str = ability_id.to_string();
    let mut info = AbilityInfo::empty();

    match id_str.as_str() {
        // damage: power
        "0194d64e-20f2-75e5-89c8-4cb812672485" => {
            info.damage = Some(dmg(ability_id)?);
        }
        // DOT split: damage = base*K*INSTANT, dot = base*K*DOT_PART
        "01958172-9e65-7061-9d15-56b2c33cc13e" => {
            const DOT_PART: f64 = 0.5;
            const INSTANT: f64 = 1.0 - DOT_PART;
            let base_dmg = dmg(ability_id)?;
            let k = INSTANT + DOT_PART * balance::OT_COEF;
            info.damage = Some(base_dmg * k * INSTANT);
            info.dot = Some(base_dmg * k * DOT_PART);
        }
        // crit_chance_bonus + de-rated damage
        "019584aa-5bde-7ac2-8850-076dafdc4603" => {
            const CRIT_CHANCE_BONUS: f64 = 0.3;
            let overall = dmg(ability_id)?;
            let raw = overall / (1.0 + CRIT_CHANCE_BONUS);
            info.crit_chance_bonus = Some(CRIT_CHANCE_BONUS);
            info.damage = Some(raw);
        }
        // AoE-scaled damage
        "019584f4-2c99-72bf-bcd3-bfc02fb33977" => {
            info.damage = Some(dmg(ability_id)? * balance::AOE_COEF);
        }
        // PROJECTILES split
        "019589e6-f9dd-7b22-8d39-5350e95aaf69" => {
            const PROJECTILES: i64 = 3;
            info.projectiles = Some(PROJECTILES);
            info.damage = Some(dmg(ability_id)? / (PROJECTILES as f64));
        }
        // vampiric, damage de-rated by VAMPIRIC/HEAL_COEF
        "019589f7-f4a3-701c-bc0f-f60d980ae250" => {
            const VAMPIRIC: f64 = 0.3;
            info.damage = Some(dmg(ability_id)? / (1.0 + VAMPIRIC / balance::HEAL_COEF));
            info.vampiric = Some(VAMPIRIC);
        }
        // empower budget → effect_duration + damage
        "01958a30-8f18-745f-928a-75028cb3ee99" => {
            const EMPOWER_BUDGET: f64 = 0.3;
            let raw_power = dmg(ability_id)?;
            info.effect_duration = Some(balance::effect_duration(raw_power * EMPOWER_BUDGET));
            info.damage = Some(raw_power * (1.0 - EMPOWER_BUDGET));
        }
        // hot only. Blessing of Life: a HoT, so it gets HEAL_COEF (like all
        // healing) — but NOT also OT_COEF. The old `* HEAL_COEF * OT_COEF`
        // double-counted (×1.2×1.2 = ×1.44), giving this one ability a unique
        // 44% bonus that no peer heal/HoT had (vs e.g. vampiric touch), making it
        // imbalanced. A HoT's over-time nature is already its identity; it should
        // not also be paid the over-time coefficient on top of the heal one.
        "01958ed0-d45f-7cad-b086-8f11962d3859" => {
            info.hot = Some(dmg(ability_id)? * balance::HEAL_COEF);
        }
        // vulnerability budget → effect_duration + damage
        "01958ef2-dff5-76dd-89f1-d9c2707b2ffc" => {
            const VULNERABILITY_BUDGET: f64 = 0.3;
            let raw_power = dmg(ability_id)?;
            info.effect_duration = Some(balance::effect_duration(raw_power * VULNERABILITY_BUDGET));
            info.damage = Some(raw_power * (1.0 - VULNERABILITY_BUDGET));
        }
        // OT-scaled damage + integer duration
        "01958efd-77f9-7dec-8444-c9d759549225" => {
            let damage = dmg(ability_id)?;
            info.damage = Some(damage * balance::OT_COEF);
            info.duration = Some(5);
        }
        // plain damage abilities
        "019a0245-ff0c-7964-b345-ded525c71e74"
        | "019a0246-5aaf-7c01-9a1a-3969e04129ec"
        | "019a0246-cf87-73b0-b701-f8788cf9cc08"
        | "019bff40-af44-75b7-940c-6074097a2925"
        | "019c00a4-38c9-7859-a642-fd82c25ef285"
        | "019cc464-e752-71c1-a9dd-8fda9f212801"
        | "019cc465-14b8-7dbc-9799-4691b91805d3"
        | "019cc465-2f63-7b54-8ddc-fcbcb483fe81" => {
            info.damage = Some(dmg(ability_id)?);
        }

        // --- Class kits -----------------------------------------------------
        // Unlike gacha abilities, class kits do NOT price off the shared
        // eff·k·cd budget: BAL-033 authors their payloads outright, as shares of
        // ATK (damage) or of the RECIPIENT's Max HP (heals). Rank moves the
        // payload and nothing else — `class_rank_payload_mult` is `×1.0…1.6`
        // over ranks 1…7, and durations, buff magnitudes, target caps,
        // cooldowns and Mana costs stay flat by design.
        //
        // `level` here IS the ability's rank: class abilities rank on Class
        // Level, not on the shard ladder.

        // Backstab (Rogue): `400% ATK`, guaranteed crit, `×1.70` against a
        // target under 30% HP. The crit is unconditional in
        // `backstab_cast`, so no crit-chance bonus is priced here.
        "019dfc4c-75ea-716c-a453-801c968be604" => {
            const BASE_ATK_SHARE: f64 = 4.00;
            info.damage = Some(BASE_ATK_SHARE * balance::class_rank_payload_mult(level));
        }
        // Thousand Cuts (Rogue): `10 × 50% ATK` on one target — ten separate
        // hit events under ONE cast and one Mana payment (BAL-034).
        "019dfc4f-5c4f-7829-affa-11b21a735f78" => {
            const CUTS: i64 = 10;
            const CUT_ATK_SHARE: f64 = 0.50;
            info.projectiles = Some(CUTS);
            info.damage = Some(CUT_ATK_SHARE * balance::class_rank_payload_mult(level));
        }
        // Arcane Blast (Mage): `500% ATK` on the target; `arcane_blast_cast`
        // washes `SECONDARY_SHARE` of it over every other living enemy, with no
        // target cap, for the authored `200%`.
        "019dfcfb-7b13-7cf2-b8e3-ab9546310c2b" => {
            const BASE_ATK_SHARE: f64 = 5.00;
            info.damage = Some(BASE_ATK_SHARE * balance::class_rank_payload_mult(level));
        }
        // Rewind (Mage): `200% ATK` AoE plus Weakness (`−50% ATK`) for `5s`.
        // The duration is authored flat — rank buys damage only.
        "019dfcfe-704c-73cf-b6e8-60f85e86799d" => {
            const BASE_ATK_SHARE: f64 = 2.00;
            const WEAKNESS_SECONDS: f64 = 5.0;
            info.damage = Some(BASE_ATK_SHARE * balance::class_rank_payload_mult(level));
            info.effect_duration = Some(WEAKNESS_SECONDS);
        }
        // Fortify (Warrior): `50%` damage reduction for `4s` (the Protection
        // effect's own magnitude) plus a heal for `10%` of the Warrior's Max HP.
        // `hot` carries the Max-HP SHARE, not an ATK share — which is also what
        // the tooltip's `floor(hot * 100)` wants to print.
        "019dfd00-594e-755f-8132-1c320fb2b5e9" => {
            const PROTECTION_SECONDS: f64 = 4.0;
            const HEAL_MAX_HP_SHARE: f64 = 0.10;
            info.effect_duration = Some(PROTECTION_SECONDS);
            info.hot = Some(HEAL_MAX_HP_SHARE * balance::class_rank_payload_mult(level));
        }
        // War Cry (Warrior): `120% ATK` to up to three enemies plus `+30% final
        // damage` on self for `5s` (the War Fury effect carries the magnitude).
        "019dfd01-073e-7aee-a993-74e20b3c439c" => {
            const BASE_ATK_SHARE: f64 = 1.20;
            const FURY_SECONDS: f64 = 5.0;
            info.damage = Some(BASE_ATK_SHARE * balance::class_rank_payload_mult(level));
            info.effect_duration = Some(FURY_SECONDS);
        }
        // Battle Heal (Priest): the whole team heals for `12%` of EACH
        // recipient's own Max HP and gains `+15% ATK / +15% Armor` for `6s`.
        "019dfd02-0c6a-7f4d-bb45-4ec2a5fc231a" => {
            const HEAL_MAX_HP_SHARE: f64 = 0.12;
            const BLESSING_SECONDS: f64 = 6.0;
            info.hot = Some(HEAL_MAX_HP_SHARE * balance::class_rank_payload_mult(level));
            info.effect_duration = Some(BLESSING_SECONDS);
        }
        // Holy Nova (Priest): `180% ATK` to up to three enemies plus ONE heal
        // for `10%` of the recipient's Max HP — the ally with the lowest HP
        // share, which in solo is the Priest. It is a flat share now, not
        // lifesteal, so `vampiric` is deliberately absent.
        "019dfd02-add4-7373-912c-8483150fd341" => {
            const BASE_ATK_SHARE: f64 = 1.80;
            const HEAL_MAX_HP_SHARE: f64 = 0.10;
            let rank = balance::class_rank_payload_mult(level);
            info.damage = Some(BASE_ATK_SHARE * rank);
            info.hot = Some(HEAL_MAX_HP_SHARE * rank);
        }

        // --- Pet-ult clones ---------------------------------------------------
        // Dedicated ability entities so a pet's ult never collides with the
        // player's equipped copy of the donor gacha ability (the cast pipeline
        // keys by template id). Combat behaviors hardcode the DONOR uuid, so
        // the clone's numbers ARE the donor's at the pet's level — delegate.
        "11db667a-a0d8-4d31-81a7-2e479d260cdc" => {
            // Albite → Vampiric Touch
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("019589f7-f4a3-701c-bc0f-f60d980ae250").unwrap(),
                level,
            );
        }
        "781e3e5f-f6e6-47d9-b4ec-b23ccc45ca10" => {
            // Nyx → Strike
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("019584aa-5bde-7ac2-8850-076dafdc4603").unwrap(),
                level,
            );
        }
        "defe3366-5f0f-4efb-a20b-a768e32308c9" => {
            // Glimmer → Fireball
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("01958172-9e65-7061-9d15-56b2c33cc13e").unwrap(),
                level,
            );
        }
        "6ade394c-78de-4bed-ac67-ef85f2525126" => {
            // Nugget → Blessing of Life
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("01958ed0-d45f-7cad-b086-8f11962d3859").unwrap(),
                level,
            );
        }
        "4342f487-315b-441d-b224-1676f67c1a72" => {
            // Rusty → Nova
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("019584f4-2c99-72bf-bcd3-bfc02fb33977").unwrap(),
                level,
            );
        }
        "15f66404-77f7-48d7-8ecd-9d9369fcd263" => {
            // Breezy → Arcane Missiles
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("019589e6-f9dd-7b22-8d39-5350e95aaf69").unwrap(),
                level,
            );
        }
        "cd3dee36-9285-41ff-9f55-49102f133367" => {
            // Thingy → Immolate
            return ability_info(
                config,
                lookups,
                Uuid::parse_str("01958efd-77f9-7dec-8444-c9d759549225").unwrap(),
                level,
            );
        }
        other => {
            anyhow::bail!("content::ability_info: no ability_info closure for ability id {other}");
        }
    }

    // AoE cap comes straight from the ability template config field (§1). Absent
    // ⇒ unlimited (legacy). Pet-ult clones return early above and inherit the
    // donor's cap via delegation.
    info.max_targets = config
        .ability_template(ability_id)
        .and_then(|t| t.max_targets);

    Ok(info)
}

/// Native port of `content::get_item_by_code(code)`: find the item template
/// whose `next_mimic_item_code` equals `code`, via
/// [`ContentLookups::item_id_by_mimic_code`] (built at init from
/// `ItemTemplate::next_mimic_item_code`). Returns the matching config
/// returns the `content_raw` item map (the chest script then reads `item.id`).
pub fn get_item_by_code<'a>(
    config: &'a GameConfig,
    lookups: &ContentLookups,
    code: i64,
) -> Option<&'a ItemTemplate> {
    let id = lookups.item_id_by_mimic_code.get(&code).copied()?;
    config.item_template(id)
}

/// One entry of `content_raw::inventory_levels`, mirroring the fields the
/// `chest_item_choose_script` reads (`from_chapter_level`, `item_types`). This
/// is exactly [`essences::item_case::InventoryLevel`].
pub type InventoryLevel = essences::item_case::InventoryLevel;

/// Native port of `content::get_inventory_levels()`: the configured inventory
/// levels (`from_chapter_level`, `item_types`). Borrowed from config rather than
/// cloned; callers sort/filter a local view.
pub fn get_inventory_levels(config: &GameConfig) -> &[InventoryLevel] {
    &config.inventory_levels
}