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::flip::WorldSide;
use essences::items::Item;
use event_system::script::random::GameRng;
use uuid::Uuid;

use crate::behaviors::{BehaviorKind, BehaviorMeta, BehaviorRegistry};
use crate::game_config_helpers::GameConfigLookup;
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> {
    // A2-BAL-003 §3.3: optional stats ride ON TOP of the full main-stat budget.
    //
    // This used to be `1.0 - optionals * AUX_ATTR_IMPACT`, so every optional an
    // item carried shrank its own main stat — the item paid for its extras out
    // of its core. The signed rule is that it does not. Removing the reduction
    // moves the exponent 0.45 -> 0.50, which multiplies main stats by roughly
    // 1.4x at low item levels rising to 2.5x at high ones.
    //
    // That buff is deliberately paired with the §3.2 rarity correction, which
    // cuts late-game quality by 36-63%. Landing either alone moves item power a
    // long way; together they roughly cancel.
    let base_attr_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> {
    // A2-BAL-003 §3.3: optional stats ride ON TOP of the full main-stat budget.
    //
    // This used to be `1.0 - optionals * AUX_ATTR_IMPACT`, so every optional an
    // item carried shrank its own main stat — the item paid for its extras out
    // of its core. The signed rule is that it does not. Removing the reduction
    // moves the exponent 0.45 -> 0.50, which multiplies main stats by roughly
    // 1.4x at low item levels rising to 2.5x at high ones.
    //
    // That buff is deliberately paired with the §3.2 rarity correction, which
    // cuts late-game quality by 36-63%. Landing either alone moves item power a
    // long way; together they roughly cancel.
    let base_attr_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> {
    // §3.3, same rule as the main stats above: the optional count no longer
    // erodes the base the regen is computed from.
    let eff = eff_item(ctx);
    let base_attr_eff = eff;
    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, world side) → item template uuid). Two-sided
/// types need one entry per side: without a Real entry the lookup used to fall
/// through to first-in-config-order, which granted the Eternal (T10) Real item
/// as the slot's guaranteed starter. Fantasy starters are the Common set; Real
/// starters are the Worker Rare set (the Real pool starts at Rare).
const ITEMS_FOR_SLOTS: &[(&str, Option<WorldSide>, &str)] = &[
    ("Boots", None, "0194d64e-216d-7059-863f-26f67c64267b"),
    ("Ring", None, "0194d64e-216d-7059-863f-26fa1fc8410b"),
    ("Waist", None, "0194d64e-216d-7059-863f-26fb000bf4e9"),
    ("Legs", None, "0194d64e-216d-7059-863f-26fc9c33e67e"),
    ("Neck", None, "0194d64e-216d-7059-863f-26fec3786536"),
    (
        "Torso",
        Some(WorldSide::Fantasy),
        "0194d64e-216d-7059-863f-26f7e69b8f4a",
    ),
    (
        "Head",
        Some(WorldSide::Fantasy),
        "0194d64e-216d-7059-863f-26f85eb1e25f",
    ),
    (
        "Gloves",
        Some(WorldSide::Fantasy),
        "0194d64e-216d-7059-863f-26f9ab123d46",
    ),
    (
        "Shoulders",
        Some(WorldSide::Fantasy),
        "0194d64e-216d-7059-863f-26fddb278b04",
    ),
    (
        "Weapon",
        Some(WorldSide::Fantasy),
        "0194d64e-216d-7059-863f-26ff77d309a3",
    ),
    (
        "Torso",
        Some(WorldSide::Real),
        "019d2490-2623-74a4-a18f-0e045d50b127",
    ), // Worker Vest
    (
        "Head",
        Some(WorldSide::Real),
        "019d2490-4df0-7ac4-a4ab-0714e7d873a3",
    ), // Worker Helmet
    (
        "Gloves",
        Some(WorldSide::Real),
        "019d2490-b494-74a5-97ab-ebfd9ab2fbaa",
    ), // Worker Gloves
    (
        "Shoulders",
        Some(WorldSide::Real),
        "019d2490-7fac-7a83-a1b0-0bef6a2ba599",
    ), // Worker Pauldrons
    (
        "Weapon",
        Some(WorldSide::Real),
        "019d2490-0262-7e9c-97e8-eea374634c5f",
    ), // Worker Hammer
];

/// 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, via [`balance::sell_gold`]: sub-linear in the item's
/// level-effectiveness, linear in the rarity's authored sale value. The
/// exponent and coefficient come from `game_settings.sell_price_{exp,coef}`,
/// falling back to the compiled constants when absent (env
/// `OVERLORD_BAL_SELL_*` still wins).
///
/// This is the only live pricing path — `sell_price_with_config` survives for
/// its own unit test, so a change here changes every sale in the game.
pub fn item_price(
    ctx: &ItemPriceCtx,
) -> anyhow::Result<Vec<event_system::script::types::ESCurrencyUnit>> {
    // BAL-008: level-effectiveness and quality are passed SEPARATELY — the
    // signed formula keeps the quality multiplier linear, outside the exponent.
    //
    // The multiplier is `sell_q`, NOT the power `q`. They were one number and
    // could not both be right: `q` grows ~1.19x per rarity row while the chest
    // price ladder grows ~1.49x per level, so sale funding decayed by ~8,400x
    // across L6..L46 and item sales ended up paying 0.03% of chest upgrades
    // instead of the signed 78-82%. `sell_q` is authored against the price
    // ladder; `q` keeps driving power untouched.
    let eff_level = crate::mechanics::balance::eff_by_level(ctx.item.level as f64);
    let quality = ctx
        .config
        .item_template(ctx.item.item_template_id)
        .and_then(|tpl| ctx.lookups.item_rarity_sell_q.get(&tpl.rarity_id).copied())
        .unwrap_or(1.0);
    let price = crate::mechanics::balance::sell_gold(
        eff_level,
        quality,
        ctx.config.game_settings.sell_price_exp,
        ctx.config.game_settings.sell_price_coef,
    );
    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 (BAL-009): [`balance::item_experience`] of the item's
/// snapshot character level and its quality multiplier. The quality enters as
/// `sqrt(M)`, so rarity pays XP on a flatter axis than it pays combat stats.
pub fn item_experience_eff_item(ctx: &ItemExperienceCtx) -> anyhow::Result<i64> {
    use crate::game_config_helpers::GameConfigLookup;

    let quality = ctx
        .config
        .item_template(ctx.item.item_template_id)
        .and_then(|template| ctx.lookups.item_rarity_q.get(&template.rarity_id).copied())
        .unwrap_or(1.0);
    Ok(crate::mechanics::balance::item_experience(
        ctx.item.level as f64,
        quality,
    ))
}

/// 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,
    /// Items already rolled in the current batch but not yet appended to
    /// `character.inventory` (that happens later, in `PlayerNewItems`). They
    /// count as filling their slot, otherwise a batch open would hand out the
    /// same guaranteed item once per open.
    pub pending_items: &'a [Item],
}

/// Plinko item override: the mimic item by `next_mimic_item_code`, else the
/// per-slot fallback for the first slot of the current inventory level that
/// the character has no item for, 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);
    };

    // InventoryLevel owns both the logical side and the first-empty priority.
    let mut slots: Vec<_> = current_level
        .slots
        .iter()
        .map(|slot| slot.equipment_slot_key())
        .collect();

    // A slot counts as filled once the character owns any item for it —
    // equipped or still in the bag. Guaranteed items cannot be sold on the
    // client, so a bagged one will be equipped eventually; granting another
    // would just duplicate it on every open until the player equips.
    for item in ctx.character.inventory.iter().chain(ctx.pending_items) {
        let filled = item.equipment_slot_key();
        slots.retain(|slot| *slot != filled);
    }

    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.
        let selected_item_type = selected_slot.item_type().to_string();
        if let Some((_, _, uuid_str)) = ITEMS_FOR_SLOTS.iter().find(|(slot, side, _)| {
            *slot == selected_item_type && *side == selected_slot.world_side()
        }) {
            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(|item| item.id == selected && item.equipment_slot_key() == *selected_slot)
            {
                return Ok(Some(selected));
            }
        }
        if let Some(item) = ctx
            .config
            .items
            .iter()
            .find(|item| item.equipment_slot_key() == *selected_slot)
        {
            return Ok(Some(item.id));
        }
    }

    Ok(None)
}

