configs/

stones.rs

//! Trigger/Effect Stone configuration — the catalog and every tunable the
//! runtime reads.
//!
//! Everything the runtime needs is here and editable from the LiveOps panel:
//! the per-template gauge gain (BAL-027), the one global trigger cooldown, the
//! `(trigger tier × effect tier)` coefficient matrix, the socket unlock
//! schedule, and the per-kill drop chance.

use essences::items::{AttributeId, ItemType};
use essences::stones::{StoneKind, StoneSocketSlot, StoneTemplateId, StoneTier};
use schema_loader::attribute_link_id_schema;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use tsify_next::Tsify;

/// Condition shape of a Trigger Stone. The numeric parameter (streak length,
/// counter period, percentage) lives in
/// [`TriggerStoneTemplate::condition_value`] and the time window in
/// [`TriggerStoneTemplate::condition_window_ticks`], so a designer retunes a
/// trigger without a code change.
///
/// Triggers subscribe to Core combat outcomes only
/// ([`essences::combat_origin::CombatEventOrigin`]).
///
/// Basic Attack is the most frequent Core event, so there is no plain "on every
/// attack" condition — the common tier counts (`EveryNthBasicAttack`) instead.
///
/// The variants map 1:1 onto the design catalog:
///
/// * `EveryNthBasicAttack` — `TR-C01`: every `condition_value`-th Basic Attack.
/// * `EveryNthHitTaken` — `TR-C02`: every `condition_value`-th Core hit on the hero.
/// * `SkillManaAtMost` — `TR-C03`: an original Skill that cost ≤ `condition_value` mana.
/// * `EveryNthSkillCast` — `TR-C04`: every `condition_value`-th original Skill Cast.
/// * `EveryNthDefeat` — `TR-C05`: every `condition_value`-th enemy killed by a Core action.
/// * `FirstAttackAfterSkill` — `TR-C06`: the first Basic Attack after an original Skill Cast.
/// * `OnSkillCast` — `TR-R01`: every original Skill Cast.
/// * `OnCrit` — `TR-R02`: every Core Critical Hit.
/// * `OnDefeat` — `TR-R03`: a Core action killed an enemy.
/// * `SkillHitsAtLeastTargets` — `TR-R04`: an original Skill that reached ≥ `condition_value` targets.
/// * `SkillDiffersFromPrevious` — `TR-R05`: an original Skill different from the previous one.
/// * `CritAfterNonCrit` — `TR-R06`: a Core Critical Hit straight after a Core non-critical hit.
/// * `OnEvasion` — `TR-E01`: every Core Dodge.
/// * `SkillManaAtLeast` — `TR-E02`: an original Skill that cost ≥ `condition_value` mana.
/// * `HpCrossedBelowPercent` — `TR-E03`: HP crossed `condition_value`% downwards, once per phase.
/// * `OnCritStreak` — `TR-E04` / `TR-L01`: `condition_value` Core Critical Hits in a row.
/// * `DistinctSkillsWithin` — `TR-E05`: `condition_value` different original Skills within `condition_window_ticks`.
/// * `SurvivedBigHitPercent` — `TR-E06`: one Core hit took ≥ `condition_value`% of Max HP and the hero lived.
/// * `DodgesWithin` — `TR-L02`: `condition_value` Core Dodges within `condition_window_ticks`.
/// * `AllEquippedSkillsCastThisPhase` — `TR-L03`: every equipped Skill cast at least once this phase.
/// * `SkillAttackSkillWithin` — `TR-L04`: original Skill → Basic Attack → *different* original Skill within `condition_window_ticks`.
/// * `SkillsWithoutDamageTaken` — `TR-L05`: `condition_value` original Skills in a row with no Core damage taken.
/// * `SkillBelowHpPercent` — `TR-L06`: an original Skill cast below `condition_value`% HP, hero survived the action.
///
/// Variant docs live here rather than on the variants themselves: a documented
/// variant makes the admin schema generate a `oneOf` of one-value enums instead
/// of a plain picker.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum TriggerCondition {
    EveryNthBasicAttack,
    EveryNthHitTaken,
    SkillManaAtMost,
    EveryNthSkillCast,
    EveryNthDefeat,
    FirstAttackAfterSkill,
    OnSkillCast,
    OnCrit,
    OnDefeat,
    SkillHitsAtLeastTargets,
    SkillDiffersFromPrevious,
    CritAfterNonCrit,
    OnEvasion,
    SkillManaAtLeast,
    HpCrossedBelowPercent,
    OnCritStreak,
    DistinctSkillsWithin,
    SurvivedBigHitPercent,
    DodgesWithin,
    AllEquippedSkillsCastThisPhase,
    SkillAttackSkillWithin,
    SkillsWithoutDamageTaken,
    SkillBelowHpPercent,
    /// BAL-027 `Battle Rhythm`: fires every `condition_value` ms of fight
    /// clock while a living hostile exists — a metronome, not an event
    /// reaction.
    OnInterval,
}

