overlord_event_system/behaviors/

items.rs

//! Native functions for the per-attribute item value calculation slots —
//! `cases.rs::try_finalize_item` via `run_expression::<i64>` with scope
//! `Item` / `Random` / `AttributesQuantity`).
//!
//! Each fn computes one attribute's value, referenced from the attribute's
//! `calculation_behavior`. The production `Random` is *fresh entropy*
//! (`GameRng::from_entropy` in `cases.rs`).
//!
//! All formula primitives live in [`crate::mechanics::balance`]. Each fn
//! maps to exactly one of the 16 attributes (keyed by attribute uuid):
//!
//! | uuid suffix    | attribute      | native fn               |
//! |----------------|----------------|-------------------------|
//! | a3d34c967544   | Health         | `attr_health`           |
//! | a3d484fc9321   | Armor          | `attr_armor`            |
//! | a3d5ae6a6d85   | Damage         | `attr_damage`           |
//! | a3d6986afce1   | Crit_Chance    | `attr_crit_chance`      |
//! | d17688fe8796   | Crit_Damage    | `attr_crit_damage`      |
//! | b7a9f4076158   | Evasion        | `attr_evasion`          |
//! | 9bc89817cd0c   | Speed          | `attr_speed`            |
//! | 58be88146385   | HP_Regen       | `attr_hp_regen`         |
//! | 0533377e501c   | Multi_Cast     | `attr_multi_cast`       |
//! | b5389ac4560b   | Counter_Attack | `attr_counter_attack`   |
//! | 68dc4f9806b8   | Damage_Received| `attr_zero` (empty)     |
//! | 5041af05d473   | Bravery        | `attr_bravery`          |
//! | cb869d6d3f95   | Guile          | `attr_guile`            |
//! | 4469382ee36c   | Block          | `attr_block`            |
//! | 9bfc229665c3   | Bonus_Health   | `attr_zero` (`0`)       |
//! | f5461b96d9ff   | Bonus_damage   | `attr_zero` (`0`)       |

use configs::game_config::GameConfig;
use essences::items::{Item, ItemType};
use event_system::script::random::GameRng;
use uuid::Uuid;

use crate::behaviors::{BehaviorKind, BehaviorMeta, BehaviorRegistry};
use crate::mechanics::balance;
use crate::mechanics::content_lookups::ContentLookups;

/// Inputs available to an item-attribute native fn — mirrors the three `const`s
/// the `cases.rs::try_finalize_item` caller pushes (`Item`, `Random`,
/// `AttributesQuantity`), plus the config / content lookups the `balance`
/// primitives need.
pub struct ItemAttributeCtx<'a> {
    pub item: &'a Item,
    pub attributes_quantity: i64,
    pub random: &'a GameRng,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Signature of an item-attribute native fn. Returns the attribute value
/// (`i64`), matching `run_expression::<i64>` (the value is later narrowed to
pub type ItemAttributeFn = fn(&ItemAttributeCtx) -> anyhow::Result<i64>;

/// `balance::eff_item(Item)`.
fn eff_item(ctx: &ItemAttributeCtx) -> f64 {
    balance::eff_item_with_config(
        ctx.config,
        ctx.lookups,
        ctx.item.item_template_id,
        ctx.item.level as f64,
    )
}

/// `balance::attr_spread(Random, Item)`.
fn attr_spread(ctx: &ItemAttributeCtx) -> f64 {
    balance::attr_spread_for_item(
        ctx.config,
        ctx.lookups,
        ctx.random,
        ctx.item.item_template_id,
        ctx.item.level as f64,
    )
}

/// `balance::aux_attr_eff(eff, Random, Item)`.
fn aux_attr_eff(ctx: &ItemAttributeCtx, base_eff: f64) -> f64 {
    balance::aux_attr_eff_for_item(
        ctx.config,
        ctx.lookups,
        base_eff,
        ctx.random,
        ctx.item.item_template_id,
        ctx.item.level as f64,
    )
}

/// Health (`...a3d34c967544`):
pub fn attr_health(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let aux_attrs = (ctx.attributes_quantity - balance::MAIN_ATTRS_QUANTITY) as f64;
    let base_attrs_impact = 1.0 - aux_attrs * balance::AUX_ATTR_IMPACT;
    let base_attr_impact = base_attrs_impact * 0.5;
    let eff = eff_item(ctx);
    let rand_mod = attr_spread(ctx);
    let attr_eff = (eff * rand_mod).powf(base_attr_impact);
    let hp_k = balance::hp_k_for_level(ctx.item.level as f64);
    Ok((balance::BASE_HP * attr_eff * hp_k / 10.0).floor() as i64)
}

