essences/

game.rs

use crate::prelude::*;

use crate::{
    abilities::AbilityId, currency::CurrencyId, fighting::FightTemplateId, items::AttributeId,
};

#[declare]
pub type EntityTemplateId = Uuid;

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct EntityAttribute {
    #[schemars(schema_with = "attribute_link_id_schema")]
    pub attribute_id: AttributeId,
    #[schemars(title = "Значение атрибута")]
    pub value: u64,
}

#[derive(Debug, serde::Deserialize)]
pub struct CharacterQuery {
    pub character_id: String,
}

#[derive(Clone, Debug, Serialize, Deserialize, Tsify, JsonSchema)]
pub struct EnemyReward {
    #[schemars(title = "Id валюты награды", schema_with = "currency_link_id_schema")]
    pub currency_id: CurrencyId,
    #[schemars(title = "Минимальная награда")]
    pub from: i64,
    #[schemars(title = "Максимальная награда")]
    pub to: i64,
    #[schemars(
        title = "Шанс выпадения",
        description = "Шанс выпадения валюты от 0 до 100"
    )]
    pub drop_chance: f64,
}

impl PartialEq for EnemyReward {
    fn eq(&self, other: &Self) -> bool {
        self.currency_id == other.currency_id && self.from == other.from && self.to == other.to
    }
}

impl Eq for EnemyReward {}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct EntityTemplate {
    #[schemars(schema_with = "id_schema")]
    pub id: EntityTemplateId,
    #[schemars(title = "Имя врага")]
    pub name: String,
    #[schemars(title = "Спайн", schema_with = "aa_entity_spine_schema")]
    pub spine: String,
    #[schemars(title = "Визуал", schema_with = "asset_unit_spine_skin")]
    pub spine_skin_path: String,
    #[schemars(title = "Размер спайна врага")]
    pub spine_scale: u64,
    #[schemars(title = "Время каста")]
    pub cast_time: u64,
    #[schemars(title = "Атрибуты врага", description = "Набор атрибутов врага")]
    pub attributes: Vec<EntityAttribute>,
    #[schemars(
        title = "Id способностей",
        description = "Набор id способностей врага",
        schema_with = "ability_link_id_array_schema"
    )]
    pub ability_ids: Vec<AbilityId>,
    #[schemars(title = "Ширина врага в клетках")]
    pub width: i8,
    #[schemars(title = "Награда за убийство врага")]
    pub rewards: Vec<EnemyReward>,

    #[schemars(
        title = "Является ли боссом",
        description = "Босс-сущность (entity_template_is_boss): влияет на босс-таланты и HP-бар."
    )]
    #[serde(default)]
    pub is_boss: bool,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct Chapter {
    #[schemars(schema_with = "id_schema")]
    pub id: Uuid,
    #[schemars(title = "Порядковый номер уровня")]
    pub level: i64,
    #[schemars(
        title = "Набор id битв",
        description = "Набор битв на уровне",
        schema_with = "fight_template_link_id_array_schema"
    )]
    pub fight_ids: Vec<FightTemplateId>,
    #[schemars(title = "Название боя")]
    pub title: i18n::I18nString,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct CharacterLevel {
    #[schemars(title = "Уровень игрока")]
    pub level: i64,
    #[schemars(title = "Слотов способностей на уровне (для генерации оппонентов)")]
    pub ability_slots: u64,
    #[schemars(
        title = "Минимальный опыт для получения",
        description = "Минимальный опыт игрока для получения уровня"
    )]
    pub required_experience: i64,
    #[schemars(
        title = "Базовые аттрибуты игрока на уровне",
        description = "Базовые аттрибуты игрока, которые выдаются на этом уровне"
    )]
    pub attributes: Vec<EntityAttribute>,
}

/// Per-attribute extrapolation for character levels beyond the authored table.
///
/// `value(level) = round(anchor_value + coefficient * (level^exponent -
/// anchor_level^exponent))`. A flat attribute uses `coefficient = 0`. The
/// `coefficient`/`exponent` pair is chosen so the value AND its per-level slope
/// stay continuous with the last authored level (see `CharacterLevelFormula`).
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Tsify, JsonSchema)]
pub struct CharacterLevelAttributeFormula {
    #[schemars(schema_with = "attribute_link_id_schema")]
    pub attribute_id: AttributeId,
    #[schemars(title = "Значение атрибута на опорном уровне")]
    pub anchor_value: f64,
    #[schemars(title = "Коэффициент прироста атрибута")]
    pub coefficient: f64,
    #[schemars(
        title = "Показатель степени прироста",
        description = "Меньше 1 — затухающий прирост на уровень"
    )]
    pub exponent: f64,
}