#[cfg(test)]
mod tests {
    use super::*;
    use essences::{
        character_state::CharacterState,
        item_case::InventorySlotConfig,
        items::{Item, ItemType, WorldSide},
    };

    #[test]
    fn items_for_slots_covers_both_sides_of_every_two_sided_type() {
        // A missing side entry silently falls through to first-in-config-order,
        // which once granted the Eternal Real item as a slot's starter.
        for item_type in [
            ItemType::Weapon,
            ItemType::Torso,
            ItemType::Head,
            ItemType::Gloves,
            ItemType::Shoulders,
            ItemType::Boots,
            ItemType::Legs,
            ItemType::Neck,
            ItemType::Ring,
            ItemType::Waist,
        ] {
            let name = item_type.to_string();
            let sides: Vec<Option<WorldSide>> = if item_type.supports_world_side() {
                vec![Some(WorldSide::Fantasy), Some(WorldSide::Real)]
            } else {
                vec![None]
            };
            for side in sides {
                assert!(
                    ITEMS_FOR_SLOTS
                        .iter()
                        .any(|(slot, s, _)| *slot == name && *s == side),
                    "ITEMS_FOR_SLOTS is missing a ({name}, {side:?}) starter entry"
                );
            }
        }
    }

    #[test]
    fn first_empty_slot_unlocks_real_side_at_flip_boundary() {
        let mut config = configs::tests_game_config::generate_game_config_for_tests();
        config.flip_settings.unlock_chapter = 3;
        config.inventory_levels = vec![
            essences::item_case::InventoryLevel {
                from_chapter_level: 0,
                slots: vec![InventorySlotConfig {
                    item_type: ItemType::Weapon,
                    world_side: Some(WorldSide::Fantasy),
                }],
            },
            essences::item_case::InventoryLevel {
                from_chapter_level: 3,
                slots: vec![
                    InventorySlotConfig {
                        item_type: ItemType::Weapon,
                        world_side: Some(WorldSide::Fantasy),
                    },
                    InventorySlotConfig {
                        item_type: ItemType::Weapon,
                        world_side: Some(WorldSide::Real),
                    },
                ],
            },
        ];
        let fantasy_template = config
            .items
            .iter()
            .find(|template| {
                template.item_type == ItemType::Weapon
                    && template.world_side == Some(WorldSide::Fantasy)
            })
            .expect("test config must contain a Fantasy weapon");
        let mut character = CharacterState::default();
        character.character.current_chapter_level = 2;
        character.inventory.push(Item {
            id: Uuid::now_v7(),
            item_template_id: fantasy_template.id,
            item_type: fantasy_template.item_type,
            world_side: fantasy_template.world_side,
            is_equipped: true,
            ..Default::default()
        });

        let selected_before_unlock = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap();
        assert!(
            selected_before_unlock.is_none(),
            "the locked Real half must not count as an empty guaranteed slot"
        );

        character.character.current_chapter_level = 3;
        let selected_id = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap()
        .expect("the empty Real weapon slot must be selected");
        let selected = config
            .items
            .iter()
            .find(|template| template.id == selected_id)
            .unwrap();

        assert_eq!(selected.item_type, ItemType::Weapon);
        assert_eq!(selected.world_side, Some(WorldSide::Real));
    }