/// Armor (`...a3d484fc9321`):
pub fn attr_armor(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let dmg_increase = balance::eff_spell_by_level(ctx.item.level as f64);
    let spread = attr_spread(ctx);
    let dr = (1.0 - 1.0 / (dmg_increase * spread)).max(0.03) * 10000.0;
    Ok((dr / 10.0).floor() as i64)
}

/// Damage (`...a3d5ae6a6d85`):
pub fn attr_damage(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let aux_attrs = (ctx.attributes_quantity - balance::MAIN_ATTRS_QUANTITY) as f64;
    let base_attrs_impact = 1.0 - aux_attrs * balance::AUX_ATTR_IMPACT;
    let base_attr_impact = base_attrs_impact * 0.5;
    let eff = eff_item(ctx);
    let rand_mod = attr_spread(ctx);
    // == `(eff ** base_attr_impact) * rand_mod`.
    let attr_eff = eff.powf(base_attr_impact) * rand_mod;
    Ok((balance::BASE_ATTACK * attr_eff / 10.0).floor() as i64)
}

/// Crit_Chance (`...a3d6986afce1`):
pub fn attr_crit_chance(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff).powi(2);
    let crit_chance = (-1.0 + (8.0 * attr_eff - 7.0).powf(0.5)) / 4.0;
    Ok((crit_chance * 10000.0 / 10.0).floor() as i64)
}

/// Crit_Damage (`...d17688fe8796`):
pub fn attr_crit_damage(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff).powi(2);
    let crit_mod = (-1.0 + (8.0 * attr_eff - 7.0).powf(0.5)) / 2.0;
    Ok((crit_mod * 10000.0 / 10.0).floor() as i64)
}

/// Evasion (`...b7a9f4076158`):
pub fn attr_evasion(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff);
    let evasion_chance = 1.0 - 1.0 / attr_eff;
    Ok((evasion_chance * 10000.0 / 10.0).floor() as i64)
}

/// Speed (`...9bc89817cd0c`):
pub fn attr_speed(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff);
    Ok(((attr_eff - 1.0) * 10000.0 / 10.0).floor() as i64)
}

/// HP_Regen (`...58be88146385`):
pub fn attr_hp_regen(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let aux_attrs = (ctx.attributes_quantity - balance::MAIN_ATTRS_QUANTITY) as f64;
    let eff = eff_item(ctx);
    let base_attr_eff = eff.powf(1.0 - aux_attrs * balance::AUX_ATTR_IMPACT);
    let hp_eff = base_attr_eff.powf(0.5);
    let hp = hp_eff * balance::BASE_HP;
    let attr_eff = aux_attr_eff(ctx, eff);
    let hp_per_sec = hp * (attr_eff - 1.0) / (balance::FIGHT_DURATION * attr_eff);
    Ok((hp_per_sec / 10.0).floor() as i64)
}

/// Multi_Cast (`...0533377e501c`):
pub fn attr_multi_cast(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff);
    Ok(((attr_eff - 1.0) * 10000.0 / 10.0).floor() as i64)
}

/// Counter_Attack (`...b5389ac4560b`):
pub fn attr_counter_attack(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff);
    let dmg_increase = balance::eff_spell_by_level(ctx.item.level as f64);
    let dps = dmg_increase * balance::SPELL_QUANTITY as f64;
    let overall_damage = dps * balance::FIGHT_DURATION;
    let added_damage = overall_damage * (attr_eff - 1.0);
    let attacks_per_fight = balance::FIGHT_DURATION * balance::ATTACKS_PER_SEC;
    let p = added_damage / attacks_per_fight / balance::COUNTERATTACK_POWER;
    Ok((p * 10000.0 / 10.0).floor() as i64)
}

/// Bravery (`...5041af05d473`):
pub fn attr_bravery(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff);
    let p = balance::bravery_p_from_eff(attr_eff);
    Ok((p * 10000.0 / 10.0).floor() as i64)
}

/// Guile (`...cb869d6d3f95`):
pub fn attr_guile(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    let attr_eff = aux_attr_eff(ctx, eff);
    let p = balance::deceit_p_from_eff(attr_eff);
    Ok((p * 10000.0 / 10.0).floor() as i64)
}

