configs/

plinko.rs

use essences::items::{AttributeId, ItemRarityId};
use schema_loader::{attribute_link_id_schema, item_rarity_link_id_schema};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use tsify_next::Tsify;

use crate::validated_types::NonEmptyVec;

/// Минимальная/максимальная высота доски. Совпадает с клиентскими
/// `PlinkoBoardConfig.MinRows`/`MaxRows` — клиент валидирует то же самое.
pub const MIN_PLINKO_ROWS: i64 = 2;
pub const MAX_PLINKO_ROWS: i64 = 16;

/// Группа физических слотов доски, подписанная одной редкостью.
/// Физические слоты нумеруются `0..=rows`; группы одного уровня должны
/// покрывать этот диапазон без дыр и пересечений. Если у редкости несколько
/// физических слотов (`from_slot != to_slot`), сервер сам выбирает, в какой
/// из них уронить шарик.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct PlinkoSlotGroup {
    #[schemars(title = "Первый физический слот группы")]
    pub from_slot: i64,

    #[schemars(title = "Последний физический слот группы")]
    pub to_slot: i64,

    #[schemars(
        title = "Редкость предмета для этой группы слотов",
        schema_with = "item_rarity_link_id_schema"
    )]
    pub rarity_id: ItemRarityId,

    #[schemars(title = "Слот показан закрытым (только визуал)")]
    pub is_locked: bool,
}

/// Раскладка доски для одного уровня сундука.
///
/// Набор выпадающих редкостей зависит от уровня сундука и ползёт вверх, а
/// слотов на доске всего `rows + 1`, поэтому одна общая раскладка неизбежно
/// оставляла бы часть выдач без своего слота. Раскладка задаётся на КАЖДЫЙ
/// уровень сундука и обязана покрывать ровно те редкости, которые на этом
/// уровне выпадают с весом > 0 (`GameConfig::validate` это требует).
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct PlinkoLevelSlotLayout {
    #[schemars(title = "Уровень сундука, для которого действует раскладка")]
    pub chest_level: i64,

    #[schemars(title = "Раскладка слотов доски на этом уровне (слот → редкость)")]
    pub slot_groups: NonEmptyVec<PlinkoSlotGroup>,
}

impl PlinkoLevelSlotLayout {
    /// Редкость, которой подписан физический слот.
    pub fn rarity_for_slot(&self, slot: i64) -> Option<ItemRarityId> {
        self.slot_groups
            .iter()
            .find(|group| slot >= group.from_slot && slot <= group.to_slot)
            .map(|group| group.rarity_id)
    }

    /// Все физические слоты, подписанные этой редкостью.
    pub fn slots_for_rarity(&self, rarity_id: ItemRarityId) -> Vec<i64> {
        self.slot_groups
            .iter()
            .filter(|group| group.rarity_id == rarity_id)
            .flat_map(|group| group.from_slot..=group.to_slot)
            .collect()
    }
}

/// Постоянная прибавка к стату за касание конкретного колышка.
///
/// Один колышек доски: какой оси он принадлежит и каков его БЕЗРАЗМЕРНЫЙ вес.
///
/// Сам по себе вес ничего не начисляет — прибавка за касание считается как
/// `вес × scale текущего транша` (BAL-021), поэтому один и тот же колышек
/// стоит по-разному на разных уровнях сундука.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct PlinkoPinBonus {
    #[schemars(title = "Ряд колышка (0 — верхний)")]
    pub row: i64,

    #[schemars(title = "Колонка колышка внутри ряда (0..=row)")]
    pub column: i64,

    #[schemars(
        title = "Атрибут, который прибавляет колышек",
        schema_with = "attribute_link_id_schema"
    )]
    pub attribute_id: AttributeId,

    #[schemars(
        title = "Базовый вес колышка",
        description = "Безразмерное число. Реальная прибавка = вес × scale активного транша соответствующего уровня сундука."
    )]
    pub value: i64,
}

/// Точность fixed-point, в которой хранятся потолки, шаги и накопленный
/// бонус игрока (BAL-021). Поздние шаги — доли единицы стата за касание, и
/// целочисленное округление на каждом касании съело бы их целиком.
pub const PLINKO_MICRO: i64 = 1_000_000;

/// Транш одной оси на одном уровне сундука: до какого суммарного значения он
/// доводит ось и по сколько прибавляет одно касание.
///
/// Потолки монотонно растут по уровню сундука, поэтому «сколько ещё можно
/// набрать» — это `cap_micro` первого незаполненного транша, а не отдельная
/// валюта: история касаний не нужна.
#[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct PlinkoAxisTranche {
    #[schemars(title = "Ось (атрибут)", schema_with = "attribute_link_id_schema")]
    pub attribute_id: AttributeId,

    #[schemars(
        title = "Потолок оси на этом уровне, микроединицы",
        description = "Суммарно накопленный бонус оси не может превысить это значение, пока сундук на этом уровне."
    )]
    pub cap_micro: i64,

    #[schemars(
        title = "Цена единицы веса на этом уровне, микроединицы",
        description = "Прибавка за касание = базовый вес колышка × это значение."
    )]
    pub scale_micro: i64,
}

