configs/

cores.rs

//! Balance knobs for the twin cores, their laws and the bridges between them
//! (OVT-2517). Every number here is a design placeholder — the vertical shipped
//! without a balance pass, on purpose.

use essences::currency::CurrencyId;
use essences::items::AttributeId;
use schema_loader::{attribute_link_id_array_schema, currency_link_id_schema};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use tsify_next::Tsify;

use crate::validated_types::{NonEmptyVec, PositiveF64, PositiveI64};

/// Cost of raising ONE core from `level - 1` to `level`. Shared by both cores:
/// the doc's «общая валюта прокачки» is one currency and one ladder.
///
/// The ladder starts at level 1, not 2: level 0 means "this core does not exist
/// yet" (the pre-feature character, plan §7.12), so buying level 1 is what
/// unlocks the core.
///
/// The table only has to cover the levels that OPEN SLOTS. Above the last
/// tabled level the cost is extended geometrically by
/// [`CoresSettings::level_cost_growth`] — that is what makes the core an
/// unbounded sink instead of a five-rung ladder.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct CoreLevelCost {
    #[schemars(title = "Уровень, до которого поднимаемся")]
    pub level: i64,

    #[schemars(title = "Стоимость в валюте ядра")]
    pub cost: PositiveI64,
}

/// Cost of raising ONE law from `level - 1` to `level`, paid in RAW COPIES of
/// that same law. The level of a copy is irrelevant — copies are stock.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct LawUpgradeStep {
    #[schemars(title = "Уровень, до которого поднимаемся")]
    pub level: i64,

    #[schemars(title = "Сколько копий нужно потратить")]
    pub required_copies: PositiveI64,
}

/// How a bridge turns delivered Resonance into Law Power (plan §3).
///
/// **Two numbers, not three.** Amplification used to be authored a third time as
/// "per delivered unit", tied to the other two by `capacity × per_unit == cap`.
/// That equality made `BL-03 Short Span` inexpressible — it moves capacity by
/// `−40%` and the cap by `−20%`, and no choice of leading parameter satisfies
/// the identity afterwards (post-merge plan §8). The per-unit field is gone and
/// amplification is now read as a share of how full the bridge is:
///
/// ```text
/// multiplier = delivered_units × amplification_cap / capacity
/// ```
///
/// Today's numbers are unchanged by the switch: a full bridge is
/// `10/10 × 50% = +50%`, half a bridge `5/10 × 50% = +25%` — exactly what
/// `5 × 5%` used to give. What is new is that the two knobs now move
/// independently, which is the whole content of the Bridge Law socket.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct BridgeChargeConfig {
    #[schemars(
        title = "Ёмкость заряда моста",
        description = "Резонанс сверх этого значения сгорает, как перелив шкалы флипа."
    )]
    pub capacity: PositiveI64,

    #[schemars(
        title = "Потолок усиления, перимириады",
        description = "5000 = +50% к числам эффекта получателя при полностью заполненном мосте. Промежуточные значения — доля от заполненности."
    )]
    pub amplification_cap_permyriad: PositiveI64,
}

/// PLACEHOLDER ECONOMY (plan §4): the core-upgrade currency drops off mobs and
/// nothing else. The real faucet is a separate design pass — when it lands,
/// this whole struct is expected to be replaced by proper drop tables, not
/// re-tuned.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct CoreCurrencyKillDrop {
    #[schemars(
        title = "Шанс дропа с убийства моба",
        description = "0..1. ЗАГЛУШКА: экономика ядер проектируется отдельно."
    )]
    pub chance: f64,

    #[schemars(title = "Сколько валюты падает за одно убийство")]
    pub amount: PositiveI64,
}

/// The lowest core level a player can BUY.
///
/// BAL-010 grants both cores at level 1 with the ch21 unlock, so the priced
/// ladder starts at 2 and the old level-1 cost of 700 is gone from the usable
/// path.
pub const CORE_FIRST_PURCHASABLE_LEVEL: i64 = 2;

/// BAL-010: the signed combat multiplier for the product `P` of the two core
/// levels — one symmetric continuous formula replacing the superseded bucket
/// table. `M_power = 1 + min(P/5, sqrt(P) − 0.2)`; the `P/5` arm rules the
/// early products, the `sqrt` arm takes over from `P ≈ 5` and keeps late
/// levels worth buying without exploding. `P ≤ 0` (a character without cores)
/// is exactly ×1.0, which is what keeps acceptance #14 ("no cores plays as
/// before") true by construction.
pub fn core_power_multiplier(product: i64) -> f64 {
    if product <= 0 {
        return 1.0;
    }
    let p = product as f64;
    1.0 + (p / 5.0).min(p.sqrt() - 0.2)
}