impl TriggerCondition {
    /// Whether the condition reads the mana cost of one specific cast.
    ///
    /// Whether this condition prices the cast off the per-cast mana cost the
    /// pool actually charged (`TR-C03` Cheap Skill, `TR-E02` Big Spend).
    /// Implemented since the mana wiring — kept as the explicit list of which
    /// conditions read the pool.
    pub const fn needs_mana(self) -> bool {
        matches!(self, Self::SkillManaAtMost | Self::SkillManaAtLeast)
    }

    /// Whether the condition is defined over a time window and therefore needs
    /// a positive [`TriggerStoneTemplate::condition_window_ticks`].
    pub const fn needs_window(self) -> bool {
        matches!(
            self,
            Self::DistinctSkillsWithin | Self::DodgesWithin | Self::SkillAttackSkillWithin
        )
    }
}

/// Action shape of an Effect Stone. The magnitudes, the duration and the charge
/// count are separate config fields for the same reason as [`TriggerCondition`].
///
/// Everything an action produces lands as
/// [`essences::combat_origin::CombatEventOrigin::Proc`], so no effect can
/// re-enter a trigger. Several catalog entries share an action and differ only
/// in numbers (`charges`, `magnitude`, `secondary_magnitude`).
///
/// * `InstantDamage` — `EF-C01`: derived damage worth `magnitude`% of Attack to the current target.
/// * `InstantDamageAll` — `EF-C02` / `EF-L01`: the same to every living enemy.
/// * `HealMaxHpPercent` — `EF-C03` / `EF-L07`: restore `magnitude`% of Max HP.
/// * `NextHitTakenReduction` — `EF-C04`: the next `charges` Core hits taken deal `magnitude`% less.
/// * `NextAttackDamageBonus` — `EF-C05` / `EF-R06` / `EF-E07`: the next `charges` Basic Attacks deal `magnitude`% more.
/// * `NextAttackCritChance` — `EF-C06`: the next `charges` Core Attacks get `+magnitude`% Crit Chance.
/// * `SkillCooldownReduction` — `EF-C07` / `EF-E05`: the `charges` longest remaining Skill cooldowns lose `magnitude` ticks.
/// * `NextSkillPayloadBonus` — `EF-C08` / `EF-L08`: the next `charges` original Skills deal `magnitude`% more.
/// * `AttackSpeedBuff` — `EF-R01`: `+magnitude`% Attack Speed for `duration_ticks`.
/// * `CritChanceBuff` — `EF-R02`: `+magnitude`% Crit Chance for `duration_ticks`.
/// * `SkillPayloadBuff` — `EF-R03`: `+magnitude`% original Skill payload for `duration_ticks`.
/// * `IncomingDamageReduction` — `EF-R04`: `−magnitude`% incoming damage for `duration_ticks`.
/// * `LifestealBuff` — `EF-R05`: `magnitude`% of Core damage heals the hero for `duration_ticks`.
/// * `CooldownRecoveryBuff` — `EF-R07`: every Skill cooldown recovers `magnitude`% faster for `duration_ticks`.
/// * `NextSkillSplash` — `EF-R08`: the next `charges` original Skills additionally hit every enemy for `magnitude`% of Attack.
/// * `NextSkillSplitCopies` — `EF-E08`: the next original Skill spreads derived copies worth `magnitude`% of **its own landed payload** onto at most `charges` additional targets.
/// * `NextSkillEchoCopies` — `EF-E01` / `EF-L02`: the next original Skill gets `charges` derived copies, at `magnitude`% and `secondary_magnitude`% of Attack.
/// * `NextAttackDerivedHits` — `EF-E02`: the next Basic Attack adds `charges` derived hits of `magnitude`% of Attack.
/// * `OrbitingProjectiles` — `EF-E03`: `charges` derived projectiles of `magnitude`% of Attack spread over `duration_ticks`.
/// * `DelayedRepeat` — `EF-E04`: after `duration_ticks`, derived damage worth `magnitude`% of Attack. The repeat never repeats itself.
/// * `NextHitBlockedRetaliation` — `EF-E06`: the next `charges` Core hits are blocked; each retaliates for `magnitude`% of Attack.
/// * `NextAttacksSplash` — `EF-L03`: the next `charges` Basic Attacks additionally hit every enemy for `magnitude`% of Attack.
/// * `ResetSkillCooldowns` — `EF-L04`: every Skill becomes ready.
/// * `DamageFloorGuard` — `EF-L05`: for `duration_ticks` Core damage cannot drop the hero below 1 HP.
/// * `DamageDealtBuff` — `EF-L06`: `+magnitude`% Basic Attack and Skill payload for `duration_ticks`.
/// * `GaugeFill` — adds `magnitude` straight to the flip gauge.
/// * `Shield` — a shield worth `magnitude`% of Max HP for `duration_ticks`.
/// * `AttackSpeedMultiplier` — Attack Speed × `magnitude` for `duration_ticks`.
/// * `NextAttackDoubleHit` — the next cast makes `magnitude` real swings instead of one.
///
/// Variant docs live here rather than on the variants themselves: a documented
/// variant makes the admin schema generate a `oneOf` of one-value enums instead
/// of a plain picker.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum EffectStoneAction {
    NextAttackDamageBonus,
    GaugeFill,
    InstantDamage,
    CritChanceBuff,
    AttackSpeedBuff,
    Shield,
    AttackSpeedMultiplier,
    NextAttackDoubleHit,
    InstantDamageAll,
    HealMaxHpPercent,
    NextHitTakenReduction,
    NextAttackCritChance,
    SkillCooldownReduction,
    NextSkillPayloadBonus,
    SkillPayloadBuff,
    IncomingDamageReduction,
    LifestealBuff,
    CooldownRecoveryBuff,
    NextSkillSplash,
    NextSkillSplitCopies,
    NextSkillEchoCopies,
    NextAttackDerivedHits,
    OrbitingProjectiles,
    DelayedRepeat,
    NextHitBlockedRetaliation,
    NextAttacksSplash,
    ResetSkillCooldowns,
    DamageFloorGuard,
    DamageDealtBuff,
}

