overlord_event_system/

attributes.rs

use configs::game_config;
use essences::{class, entity, entity::EntityState, items, talent_tree::TalentTemplate};

use crate::game_config_helpers::GameConfigLookup;

#[derive(Default)]
pub struct EntityStats {
    pub attributes: entity::EntityAttributes,
    pub max_hp: u64,
}

pub type AttributeDeltas = std::collections::HashMap<items::AttributeId, i64>;

pub fn calculate_entity_stats(
    game_config: &game_config::GameConfig,
    attributes_deltas: AttributeDeltas,
) -> anyhow::Result<EntityStats> {
    calculate_entity_stats_with_mods(game_config, attributes_deltas, &[])
}

/// Same as [`calculate_entity_stats`], plus `.mod` multipliers addressed by
/// attribute **code** rather than by config id.
///
/// The artifact ownership bonus is a percentage on hp / attack / armor, and
/// `<code>.mod` is read generically by both combat (`get_entity_stat`) and the
/// honest power scalar (`balance::get_attr_from_attrs`) — so it needs no
/// attribute of its own in the catalog, which is what lets `armor.mod` work
/// without one existing. Folded in **before** `compose_max_hp`, so an artifact's
/// HP percentage reaches the fight's `max_hp` and not just the displayed number.
pub fn calculate_entity_stats_with_mods(
    game_config: &game_config::GameConfig,
    attributes_deltas: AttributeDeltas,
    extra_mods: &[(&str, i64)],
) -> anyhow::Result<EntityStats> {
    let mut attributes = entity::EntityAttributes::default();

    for attribute_delta in attributes_deltas {
        let Some(config_attribute) = game_config.attribute(attribute_delta.0) else {
            anyhow::bail!("Couldn't find attribute with id = {}", attribute_delta.0);
        };

        attributes.add(&config_attribute.code.clone(), attribute_delta.1);
    }

    for (code, value) in extra_mods {
        if *value != 0 {
            attributes.add(code, *value);
        }
    }

    let max_hp = compose_max_hp(&attributes, game_config)?;

    Ok(EntityStats { attributes, max_hp })
}

/// Compose the fight `max_hp` from an aggregated attribute map the same way
/// combat composes every other stat (`fight::get_entity_stat`): raw hp, plus
/// additive `hp.bonus`, times the `hp.mod` multiplier (`+10000 == +1.0`,
/// floored at `MIN_STAT_MOD_MULT`). This keeps `hp.mod`/`hp.bonus` grants
/// (class levels, the Endurance talent) real in combat and consistent with
/// the power scalar's `get_attr_from_attrs` composition.
pub fn compose_max_hp(
    attributes: &entity::EntityAttributes,
    game_config: &game_config::GameConfig,
) -> anyhow::Result<u64> {
    let hp_attribute_id = game_config.game_settings.hp_attribute_id;
    let Some(hp_attribute) = game_config.attribute(hp_attribute_id) else {
        anyhow::bail!("Couldn't find hp attribute with id = {hp_attribute_id}");
    };
    let code = &hp_attribute.code;
    let get = |key: String| attributes.0.get(&key).copied().unwrap_or(0) as f64;
    let base = get(code.clone());
    let bonus = get(format!("{code}.bonus"));
    let mod_v = (get(format!("{code}.mod")) / 10000.0 + 1.0)
        .max(crate::mechanics::balance::MIN_STAT_MOD_MULT);
    Ok(((base + bonus) * mod_v).max(0.0).floor() as u64)
}