/// Block (`...4469382ee36c`):
pub fn attr_block(ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    let eff = eff_item(ctx);
    // f64. Mirror with `f64::min(_, 2.0)`.
    let attr_eff = aux_attr_eff(ctx, eff).min(2.0);
    let block_chance = 2.0 - 2.0 / attr_eff;
    Ok((block_chance * 10000.0 / 10.0).floor() as i64)
}

/// Trivial slots: Damage_Received (empty script), Bonus_Health (`0`),
/// `0` as `i64`.
pub fn attr_zero(_ctx: &ItemAttributeCtx) -> anyhow::Result<i64> {
    Ok(0)
}

/// Register this category's native fns into the registry (Expression category —
/// scalar `i64` slots, same as `item_experience`).
pub fn register(registry: &mut BehaviorRegistry) {
    let fns: &[(&str, &str, &str, ItemAttributeFn)] = &[
        (
            "attr_health",
            "Атрибут: здоровье",
            "Порт calculation_behavior атрибута Health.",
            attr_health,
        ),
        (
            "attr_armor",
            "Атрибут: броня",
            "Порт calculation_behavior атрибута Armor.",
            attr_armor,
        ),
        (
            "attr_damage",
            "Атрибут: урон",
            "Порт calculation_behavior атрибута Damage.",
            attr_damage,
        ),
        (
            "attr_crit_chance",
            "Атрибут: шанс крита",
            "Порт calculation_behavior атрибута Crit_Chance.",
            attr_crit_chance,
        ),
        (
            "attr_crit_damage",
            "Атрибут: крит. урон",
            "Порт calculation_behavior атрибута Crit_Damage.",
            attr_crit_damage,
        ),
        (
            "attr_evasion",
            "Атрибут: уклонение",
            "Порт calculation_behavior атрибута Evasion.",
            attr_evasion,
        ),
        (
            "attr_speed",
            "Атрибут: скорость",
            "Порт calculation_behavior атрибута Speed.",
            attr_speed,
        ),
        (
            "attr_hp_regen",
            "Атрибут: реген HP",
            "Порт calculation_behavior атрибута HP_Regen.",
            attr_hp_regen,
        ),
        (
            "attr_multi_cast",
            "Атрибут: мультикаст",
            "Порт calculation_behavior атрибута Multi_Cast.",
            attr_multi_cast,
        ),
        (
            "attr_counter_attack",
            "Атрибут: контратака",
            "Порт calculation_behavior атрибута Counter_Attack.",
            attr_counter_attack,
        ),
        (
            "attr_bravery",
            "Атрибут: храбрость",
            "Порт calculation_behavior атрибута Bravery.",
            attr_bravery,
        ),
        (
            "attr_guile",
            "Атрибут: коварство",
            "Порт calculation_behavior атрибута Guile.",
            attr_guile,
        ),
        (
            "attr_block",
            "Атрибут: блок",
            "Порт calculation_behavior атрибута Block.",
            attr_block,
        ),
        (
            "attr_zero",
            "Атрибут: ноль",
            "Возвращает 0 (порт пустых / `0` calculation_behavior: \
             Damage_Received, Bonus_Health, Bonus_damage).",
            attr_zero,
        ),
    ];
    for (name, title, description, f) in fns {
        registry.register_item_attribute(
            BehaviorMeta {
                name: name.to_string(),
                category: BehaviorKind::ItemAttribute,
                title: title.to_string(),
                description: description.to_string(),
            },
            *f,
        );
    }
}

/// TODO: source from config. Per-slot fallback item template for the chest
/// item-choose path (slot name → item template uuid).
const ITEMS_FOR_SLOTS: &[(&str, &str)] = &[
    ("Boots", "0194d64e-216d-7059-863f-26f67c64267b"),
    ("Torso", "0194d64e-216d-7059-863f-26f7e69b8f4a"),
    ("Head", "0194d64e-216d-7059-863f-26f85eb1e25f"),
    ("Gloves", "0194d64e-216d-7059-863f-26f9ab123d46"),
    ("Ring", "0194d64e-216d-7059-863f-26fa1fc8410b"),
    ("Waist", "0194d64e-216d-7059-863f-26fb000bf4e9"),
    ("Legs", "0194d64e-216d-7059-863f-26fc9c33e67e"),
    ("Shoulders", "0194d64e-216d-7059-863f-26fddb278b04"),
    ("Neck", "0194d64e-216d-7059-863f-26fec3786536"),
    ("Weapon", "0194d64e-216d-7059-863f-26ff77d309a3"),
];