impl EffectStoneAction {
    /// Whether the action leaves a state behind and therefore needs a positive
    /// [`EffectStoneTemplate::duration_ticks`]. A timed action with a zero
    /// duration would never expire, so `GameConfig::validate_stones` refuses it
    /// rather than letting the runtime strand a permanent stat.
    pub const fn needs_duration(self) -> bool {
        matches!(
            self,
            Self::CritChanceBuff
                | Self::AttackSpeedBuff
                | Self::Shield
                | Self::AttackSpeedMultiplier
                | Self::SkillPayloadBuff
                | Self::IncomingDamageReduction
                | Self::LifestealBuff
                | Self::CooldownRecoveryBuff
                | Self::OrbitingProjectiles
                | Self::DelayedRepeat
                | Self::DamageFloorGuard
                | Self::DamageDealtBuff
        )
    }

    /// Whether the action is spent over a countable number of uses, hits or
    /// copies and therefore needs a positive [`EffectStoneTemplate::charges`].
    pub const fn needs_charges(self) -> bool {
        matches!(
            self,
            Self::NextHitTakenReduction
                | Self::NextAttackDamageBonus
                | Self::NextAttackCritChance
                | Self::SkillCooldownReduction
                | Self::NextSkillPayloadBonus
                | Self::NextSkillSplash
                | Self::NextSkillSplitCopies
                | Self::NextSkillEchoCopies
                | Self::NextAttackDerivedHits
                | Self::OrbitingProjectiles
                | Self::NextHitBlockedRetaliation
                | Self::NextAttacksSplash
        )
    }
}