pub fn calculate_player_entity_stats_with_zeroes(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
) -> anyhow::Result<EntityStats> {
    let mut attributes_deltas = AttributeDeltas::new();

    for attribute in &game_config.attributes {
        attributes_deltas.insert(attribute.id, 0);
    }

    let Some(level_attributes) = game_config.character_level(entity_state.level()) else {
        anyhow::bail!(
            "Couldn't find character level attributes for level={}",
            entity_state.level()
        );
    };

    for attribute in &level_attributes.attributes {
        *attributes_deltas.entry(attribute.attribute_id).or_insert(0) += attribute.value as i64;
    }

    for item in entity_state.inventory() {
        if !item.is_equipped {
            continue;
        }

        for attribute in &item.attributes {
            *attributes_deltas.entry(attribute.attr_id).or_insert(0) += attribute.value as i64;
        }
    }

    let Some(class) = game_config.class(entity_state.class()) else {
        anyhow::bail!("Couldn't find class with id={}", entity_state.class());
    };

    for class_attribute in &class.attributes {
        let class::ClassAttribute::EntityAttribute(entity_attribute) = class_attribute;
        *attributes_deltas
            .entry(entity_attribute.attribute_id)
            .or_insert(0) += entity_attribute.value as i64;
    }

    aggregate_pet_stats(entity_state, game_config, &mut attributes_deltas);
    aggregate_talent_attribute_bonuses(entity_state, &game_config.talents, &mut attributes_deltas);
    aggregate_statue_attribute_bonuses(entity_state, game_config, &mut attributes_deltas);
    aggregate_plinko_pin_attribute_bonuses(entity_state, &mut attributes_deltas);
    aggregate_class_level_attribute_bonuses(entity_state, game_config, &mut attributes_deltas);
    aggregate_stone_attribute_bonuses(entity_state, game_config, &mut attributes_deltas);

    // Deflate the aggregated ARMOR
    // rating by character level (WoW-style rating→percent conversion indexed
    // by level). Item armor saturates the DR curve from band 1 (64%→78.5%
    // mitigation across the game, marginal decay ×1.66) — deflation keeps an
    // armor point buying a comparable mitigation slice at every level.
    // Applied here, in ONE place, so combat, the honest power scalar and the
    // UI all see the same effective rating. Dodge needs no deflation
    // (measured circulation 236-474 vs K_DODGE 6000 — far from saturation).
    let deflator = crate::mechanics::balance::player_armor_rating_deflator(entity_state.level());
    if deflator < 1.0
        && let Some(armor_id) = game_config
            .attributes
            .iter()
            .find(|a| a.code == "armor")
            .map(|a| a.id)
        && let Some(v) = attributes_deltas.get_mut(&armor_id)
    {
        *v = (*v as f64 * deflator).round() as i64;
    }

    apply_core_multiplier(entity_state, game_config, &mut attributes_deltas);

    // Two ownership sources, both `<code>.mod`, both summed here rather than
    // in two places: artifacts pay their own per-template bonus (BAL-011) and
    // Collection Power pays the universal one for every OTHER catalog. They
    // never overlap — artifacts are deliberately outside Collection Power — so
    // adding them is not a double count.
    let mut ownership_mods = artifact_ownership_mods(entity_state, game_config);
    ownership_mods.extend(crate::mechanics::collection_power::collection_stat_mods(
        game_config,
        entity_state,
    ));
    let ownership_mods: Vec<(&str, i64)> = ownership_mods
        .iter()
        .map(|(code, value)| (code.as_str(), *value))
        .collect();
    calculate_entity_stats_with_mods(game_config, attributes_deltas, &ownership_mods)
}

/// The artifact ownership bonus, as `("<code>.mod", permyriad)` pairs.
///
/// Summed over the **whole collection**, worn or not: an artifact pays for being
/// owned, which is the one thing that makes a second artifact worth having once
/// only one can be worn. Which attributes it pays in is per-template
/// (`ArtifactTemplate::ownership_bonuses`) — an artifact with an empty list pays
/// nothing without needing a flag of its own.
///
/// Applied here, in the same aggregation as items, pets, talents and the statue,
/// so the bonus reaches combat, the displayed stats, the power scalar and
/// therefore PvE gating and PvP matchmaking through one path.
fn artifact_ownership_mods(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
) -> Vec<(String, i64)> {
    // Ownership is allowed to exist before the feature opens (the starter
    // Empty Frame is granted at account creation), but it must be combat-inert
    // until the artifact chapter gate. This choke point feeds raw combat
    // attributes, displayed stats, honest power, PvE and PvP for both the local
    // character and a human opponent, so gating here prevents every ownership
    // stat contribution from leaking early.
    let Some(artifacts) = entity_state.artifacts() else {
        // Arena filler bots have no collection and, crucially, no campaign
        // chapter. Do not reinterpret their bot level as a feature gate.
        return Vec::new();
    };
    if entity_state.current_chapter_level() < game_config.artifacts_settings.unlock_chapter {
        return Vec::new();
    }
    if artifacts.artifacts.is_empty() {
        return Vec::new();
    }
    crate::mechanics::artifacts::ownership_stat_mods(game_config, artifacts)
}

