overlord_event_system/mechanics/

power_q.rs

//! The dynamic half of displayed / matchmaking Power (BAL-030).
//!
//! `P_ui = floor(P_static × Πq)`. `P_static` is combat-effective stats run
//! through [`crate::mechanics::balance::power_from_attrs`]; everything that
//! cannot be folded honestly into a stat — a law, an artifact rule, a socketed
//! effect, a facet — enters here as an approximate multiplier `q` authored on
//! its own template.
//!
//! Three rules hold the whole module together:
//!
//! * **A bad combination never lowers Power.** Every `q` is `>= 1`, so a
//!   no-op stone reads as "no contribution", not as a penalty.
//! * **The estimate is STABLE out of combat.** Nothing here reads the live
//!   flip side, gauge, law stacks or the rolled facet: a build is worth the
//!   same number before the fight and during it. The two-sided systems are
//!   averaged instead (`50/50` sides, the expected value of the facet die).
//! * **Nothing is counted twice.** Raw stats — Twin Core multipliers, artifact
//!   ownership bonuses, pet base stats, passive stone stats, ability payloads —
//!   already moved `P_static`, so they contribute no `q`.
//!
//! The coefficients are approximate by construction and are allowed to be
//! wrong about a specific matchup; `S_real` (the combat outcome) stays the
//! balance truth.

use configs::game_config::GameConfig;
use essences::ability_stones::AbilityStoneId;
use essences::character_state::CharacterState;
use essences::items::ItemType;
use essences::stones::{Stone, StoneSocketSlot};
use essences::{artifacts::ArtifactCollection, cores::CoresState};

use crate::game_config_helpers::GameConfigLookup;
use crate::mechanics::cores as cores_mech;

/// One coefficient interpolated between its first and last rank.
///
/// Interpolation is linear in `ln(q)`, so a rank ladder compounds evenly
/// instead of front-loading. A single-rank component (`max_rank <= 1`) is worth
/// its first-rank value.
pub fn interpolated_q(first_rank: f64, max_rank_value: f64, rank: i64, max_rank: i64) -> f64 {
    let first = first_rank.max(1.0);
    let last = max_rank_value.max(first);
    if max_rank <= 1 {
        return first;
    }
    let t = ((rank.max(1) - 1) as f64 / (max_rank - 1) as f64).clamp(0.0, 1.0);
    (first.ln() + (last.ln() - first.ln()) * t).exp()
}

/// Πq over every dynamic system of `character`'s CURRENT loadout.
///
/// Multiplies — an equivalent implementation could sum the logarithms. There is
/// no global cap and no combo-correction table: interactions are deliberately
/// left uncalibrated rather than patched with exceptions.
pub fn dynamic_power_multiplier(config: &GameConfig, character: &CharacterState) -> f64 {
    let mut q = 1.0;
    q *= laws_and_bridges_q(config, &character.cores);
    q *= artifacts_q(config, &character.artifacts);
    q *= ability_stones_q(config, character);
    q *= pet_facets_q(config, character);
    q *= equipment_q(config, character);
    q *= class_q(config, character);
    q.max(1.0)
}

/// The active class's passive plus whichever of its kit the character actually
/// has equipped.
///
/// The abilities' own payloads are already in `P_static` (the analytic ability
/// multipliers price them), so what is counted here is only the utility a
/// closed form cannot express: a damage window, a cooldown cut, a team buff.
/// An unequipped class ability is worth nothing, exactly like an unslotted
/// law.
fn class_q(config: &GameConfig, character: &CharacterState) -> f64 {
    const MAX_CLASS_LEVEL: i64 = 20;

    let active = character.character.class;
    let Some(class) = config.classes.iter().find(|c| c.id == active) else {
        return 1.0;
    };

    // The shared account level makes every row equal in a consistent state, but
    // legacy rows may diverge — price the ACTIVE class's own ladder position.
    let class_level = character
        .character_classes
        .iter()
        .find(|row| row.class_id == active)
        .map(|row| row.level as i64)
        .unwrap_or(1);

    let mut q = interpolated_q(
        class.passive_power_q_l1,
        class.passive_power_q_l20,
        class_level,
        MAX_CLASS_LEVEL,
    );

    for row in &class.ability_power_q {
        let equipped = character
            .equipped_abilities
            .slotted
            .values()
            .any(|ability| ability.template_id == row.ability_id);
        if equipped {
            q *= row.q.max(1.0);
        }
    }
    q
}

