overlord_event_system/behaviors/

ui_values.rs

//! Native function for the `description_values` category — computes the values
//! for an ability's `description_values_script`.
//!
//! Follows the `power` reference shape: a typed `*Ctx`, a `*Fn` alias, a native
//! impl, and a `register`.
//!
//! ## What these scripts compute
//! Each ability's `description_values_script` (in
//! `overlord/admin/config/scripts/content.templates.abilities.*`) is one of two
//! shapes:
//!
//! 1. **Content-driven** — import `content`, fetch the ability info, then push
//!    one or more derived fields:
//!    Each push is either `floor(ability_info.<field> * 100)` (a `f64` →
//!    `floor` → pushed as `f64`) or a bare `ability_info.<field>` (an integer
//!    field like `projectiles`, pushed via the `push(i64)` overload as
//!    `value as f64`).
//!
//! 2. **Literal** — no content dependency, just integer literals:
//!
//! The native port reads the script source (the only way to know the field
//! order and the literal values — they live in the source, not in any typed
//! scope value), parses the canonical statement family, and reproduces the same
//! `Vec<f64>`. It dispatches the ability info through
//! [`crate::mechanics::content::ability_info`] so a discrepancy points at
//! the per-ability composition, not at this glue.
//!
//! Any script shape this parser does not cover returns `Err`, surfacing the
//! uncovered script rather than silently mis-evaluating it.

use configs::game_config::GameConfig;

use crate::mechanics::content::{self, AbilityInfo};
use crate::mechanics::content_lookups::ContentLookups;

/// Inputs available to a `description_values` native fn — the same two inputs
/// constant and the script source), plus the config / content lookups
/// `content::ability_info` needs. The `scope_setter` for this slot is the
/// identity closure (`compute_description_values_for_ability`), so there are no
/// other scope variables to mirror.
pub struct DescriptionValuesCtx<'a> {
    pub ability_level: i64,
    /// The template id of the ability being described. The shipped scripts read
    /// their own info via `content::get_ability($.id)`, where `$.id` is this id.
    pub ability_template_id: uuid::Uuid,
    pub script: &'a str,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Which ability's `ability_info` a `description_values` script reads.
#[derive(Clone, Copy)]
enum AbilityIdRef {
    /// `content::get_ability("<literal uuid>")` — a specific ability.
    Literal(uuid::Uuid),
    /// `content::get_ability($.id)` — the ability being described; resolved from
    /// [`DescriptionValuesCtx::ability_template_id`]. Every shipped script uses
    /// this self-reference form.
    SelfId,
}

/// Signature of a `description_values` native fn. Free `fn` (no captured state)
/// so it is `Copy`; runtime context arrives via [`DescriptionValuesCtx`].
pub type DescriptionValuesFn = fn(&DescriptionValuesCtx) -> anyhow::Result<Vec<f64>>;

/// One parsed `Result.push(...)` statement.
enum Push {
    /// `Result.push(<int literal>)` — pushed via `push(i64)` → `value as f64`.
    Literal(i64),
    /// `Result.push(floor(ability_info.<field> * 100))` — a `f64` field times
    /// 100, floored, pushed as `f64`.
    FloorField(String),
    /// `Result.push(ability_info.<field>)` — a bare integer field (e.g.
    /// `projectiles`), pushed via `push(i64)` → `value as f64`.
    IntField(String),
}