/// Scale HP / attack / defense by the twin-core PER-STAT multiplier `M_stat`
/// (BAL-010) — the product of the two core levels through
/// `configs::cores::core_stat_multiplier`, so total POWER moves by `M_power`.
///
/// Applied HERE, last, for two reasons. First, "поверх статов от предметов":
/// every other source (items, class, pets, talents, statue, class levels) is
/// already summed in, so the multiplier genuinely compounds with gear rather
/// than with a bare base. Second, this function is the single choke point that
/// BOTH the displayed power scalar (`behaviors::power::character_power`) and
/// the combat entity (`entities::create_player_entity`) go through, so the two
/// cannot disagree — plan §7.1 holds by construction, not by two call sites
/// being kept in sync by hand.
///
/// Keyed on whoever the combatant is, not on whose session this is: a human PvP
/// opponent carries a full `CharacterState` and gets their own multiplier, so
/// two identical builds meet as equals in the arena. Mobs and arena filler bots
/// have no cores and are untouched.
fn apply_core_multiplier(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(cores) = entity_state.cores() else {
        return;
    };
    let multiplier = crate::mechanics::cores::core_multiplier(game_config, cores);
    if multiplier == 1.0 {
        return;
    }
    for attribute_id in &game_config.cores_settings.multiplied_attribute_ids {
        if let Some(value) = attributes_deltas.get_mut(attribute_id) {
            *value = (*value as f64 * multiplier).round() as i64;
        }
    }
}

/// Apply the attribute row of the character's active class at its current
/// level.
///
/// The rows are TOTAL SNAPSHOTS, not increments (BAL-033): the row of the
/// highest level the character has reached is applied whole, and the rows below
/// it are not added on top. Summing them — which is what this used to do — made
/// every authored row an increment by accident and inflated a max-level class
/// far past the numbers the table shows.
///
/// The active class is read from `character.class`, the level from the matching
/// `character_classes` entry. Missing entry → no bonuses.
///
/// Crucially these bonuses are scoped to the active class, so a switch drops
/// them and a switch back restores them — class progression is not "permanent
/// character growth."
///
/// Keyed on `EntityState::character_classes()`, not on the enum variant, so a
/// human PvP opponent gets their own class levels — matchmaking already prices
/// them in through the stored `character.power`. Arena filler bots have no
/// class-level rows and contribute nothing.
fn aggregate_class_level_attribute_bonuses(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(character_classes) = entity_state.character_classes() else {
        return;
    };
    let active_class_id = entity_state.class();
    let Some(active) = character_classes
        .iter()
        .find(|cc| cc.class_id == active_class_id)
    else {
        return;
    };
    let Some(row) = game_config
        .class_levels
        .iter()
        .filter(|row| row.class_id == active_class_id && row.level <= active.level)
        .max_by_key(|row| row.level)
    else {
        return;
    };
    for attr in &row.attrs {
        *attributes_deltas.entry(attr.attribute_id).or_insert(0) += attr.value as i64;
    }
}

fn aggregate_pet_stats(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(equipped_pets) = entity_state.equipped_pets() else {
        return;
    };

    for pet in equipped_pets.slotted.values() {
        // TODO fix this shit
        let template = match game_config.pet_template(pet.template_id) {
            Some(t) => t,
            None => continue,
        };

        for stat in &template.stats {
            let value = stat.base_value + stat.per_level_value * (pet.level - 1);
            *attributes_deltas.entry(stat.attribute_id).or_insert(0) += value;
        }
    }
}

/// Accumulate flat attribute bonuses from completed talent levels.
///
/// Keyed on `EntityState::talent_levels()`, so a human PvP opponent brings their own
/// researched talents into the arena; arena filler bots have no talent tree and
/// contribute nothing.
fn aggregate_talent_attribute_bonuses(
    entity_state: &EntityState,
    talents: &[TalentTemplate],
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(talent_levels) = entity_state.talent_levels() else {
        return;
    };
    for talent in talents {
        let Some(&level) = talent_levels.get(&talent.id) else {
            continue;
        };
        for level_config in &talent.levels {
            if level_config.level > level {
                break;
            }
            for bonus in &level_config.attribute_bonuses {
                *attributes_deltas.entry(bonus.attribute_id).or_insert(0) += bonus.value;
            }
        }
    }
}