/// One plain passive stat a stone grants while it is socketed.
///
/// Both catalogs carry a list of these, so a stone is worth something the
/// moment it goes into a socket, before any trigger fires. The attribute is the
/// same [`essences::items::AttributeId`] items, pets and the statue use.
///
/// Rules the aggregation depends on: only a socketed stone grants its stats; a
/// slot's Real and Fantasy effect stones both contribute at once, so
/// `active_side` is not read here and a flip never moves Power; level scaling
/// is `value + value_per_level * (level - 1)`.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StoneStat {
    #[schemars(title = "Id атрибута", schema_with = "attribute_link_id_schema")]
    pub attribute_id: AttributeId,

    #[schemars(title = "Базовое значение")]
    pub value: i64,

    #[schemars(title = "Прибавка за уровень прокачки")]
    pub value_per_level: i64,
}

impl StoneStat {
    /// The stat's value on a stone of upgrade level `level`. Level 1 (and any
    /// nonsense below it) is the base value.
    pub const fn value_at_level(&self, level: i64) -> i64 {
        let levels_above_first = if level > 1 { level - 1 } else { 0 };
        self.value + self.value_per_level * levels_above_first
    }
}

/// One entry of the Trigger Stone catalog.
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Tsify, i18n::Translate)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct TriggerStoneTemplate {
    #[schemars(schema_with = "schema_loader::id_schema")]
    pub id: StoneTemplateId,

    #[schemars(title = "Название")]
    #[translate]
    pub name: i18n::I18nString,

    #[schemars(title = "Описание")]
    #[translate]
    pub description: i18n::I18nString,

    /// Tier drives the gauge weight and the shape of the condition — not how
    /// hard the stone is to farm.
    #[schemars(title = "Тир")]
    pub tier: StoneTier,

    #[schemars(title = "Условие срабатывания")]
    pub condition: TriggerCondition,

    /// Numeric parameter of the condition: streak length, counter period,
    /// target count or percentage, depending on [`Self::condition`]. `0` for
    /// the conditions that take no number.
    #[schemars(
        title = "Параметр условия",
        description = "Длина серии, период счётчика, число целей или проценты — смотря какое условие. Для условий без числа — 0."
    )]
    pub condition_value: i64,

    /// Length of the window the condition is defined over, in ticks
    /// (milliseconds). Positive exactly for the three windowed conditions
    /// (`TriggerCondition::needs_window`), `0` for every other trigger —
    /// `GameConfig::validate_stones` enforces the pairing.
    #[schemars(
        title = "Окно условия, тики",
        description = "Только для условий «за N секунд» (три разных скилла за 6 с и т.п.). Для остальных — 0."
    )]
    pub condition_window_ticks: u64,

    /// BAL-027: this trigger's own Flip-gauge award per successful fire. The
    /// tier-wide ladder is gone — a reliable condition earns less per proc, a
    /// rare once-per-phase one earns more, and tier by itself grants nothing.
    #[schemars(
        title = "Вклад в шкалу флипа за срабатывание",
        description = "Собственная награда шкалы этого триггера. Частые условия получают меньше за прок, редкие — больше; тир сам по себе ничего не даёт."
    )]
    pub gauge_gain: f64,

    /// Whether the runtime evaluates this trigger at all.
    ///
    /// A switched-off trigger stays in config and in the UI catalog, but is
    /// never evaluated, never fires and never contributes to the gauge — the
    /// designer's switch for content that should wait.
    #[schemars(
        title = "Триггер активен",
        description = "Выключенный триггер не проверяется и не срабатывает. Камень остаётся в каталоге — так выключают контент, которому ещё рано."
    )]
    pub active: bool,

    /// Passive stats granted while this stone sits in a socket, on top of what
    /// its condition does. A trigger's upgrade level scales these — which is,
    /// today, the only thing a trigger's level does.
    #[schemars(title = "Статы камня")]
    pub stats: Vec<StoneStat>,

    #[schemars(
        title = "Иконка",
        schema_with = "schema_loader::asset_trigger_stone_icon_schema"
    )]
    pub icon_path: String,

    #[schemars(
        title = "Ожидаемая частота срабатываний, раз в секунду",
        description = "Авторская оценка частоты условия в подходящем билде. Питает оценку Power (BAL-030) и ничего не меняет в бою."
    )]
    pub power_proc_rate: f64,
}