/// Все оси одного уровня сундука.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct PlinkoTranche {
    #[schemars(title = "Уровень сундука")]
    pub chest_level: i64,

    #[schemars(
        title = "Оси уровня",
        description = "По одной строке на каждую ось таблицы колышков."
    )]
    pub axes: Vec<PlinkoAxisTranche>,
}

/// Настройки мини-игры Plinko.
///
/// Сервер — единственный источник правды: он знает высоту доски, раскладку
/// «слот → редкость» для каждого уровня сундука и таблицу колышков, сам катит
/// путь шарика и сам начисляет статы за задетые колышки. Клиент только
/// проигрывает анимацию по присланному пути.
#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, Tsify)]
pub struct PlinkoSettings {
    #[schemars(
        title = "Высота доски (рядов колышков)",
        description = "Физических слотов будет rows + 1, колышков — rows*(rows+1)/2. Путь шарика состоит ровно из rows шагов."
    )]
    pub rows: i64,

    #[schemars(
        title = "Раскладки слотов доски по уровням сундука",
        description = "По одной раскладке на каждый уровень item_cases_settings. Раскладка уровня обязана покрывать все редкости, выпадающие на этом уровне."
    )]
    pub slot_layouts: NonEmptyVec<PlinkoLevelSlotLayout>,

    #[schemars(
        title = "Бонусы за колышки (ПЛЕЙСХОЛДЕРЫ)",
        description = "Значения не отбалансированы: симуляция не проводилась. Колышки без записи не дают ничего."
    )]
    pub pin_bonuses: Vec<PlinkoPinBonus>,

    #[schemars(
        title = "Траншы потолков и шагов по уровням сундука",
        description = "По одной строке на уровень сундука; каждая ось таблицы колышков обязана присутствовать в каждой строке. Потолки не убывают с уровнем."
    )]
    pub tranches: Vec<PlinkoTranche>,
}

impl PlinkoSettings {
    /// Число физических слотов доски.
    pub fn slot_count(&self) -> i64 {
        self.rows + 1
    }

    /// Раскладка доски для уровня сундука. Отсутствие записи означает
    /// сломанный конфиг: `validate` требует раскладку на каждый уровень
    /// `item_cases_settings`.
    pub fn layout_for_level(&self, chest_level: i64) -> Option<&PlinkoLevelSlotLayout> {
        self.slot_layouts
            .iter()
            .find(|layout| layout.chest_level == chest_level)
    }

    /// Бонус конкретного колышка, если он задан в таблице.
    pub fn pin_bonus(&self, row: i64, column: i64) -> Option<&PlinkoPinBonus> {
        self.pin_bonuses
            .iter()
            .find(|bonus| bonus.row == row && bonus.column == column)
    }

    /// Транш оси `attribute_id` на уровне сундука `chest_level`.
    pub fn tranche(
        &self,
        chest_level: i64,
        attribute_id: AttributeId,
    ) -> Option<&PlinkoAxisTranche> {
        self.tranches
            .iter()
            .find(|tranche| tranche.chest_level == chest_level)
            .and_then(|tranche| {
                tranche
                    .axes
                    .iter()
                    .find(|axis| axis.attribute_id == attribute_id)
            })
    }

    /// Транш, который ось `attribute_id` набирает прямо сейчас: САМЫЙ РАННИЙ
    /// уровень не выше текущего, чей потолок ещё не достигнут и который вообще
    /// добавляет ёмкость (BAL-021).
    ///
    /// Это и есть догон: игрок, проскочивший несколько уровней сундука, не
    /// теряет пропущенную ёмкость и не получает её мгновенно — он добирает её
    /// по шагам того уровня, на котором она открылась. История касаний для
    /// этого не нужна: потолки монотонны, поэтому накопленного значения
    /// достаточно, чтобы понять, где игрок стоит.
    pub fn active_tranche(
        &self,
        chest_level: i64,
        attribute_id: AttributeId,
        current_micro: i64,
    ) -> Option<&PlinkoAxisTranche> {
        let mut previous_cap = 0;
        let mut fallback: Option<&PlinkoAxisTranche> = None;
        for level in 1..=chest_level {
            let Some(axis) = self.tranche(level, attribute_id) else {
                continue;
            };
            let adds_capacity = axis.cap_micro > previous_cap;
            previous_cap = axis.cap_micro.max(previous_cap);
            if adds_capacity && axis.cap_micro > current_micro {
                return Some(axis);
            }
            fallback = Some(axis);
        }
        // Every tranche up to here is full: the axis is capped, and the caller
        // grants nothing. The last one is returned so the cap it carries is the
        // one the clamp reads.
        fallback
    }

    /// Потолок оси на текущем уровне сундука — верхняя граница накопления,
    /// пока сундук не вырастет.
    pub fn cap_micro_at(&self, chest_level: i64, attribute_id: AttributeId) -> i64 {
        (1..=chest_level)
            .filter_map(|level| self.tranche(level, attribute_id))
            .map(|axis| axis.cap_micro)
            .max()
            .unwrap_or(0)
    }

    /// Целая часть накопленного бонуса — то, что видит бой и UI.
    pub fn whole_from_micro(micro: i64) -> i64 {
        micro.div_euclid(PLINKO_MICRO)
    }
}