/// Native port of `run_description_values_calculate` for the ability
/// `f64` fields push directly; bare integer fields and integer literals push
/// `value as f64`.
pub fn description_values(ctx: &DescriptionValuesCtx) -> anyhow::Result<Vec<f64>> {
    let (ability_id_ref, pushes) = parse_script(ctx.script)?;

    // Resolve the ability id the script reads: a literal `get_ability("id")`, or
    // `$.id` (the ability being described → this template id).
    let ability_id: Option<uuid::Uuid> = ability_id_ref.map(|r| match r {
        AbilityIdRef::Literal(id) => id,
        AbilityIdRef::SelfId => ctx.ability_template_id,
    });

    // Only fetch ability info if some statement actually reads it (literal-only
    // scripts have no content dependency / no id).
    let info: Option<AbilityInfo> = match ability_id {
        Some(id) => Some(content::ability_info(
            ctx.config,
            ctx.lookups,
            id,
            ctx.ability_level,
        )?),
        None => None,
    };

    let mut out: Vec<f64> = Vec::with_capacity(pushes.len());
    for push in pushes {
        match push {
            Push::Literal(n) => out.push(n as f64),
            Push::FloorField(field) => {
                let info = info.as_ref().ok_or_else(|| {
                    anyhow::anyhow!("ability_info field push without an ability id")
                })?;
                let v = read_f64_field(info, &field)?;
                out.push((v * 100.0).floor());
            }
            Push::IntField(field) => {
                let info = info.as_ref().ok_or_else(|| {
                    anyhow::anyhow!("ability_info field push without an ability id")
                })?;
                let v = read_i64_field(info, &field)?;
                out.push(v as f64);
            }
        }
    }

    Ok(out)
}

/// Read a `f64`-typed `ability_info.<field>` (the ones pushed via `floor(... *
/// 100)`). `Err` for absent / non-`f64` fields so an uncovered combination
/// surfaces as a mismatch.
fn read_f64_field(info: &AbilityInfo, field: &str) -> anyhow::Result<f64> {
    let v = match field {
        "damage" => info.damage,
        "dot" => info.dot,
        "hot" => info.hot,
        "effect_duration" => info.effect_duration,
        "crit_chance_bonus" => info.crit_chance_bonus,
        "vampiric" => info.vampiric,
        other => anyhow::bail!("unknown f64 ability_info field {other:?}"),
    };
    v.ok_or_else(|| anyhow::anyhow!("ability_info.{field} is absent for this ability"))
}

/// Read an `i64`-typed `ability_info.<field>` (pushed bare, e.g. `projectiles`).
fn read_i64_field(info: &AbilityInfo, field: &str) -> anyhow::Result<i64> {
    let v = match field {
        "projectiles" => info.projectiles,
        "duration" => info.duration,
        other => anyhow::bail!("unknown i64 ability_info field {other:?}"),
    };
    v.ok_or_else(|| anyhow::anyhow!("ability_info.{field} is absent for this ability"))
}

/// Parse the script into `(ability_id, ordered pushes)`. Returns `Err` on any
/// statement that is not part of the covered family. The ability id is taken
/// from the `get_ability_info("<id>", ...)` / `get_ability("<id>")` call; literal
/// scripts have no id.
fn parse_script(script: &str) -> anyhow::Result<(Option<AbilityIdRef>, Vec<Push>)> {
    // Strip line comments, then split on `;` so leading `import` / `let`
    // statements and the pushes are handled uniformly.
    let cleaned: String = script
        .lines()
        .map(|line| match line.find("//") {
            Some(idx) => &line[..idx],
            None => line,
        })
        .collect::<Vec<_>>()
        .join("\n");

    let mut ability_id: Option<AbilityIdRef> = None;
    let mut pushes = Vec::new();

    for raw in cleaned.split(';') {
        let stmt = raw.trim();
        if stmt.is_empty() {
            continue;
        }

        // Non-push statements: the `content` import and the `ability_info` /
        // `ability_tpl` `let` bindings. Extract the ability id from them.
        if stmt.starts_with("import ") {
            continue;
        }
        if let Some(rest) = stmt.strip_prefix("let ") {
            if let Some(id) = extract_ability_id(rest) {
                ability_id = Some(id);
            }
            // A `let` we recognize as an ability-info binding is fine; any other
            // `let` is unexpected — but the only `let`s in this family bind
            // `ability_tpl`/`ability_info`, so accept and move on.
            continue;
        }

        // Push statements.
        let inner = stmt
            .strip_prefix("Result.push(")
            .and_then(|s| s.strip_suffix(')'))
            .ok_or_else(|| anyhow::anyhow!("non-canonical description statement: {stmt:?}"))?
            .trim();

        pushes.push(parse_push(inner)?);
    }

    Ok((ability_id, pushes))
}