/// One entry of the Effect Stone catalog.
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Tsify, i18n::Translate)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct EffectStoneTemplate {
    #[schemars(schema_with = "schema_loader::id_schema")]
    pub id: StoneTemplateId,

    #[schemars(title = "Название")]
    #[translate]
    pub name: i18n::I18nString,

    #[schemars(title = "Описание")]
    #[translate]
    pub description: i18n::I18nString,

    #[schemars(title = "Тир")]
    pub tier: StoneTier,

    #[schemars(title = "Действие")]
    pub action: EffectStoneAction,

    /// Magnitude of the action at upgrade level 1, in the action's own unit
    /// (percent, flat gauge points, multiplier).
    #[schemars(title = "Базовая величина эффекта")]
    pub magnitude: f64,

    /// Added to `magnitude` per upgrade level above 1. The first copy already
    /// carries the whole mechanic; an upgrade only scales the number.
    #[schemars(title = "Прибавка величины за уровень прокачки")]
    pub magnitude_per_level: f64,

    /// Second number a few actions need: the weaker copy of `EF-L02`, and any
    /// future two-number action. `0.0` when the action takes one number.
    #[schemars(
        title = "Вторая величина эффекта",
        description = "Нужна эффектам с двумя числами (например, вторая, более слабая копия скилла). Иначе 0."
    )]
    pub secondary_magnitude: f64,

    /// How many uses, hits, copies or targets the action is spent over.
    /// Positive exactly for the charge-based actions
    /// (`EffectStoneAction::needs_charges`), `0` for the rest —
    /// `GameConfig::validate_stones` enforces the pairing.
    #[schemars(
        title = "Число зарядов эффекта",
        description = "Сколько применений/ударов/копий тратит эффект. Для эффектов без зарядов — 0."
    )]
    pub charges: i64,

    /// How long the state the action leaves behind lasts; `0` for instant
    /// actions.
    #[schemars(title = "Длительность состояния, тики")]
    pub duration_ticks: u64,

    /// Passive stats granted while this stone sits in a socket, independently
    /// of whether its side is the active one — both the Real and the Fantasy
    /// effect stone of a slot grant theirs at all times.
    #[schemars(title = "Статы камня")]
    pub stats: Vec<StoneStat>,

    #[schemars(
        title = "Иконка",
        schema_with = "schema_loader::asset_effect_stone_icon_schema"
    )]
    pub icon_path: String,

    #[schemars(
        title = "Базовый множитель Power на первом ранге",
        description = "Вклад эффекта в Power при эталонной частоте триггера (BAL-030), до масштабирования частотой и матрицей тиров."
    )]
    pub power_q_base_first_rank: f64,

    #[schemars(
        title = "Базовый множитель Power на максимальном ранге",
        description = "То же значение на последнем ранге камня; промежуточные ранги интерполируются линейно по ln(q)."
    )]
    pub power_q_base_max_rank: f64,
}

/// One cell of the `(trigger tier × effect tier) → effect power multiplier`
/// matrix.
///
/// The design doc and the working chat disagree about whether a tier gap should
/// strengthen or weaken the effect. The matrix implements the doc — every cell
/// `1.0`, i.e. no such mechanic — while making the chat's version a pure config
/// edit. Legality is never affected: any effect fits any trigger.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StoneTierCoefficient {
    #[schemars(title = "Тир триггера")]
    pub trigger_tier: StoneTier,
    #[schemars(title = "Тир эффекта")]
    pub effect_tier: StoneTier,
    #[schemars(title = "Множитель силы эффекта")]
    pub multiplier: f64,
}

/// When one socket opens. Sockets open gradually — one piece of gear at a time
/// — modelled on `FlipSettings.unlock_chapter`.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StoneSocketUnlock {
    #[schemars(title = "Слот экипировки")]
    pub item_type: ItemType,
    #[schemars(title = "Сокет")]
    pub socket: StoneSocketSlot,
    #[schemars(title = "Глава разблокировки")]
    pub unlock_chapter: i64,
}

