overlord_event_system/mechanics/

collection_power.rs

//! Collection Power: the passive stat bonus paid for OWNING catalog content.
//!
//! Six catalogs pay: equipment Trigger/Effect stones, laws, artifact stones,
//! ability stones, gacha abilities and pets. Each owned template contributes
//!
//! ```text
//! b = k_family × weight × u,   u = first_share + (1 − first_share) × (L−1)/(Lmax−1)
//! ```
//!
//! and the sum of every `b` becomes ONE multiplier on Attack / HP / Armor. The
//! first copy opens a fixed share of a template's contribution and its rank
//! ladder pays the rest, so breadth is worth something immediately while depth
//! is worth most of it.
//!
//! Three rules that are design, not implementation detail:
//!
//! * it reads the COLLECTION, not the loadout — equipping, unslotting or
//!   swapping a preset changes nothing here. Only a grant, a rank-up or a
//!   feature gate opening does;
//! * a family pays nothing before its own vertical opens. Ownership carried in
//!   from a migration or a legacy grant waits for the gate like everything
//!   else, which is why every family below reads the gate it already has
//!   rather than a second chapter number authored here. The gate is the
//!   chapter the family's SCREEN opens, never the chapter its first socket
//!   does — a stone with nowhere to put it yet is exactly the collection this
//!   system exists to pay for;
//! * artifacts are absent on purpose. They already pay
//!   `ArtifactTemplate::ownership_bonuses`, and a universal bonus on top would
//!   count the same collection twice.
//!
//! Returned as `("<code>.mod", permyriad)` pairs, the same channel artifact
//! ownership uses, so combat (`fight::get_entity_stat`), the honest power
//! scalar (`balance::get_attr_from_attrs`) and therefore PvE gating and PvP
//! matchmaking all see one number.

use configs::game_config::GameConfig;
use essences::entity::EntityState;

use crate::game_config_helpers::GameConfigLookup;

/// The total collection bonus as `("<code>.mod", permyriad)` pairs.
///
/// Every multiplied attribute gets the SAME total — Collection Power is one
/// scalar `M_collection`, not a per-attribute table. Percentages become
/// permyriad because that is the unit `.mod` is read in (`+10000 == +1.0`), and
/// the sum is accumulated in `f64` and rounded exactly once, so a catalog of
/// contributions far below the rounding step still adds up to its budget.
///
/// An empty result means no owned template pays anything yet — an arena filler
/// bot, or a character whose collection is entirely behind closed gates.
pub fn collection_stat_mods(config: &GameConfig, entity_state: &EntityState) -> Vec<(String, i64)> {
    let total = collection_bonus(config, entity_state);
    let permyriad = (total * 10_000.0).round() as i64;
    if permyriad == 0 {
        return Vec::new();
    }

    config
        .collection_power
        .multiplied_attribute_ids
        .iter()
        .filter_map(|attribute_id| {
            config
                .attributes
                .iter()
                .find(|attr| attr.id == *attribute_id)
                .map(|attr| (format!("{}.mod", attr.code), permyriad))
        })
        .collect()
}

/// `B_collection` — the summed contribution of the whole collection, as a
/// fraction (`0.08` is the `+8%` the current catalog is budgeted for).
///
/// Split out from [`collection_stat_mods`] because it is the number the UI
/// shows and the tests assert on; the mod pairs are just its delivery.
pub fn collection_bonus(config: &GameConfig, entity_state: &EntityState) -> f64 {
    let chapter = entity_state.current_chapter_level();

    equipment_stone_bonus(config, entity_state, chapter)
        + law_bonus(config, entity_state, chapter)
        + artifact_stone_bonus(config, entity_state, chapter)
        + ability_stone_bonus(config, entity_state, chapter)
        + gacha_ability_bonus(config, entity_state, chapter)
        + pet_bonus(config, entity_state, chapter)
}

/// Trigger and Effect stones, weighted by tier. Gate: the Runes tab, where the
/// collection lives.
///
/// Deliberately the TAB and not the first socket. Ownership is what this system
/// pays for, and the whole reason to pay for it is that a stone is worth having
/// before — and after — it fits a build. Gating on the socket would withhold the
/// bonus from exactly the stones it exists to make worth keeping.
fn equipment_stone_bonus(config: &GameConfig, entity_state: &EntityState, chapter: i64) -> f64 {
    let Some(inventory) = entity_state.stones() else {
        return 0.0;
    };
    let unlock = config.gatings.navbar_navigation.runes_button_unlock_chapter;
    if !is_open(Some(unlock), chapter) {
        return 0.0;
    }

    let settings = &config.collection_power;
    let max_level = config.stones_settings.max_stone_level;
    inventory
        .all()
        .map(|(_, stone)| {
            settings.stone_tier_weight(stone.tier) * settings.progress(stone.level, max_level)
        })
        .sum::<f64>()
        * settings.equipment_stones.k
}