/// Parse the argument of a single `Result.push(<inner>)`.
fn parse_push(inner: &str) -> anyhow::Result<Push> {
    // floor(ability_info.<field> * 100)
    if let Some(rest) = inner.strip_prefix("floor(") {
        let body = rest
            .strip_suffix(')')
            .ok_or_else(|| anyhow::anyhow!("unbalanced floor(...): {inner:?}"))?
            .trim();
        let field = body
            .strip_prefix("ability_info.")
            .and_then(|s| s.trim_end().strip_suffix("100"))
            .map(|s| s.trim_end())
            .and_then(|s| s.strip_suffix('*'))
            .map(|s| s.trim().to_string())
            .ok_or_else(|| {
                anyhow::anyhow!("floor body is not `ability_info.<field> * 100`: {body:?}")
            })?;
        return Ok(Push::FloorField(field));
    }

    // bare ability_info.<field>
    if let Some(field) = inner.strip_prefix("ability_info.") {
        return Ok(Push::IntField(field.trim().to_string()));
    }

    // integer literal
    if let Ok(n) = inner.parse::<i64>() {
        return Ok(Push::Literal(n));
    }

    anyhow::bail!("unsupported description push argument: {inner:?}")
}

/// Pull the ability reference out of a `let ... = content::get_ability_info(<arg>,
/// ...)` or `... content::get_ability(<arg>)` binding, where `<arg>` is either a
/// quoted literal uuid or `$.id` (the self-reference every shipped script uses).
/// Returns `None` if this binding is not such a call.
fn extract_ability_id(rest: &str) -> Option<AbilityIdRef> {
    for marker in ["get_ability_info(", "get_ability("] {
        if let Some(idx) = rest.find(marker) {
            let after = rest[idx + marker.len()..].trim_start();
            // `get_ability("<literal uuid>")`
            if let Some(quoted) = after.strip_prefix('"') {
                let end = quoted.find('"')?;
                return uuid::Uuid::parse_str(&quoted[..end])
                    .ok()
                    .map(AbilityIdRef::Literal);
            }
            // `get_ability($.id)` — self-reference, resolved from the ctx.
            if after.starts_with('$') {
                return Some(AbilityIdRef::SelfId);
            }
            return None;
        }
    }
    None
}

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

    #[test]
    fn parses_literal_only() {
        let (id, pushes) = parse_script("Result.push(100);\nResult.push(2);").unwrap();
        assert!(id.is_none());
        assert_eq!(pushes.len(), 2);
        assert!(matches!(pushes[0], Push::Literal(100)));
        assert!(matches!(pushes[1], Push::Literal(2)));
    }

    #[test]
    fn parses_get_ability_info_floor() {
        let script = "import \"content\" as content;\n\
            let ability_info = content::get_ability_info(\"019584aa-5bde-7ac2-8850-076dafdc4603\", AbilityLevel);\n\
            Result.push(floor(ability_info.damage * 100));\n\
            Result.push(floor(ability_info.crit_chance_bonus * 100));";
        let (id, pushes) = parse_script(script).unwrap();
        assert!(matches!(
            id,
            Some(AbilityIdRef::Literal(u)) if u.to_string() == "019584aa-5bde-7ac2-8850-076dafdc4603"
        ));
        assert_eq!(pushes.len(), 2);
        assert!(matches!(&pushes[0], Push::FloorField(f) if f == "damage"));
        assert!(matches!(&pushes[1], Push::FloorField(f) if f == "crit_chance_bonus"));
    }

    #[test]
    fn parses_get_ability_tpl_form() {
        let script = "import \"content\" as content;\n\
            let ability_tpl = content::get_ability(\"0194d64e-20f2-75e5-89c8-4cb812672485\");\n\
            let ability_info = ability_tpl.ability_info(AbilityLevel);\n\
            Result.push(floor(ability_info.damage * 100));";
        let (id, pushes) = parse_script(script).unwrap();
        assert!(matches!(
            id,
            Some(AbilityIdRef::Literal(u)) if u.to_string() == "0194d64e-20f2-75e5-89c8-4cb812672485"
        ));
        assert_eq!(pushes.len(), 1);
        assert!(matches!(&pushes[0], Push::FloorField(f) if f == "damage"));
    }

    /// Regression: every shipped ability `description_values_script` reads its own
    /// info via `content::get_ability($.id)` (a self-reference variable, NOT a
    /// quoted literal). The parser must recognise it as `SelfId` so the value
    /// computation resolves the ability id from the ctx — otherwise the id is
    /// `None`, the `floor(ability_info.*)` pushes error, and `%s%` placeholders in
    /// the description are never filled.
    #[test]
    fn parses_get_ability_self_id_form() {
        let script = "import \"content\" as content;\n\
            let ability_tpl = content::get_ability($.id);\n\
            let ability_info = ability_tpl.ability_info(AbilityLevel);\n\
            Result.push(floor(ability_info.damage * 100));";
        let (id, pushes) = parse_script(script).unwrap();
        assert!(matches!(id, Some(AbilityIdRef::SelfId)));
        assert_eq!(pushes.len(), 1);
        assert!(matches!(&pushes[0], Push::FloorField(f) if f == "damage"));
    }

    #[test]
    fn parses_bare_int_field() {
        let script = "import \"content\" as content;\n\
            let ability_info = content::get_ability_info(\"019589e6-f9dd-7b22-8d39-5350e95aaf69\", AbilityLevel);\n\
            Result.push(ability_info.projectiles);\n\
            Result.push(floor(ability_info.damage * 100));";
        let (_id, pushes) = parse_script(script).unwrap();
        assert_eq!(pushes.len(), 2);
        assert!(matches!(&pushes[0], Push::IntField(f) if f == "projectiles"));
        assert!(matches!(&pushes[1], Push::FloorField(f) if f == "damage"));
    }

    #[test]
    fn literal_values_are_pushed_as_f64() {
        let ctx_script = "Result.push(100);\nResult.push(5);";
        // No config needed for the literal-only path.
        let (id, pushes) = parse_script(ctx_script).unwrap();
        assert!(id.is_none());
        let out: Vec<f64> = pushes
            .into_iter()
            .map(|p| match p {
                Push::Literal(n) => n as f64,
                _ => unreachable!(),
            })
            .collect();
        assert_eq!(out, vec![100.0, 5.0]);
    }
}
// Native function for the `talent_description_values` category — computes the
// values for a talent's `description_values_script`.
//
// Follows the `power` reference shape: a typed `*Ctx`, a `*Fn` alias, native
// impl(s), and a `register`.
//
// ## What these scripts compute
// Every talent's `description_values_script` observed in
// `overlord/admin/config/scripts/content.templates.talents.*` is the single
// canonical form:
//
//
// where `TalentLevel` is the `i64` constant pushed into scope by the `run_*`
// evaluates `TalentLevel * N` as `i64`, resolves the `push(i64)` overload
// ([`crate::script::DescriptionValuesVec::push_int`]) and stores it as
// `value as f64`. The slot output is `Vec<f64>` (one element per `push`).
//
// Because the multiplier `N` lives in the script *source* (not in any typed
// scope value), the native port must read the script text. The [`Ctx`] carries
// the raw script alongside the `talent_level`, mirroring exactly the two
// N)` statements and reproduce the same `(talent_level * N) as f64` push order.
//
// If a script uses any other shape (a non-canonical expression, floats, helper
// calls, etc.) the parser returns `Err`, surfacing precisely the scripts whose
// shape this port does not yet cover, rather than silently mis-evaluating them.