/// One rung of the upgrade ladder: how many raw copies it costs to reach
/// `level`.
///
/// Copies are counted, not levelled: a copy of any level is worth exactly one
/// copy, so a level-1 copy still advances a level-3 stone. `copies` excludes
/// the stone being upgraded — it is what gets consumed on top of it.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StoneUpgradeStep {
    // The ladder starts at 2 (level 1 is the first copy, which is free by
    // definition) and must run to [`StonesSettings::max_stone_level`] without a
    // gap — `GameConfig::validate_stones` enforces exactly that, so an
    // unreachable level cannot ship.
    #[schemars(
        title = "Уровень, который покупается",
        description = "Лестница начинается со 2-го уровня и должна доходить до максимального уровня камня без пропусков."
    )]
    pub level: i64,

    /// Raw copies consumed to reach [`Self::level`], not counting the stone
    /// itself.
    #[schemars(
        title = "Сколько сырых копий нужно",
        description = "Копии считаются штуками: уровень копии не важен, копия любого уровня стоит одну штуку. Сам прокачиваемый камень в это число не входит."
    )]
    pub copies: i64,
}

/// Where Trigger/Effect stones come from: **enemy kills**.
///
/// They used to ride the item-chest open, which was marked temporary for a
/// reason — it tied the stone faucet to a purchased channel, so a whale opening
/// ~26k chests a day drew two orders of magnitude more stones than a player who
/// fought for them. The acquisition pass moved the faucet onto the kill path,
/// where the cores currency and the law copies already live, and scaled the
/// chance up for the rarer event (see `stones_settings/_data.yaml`).
///
/// Like every other per-kill payout the roll is scaled by the dead mob's
/// `wave_share`, so an inflated wave does not inflate the faucet.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StoneKillDropSettings {
    #[schemars(
        title = "Шанс дропа камня с убийства моба",
        description = "Доля в [0,1], домножается на wave_share убитого моба."
    )]
    pub chance: f64,

    #[schemars(
        title = "Доля Trigger-камней среди дропа",
        description = "Остальная часть дропа приходится на Effect-камни."
    )]
    pub trigger_share: f64,
}

/// One rarity rung of the equipment-stone drop roll (BAL-012, released with
/// BAL-031's roll order).
///
/// The signed order is `50/50` kind → **this** rarity step → uniform inside the
/// drawn tier. Weights are relative, not percentages: the roll normalizes by
/// their sum, so authoring `55/25/15/5` and `11/5/3/1` behave identically.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StoneRarityWeight {
    #[schemars(title = "Тир камня")]
    pub tier: StoneTier,

    #[schemars(
        title = "Относительный вес тира",
        description = "Веса относительные: ролл нормируется на их сумму, поэтому 55/25/15/5 и 11/5/3/1 эквивалентны."
    )]
    pub weight: f64,
}

/// All Trigger/Effect Stone tunables.
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct StonesSettings {
    /// One trigger cooldown for the whole build, not per slot. A Core event
    /// checks all five socketed triggers at once, every matching one fires,
    /// then this cooldown runs; a condition that comes true while it runs is
    /// lost and the sequence counter behind it restarts.
    ///
    /// It is the only rate limit the mechanic has — it bounds a five-Legendary
    /// build to `5 × 8 = 40` gauge per window.
    #[schemars(
        title = "Общий кулдаун триггеров, тики",
        description = "Один кулдаун на весь билд, отсчитывается от успешного срабатывания. Не сбрасывается флипом, не масштабируется скоростью атаки и не обходится ни одним эффектом."
    )]
    pub global_trigger_cooldown_ticks: u64,

    #[schemars(title = "Матрица коэффициентов «тир триггера × тир эффекта»")]
    pub tier_coefficients: Vec<StoneTierCoefficient>,

    /// BAL-012: the rarity step of the kill-drop roll. One row per
    /// [`StoneTier`], checked by `GameConfig::validate_stones`.
    #[schemars(title = "Веса редкостей в дропе камней")]
    pub rarity_weights: Vec<StoneRarityWeight>,

    #[schemars(title = "Расписание открытия сокетов")]
    pub socket_unlocks: Vec<StoneSocketUnlock>,

    /// Cost of every level above the first, in raw copies. One rung per level
    /// in `2..=max_stone_level`, no gaps (`GameConfig::validate_stones`).
    ///
    /// Triggers and effects read the same ladder but never share copies: a
    /// copy is a copy of one catalog entry, and the two catalogs share no ids.
    #[schemars(title = "Лестница прокачки: сырых копий за уровень")]
    pub upgrade_ladder: Vec<StoneUpgradeStep>,

    #[schemars(title = "Максимальный уровень камня")]
    pub max_stone_level: i64,

    #[schemars(title = "Дроп камней с убийства мобов")]
    pub kill_drop: StoneKillDropSettings,

    /// BAL-024/BAL-025: guaranteed one-time packages at the equipment item
    /// gates. Reaching `chapter` guarantees OWNERSHIP of every listed
    /// template — a missing one is granted as a single copy, an already owned
    /// one is left alone, so the check is idempotent and never inflates
    /// recurring drops.
    #[schemars(
        title = "Гарантированные наборы камней по главам",
        description = "Достигнув главы, персонаж гарантированно владеет каждым перечисленным камнем: недостающие выдаются одной копией, уже имеющиеся не трогаются."
    )]
    pub milestone_grants: Vec<StoneMilestoneGrant>,
}