    #[test]
    fn first_empty_slot_respects_gloves_before_gated_legs() {
        let mut config = configs::tests_game_config::generate_game_config_for_tests();
        let mut fantasy_gloves = config
            .items
            .iter()
            .find(|template| template.item_type == ItemType::Gloves)
            .unwrap()
            .clone();
        fantasy_gloves.id = Uuid::now_v7();
        fantasy_gloves.world_side = Some(WorldSide::Fantasy);
        config.items.push(fantasy_gloves);
        config.inventory_levels = vec![
            essences::item_case::InventoryLevel {
                from_chapter_level: 0,
                slots: vec![InventorySlotConfig {
                    item_type: ItemType::Gloves,
                    world_side: Some(WorldSide::Fantasy),
                }],
            },
            essences::item_case::InventoryLevel {
                from_chapter_level: 6,
                slots: vec![
                    InventorySlotConfig {
                        item_type: ItemType::Gloves,
                        world_side: Some(WorldSide::Fantasy),
                    },
                    InventorySlotConfig {
                        item_type: ItemType::Legs,
                        world_side: None,
                    },
                ],
            },
        ];

        let mut character = CharacterState::default();
        let selected_id = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap()
        .expect("the chapter-zero Gloves slot must be selected");
        assert_eq!(
            config
                .items
                .iter()
                .find(|template| template.id == selected_id)
                .unwrap()
                .item_type,
            ItemType::Gloves
        );

        character.inventory.extend(
            config
                .items
                .iter()
                .filter(|template| template.item_type == ItemType::Gloves)
                .map(|template| Item {
                    id: Uuid::now_v7(),
                    item_template_id: template.id,
                    item_type: template.item_type,
                    world_side: template.world_side,
                    is_equipped: true,
                    ..Default::default()
                }),
        );

        let selected_before_legs_unlock = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap();
        assert!(
            selected_before_legs_unlock.is_none(),
            "the locked Legs slot must not receive a guaranteed chest item"
        );

        character.character.current_chapter_level = 6;
        let selected_id = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap()
        .expect("the Legs slot must become eligible at chapter six");
        assert_eq!(
            config
                .items
                .iter()
                .find(|template| template.id == selected_id)
                .unwrap()
                .item_type,
            ItemType::Legs
        );
    }