/// Slotted laws and the bridges between them.
///
/// Only SLOTTED laws pay: owning a law is not power, using it is. The seeds
/// already carry the `50/50` share of a law's own side, so a Real and a Fantasy
/// law in the same build simply multiply.
fn laws_and_bridges_q(config: &GameConfig, cores: &CoresState) -> f64 {
    let max_rank = config
        .cores_settings
        .law_upgrade_ladder
        .iter()
        .map(|step| step.level)
        .max()
        .unwrap_or(1);

    let law_q = |law_id| -> Option<f64> {
        let owned = cores
            .laws
            .iter()
            .find(|law| law.template_id == law_id && law.slot_index.is_some())?;
        let template = cores_mech::law_template(config, law_id)?;
        Some(interpolated_q(
            template.power_q_first_rank,
            template.power_q_max_rank,
            owned.level,
            max_rank,
        ))
    };

    let mut q = 1.0;
    for law in cores.laws.iter().filter(|law| law.slot_index.is_some()) {
        if let Some(law_value) = law_q(law.template_id) {
            q *= law_value;
        }
    }

    // A bridge is worth the amplification it actually delivers to the law on
    // the far end, in both directions, at the expected fill.
    let fill = config
        .game_settings
        .power_estimator
        .bridge_expected_fill
        .clamp(0.0, 1.0);
    for bridge in &cores.bridges {
        let (Some(real_q), Some(fantasy_q)) =
            (law_q(bridge.real_law_id), law_q(bridge.fantasy_law_id))
        else {
            continue;
        };
        q *= (0.5 * fill * fantasy_q.ln() + 0.5 * fill * real_q.ln()).exp();
    }
    q
}

/// The worn artifact's World Law plus the stones in its sockets. Ownership
/// bonuses are stats and already moved `P_static`, so they add nothing here.
fn artifacts_q(config: &GameConfig, collection: &ArtifactCollection) -> f64 {
    let mut q = 1.0;

    if let Some(equipped) = collection.equipped
        && let Some(template) = config.artifacts.iter().find(|a| a.id == equipped)
    {
        q *= template.power_q.max(1.0);
    }

    let max_rank = config.artifacts_settings.max_stone_level;
    for stone in collection.stones.iter().filter(|s| s.socket.is_some()) {
        let Some(template) = config
            .artifact_stones
            .iter()
            .find(|t| t.id == stone.template_id)
        else {
            continue;
        };
        if !template.active {
            continue;
        }
        q *= interpolated_q(
            template.power_q_first_rank,
            template.power_q_max_rank,
            stone.level,
            max_rank,
        );
    }
    q
}

/// Every ability stone sitting in an equipped ability's socket. Several
/// modifiers on one ability multiply; the ability's own payload is already in
/// `P_static`, so only the modifiers count.
fn ability_stones_q(config: &GameConfig, character: &CharacterState) -> f64 {
    let max_rank = config.ability_stone_settings.upgrade_copies.len() as i64 + 1;
    let level_of = |stone_id: AbilityStoneId| {
        character
            .ability_stones
            .iter()
            .find(|owned| owned.template_id == stone_id)
            .map_or(1, |owned| owned.level)
    };

    let mut q = 1.0;
    for (ability_id, sockets) in &character.ability_stone_sockets.0 {
        if !character
            .equipped_abilities
            .slotted
            .values()
            .any(|ability| ability.template_id == *ability_id)
        {
            continue;
        }
        for stone_id in sockets.values() {
            let Some(template) = config.ability_stone_template(*stone_id) else {
                continue;
            };
            q *= interpolated_q(
                template.power_q_first_rank,
                template.power_q_max_rank,
                level_of(*stone_id),
                max_rank,
            );
        }
    }
    q
}