/// One guaranteed package: the stones a character must own from `chapter` on.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct StoneMilestoneGrant {
    #[schemars(title = "Глава выдачи")]
    pub chapter: i64,

    #[schemars(
        title = "Гарантированные триггер-камни",
        schema_with = "schema_loader::trigger_stone_link_id_array_schema"
    )]
    pub trigger_stones: Vec<StoneTemplateId>,

    #[schemars(
        title = "Гарантированные камни-эффекты",
        schema_with = "schema_loader::effect_stone_link_id_array_schema"
    )]
    pub effect_stones: Vec<StoneTemplateId>,
}

impl StonesSettings {
    /// Whether `socket` on `item_type` is open at `chapter_level`. An
    /// unscheduled socket never opens — the config carries all 15 entries and
    /// `GameConfig::validate` enforces that, so this is a safety net, not a
    /// reachable state.
    pub fn is_socket_unlocked(
        &self,
        item_type: ItemType,
        socket: StoneSocketSlot,
        chapter_level: i64,
    ) -> bool {
        self.socket_unlocks
            .iter()
            .find(|unlock| unlock.item_type == item_type && unlock.socket == socket)
            .is_some_and(|unlock| chapter_level >= unlock.unlock_chapter)
    }

    /// Effect power multiplier for a `(trigger, effect)` tier pair. `1.0` when
    /// the pair is missing, which is also the shipped value of every cell.
    pub fn tier_coefficient(&self, trigger_tier: StoneTier, effect_tier: StoneTier) -> f64 {
        self.tier_coefficients
            .iter()
            .find(|cell| cell.trigger_tier == trigger_tier && cell.effect_tier == effect_tier)
            .map_or(1.0, |cell| cell.multiplier)
    }

    /// Raw copies needed to take a stone **to** `target_level`, not counting
    /// the stone itself.
    ///
    /// `None` means the ladder has no rung for that level — either the stone is
    /// already at the cap or the config has a gap. `GameConfig::validate_stones`
    /// rules the gap out at load time, so a live `None` is the cap.
    pub fn upgrade_copies_required(&self, target_level: i64) -> Option<i64> {
        self.upgrade_ladder
            .iter()
            .find(|step| step.level == target_level)
            .map(|step| step.copies)
    }

    /// Which collection the drop roll `roll` (in `[0, 1)`) produces.
    pub fn dropped_kind(&self, roll: f64) -> StoneKind {
        if roll < self.trigger_share_clamped() {
            StoneKind::Trigger
        } else {
            StoneKind::Effect
        }
    }

    fn trigger_share_clamped(&self) -> f64 {
        self.kill_drop.trigger_share.clamp(0.0, 1.0)
    }