/// Accumulate the flat passive stats of every **socketed** Trigger/Effect
/// Stone.
///
/// Folded in here, alongside items and the statue, so stone stats reach combat,
/// the displayed attribute list and the power scalar through the one
/// aggregation everything already shares — which is also why they count toward
/// Power, and therefore toward PvE gating and PvP matchmaking, exactly like
/// item stats.
///
/// `active_side` is deliberately not consulted: both effect stones of a slot
/// contribute at all times, so a flip changes which effect *fires* and nothing
/// about the character's stats or Power.
fn aggregate_stone_attribute_bonuses(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(stones) = entity_state.stones() else {
        return;
    };
    for (attribute_id, value) in
        crate::mechanics::stones::socketed_stat_bonuses(game_config, stones)
    {
        *attributes_deltas.entry(attribute_id).or_insert(0) += value;
    }
}

/// Accumulate flat attribute bonuses from the active statue set.
///
/// Keyed on `EntityState::statue_state()`, so a human PvP opponent brings their own
/// carved statue into the arena; arena filler bots have no statue and contribute
/// nothing.
fn aggregate_statue_attribute_bonuses(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(statue) = entity_state.statue_state() else {
        return;
    };
    let active_index = statue.active_set_index as usize;
    let Some(active_set) = statue.sets.get(active_index) else {
        return;
    };
    for slot in active_set.slots.0.values() {
        let Some(bonus_type) = game_config
            .statue_bonus_type_configs
            .iter()
            .find(|bt| bt.attribute_id == slot.attribute_id)
        else {
            continue;
        };
        let Some(grade_value) = bonus_type
            .grade_values
            .iter()
            .find(|gv| gv.grade_id == slot.grade_id)
        else {
            continue;
        };
        *attributes_deltas.entry(slot.attribute_id).or_insert(0) += grade_value.value.get() as i64;
    }
}

/// Accumulate the permanent Plinko pin bonuses the player has banked so far.
///
/// Stored per attribute in `character_state.plinko_pin_bonuses` in MICRO-UNITS
/// and already clamped to the axis's current tranche cap at grant time
/// (BAL-021). Combat and the displayed stats read whole stat points, so the
/// fractional tail of a late pin accumulates across opens instead of being
/// rounded away on each one. Otherwise the same shape as talents and the
/// statue, which is what puts the bonus in combat, in the displayed stats and
/// in the power scalar through one path.
fn aggregate_plinko_pin_attribute_bonuses(
    entity_state: &EntityState,
    attributes_deltas: &mut AttributeDeltas,
) {
    let Some(bonuses) = entity_state.plinko_pin_bonuses() else {
        return;
    };
    for (attribute_id, micro) in bonuses.iter() {
        *attributes_deltas.entry(*attribute_id).or_insert(0) +=
            configs::plinko::PlinkoSettings::whole_from_micro(*micro);
    }
}

pub fn calculate_player_entity_stats_without_zeroes(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
) -> anyhow::Result<EntityStats> {
    let mut stats = calculate_player_entity_stats_with_zeroes(entity_state, game_config)?;
    stats.attributes.remove_zeroes();

    Ok(stats)
}

#[cfg(test)]
mod tests {
    use super::*;
    use ::essences::character_state::CharacterState;
    use ::essences::characters::CharacterBuilder;
    use ::essences::class::{CharacterClass, ClassLevels};
    use ::essences::currency::CurrencyUnit;
    use ::essences::game::EntityAttribute;
    use configs::tests_game_config::generate_game_config_for_tests;
    use uuid::uuid;

    const STARTER_CLASS_ID: uuid::Uuid = uuid!("5956e37c-ca7f-45cf-8bfb-49601dc9aca3");
    const ALT_CLASS_ID: uuid::Uuid = uuid!("95d314ee-ce2c-4b10-a8bc-596b0f03ab8a");
    // Currency id used as a placeholder price for ClassLevels rows. We never charge; this is just
    // shape-valid config data.
    const PLACEHOLDER_CURRENCY: uuid::Uuid = uuid!("b59b33a2-4d19-4e2c-9cea-e03ea15882a0");
    // Some attribute id that exists in tests_game_config and isn't already affected by the
    // base class/character/level bonuses we'd accidentally collide with.
    const TEST_ATTRIBUTE_ID: uuid::Uuid = uuid!("3a6ec1c8-7494-43df-a345-d23e297b892d");