/// Inputs available to a `talent_description_values` native fn — the same two
/// `TalentLevel` constant and the script source (the multipliers `N` live in
/// the source text). The `scope_setter` for this slot is the identity closure
/// (`compute_description_values_for_talent`), so there are no other scope
/// variables to mirror.
pub struct TalentDescriptionValuesCtx<'a> {
    pub talent_level: i64,
    pub script: &'a str,
}

/// Signature of a `talent_description_values` native fn. Free `fn` (no captured
/// state) so it is `Copy`; runtime context arrives via [`TalentDescriptionValuesCtx`].
pub type TalentDescriptionValuesFn = fn(&TalentDescriptionValuesCtx) -> anyhow::Result<Vec<f64>>;

/// Native port of `run_talent_description_values_calculate` for the canonical
/// each push contributes `(TalentLevel * N) as f64`, in source order.
pub fn talent_description_values(ctx: &TalentDescriptionValuesCtx) -> anyhow::Result<Vec<f64>> {
    let mut out: Vec<f64> = Vec::new();

    for stmt in canonical_statements(ctx.script)? {
        // `value as f64` (DescriptionValuesVec::push_int).
        let value = ctx
            .talent_level
            .checked_mul(stmt)
            .ok_or_else(|| anyhow::anyhow!("talent_level * multiplier overflowed i64"))?;
        out.push(value as f64);
    }

    Ok(out)
}