/// Laws. Gate: the cores vertical, which laws live inside.
fn law_bonus(config: &GameConfig, entity_state: &EntityState, chapter: i64) -> f64 {
    let Some(cores) = entity_state.cores() else {
        return 0.0;
    };
    if !is_open(Some(config.cores_settings.unlock_chapter), chapter) {
        return 0.0;
    }

    let settings = &config.collection_power;
    let max_level = config.cores_settings.max_law_level();
    // Weight 1 for every law: the catalog has no rarity axis, so breadth and
    // rank are the whole of it.
    cores
        .laws
        .iter()
        .map(|law| settings.progress(law.level, max_level))
        .sum::<f64>()
        * settings.laws.k
}

/// Artifact stones — the stones, NOT the artifacts, which pay their own
/// ownership bonus. Gate: the artifact vertical.
///
/// Same reasoning as [`equipment_stone_bonus`], and here it matters most: the
/// vertical opens at chapter 21 and the first artifact socket only at 91, so
/// gating on the socket would leave seventy chapters of collected stones worth
/// nothing. `artifacts_settings.unlock_chapter` is the chapter from which a
/// stone can legitimately be owned at all.
fn artifact_stone_bonus(config: &GameConfig, entity_state: &EntityState, chapter: i64) -> f64 {
    let Some(collection) = entity_state.artifacts() else {
        return 0.0;
    };
    let unlock = config.artifacts_settings.unlock_chapter;
    if !is_open(Some(unlock), chapter) {
        return 0.0;
    }

    let settings = &config.collection_power;
    let max_level = config.artifacts_settings.max_stone_level;
    collection
        .stones
        .iter()
        .map(|stone| settings.progress(stone.level, max_level))
        .sum::<f64>()
        * settings.artifact_stones.k
}

/// Ability stones. Gate: their own `unlock_chapter`.
fn ability_stone_bonus(config: &GameConfig, entity_state: &EntityState, chapter: i64) -> f64 {
    let Some(stones) = entity_state.ability_stones() else {
        return 0.0;
    };
    if !config.ability_stone_settings.is_unlocked(chapter) {
        return 0.0;
    }

    let settings = &config.collection_power;
    let max_level = config.ability_stone_settings.max_level();
    stones
        .iter()
        .map(|stone| settings.progress(stone.level, max_level))
        .sum::<f64>()
        * settings.ability_stones.k
}

/// Every `is_gacha_ability` template, by ability level.
///
/// Class basics, mob attacks and pet ults are excluded: they are granted by
/// progression rather than collected, so they are not a collection to reward.
/// The doc prices this family by "evolved quality", but an ability's rarity is
/// fixed at authoring time and evolve re-rolls a DIFFERENT template rather than
/// upgrading one — so rank here is the ability's level, the axis the player
/// actually advances.
///
/// Gate: the Skills screen.
fn gacha_ability_bonus(config: &GameConfig, entity_state: &EntityState, chapter: i64) -> f64 {
    let Some(abilities) = entity_state.all_abilities() else {
        return 0.0;
    };
    let unlock = config
        .gatings
        .navbar_navigation
        .skills_button_unlock_chapter;
    if !is_open(Some(unlock), chapter) {
        return 0.0;
    }

    let settings = &config.collection_power;
    abilities
        .iter()
        .filter_map(|ability| {
            let template = config.ability_template(ability.template_id)?;
            if !template.is_gacha_ability {
                return None;
            }
            let max_level = max_ability_level(config, template.rarity_id)?;
            Some(settings.progress(ability.level, max_level))
        })
        .sum::<f64>()
        * settings.gacha_abilities.k
}

/// Pets, weighted by rarity. Gate: the Pets screen.
fn pet_bonus(config: &GameConfig, entity_state: &EntityState, chapter: i64) -> f64 {
    let Some(pets) = entity_state.all_pets() else {
        return 0.0;
    };
    let unlock = config.gatings.navbar_navigation.pets_button_unlock_chapter;
    if !is_open(Some(unlock), chapter) {
        return 0.0;
    }

    let settings = &config.collection_power;
    pets.iter()
        .filter_map(|pet| {
            let max_level = max_pet_level(config, pet.rarity.id)?;
            Some(
                settings.pet_rarity_weight(pet.rarity.id) * settings.progress(pet.level, max_level),
            )
        })
        .sum::<f64>()
        * settings.pets.k
}

/// Top of the ability ladder for a rarity, or `None` when the rarity has no
/// rows — content the player cannot legally rank up, so it pays nothing.
fn max_ability_level(
    config: &GameConfig,
    rarity_id: essences::abilities::AbilityRarityId,
) -> Option<i64> {
    config
        .ability_levels
        .iter()
        .filter(|row| row.rarity_id == rarity_id)
        .map(|row| row.level)
        .max()
}

/// Top of the pet ladder for a rarity. Same rule as [`max_ability_level`].
fn max_pet_level(config: &GameConfig, rarity_id: essences::pets::PetRarityId) -> Option<i64> {
    config
        .pet_levels
        .iter()
        .filter(|row| row.rarity_id == rarity_id)
        .map(|row| row.level)
        .max()
}

/// A family with no scheduled unlock never opens — the same safety-net rule the
/// socket-unlock lookups use, rather than defaulting an unscheduled system open.
fn is_open(unlock_chapter: Option<i64>, chapter: i64) -> bool {
    unlock_chapter.is_some_and(|unlock| chapter >= unlock)
}