    /// Which rarity the drop roll `roll` (in `[0, 1)`) produces.
    ///
    /// `roll` is a fraction of the weight SUM, so the rows stay relative and a
    /// designer can retune one tier without rebalancing the rest to 100.
    /// Negative weights are floored at zero; an all-zero table degenerates to
    /// the first row rather than dropping nothing.
    pub fn dropped_tier(&self, roll: f64) -> StoneTier {
        let total: f64 = self
            .rarity_weights
            .iter()
            .map(|row| row.weight.max(0.0))
            .sum();
        let first = self
            .rarity_weights
            .first()
            .map_or(StoneTier::Common, |row| row.tier);
        if total <= 0.0 {
            return first;
        }
        let mut cursor = roll.clamp(0.0, 1.0) * total;
        for row in &self.rarity_weights {
            cursor -= row.weight.max(0.0);
            if cursor < 0.0 {
                return row.tier;
            }
        }
        // Only reachable on float drift at roll ~= 1.0.
        self.rarity_weights.last().map_or(first, |row| row.tier)
    }
}

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

    fn stat(value: i64, per_level: i64) -> StoneStat {
        StoneStat {
            attribute_id: uuid::Uuid::from_u128(1),
            value,
            value_per_level: per_level,
        }
    }

    /// Same shape as `mechanics::stones::effect_magnitude`: level 1 is the base
    /// value, every level above it adds `value_per_level` once.
    #[test]
    fn a_stat_scales_by_upgrade_level_like_effect_magnitude_does() {
        let stat = stat(100, 25);
        assert_eq!(stat.value_at_level(1), 100);
        assert_eq!(stat.value_at_level(2), 125);
        assert_eq!(stat.value_at_level(5), 200);
    }

    /// A level below 1 is not a real state, but it must not subtract.
    #[test]
    fn a_nonsense_level_reads_as_the_base_value() {
        let stat = stat(100, 25);
        assert_eq!(stat.value_at_level(0), 100);
        assert_eq!(stat.value_at_level(-3), 100);
    }

    fn ladder_settings(ladder: Vec<StoneUpgradeStep>) -> StonesSettings {
        StonesSettings {
            global_trigger_cooldown_ticks: 1_000,
            tier_coefficients: Vec::new(),
            rarity_weights: Vec::new(),
            socket_unlocks: Vec::new(),
            upgrade_ladder: ladder,
            max_stone_level: 4,
            kill_drop: StoneKillDropSettings {
                chance: 0.0,
                trigger_share: 0.5,
            },
            milestone_grants: vec![],
        }
    }

    /// The cost of a level is read off the ladder, per level — not one flat
    /// count reused for every level (design §5).
    #[test]
    fn the_cost_of_a_level_comes_from_its_own_rung() {
        let settings = ladder_settings(vec![
            StoneUpgradeStep {
                level: 2,
                copies: 2,
            },
            StoneUpgradeStep {
                level: 3,
                copies: 3,
            },
            StoneUpgradeStep {
                level: 4,
                copies: 5,
            },
        ]);

        assert_eq!(settings.upgrade_copies_required(2), Some(2));
        assert_eq!(settings.upgrade_copies_required(3), Some(3));
        assert_eq!(settings.upgrade_copies_required(4), Some(5));
    }

    /// Level 1 is the first copy and is never bought, and there is no rung past
    /// the cap — both read as "no such upgrade".
    #[test]
    fn there_is_no_rung_for_level_one_or_past_the_cap() {
        let settings = ladder_settings(vec![StoneUpgradeStep {
            level: 2,
            copies: 2,
        }]);

        assert_eq!(settings.upgrade_copies_required(1), None);
        assert_eq!(settings.upgrade_copies_required(5), None);
    }

    /// Design v0.2 §10: exactly the two mana conditions are the ones the branch
    /// cannot evaluate. Every other §5 condition is implementable today, so
    /// nothing else may be shipped inactive.
    #[test]
    fn only_the_two_mana_conditions_need_mana() {
        use TriggerCondition::*;
        let needing: Vec<TriggerCondition> = [
            EveryNthBasicAttack,
            EveryNthHitTaken,
            SkillManaAtMost,
            EveryNthSkillCast,
            EveryNthDefeat,
            FirstAttackAfterSkill,
            OnSkillCast,
            OnCrit,
            OnDefeat,
            SkillHitsAtLeastTargets,
            SkillDiffersFromPrevious,
            CritAfterNonCrit,
            OnEvasion,
            SkillManaAtLeast,
            HpCrossedBelowPercent,
            OnCritStreak,
            DistinctSkillsWithin,
            SurvivedBigHitPercent,
            DodgesWithin,
            AllEquippedSkillsCastThisPhase,
            SkillAttackSkillWithin,
            SkillsWithoutDamageTaken,
            SkillBelowHpPercent,
        ]
        .into_iter()
        .filter(|c| c.needs_mana())
        .collect();
        assert_eq!(needing, vec![SkillManaAtMost, SkillManaAtLeast]);
    }
}