    fn make_class_levels_row(class_id: uuid::Uuid, level: u64, value: u64) -> ClassLevels {
        ClassLevels {
            class_id,
            level,
            attrs: vec![EntityAttribute {
                attribute_id: TEST_ATTRIBUTE_ID,
                value,
            }],
            price: CurrencyUnit {
                currency_id: PLACEHOLDER_CURRENCY,
                amount: 0,
            },
            ability_levels: vec![],
        }
    }

    fn make_character_state(class_id: uuid::Uuid, character_class_level: u64) -> CharacterState {
        let character = CharacterBuilder::new()
            .with_class(class_id)
            .with_character_level(2)
            .build();
        let character_id = character.id;
        CharacterState {
            character,
            character_classes: vec![CharacterClass {
                character_id,
                class_id,
                level: character_class_level,
                xp: 0,
            }],
            ..Default::default()
        }
    }

    fn attr_value(stats: &EntityStats, attribute_code: &str) -> i64 {
        stats.attributes.0.get(attribute_code).copied().unwrap_or(0)
    }

    /// BAL-033: the rows are TOTAL snapshots, so the character wears the row of
    /// the level they reached — not that row plus every row below it.
    #[test]
    fn class_level_attrs_apply_up_to_current_level() {
        let mut config = generate_game_config_for_tests();
        config.class_levels = vec![
            make_class_levels_row(STARTER_CLASS_ID, 1, 5),
            make_class_levels_row(STARTER_CLASS_ID, 2, 7),
            make_class_levels_row(STARTER_CLASS_ID, 3, 11),
        ];

        let attribute_code = config
            .attributes
            .iter()
            .find(|a| a.id == TEST_ATTRIBUTE_ID)
            .expect("test attribute id must exist in test config")
            .code
            .clone();

        // Level 1: only the L1 row contributes (5).
        let cs_l1 = make_character_state(STARTER_CLASS_ID, 1);
        let stats_l1 =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs_l1), &config)
                .unwrap();
        let baseline = attr_value(&stats_l1, &attribute_code);

        // Level 2 wears the L2 row alone: +7 instead of the L1 row's +5, i.e.
        // two more than the baseline, not seven more.
        let cs_l2 = make_character_state(STARTER_CLASS_ID, 2);
        let stats_l2 =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs_l2), &config)
                .unwrap();
        assert_eq!(attr_value(&stats_l2, &attribute_code), baseline + 2);

        // Level 3 wears the L3 row alone: 11 against the L1 row's 5.
        let cs_l3 = make_character_state(STARTER_CLASS_ID, 3);
        let stats_l3 =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs_l3), &config)
                .unwrap();
        assert_eq!(attr_value(&stats_l3, &attribute_code), baseline + 6);
    }

    /// Class-level attrs are scoped to the active class — bonuses from rows belonging to a
    /// different class id are not included.
    #[test]
    fn class_level_attrs_only_apply_for_active_class() {
        let mut config = generate_game_config_for_tests();
        config.class_levels = vec![
            make_class_levels_row(STARTER_CLASS_ID, 1, 5),
            make_class_levels_row(ALT_CLASS_ID, 1, 99),
            make_class_levels_row(ALT_CLASS_ID, 2, 99),
        ];

        let attribute_code = config
            .attributes
            .iter()
            .find(|a| a.id == TEST_ATTRIBUTE_ID)
            .unwrap()
            .code
            .clone();

        // Active class STARTER_CLASS_ID at L1; ALT class also has rows but those must not apply.
        let mut cs = make_character_state(STARTER_CLASS_ID, 1);
        // Even if the player has a high-level entry for ALT in their character_classes, it
        // doesn't contribute while STARTER is active.
        cs.character_classes.push(CharacterClass {
            character_id: cs.character.id,
            class_id: ALT_CLASS_ID,
            level: 99,
            xp: 0,
        });
        let stats =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs), &config)
                .unwrap();
        let starter_only = attr_value(&stats, &attribute_code);

        // Compare against a control with only the STARTER row.
        let mut control = generate_game_config_for_tests();
        control.class_levels = vec![make_class_levels_row(STARTER_CLASS_ID, 1, 5)];
        let cs_control = make_character_state(STARTER_CLASS_ID, 1);
        let stats_control = calculate_player_entity_stats_with_zeroes(
            &EntityState::Character(&cs_control),
            &control,
        )
        .unwrap();
        assert_eq!(starter_only, attr_value(&stats_control, &attribute_code));
    }

    /// Character with no `character_classes` entry for the active class: no class-level bonuses
    /// apply (treated as no progression yet). Other sources still contribute normally.
    #[test]
    fn class_level_attrs_missing_character_class_entry_is_noop() {
        let mut config = generate_game_config_for_tests();
        config.class_levels = vec![
            make_class_levels_row(STARTER_CLASS_ID, 1, 5),
            make_class_levels_row(STARTER_CLASS_ID, 2, 7),
        ];

        let attribute_code = config
            .attributes
            .iter()
            .find(|a| a.id == TEST_ATTRIBUTE_ID)
            .unwrap()
            .code
            .clone();

        let mut cs = make_character_state(STARTER_CLASS_ID, 1);
        // Simulate a not-yet-migrated character: no character_classes rows at all.
        cs.character_classes.clear();

        let stats =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs), &config)
                .unwrap();

        // Compare against a config with no class_levels at all — should match exactly.
        let mut control = generate_game_config_for_tests();
        control.class_levels = vec![];
        let stats_control =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs), &control)
                .unwrap();
        assert_eq!(
            attr_value(&stats, &attribute_code),
            attr_value(&stats_control, &attribute_code)
        );
    }

    /// `hp.mod` / `hp.bonus` grants compose into the fight `max_hp` the same
    /// way `.mod`/`.bonus` compose for every combat stat:
    /// `(hp + hp.bonus) × (1 + mod/10000)`.
    #[test]
    fn hp_mod_and_bonus_scale_fight_max_hp() {
        let mut config = generate_game_config_for_tests();
        let hp_attribute = config
            .attributes
            .iter()
            .find(|a| a.id == config.game_settings.hp_attribute_id)
            .expect("hp attribute must exist in test config")
            .clone();

        // Register `hp.mod` / `hp.bonus` attributes and grant +50% mod and
        // +40 flat bonus via class levels.
        let hp_mod_id = uuid!("6f0a48f2-52aa-4a56-9d40-1de35bb2dd01");
        let mut hp_mod_attribute = hp_attribute.clone();
        hp_mod_attribute.id = hp_mod_id;
        hp_mod_attribute.code = "hp.mod".to_string();
        config.attributes.push(hp_mod_attribute);

        let hp_bonus_id = uuid!("6f0a48f2-52aa-4a56-9d40-1de35bb2dd02");
        let mut hp_bonus_attribute = hp_attribute.clone();
        hp_bonus_attribute.id = hp_bonus_id;
        hp_bonus_attribute.code = "hp.bonus".to_string();
        config.attributes.push(hp_bonus_attribute);

        config.class_levels = vec![ClassLevels {
            class_id: STARTER_CLASS_ID,
            level: 1,
            attrs: vec![
                EntityAttribute {
                    attribute_id: hp_mod_id,
                    value: 5000,
                },
                EntityAttribute {
                    attribute_id: hp_bonus_id,
                    value: 40,
                },
            ],
            price: CurrencyUnit {
                currency_id: PLACEHOLDER_CURRENCY,
                amount: 0,
            },
            ability_levels: vec![],
        }];

        let baseline_config = {
            let mut control = generate_game_config_for_tests();
            control.class_levels = vec![];
            control
        };
        let cs = make_character_state(STARTER_CLASS_ID, 1);

        let baseline = calculate_player_entity_stats_with_zeroes(
            &EntityState::Character(&cs),
            &baseline_config,
        )
        .unwrap();
        let raw_hp = attr_value(&baseline, "hp");
        assert!(raw_hp > 0, "the test character must have base hp");
        assert_eq!(baseline.max_hp, raw_hp as u64);

        let stats =
            calculate_player_entity_stats_with_zeroes(&EntityState::Character(&cs), &config)
                .unwrap();
        assert_eq!(stats.max_hp, (((raw_hp + 40) as f64) * 1.5).floor() as u64);
    }
}