/// BAL-010: the PER-STAT multiplier, `M_stat = M_power^(1/2.75)`.
///
/// Displayed/combat power composes the multiplied stats back at roughly the
/// 2.75th power, so applying `M_stat` to each of HP/Attack/Armor makes the
/// character's POWER move by `M_power` — the doc's fix for the superseded
/// model, which applied the whole power multiplier to every stat separately
/// and overshot the intended strength several times over.
pub fn core_stat_multiplier(product: i64) -> f64 {
    core_power_multiplier(product).powf(1.0 / 2.75)
}

/// One chapter band of the A3 all-free Core Essence faucet. Its source rates
/// supersede BAL-010; the Core price ladder remains unchanged.
///
/// `r_value` is an AMOUNT, not a rate: the Essence a canonical campaign route
/// yields in one active hour inside this band. The active rate is
/// `r_value / hour`, the daily hard cap is `2 × r_value`, and the accelerator
/// packets (daily / weekly / AFK / Ratings) are all expressed as fractions of
/// it, so one number moves the whole band coherently.
///
/// Supply steps by REACHED CHAPTER, never by `min(core level)` — otherwise a
/// player who banked Essence without spending it would slow their own faucet.
#[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct CoreEssenceChapterBand {
    #[schemars(title = "Первая глава полосы")]
    pub from_chapter: i64,

    #[schemars(
        title = "R_value: Essence за активный час",
        description = "Количество, а не скорость. Дневной hard cap = 2 x R_value."
    )]
    pub r_value: f64,

    #[schemars(title = "Essence за одно успешное убийство")]
    pub packet: PositiveI64,

    #[schemars(
        title = "Базовый шанс до дневного затухания",
        description = "0..1. Рассчитан как R_value / (520 x packet) по каноническим ~520 raw eligible kills за 60 минут."
    )]
    pub base_chance: f64,
}