/// Formula-driven, unbounded extrapolation of character levels ABOVE the
/// authored `character_levels` table. For `level <= anchor_level` the authored
/// table is used verbatim; for `level > anchor_level` stats and experience are
/// computed from these parameters, so levels are uncapped.
///
/// Experience is cumulative and grows in TWO bands (BAL-009): up to
/// `experience_late_band_level` each level costs
/// `experience_marginal_growth` times the previous one, starting from
/// `experience_marginal_base` at `anchor_level + 1`; above it the ratio drops to
/// `experience_marginal_growth_late`. The seam is continuous — the late band's
/// first marginal cost is the first band's last one times the late growth — so
/// no second base is authored and the two can never drift apart.
/// `ability_slots` is constant (kept at the authored cap) so slots never grow
/// with infinite levels.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Tsify, JsonSchema)]
pub struct CharacterLevelFormula {
    #[schemars(
        title = "Опорный уровень",
        description = "Последний авторский уровень; формула действует для уровней выше него"
    )]
    pub anchor_level: i64,
    #[schemars(title = "Суммарный опыт на опорном уровне")]
    pub anchor_experience: i64,
    #[schemars(
        title = "Стоимость первого уровня после опорного",
        description = "Прирост требуемого опыта на уровне anchor_level+1"
    )]
    pub experience_marginal_base: i64,
    #[schemars(
        title = "Рост стоимости уровня",
        description = "Геометрический множитель стоимости каждого следующего уровня до late_band_level"
    )]
    pub experience_marginal_growth: f64,
    #[schemars(
        title = "Уровень смены полосы роста",
        description = "Последний уровень, растущий по experience_marginal_growth; выше действует experience_marginal_growth_late"
    )]
    pub experience_late_band_level: i64,
    #[schemars(
        title = "Рост стоимости уровня после смены полосы",
        description = "Геометрический множитель стоимости уровня выше experience_late_band_level"
    )]
    pub experience_marginal_growth_late: f64,
    #[schemars(
        title = "Слотов способностей после опорного уровня",
        description = "Постоянное значение — слоты не растут с бесконечными уровнями"
    )]
    pub ability_slots: u64,
    #[schemars(title = "Формулы атрибутов на уровнях выше опорного")]
    pub attributes: Vec<CharacterLevelAttributeFormula>,
}

/// `base · (1 + g + … + g^(n−1))` — the cost of `n` consecutive levels whose
/// first one costs `base` and each next one `g` times the previous.
fn geometric_sum(base: f64, g: f64, n: i64) -> f64 {
    if n <= 0 {
        return 0.0;
    }
    if (g - 1.0).abs() < f64::EPSILON {
        base * n as f64
    } else {
        base * (g.powf(n as f64) - 1.0) / (g - 1.0)
    }
}

impl CharacterLevelFormula {
    /// Cumulative experience required to REACH `level` (for `level > anchor_level`).
    ///
    /// Saturates at `i64::MAX` for astronomically high levels (with geometric
    /// growth the cost exceeds `i64` around ~150 levels past the anchor — a level
    /// no real income can ever fund) instead of overflowing. Levels stay
    /// unbounded: the function is defined and finite for every input.
    pub fn required_experience(&self, level: i64) -> i64 {
        let n = (level - self.anchor_level).max(0);
        if n == 0 {
            return self.anchor_experience;
        }
        let base = self.experience_marginal_base as f64;
        let first_band = (self.experience_late_band_level - self.anchor_level).max(0);
        let in_first = n.min(first_band);

        let mut extra = geometric_sum(base, self.experience_marginal_growth, in_first);
        if n > first_band {
            // BAL-009's second band. Its first marginal cost continues the
            // first band's last one, so only the growth changes at the seam —
            // authoring a separate late base would let the two drift apart.
            let late_base = base
                * self
                    .experience_marginal_growth
                    .powi((first_band - 1).max(0) as i32)
                * self.experience_marginal_growth_late;
            extra += geometric_sum(
                late_base,
                self.experience_marginal_growth_late,
                n - first_band,
            );
        }

        let total = self.anchor_experience as f64 + extra;
        if total >= i64::MAX as f64 {
            i64::MAX
        } else {
            total.round() as i64
        }
    }