/// Parse the script into the ordered list of integer multipliers `N`, one per
/// `Result.push(TalentLevel * N);` statement. Returns `Err` on any statement
/// that is not exactly this canonical shape, so non-covered script forms are
/// flagged rather than silently mis-evaluated.
fn canonical_statements(script: &str) -> anyhow::Result<Vec<i64>> {
    // Strip line comments (`// ...`) so trailing comments don't break parsing;
    // the observed scripts have none, but be conservative.
    let cleaned: String = script
        .lines()
        .map(|line| match line.find("//") {
            Some(idx) => &line[..idx],
            None => line,
        })
        .collect::<Vec<_>>()
        .join("\n");

    let mut multipliers = Vec::new();
    for raw in cleaned.split(';') {
        let stmt = raw.trim();
        if stmt.is_empty() {
            continue;
        }

        // Expect exactly: Result.push(TalentLevel * N)
        let inner = stmt
            .strip_prefix("Result.push(")
            .and_then(|s| s.strip_suffix(')'))
            .ok_or_else(|| {
                anyhow::anyhow!("non-canonical talent description statement: {stmt:?}")
            })?;

        // inner should be: TalentLevel * N
        let rest = inner.trim().strip_prefix("TalentLevel").ok_or_else(|| {
            anyhow::anyhow!("statement does not start with TalentLevel: {inner:?}")
        })?;
        let mul = rest.trim().strip_prefix('*').ok_or_else(|| {
            anyhow::anyhow!("statement is not a `TalentLevel * N` product: {inner:?}")
        })?;
        let n: i64 = mul
            .trim()
            .parse()
            .map_err(|e| anyhow::anyhow!("multiplier in {inner:?} is not an i64 literal: {e}"))?;
        multipliers.push(n);
    }

    Ok(multipliers)
}

#[cfg(test)]
mod talent_tests {
    use super::*;

    fn run(script: &str, level: i64) -> anyhow::Result<Vec<f64>> {
        talent_description_values(&TalentDescriptionValuesCtx {
            talent_level: level,
            script,
        })
    }

    #[test]
    fn single_push_times_one() {
        assert_eq!(run("Result.push(TalentLevel * 1);", 5).unwrap(), vec![5.0]);
    }

    #[test]
    fn single_push_times_ten() {
        assert_eq!(
            run("Result.push(TalentLevel * 10);", 3).unwrap(),
            vec![30.0]
        );
    }

    #[test]
    fn level_zero() {
        assert_eq!(run("Result.push(TalentLevel * 2);", 0).unwrap(), vec![0.0]);
    }

    #[test]
    fn whitespace_tolerant() {
        assert_eq!(
            run("Result.push( TalentLevel  *  2 ) ;", 4).unwrap(),
            vec![8.0]
        );
    }

    #[test]
    fn non_canonical_is_error() {
        assert!(run("Result.push(TalentLevel + 1);", 1).is_err());
        assert!(run("let x = 3;", 1).is_err());
    }
}