    /// A batch open must not hand out the same guaranteed item once per open.
    /// Items already rolled earlier in the batch, and items sitting unequipped
    /// in the bag, both count as filling their slot.
    #[test]
    fn first_empty_slot_counts_pending_and_bagged_items() {
        let mut config = configs::tests_game_config::generate_game_config_for_tests();
        config.inventory_levels = vec![essences::item_case::InventoryLevel {
            from_chapter_level: 0,
            slots: vec![
                InventorySlotConfig {
                    item_type: ItemType::Weapon,
                    world_side: Some(WorldSide::Fantasy),
                },
                InventorySlotConfig {
                    item_type: ItemType::Weapon,
                    world_side: Some(WorldSide::Real),
                },
            ],
        }];

        let bagged_item = |config: &GameConfig, template_id: Uuid| {
            let template = config
                .items
                .iter()
                .find(|template| template.id == template_id)
                .unwrap();
            Item {
                id: Uuid::now_v7(),
                item_template_id: template.id,
                item_type: template.item_type,
                world_side: template.world_side,
                is_equipped: false,
                ..Default::default()
            }
        };

        let mut character = CharacterState::default();
        let first = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap()
        .expect("the empty Fantasy weapon slot must be selected");

        // Second roll of the same batch: the first item is not in the
        // inventory yet, but its slot is already covered.
        let pending = vec![bagged_item(&config, first)];
        let second = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &pending,
        })
        .unwrap()
        .expect("the second open of the batch must move on to the Real weapon slot");
        assert_ne!(
            first, second,
            "a batch open must not repeat the same guaranteed item"
        );

        let pending = vec![bagged_item(&config, first), bagged_item(&config, second)];
        assert!(
            chest_item_choose(&ChestItemChooseCtx {
                character: &character,
                config: &config,
                lookups: &ContentLookups::default(),
                pending_items: &pending,
            })
            .unwrap()
            .is_none(),
            "once the batch covers every slot the rest must roll by weights"
        );

        // Next chest open: the first item is in the bag, still unequipped.
        character.inventory.push(bagged_item(&config, first));
        let after_bagged = chest_item_choose(&ChestItemChooseCtx {
            character: &character,
            config: &config,
            lookups: &ContentLookups::default(),
            pending_items: &[],
        })
        .unwrap()
        .expect("the still-empty Real weapon slot must be selected");
        assert_eq!(
            second, after_bagged,
            "an unequipped item in the bag must count as filling its slot"
        );
    }
}