    /// Highest level whose `required_experience <= experience`, for the
    /// unbounded region (returns `anchor_level` when `experience` is below the
    /// first extrapolated level's cost). Inverts `required_experience`.
    pub fn level_for_experience(&self, experience: i64) -> i64 {
        if experience <= self.anchor_experience {
            return self.anchor_level;
        }
        let base = self.experience_marginal_base as f64;
        let first_band = (self.experience_late_band_level - self.anchor_level).max(0);
        let band_end_experience = self.required_experience(self.experience_late_band_level);

        // Invert the band the experience actually falls in; the walk below
        // still corrects the rounding, but only by a step or two.
        let (g, band_base, band_offset, surplus) = if experience <= band_end_experience {
            (
                self.experience_marginal_growth,
                base,
                0,
                (experience - self.anchor_experience) as f64,
            )
        } else {
            let late_base = base
                * self
                    .experience_marginal_growth
                    .powi((first_band - 1).max(0) as i32)
                * self.experience_marginal_growth_late;
            (
                self.experience_marginal_growth_late,
                late_base,
                first_band,
                (experience - band_end_experience) as f64,
            )
        };
        let n_approx = if (g - 1.0).abs() < f64::EPSILON {
            band_offset as f64 + surplus / band_base
        } else {
            band_offset as f64 + (1.0 + surplus * (g - 1.0) / band_base).ln() / g.ln()
        };
        // The closed-form inverse can land one level off because
        // `required_experience` rounds to an integer. Correct exactly with a
        // bounded integer walk (a couple of steps), guarding against the
        // saturated (`i64::MAX`) tail so the up-walk always terminates.
        let mut n = n_approx.floor().max(0.0) as i64;
        loop {
            let next = self.required_experience(self.anchor_level + n + 1);
            if next == i64::MAX || next > experience {
                break;
            }
            n += 1;
        }
        while n > 0 && self.required_experience(self.anchor_level + n) > experience {
            n -= 1;
        }
        self.anchor_level + n
    }

    /// Computed attributes for a level in the unbounded region.
    pub fn attributes_for_level(&self, level: i64) -> Vec<EntityAttribute> {
        let anchor = self.anchor_level as f64;
        let l = level as f64;
        self.attributes
            .iter()
            .map(|a| {
                let value = if a.coefficient == 0.0 {
                    a.anchor_value
                } else {
                    a.anchor_value + a.coefficient * (l.powf(a.exponent) - anchor.powf(a.exponent))
                };
                EntityAttribute {
                    attribute_id: a.attribute_id,
                    value: value.round().max(0.0) as u64,
                }
            })
            .collect()
    }