/// The expected value of the facet die: each side's equipped faces averaged,
/// then the two sides averaged `50/50`. An empty side is worth `1`, and the
/// face that happens to be up right now is deliberately ignored.
fn pet_facets_q(config: &GameConfig, character: &CharacterState) -> f64 {
    const MAX_PET_LEVEL: i64 = 10;

    let mut real: Vec<f64> = Vec::new();
    let mut fantasy: Vec<f64> = Vec::new();

    for pet in character.equipped_pets.slotted.values() {
        let Some(template) = config.pet_template(pet.template_id) else {
            continue;
        };
        let face_q = |facet| {
            config
                .pet_facet_settings
                .power_q_row(facet)
                .map(|row| {
                    interpolated_q(row.q_first_level, row.q_max_level, pet.level, MAX_PET_LEVEL)
                })
                .unwrap_or(1.0)
        };
        real.push(face_q(template.real_facet));
        fantasy.push(face_q(template.fantasy_facet));
    }

    let mean = |faces: &[f64]| {
        if faces.is_empty() {
            1.0
        } else {
            faces.iter().sum::<f64>() / faces.len() as f64
        }
    };
    0.5 * mean(&real) + 0.5 * mean(&fantasy)
}

/// One `q` per equipment item, from the package in its sockets.
///
/// The trigger sets how OFTEN the package runs and the effects set what it
/// does, so the two are priced together rather than multiplied as three
/// independent stones — that would double-count the synergy the package is.
/// A legal Trigger with no Effect yet is worth the authored floor: the gauge
/// alone produces no measurable DPS or EHP, but the player must still see the
/// number move.
fn equipment_q(config: &GameConfig, character: &CharacterState) -> f64 {
    use strum::IntoEnumIterator;

    let settings = &config.game_settings.power_estimator;
    let reference_rate = settings.reference_trigger_proc_rate.max(f64::MIN_POSITIVE);
    let max_rank = config.stones_settings.max_stone_level;

    let socketed = |item_type: ItemType, slot: StoneSocketSlot, stones: &[Stone]| {
        stones
            .iter()
            .find(|stone| {
                stone
                    .socket
                    .is_some_and(|key| key.item_type == item_type && key.socket == slot)
            })
            .cloned()
    };

    let mut q = 1.0;
    for item_type in ItemType::iter() {
        let trigger = socketed(
            item_type,
            StoneSocketSlot::Trigger,
            &character.stones.trigger_stones,
        );
        let Some(trigger) = trigger else {
            continue;
        };
        let Some(trigger_template) = config.trigger_stone_template(trigger.template_id) else {
            continue;
        };
        if !trigger_template.active {
            continue;
        }

        let rate_scale = (trigger_template.power_proc_rate / reference_rate).max(0.0);

        let side_q = |slot: StoneSocketSlot| -> f64 {
            let Some(effect) = socketed(item_type, slot, &character.stones.effect_stones) else {
                return 1.0;
            };
            let Some(template) = config.effect_stone_template(effect.template_id) else {
                return 1.0;
            };
            let base = interpolated_q(
                template.power_q_base_first_rank,
                template.power_q_base_max_rank,
                effect.level,
                max_rank,
            );
            // The same tier matrix combat prices the effect with: a mismatched
            // pair is worth less here exactly as it hits for less there.
            let tier_scale = config
                .stones_settings
                .tier_coefficients
                .iter()
                .find(|row| row.trigger_tier == trigger.tier && row.effect_tier == effect.tier)
                .map_or(1.0, |row| row.multiplier);
            1.0 + rate_scale * tier_scale * (base - 1.0)
        };

        let real = side_q(StoneSocketSlot::RealEffect);
        let fantasy = side_q(StoneSocketSlot::FantasyEffect);
        let package = ((real.ln() + fantasy.ln()) / 2.0).exp();
        q *= package.max(settings.trigger_only_q);
    }
    q
}