/// Inputs for the item sell-price / experience calculations (code-dispatched
/// from item finalization).
pub struct ItemPriceCtx<'a> {
    pub item: &'a Item,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Sell price of an item, from its effectiveness `eff` via
/// [`balance::sell_price`] (Phase 2: sub-linear in `eff` so gold income grows
/// ~linearly with item level — model's linear-income assumption — letting the
/// geometric chest-upgrade cost bind instead of being swamped by surplus; early
/// low-`eff` sales stay ≈ the legacy `eff·100`).
pub fn item_price(
    ctx: &ItemPriceCtx,
) -> anyhow::Result<Vec<event_system::script::types::ESCurrencyUnit>> {
    let eff = crate::mechanics::balance::eff_item_with_config(
        ctx.config,
        ctx.lookups,
        ctx.item.item_template_id,
        ctx.item.level as f64,
    );
    let price = crate::mechanics::balance::sell_price(eff);
    Ok(vec![event_system::script::types::ESCurrencyUnit {
        currency_id: Uuid::from_u128(0x0194d64e_2386_7020_8b01_d6b3d5424506),
        amount: price,
    }])
}

/// Inputs for the item-experience calculation (code-dispatched).
pub struct ItemExperienceCtx<'a> {
    pub item: &'a Item,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Item experience: `floor(balance::eff_item * 100)`.
pub fn item_experience_eff_item(ctx: &ItemExperienceCtx) -> anyhow::Result<i64> {
    let eff = crate::mechanics::balance::eff_item_with_config(
        ctx.config,
        ctx.lookups,
        ctx.item.item_template_id,
        ctx.item.level as f64,
    );
    Ok((eff * 100.0).floor() as i64)
}

/// Inputs for the chest item-choose override (code-dispatched).
pub struct ChestItemChooseCtx<'a> {
    pub character: &'a essences::character_state::CharacterState,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Chest item override: the mimic item by `next_mimic_item_code`, else the
/// per-slot fallback for the first unequipped slot of the current inventory
/// level, else `None` (roll by weights).
pub fn chest_item_choose(ctx: &ChestItemChooseCtx) -> anyhow::Result<Option<Uuid>> {
    use crate::mechanics::content;

    let character = &ctx.character.character;

    // Branch 1: explicit mimic custom item code (absent or 0 → no override).
    if let Some(&code) = character.custom_values.0.get("next_mimic_item_code")
        && code != 0
        && let Some(item) = content::get_item_by_code(ctx.config, ctx.lookups, code)
    {
        return Ok(Some(item.id));
    }

    // Branch 2: per-slot fallback by inventory level (highest
    // `from_chapter_level <= current_chapter_level`).
    let mut levels: Vec<&content::InventoryLevel> =
        content::get_inventory_levels(ctx.config).iter().collect();
    levels.sort_by_key(|l| std::cmp::Reverse(l.from_chapter_level));
    let Some(current_level) = levels
        .into_iter()
        .find(|l| l.from_chapter_level <= character.current_chapter_level)
    else {
        return Ok(None);
    };

    // Artifact is never granted via chests — exclude it from the slot list so
    // the per-slot fallback never returns an Artifact template.
    let mut slots: Vec<String> = current_level
        .item_types
        .iter()
        .filter(|t| **t != ItemType::Artifact)
        .map(|t| t.to_string())
        .collect();
    for item in &ctx.character.inventory {
        if item.is_equipped {
            let equipped = item.item_type.to_string();
            slots.retain(|s| *s != equipped);
        }
    }

    if let Some(selected_slot) = slots.first() {
        // Prefer the hardcoded per-slot fallback item (production parity). If
        // it is not present in the loaded config (e.g. a synthetic test
        // config), fall back to any config item of that slot type.
        if let Some((_, uuid_str)) = ITEMS_FOR_SLOTS.iter().find(|(s, _)| s == selected_slot) {
            let selected = Uuid::parse_str(uuid_str)
                .map_err(|e| anyhow::anyhow!("ITEMS_FOR_SLOTS bad uuid {uuid_str:?}: {e}"))?;
            if ctx.config.items.iter().any(|i| i.id == selected) {
                return Ok(Some(selected));
            }
        }
        if let Some(item) = ctx
            .config
            .items
            .iter()
            .find(|i| i.item_type.to_string() == *selected_slot)
        {
            return Ok(Some(item.id));
        }
    }

    Ok(None)
}