    /// Full computed `CharacterLevel` for a level ABOVE `anchor_level`.
    pub fn character_level(&self, level: i64) -> CharacterLevel {
        CharacterLevel {
            level,
            ability_slots: self.ability_slots,
            required_experience: self.required_experience(level),
            attributes: self.attributes_for_level(level),
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct AbilitySlotsLevel {
    #[schemars(title = "Минимальный уровень главы")]
    pub from_chapter_level: i64,
    #[schemars(title = "Сколько слотов абилок открыто на уровне")]
    pub ability_slots: u64,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Tsify, JsonSchema)]
pub struct PetSlotsLevel {
    #[schemars(title = "Минимальный уровень главы")]
    pub from_chapter_level: i64,
    #[schemars(title = "Сколько слотов петов открыто на уровне")]
    pub pet_slots: u64,
}

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

    // Mirrors the shipped config: anchor at level 100, Health/Damage sqrt-decayed.
    fn shipped_formula() -> CharacterLevelFormula {
        CharacterLevelFormula {
            anchor_level: 100,
            anchor_experience: 3_996_483,
            experience_marginal_base: 204_604,
            experience_marginal_growth: 1.03,
            experience_late_band_level: 200,
            experience_marginal_growth_late: 1.015,
            ability_slots: 6,
            attributes: vec![
                CharacterLevelAttributeFormula {
                    attribute_id: uuid::Uuid::nil(),
                    anchor_value: 505.0,
                    coefficient: 100.0,
                    exponent: 0.5,
                },
                CharacterLevelAttributeFormula {
                    attribute_id: uuid::Uuid::from_u128(1),
                    anchor_value: 101.0,
                    coefficient: 20.0,
                    exponent: 0.5,
                },
            ],
        }
    }

    #[test]
    fn experience_is_continuous_and_monotonic_at_anchor() {
        let f = shipped_formula();
        // Value continuity at the anchor.
        assert_eq!(f.required_experience(100), 3_996_483);
        // First marginal step equals the base (continuous with the table).
        assert_eq!(
            f.required_experience(101) - f.required_experience(100),
            204_604
        );
        // Marginal cost grows geometrically and is strictly increasing (within
        // the non-saturating range; the geometric cost tops out at i64::MAX far
        // beyond any reachable level).
        let mut prev = f.required_experience(100);
        for level in 101..=200 {
            let cur = f.required_experience(level);
            assert!(cur > prev, "exp must be strictly increasing at {level}");
            prev = cur;
        }
    }

    /// BAL-009's second band: the ratio drops at `experience_late_band_level`
    /// and the seam stays continuous — the first late level costs the last
    /// early one times the late growth, not a fresh base.
    #[test]
    fn the_late_band_slows_growth_without_a_step() {
        let f = shipped_formula();
        let marginal = |level: i64| f.required_experience(level) - f.required_experience(level - 1);

        let last_early = marginal(200);
        let first_late = marginal(201);
        assert!(
            (first_late as f64 - last_early as f64 * 1.015).abs() <= 1.0,
            "the seam continues the curve: {last_early} -> {first_late}"
        );

        // Ratios: 3% below the seam, 1.5% above it.
        assert!((marginal(150) as f64 / marginal(149) as f64 - 1.03).abs() < 1e-3);
        assert!((marginal(250) as f64 / marginal(249) as f64 - 1.015).abs() < 1e-3);

        // The published anchors of the accepted curve, within the rounding the
        // closed form accumulates against the doc's per-level recurrence.
        for (level, expected) in [
            (200_i64, 128_249_255_i64),
            (250, 413_764_313),
            (300, 1_014_842_556),
        ] {
            let got = f.required_experience(level);
            let drift = (got - expected).abs() as f64 / expected as f64;
            assert!(drift < 1e-4, "L{level}: {got} vs {expected}");
        }
    }

    #[test]
    fn level_for_experience_inverts_required_experience() {
        let f = shipped_formula();
        for level in 101..=200 {
            let exp = f.required_experience(level);
            // Exactly at the threshold resolves to that level.
            assert_eq!(f.level_for_experience(exp), level, "at level {level}");
            // Just under the next threshold stays at `level`.
            assert_eq!(
                f.level_for_experience(f.required_experience(level + 1) - 1),
                level
            );
        }
    }

    #[test]
    fn stats_diminish_but_keep_growing() {
        let f = shipped_formula();
        // Continuity at the anchor.
        let a = f.attributes_for_level(100);
        assert_eq!(a[0].value, 505);
        assert_eq!(a[1].value, 101);
        // First step past the anchor keeps ~the authored slope (+5 hp, +1 dmg).
        let a101 = f.attributes_for_level(101);
        assert_eq!(a101[0].value, 510);
        assert_eq!(a101[1].value, 102);
        // Per-level gain strictly diminishes but stays positive (sqrt growth).
        let d_early = f.attributes_for_level(120)[0].value - f.attributes_for_level(119)[0].value;
        let d_late = f.attributes_for_level(400)[0].value - f.attributes_for_level(399)[0].value;
        assert!(d_late < d_early, "late hp gain must be smaller than early");
        assert!(d_late >= 1, "hp must keep growing");
    }

    #[test]
    fn ability_slots_never_grow() {
        let f = shipped_formula();
        for level in [101, 200, 1000, 100_000] {
            assert_eq!(f.character_level(level).ability_slots, 6);
        }
    }

    #[test]
    fn levels_are_unbounded() {
        let f = shipped_formula();
        // Within the reachable range, exp is finite and strictly grows.
        let cl = f.character_level(200);
        assert_eq!(cl.level, 200);
        assert!(cl.required_experience > f.required_experience(199));
        assert!(cl.attributes[0].value > 505);
        // An astronomically high level does NOT panic (exp saturates at
        // i64::MAX); stats keep growing and slots stay capped.
        let huge = f.character_level(100_000);
        assert_eq!(huge.level, 100_000);
        assert_eq!(huge.ability_slots, 6);
        assert!(huge.attributes[0].value > cl.attributes[0].value);
        assert_eq!(
            f.level_for_experience(i64::MAX),
            f.level_for_experience(i64::MAX)
        );
    }
}