/// Everything tunable about cores, laws and bridges.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct CoresSettings {
    #[schemars(
        title = "Глава разблокировки ядер",
        description = "До этой главы ядра, законы и мосты недоступны."
    )]
    pub unlock_chapter: i64,

    /// The hard stop on core levels. **Effectively unbounded since the
    /// acquisition pass**: everything the level cap used to be coupled to now
    /// keys off [`Self::max_slot_level`] (`max_slots_per_core ×
    /// core_levels_per_slot`) instead, so levels above that open no slot, allow
    /// no extra bridge and only grow the stat multiplier.
    ///
    /// The history below explains why the SLOT ladder is what it is; it is no
    /// longer a statement about this field.
    ///
    /// The old pair (cap 10, a slot every 2 levels) came from the pre-v0.2 rule
    /// "a law sits in two bridges": possible bridges were `2 × slots`, so the
    /// allowed count only caught up at level 11, and the every-two-levels
    /// ladder existed solely to stretch 5 slots over that cap. Laws v0.2 cut a
    /// law to ONE partner, halving the possible count — and the limit stopped
    /// binding from level 4, which made `BL-01 Extra Span`'s "+1 bridge" half
    /// dead content. With one slot per level and a cap of 5: slots = level,
    /// possible = slots, allowed = level − 1 — exactly one short at every level,
    /// so the limit binds again and `BL-01` buys a bridge that has somewhere to
    /// go.
    ///
    /// The cost ladder covers the slot-opening levels and is EXTENDED past
    /// them by `level_cost_growth`; the stat multiplier is the closed
    /// [`core_stat_multiplier`] formula (see `cores_settings/_data.yaml`).
    #[schemars(
        title = "Максимальный уровень ядра",
        description = "Практически безграничен. Слоты, мосты и детерминированная выдача законов заканчиваются на уровне последнего слота; выше растёт только множитель."
    )]
    pub max_core_level: i64,

    /// The slot cap, and — through [`CoresSettings::max_slot_level`] — the
    /// level at which slots, bridges and the deterministic law schedule all
    /// stop moving.
    #[schemars(title = "Максимум слотов на ядро")]
    pub max_slots_per_core: i64,

    #[schemars(
        title = "Уровней ядра на один слот",
        description = "Слотов = min(ceil(уровень / N), максимум слотов). N = это значение."
    )]
    pub core_levels_per_slot: PositiveI64,

    #[schemars(
        title = "Валюта прокачки ядер",
        schema_with = "currency_link_id_schema"
    )]
    pub upgrade_currency_id: CurrencyId,

    #[schemars(
        title = "Эссенция при разблокировке ядер",
        description = "Одноразовая гарантированная выдача при первом переходе через главу разблокировки. Не начисляется задним числом."
    )]
    pub unlock_essence_grant: i64,

    #[schemars(title = "ЗАГЛУШКА: дроп валюты ядер с мобов")]
    /// SUPERSEDED by [`Self::essence_chapter_bands`] (BAL-010) and no longer
    /// read by the runtime. Kept only as the rollback shape — editing it has no
    /// effect on the live faucet.
    pub kill_drop: CoreCurrencyKillDrop,

    /// BAL-010: the signed Core Essence faucet. Supersedes the flat
    /// `kill_drop` placeholder above, which stays only as the rollback shape.
    ///
    /// Bands are checked in order and the LAST one whose `from_chapter` is at or
    /// below the reached chapter wins, so the final row is open-ended.
    #[schemars(title = "Полосы добычи эссенции ядра по главам")]
    pub essence_chapter_bands: Vec<CoreEssenceChapterBand>,

    /// PLACEHOLDER ECONOMY (plan §4): the plan leaves the law drop source
    /// explicitly unassigned and asks for an existing one to be picked and
    /// marked as a stand-in. The mob-kill path is that pick — one random law
    /// template at this chance per enemy killed.
    #[schemars(
        title = "ЗАГЛУШКА: шанс дропа копии закона с моба",
        description = "0..1. Источник дропа законов в плане НЕ НАЗНАЧЕН — это заглушка на существующем пути наград за убийство."
    )]
    pub law_drop_chance: f64,

    #[schemars(title = "Стоимость уровней ядра")]
    pub level_costs: NonEmptyVec<CoreLevelCost>,

    /// Geometric continuation of `level_costs` above its last tabled level:
    /// `cost(L) = last_tabled_cost × growth^(L − last_tabled_level)`.
    ///
    /// This is the whole of the unbounded sink. The tabled rows double
    /// (700 → 11 200), so anything at or below 2.0 continues the table's own
    /// shape; a value at the low end of that range keeps the post-slot levels
    /// reachable instead of decorative.
    #[schemars(
        title = "Рост стоимости уровня сверх таблицы",
        description = "Множитель к стоимости за каждый уровень выше последней строки таблицы. Именно он делает ядро бесконечным стоком."
    )]
    pub level_cost_growth: PositiveF64,

    #[schemars(
        title = "Атрибуты, на которые действует множитель ядер",
        description = "HP / атака / защита. Множитель применяется поверх статов от предметов.",
        schema_with = "attribute_link_id_array_schema"
    )]
    pub multiplied_attribute_ids: Vec<AttributeId>,

    #[schemars(title = "Лестница прокачки законов (в копиях)")]
    pub law_upgrade_ladder: NonEmptyVec<LawUpgradeStep>,

    #[schemars(title = "Заряд моста")]
    pub bridge_charge: BridgeChargeConfig,
}

impl CoresSettings {
    /// The band governing `chapter`: the last row whose `from_chapter` is at or
    /// below it, so the final row stays open-ended. `None` only when no band is
    /// authored at all or the player is below the first one — before the ch21
    /// gate no source hands out Essence, so that is a real state, not an error.
    pub fn essence_band(&self, chapter: i64) -> Option<&CoreEssenceChapterBand> {
        self.essence_chapter_bands
            .iter()
            .filter(|b| b.from_chapter <= chapter)
            .max_by_key(|b| b.from_chapter)
    }
}

impl CoresSettings {
    pub const fn is_unlocked(&self, chapter_level: i64) -> bool {
        chapter_level >= self.unlock_chapter
    }

    /// The level at which the LAST law slot opens — and with it the last
    /// bridge, the last deterministic law grant, and the end of every rule that
    /// used to be pinned to `max_core_level`.
    ///
    /// `max_slots_per_core × core_levels_per_slot` is exactly the argument that
    /// makes `law_slots_for_level` return `max_slots_per_core`, so the two can
    /// never drift apart.
    pub fn max_slot_level(&self) -> i64 {
        self.max_slots_per_core
            .max(0)
            .saturating_mul(self.core_levels_per_slot.get().max(1))
    }

