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> {
    let mut attributes = entity::EntityAttributes::default();
    let mut max_hp = 0;

    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);
        };

        if attribute_delta.0 == game_config.game_settings.hp_attribute_id {
            max_hp += attribute_delta.1 as u64;
        }

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

    Ok(EntityStats { attributes, max_hp })
}

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_class_level_attribute_bonuses(entity_state, game_config, &mut attributes_deltas);

    calculate_entity_stats(game_config, attributes_deltas)
}

/// Accumulate per-level attribute bonuses for the character's active class. Walks every
/// `ClassLevels` row for the active class with `level <= character_class.level` and sums the
/// `attrs` values. The active class is read from `character.class`, the level from the matching
/// `character_classes` entry. Missing entry → no bonuses (treated as L1 with no level rows
/// applied yet).
///
/// Crucially these bonuses are scoped to the active class, so a respec drops them and a
/// switch back restores them — class-level progression is not "permanent character growth."
fn aggregate_class_level_attribute_bonuses(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let EntityState::Character(character_state) = entity_state else {
        return;
    };
    let active_class_id = character_state.character.class;
    let Some(active) = character_state
        .character_classes
        .iter()
        .find(|cc| cc.class_id == active_class_id)
    else {
        return;
    };
    for row in &game_config.class_levels {
        if row.class_id != active_class_id || row.level > active.level {
            continue;
        }
        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.
fn aggregate_talent_attribute_bonuses(
    entity_state: &EntityState,
    talents: &[TalentTemplate],
    attributes_deltas: &mut AttributeDeltas,
) {
    let EntityState::Character(character_state) = entity_state else {
        return;
    };
    for talent in talents {
        let Some(&level) = character_state.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 flat attribute bonuses from the active statue set.
fn aggregate_statue_attribute_bonuses(
    entity_state: &EntityState,
    game_config: &game_config::GameConfig,
    attributes_deltas: &mut AttributeDeltas,
) {
    let EntityState::Character(character_state) = entity_state else {
        return;
    };
    let statue = &character_state.statue_state;
    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;
    }
}

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)
    }

    /// Walks `class_levels` rows up to the active class's level and sums their attrs into the
    /// computed player attributes.
    #[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: L1 + L2 (5 + 7 = +7 over baseline).
        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 + 7);

        // Level 3: L1 + L2 + L3 (5 + 7 + 11 = +18 over baseline).
        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 + 7 + 11);
    }

    /// 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)
        );
    }
}