    /// Highest level `level_costs` prices explicitly. Above it the ladder is
    /// continued by [`Self::level_cost_growth`].
    pub fn max_tabled_core_level(&self) -> i64 {
        self.level_costs
            .iter()
            .map(|row| row.level)
            .max()
            .unwrap_or(0)
    }

    /// Cost of raising a core to `level`, or `None` for level 0 and below or
    /// above `max_core_level` (which is how "above the cap" is refused).
    ///
    /// Inside the table the authored row wins verbatim. Above it the cost grows
    /// geometrically from the last tabled row — the extension the unbounded
    /// level cap needs, kept here so the handler cannot disagree with it.
    ///
    /// Saturating on purpose: `growth^level` overflows `f64` to infinity long
    /// before level 9999, and `f64 as i64` saturates at `i64::MAX`, which reads
    /// as "unaffordable" everywhere downstream rather than as a wrapped bargain.
    pub fn core_level_cost(&self, level: i64) -> Option<i64> {
        if level < 1 || level > self.max_core_level {
            return None;
        }
        if let Some(row) = self.level_costs.iter().find(|row| row.level == level) {
            return Some(row.cost.get());
        }
        let last = self
            .level_costs
            .iter()
            .max_by_key(|row| row.level)
            .expect("level_costs is NonEmptyVec");
        let steps = level - last.level;
        if steps <= 0 {
            // A gap BELOW the last tabled level. The validator refuses a
            // non-contiguous ladder, so this is unreachable; refusing beats
            // inventing a price for a level the designer skipped.
            return None;
        }
        let grown = last.cost.get() as f64 * self.level_cost_growth.get().powi(steps as i32);
        Some(if grown.is_finite() {
            (grown.round() as i64).max(last.cost.get())
        } else {
            i64::MAX
        })
    }

    /// Raw copies needed to raise a law to `level`, or `None` when the ladder
    /// stops there (that is the law level cap).
    pub fn law_upgrade_cost(&self, level: i64) -> Option<i64> {
        self.law_upgrade_ladder
            .iter()
            .find(|row| row.level == level)
            .map(|row| row.required_copies.get())
    }

    /// Highest law level the ladder can reach.
    pub fn max_law_level(&self) -> i64 {
        self.law_upgrade_ladder
            .iter()
            .map(|row| row.level)
            .max()
            .unwrap_or(1)
    }

    /// Charge one bridge direction can hold, in WHOLE units; everything above
    /// it burns. The runtime scales this by `essences::cores::CHARGE_SCALE` and
    /// by whatever the Bridge Law socket does to it.
    pub fn bridge_capacity(&self) -> i64 {
        self.bridge_charge.capacity.get()
    }

    /// Amplification a completely full bridge is worth, in permyriad.
    pub fn bridge_amplification_cap(&self) -> i64 {
        self.bridge_charge.amplification_cap_permyriad.get()
    }

    /// Law Power multiplier for a law that received `units` of charge at the
    /// last flip, at the shipped capacity and cap.
    ///
    /// This is the ONLY place amplification is priced. It multiplies the
    /// numbers of a law's effect (and of its passive modifiers) and nothing
    /// else — never a condition, never a Resonance — which is what stops a law
    /// from amplifying its own bridge (plan §3).
    pub fn law_power_multiplier(&self, units: i64) -> f64 {
        law_power_multiplier_for(
            units,
            self.bridge_capacity(),
            self.bridge_amplification_cap(),
        )
    }
}

/// `1 + delivered × cap / capacity`, in permyriad, clamped at the cap.
///
/// A free function because the Bridge Law stones move `capacity` and `cap` away
/// from the configured pair and still have to price amplification the same way.
///
/// **Multiply before dividing, on integers.** `delivered / capacity` in `f64`
/// turns `3/10` into `0.2999…` and a `1.15` multiplier into
/// `1.1499999999999999`; that multiplier goes into damage, which is floored, so
/// the difference is a whole point of damage at the boundary. On integers the
/// two forms are identical.
pub fn law_power_multiplier_for(units: i64, capacity: i64, cap_permyriad: i64) -> f64 {
    if units <= 0 || capacity <= 0 || cap_permyriad <= 0 {
        return 1.0;
    }
    let raw = units.saturating_mul(cap_permyriad) / capacity;
    1.0 + raw.min(cap_permyriad) as f64 / 10_000.0
}