overlord_event_system/

game_config_helpers.rs

use anyhow::Context;

use configs::{
    abilities::{AbilityCasesSettingsByLevel, AbilityLevel, Projectile, ProjectileId},
    cheats::{CheatScript, CheatScriptId},
    fighting::ArenaLeague,
    game_config::GameConfig,
    pets::{PetCasesSettingsByLevel, PetLevel},
    stones::{EffectStoneTemplate, TriggerStoneTemplate},
};

use essences::{
    abilities::{AbilityId, AbilityRarity, AbilityRarityId, AbilityTemplate},
    ability_stones::AbilityStoneId,
    bundles::{BundleId, BundleRaw},
    class::{Class, ClassId},
    dungeons::{DungeonTemplate, DungeonTemplateId},
    effect::{Effect, EffectId},
    fighting::{FightTemplate, FightTemplateId},
    game::{Chapter, CharacterLevel, EntityTemplate, EntityTemplateId},
    gift::GiftTemplate,
    item_case::ItemCasesSettingsByLevel,
    items::{Attribute, AttributeId, ItemRarity, ItemRarityId, ItemTemplate, ItemTemplateId},
    mail::MailTemplate,
    pets::{PetId, PetRarity, PetRarityId, PetTemplate},
    quest::QuestTemplate,
    referrals::ReferralLevelInfo,
    skins::{ConfigSkin, SkinId},
    stones::StoneTemplateId,
    talent_tree::{TalentId, TalentTemplate},
    vassals::VassalTaskTemplate,
};

pub trait GameConfigLookup {
    fn attribute(&self, attribute_id: AttributeId) -> Option<&Attribute>;
    fn require_attribute(&self, attribute_id: AttributeId) -> anyhow::Result<&Attribute>;

    fn attribute_by_db_code(&self, db_code: u8) -> Option<&Attribute>;
    fn require_attribute_by_db_code(&self, db_code: u8) -> anyhow::Result<&Attribute>;

    fn ability_template(&self, ability_id: AbilityId) -> Option<&AbilityTemplate>;
    fn require_ability_template(&self, ability_id: AbilityId) -> anyhow::Result<&AbilityTemplate>;

    fn ability_rarity(&self, rarity_id: AbilityRarityId) -> Option<&AbilityRarity>;
    fn require_ability_rarity(&self, rarity_id: AbilityRarityId) -> anyhow::Result<&AbilityRarity>;

    fn ability_stone_template(
        &self,
        stone_id: AbilityStoneId,
    ) -> Option<&essences::ability_stones::AbilityStoneTemplate>;

    fn ability_level(&self, rarity_id: AbilityRarityId, level: i64) -> Option<&AbilityLevel>;
    fn require_ability_level(
        &self,
        rarity_id: AbilityRarityId,
        level: i64,
    ) -> anyhow::Result<&AbilityLevel>;

    fn ability_case_settings_by_level(&self, level: i64) -> Option<&AbilityCasesSettingsByLevel>;
    fn require_ability_case_settings_by_level(
        &self,
        level: i64,
    ) -> anyhow::Result<&AbilityCasesSettingsByLevel>;

    fn bundle(&self, bundle_id: BundleId) -> Option<&BundleRaw>;
    fn require_bundle(&self, bundle_id: BundleId) -> anyhow::Result<&BundleRaw>;

    fn chapter_by_level(&self, chapter_level: i64) -> Option<&Chapter>;
    fn require_chapter_by_level(&self, chapter_level: i64) -> anyhow::Result<&Chapter>;

    fn ability_slots_for_chapter_level(&self, chapter_level: i64) -> Option<u64>;

    fn character_level(&self, level: i64) -> Option<CharacterLevel>;
    fn require_character_level(&self, level: i64) -> anyhow::Result<CharacterLevel>;
    /// Highest level reachable with `experience`, unbounded via the level formula.
    fn level_for_experience(&self, experience: i64) -> i64;

    fn class(&self, class_id: ClassId) -> Option<&Class>;
    fn require_class(&self, class_id: ClassId) -> anyhow::Result<&Class>;

    fn dungeon_template(&self, dungeon_id: DungeonTemplateId) -> Option<&DungeonTemplate>;
    fn require_dungeon_template(
        &self,
        dungeon_id: DungeonTemplateId,
    ) -> anyhow::Result<&DungeonTemplate>;

    fn effect(&self, effect_id: EffectId) -> Option<&Effect>;
    fn require_effect(&self, effect_id: EffectId) -> anyhow::Result<&Effect>;

    fn fight_template(&self, fight_id: FightTemplateId) -> Option<&FightTemplate>;
    fn require_fight_template(&self, fight_id: FightTemplateId) -> anyhow::Result<&FightTemplate>;

    fn arena_league_for_rating(&self, rating: i64) -> Option<&ArenaLeague>;
    fn require_arena_league_for_rating(&self, rating: i64) -> anyhow::Result<&ArenaLeague>;

    fn entity_template(&self, entity_template_id: EntityTemplateId) -> Option<&EntityTemplate>;
    fn require_entity_template(
        &self,
        entity_template_id: EntityTemplateId,
    ) -> anyhow::Result<&EntityTemplate>;

    fn gift_template(&self, gift_id: uuid::Uuid) -> Option<&GiftTemplate>;
    fn require_gift_template(&self, gift_id: uuid::Uuid) -> anyhow::Result<&GiftTemplate>;

    fn item_case_settings_by_level(&self, level: i64) -> Option<&ItemCasesSettingsByLevel>;
    fn require_item_case_settings_by_level(
        &self,
        level: i64,
    ) -> anyhow::Result<&ItemCasesSettingsByLevel>;

    fn item_rarity(&self, rarity_id: ItemRarityId) -> Option<&ItemRarity>;
    fn require_item_rarity(&self, rarity_id: ItemRarityId) -> anyhow::Result<&ItemRarity>;

    fn item_template(&self, item_id: ItemTemplateId) -> Option<&ItemTemplate>;
    fn require_item_template(&self, item_id: ItemTemplateId) -> anyhow::Result<&ItemTemplate>;

    fn mail_template(&self, template_id: uuid::Uuid) -> Option<&MailTemplate>;
    fn require_mail_template(&self, template_id: uuid::Uuid) -> anyhow::Result<&MailTemplate>;

    fn patron_level_info(&self, level: i64) -> Option<&ReferralLevelInfo>;
    fn require_patron_level_info(&self, level: i64) -> anyhow::Result<&ReferralLevelInfo>;

    fn projectile(&self, projectile_id: ProjectileId) -> Option<&Projectile>;
    fn require_projectile(&self, projectile_id: ProjectileId) -> anyhow::Result<&Projectile>;

    fn quest(&self, quest_id: uuid::Uuid) -> Option<&QuestTemplate>;
    fn require_quest(&self, quest_id: uuid::Uuid) -> anyhow::Result<&QuestTemplate>;

    fn quest_by_code(&self, code: &str) -> Option<&QuestTemplate>;

    fn skin(&self, skin_id: SkinId) -> Option<&ConfigSkin>;
    fn require_skin(&self, skin_id: SkinId) -> anyhow::Result<&ConfigSkin>;

    fn vassal_task_template(&self, task_template_id: uuid::Uuid) -> Option<&VassalTaskTemplate>;
    fn require_vassal_task_template(
        &self,
        task_template_id: uuid::Uuid,
    ) -> anyhow::Result<&VassalTaskTemplate>;

    fn cheat_script(&self, cheat_script_id: CheatScriptId) -> Option<&CheatScript>;

    fn talent(&self, talent_id: TalentId) -> Option<&TalentTemplate>;
    fn require_talent(&self, talent_id: TalentId) -> anyhow::Result<&TalentTemplate>;

    fn allowed_wishlist_rarity_ids(
        &self,
        ability_case_level: i64,
    ) -> Vec<essences::abilities::AbilityRarityId>;

    fn pet_template(&self, pet_id: PetId) -> Option<&PetTemplate>;
    fn require_pet_template(&self, pet_id: PetId) -> anyhow::Result<&PetTemplate>;

    fn pet_rarity(&self, rarity_id: PetRarityId) -> Option<&PetRarity>;

    fn pet_level(&self, rarity_id: PetRarityId, level: i64) -> Option<&PetLevel>;

    fn pet_slots_for_chapter_level(&self, chapter_level: i64) -> Option<u64>;

    fn pet_case_settings_by_level(&self, level: i64) -> Option<&PetCasesSettingsByLevel>;
    fn require_pet_case_settings_by_level(
        &self,
        level: i64,
    ) -> anyhow::Result<&PetCasesSettingsByLevel>;

    fn allowed_pet_wishlist_rarity_ids(
        &self,
        pet_case_level: i64,
    ) -> Vec<essences::pets::PetRarityId>;

    /// Catalog entry an owned Trigger Stone is a copy of.
    ///
    /// Deliberately has no `require_*` twin. `character_stones.template_id` is
    /// registered with `collection: none`, so the deploy-time orphan check does
    /// not cover it and `row_to_stone` does not validate against config: a
    /// template deleted while players own copies leaves live rows pointing
    /// nowhere. Every caller must skip-and-log such a stone, never fail the
    /// session.
    fn trigger_stone_template(&self, template_id: StoneTemplateId)
    -> Option<&TriggerStoneTemplate>;

    /// Catalog entry an owned Effect Stone is a copy of. Same no-`require_*`
    /// rule as [`GameConfigLookup::trigger_stone_template`].
    fn effect_stone_template(&self, template_id: StoneTemplateId) -> Option<&EffectStoneTemplate>;
}

impl GameConfigLookup for GameConfig {
    fn attribute(&self, attribute_id: AttributeId) -> Option<&Attribute> {
        self.attributes.iter().find(|a| a.id == attribute_id)
    }

    fn require_attribute(&self, attribute_id: AttributeId) -> anyhow::Result<&Attribute> {
        self.attribute(attribute_id)
            .with_context(|| format!("No attribute in config with id={attribute_id}"))
    }

    fn attribute_by_db_code(&self, db_code: u8) -> Option<&Attribute> {
        self.attributes.iter().find(|a| a.db_code == db_code)
    }

    fn require_attribute_by_db_code(&self, db_code: u8) -> anyhow::Result<&Attribute> {
        self.attribute_by_db_code(db_code)
            .with_context(|| format!("No attribute in config with db_code={db_code}"))
    }

    fn ability_template(&self, ability_id: AbilityId) -> Option<&AbilityTemplate> {
        self.abilities.iter().find(|a| a.id == ability_id)
    }

    fn require_ability_template(&self, ability_id: AbilityId) -> anyhow::Result<&AbilityTemplate> {
        self.ability_template(ability_id)
            .with_context(|| format!("No ability_template in config with id={ability_id}"))
    }

    fn ability_rarity(&self, rarity_id: AbilityRarityId) -> Option<&AbilityRarity> {
        self.ability_rarities.iter().find(|r| r.id == rarity_id)
    }

    fn require_ability_rarity(&self, rarity_id: AbilityRarityId) -> anyhow::Result<&AbilityRarity> {
        self.ability_rarity(rarity_id)
            .with_context(|| format!("No ability_rarity in config with id={rarity_id}"))
    }

    fn ability_stone_template(
        &self,
        stone_id: AbilityStoneId,
    ) -> Option<&essences::ability_stones::AbilityStoneTemplate> {
        self.ability_stones.iter().find(|s| s.id == stone_id)
    }

    fn ability_level(&self, rarity_id: AbilityRarityId, level: i64) -> Option<&AbilityLevel> {
        self.ability_levels
            .iter()
            .find(|x| x.rarity_id == rarity_id && x.level == level)
    }

    fn require_ability_level(
        &self,
        rarity_id: AbilityRarityId,
        level: i64,
    ) -> anyhow::Result<&AbilityLevel> {
        self.ability_level(rarity_id, level).with_context(|| {
            format!("No ability_level in config with rarity_id={rarity_id} and level={level}")
        })
    }

    fn ability_case_settings_by_level(&self, level: i64) -> Option<&AbilityCasesSettingsByLevel> {
        self.ability_cases_settings
            .iter()
            .find(|x| x.level == level)
    }

    fn require_ability_case_settings_by_level(
        &self,
        level: i64,
    ) -> anyhow::Result<&AbilityCasesSettingsByLevel> {
        self.ability_case_settings_by_level(level)
            .with_context(|| format!("No ability_case_settings with level={level}"))
    }

    fn bundle(&self, bundle_id: BundleId) -> Option<&BundleRaw> {
        self.bundles.iter().find(|b| b.id == bundle_id)
    }

    fn require_bundle(&self, bundle_id: BundleId) -> anyhow::Result<&BundleRaw> {
        self.bundle(bundle_id)
            .with_context(|| format!("No bundle in config with id={bundle_id}"))
    }

    fn chapter_by_level(&self, chapter_level: i64) -> Option<&Chapter> {
        self.chapters.iter().find(|c| c.level == chapter_level)
    }

    fn require_chapter_by_level(&self, chapter_level: i64) -> anyhow::Result<&Chapter> {
        self.chapter_by_level(chapter_level)
            .with_context(|| format!("No chapter with level={chapter_level}"))
    }

    fn ability_slots_for_chapter_level(&self, chapter_level: i64) -> Option<u64> {
        self.ability_slots_levels
            .iter()
            .rev()
            .find(|level| level.from_chapter_level <= chapter_level)
            .map(|level| level.ability_slots)
    }

    fn character_level(&self, level: i64) -> Option<CharacterLevel> {
        // Above the authored table the level is computed from the formula, so
        // levels are unbounded. At or below the anchor the authored table wins.
        if level > self.character_level_formula.anchor_level {
            return Some(self.character_level_formula.character_level(level));
        }
        self.character_levels
            .iter()
            .find(|x| x.level == level)
            .cloned()
    }

    fn require_character_level(&self, level: i64) -> anyhow::Result<CharacterLevel> {
        self.character_level(level)
            .with_context(|| format!("No character_level with level={level}"))
    }

    fn level_for_experience(&self, experience: i64) -> i64 {
        let formula = &self.character_level_formula;
        if experience >= formula.anchor_experience {
            return formula.level_for_experience(experience);
        }
        // Below the anchor: highest authored level whose requirement is met.
        self.character_levels
            .iter()
            .filter(|x| x.required_experience <= experience)
            .map(|x| x.level)
            .max()
            .unwrap_or(0)
    }

    fn class(&self, class_id: ClassId) -> Option<&Class> {
        self.classes.iter().find(|c| c.id == class_id)
    }

    fn require_class(&self, class_id: ClassId) -> anyhow::Result<&Class> {
        self.class(class_id)
            .with_context(|| format!("No class in config with id={class_id}"))
    }

    fn dungeon_template(&self, dungeon_id: DungeonTemplateId) -> Option<&DungeonTemplate> {
        self.dungeon_templates.iter().find(|d| d.id == dungeon_id)
    }

    fn require_dungeon_template(
        &self,
        dungeon_id: DungeonTemplateId,
    ) -> anyhow::Result<&DungeonTemplate> {
        self.dungeon_template(dungeon_id)
            .with_context(|| format!("No dungeon_template in config with id={dungeon_id}"))
    }

    fn effect(&self, effect_id: EffectId) -> Option<&Effect> {
        self.effects.iter().find(|e| e.id == effect_id)
    }

    fn require_effect(&self, effect_id: EffectId) -> anyhow::Result<&Effect> {
        self.effect(effect_id)
            .with_context(|| format!("No effect in config with id={effect_id}"))
    }

    fn fight_template(&self, fight_id: FightTemplateId) -> Option<&FightTemplate> {
        self.fight_templates.iter().find(|f| f.id == fight_id)
    }

    fn require_fight_template(&self, fight_id: FightTemplateId) -> anyhow::Result<&FightTemplate> {
        self.fight_template(fight_id)
            .with_context(|| format!("No fight_template in config with id={fight_id}"))
    }

    fn arena_league_for_rating(&self, rating: i64) -> Option<&ArenaLeague> {
        self.arena_leagues
            .iter()
            .find(|league| rating >= league.min_rating && rating <= league.max_rating)
    }

    fn require_arena_league_for_rating(&self, rating: i64) -> anyhow::Result<&ArenaLeague> {
        self.arena_league_for_rating(rating)
            .with_context(|| format!("No arena_league in config for rating={rating}"))
    }

    fn entity_template(&self, entity_template_id: EntityTemplateId) -> Option<&EntityTemplate> {
        self.entities.iter().find(|e| e.id == entity_template_id)
    }

    fn require_entity_template(
        &self,
        entity_template_id: EntityTemplateId,
    ) -> anyhow::Result<&EntityTemplate> {
        self.entity_template(entity_template_id)
            .with_context(|| format!("No entity_template in config with id={entity_template_id}"))
    }

    fn gift_template(&self, gift_id: uuid::Uuid) -> Option<&GiftTemplate> {
        self.gifts.iter().find(|g| g.id == gift_id)
    }

    fn require_gift_template(&self, gift_id: uuid::Uuid) -> anyhow::Result<&GiftTemplate> {
        self.gift_template(gift_id)
            .with_context(|| format!("No gift_template in config with id={gift_id}"))
    }

    fn item_case_settings_by_level(&self, level: i64) -> Option<&ItemCasesSettingsByLevel> {
        self.item_cases_settings.iter().find(|s| s.level == level)
    }

    fn require_item_case_settings_by_level(
        &self,
        level: i64,
    ) -> anyhow::Result<&ItemCasesSettingsByLevel> {
        self.item_case_settings_by_level(level)
            .with_context(|| format!("No item_case_settings with level={level}"))
    }

    fn item_rarity(&self, rarity_id: ItemRarityId) -> Option<&ItemRarity> {
        self.item_rarities.iter().find(|r| r.id == rarity_id)
    }

    fn require_item_rarity(&self, rarity_id: ItemRarityId) -> anyhow::Result<&ItemRarity> {
        self.item_rarity(rarity_id)
            .with_context(|| format!("No item_rarity in config with id={rarity_id}"))
    }

    fn item_template(&self, item_id: ItemTemplateId) -> Option<&ItemTemplate> {
        self.items.iter().find(|i| i.id == item_id)
    }

    fn require_item_template(&self, item_id: ItemTemplateId) -> anyhow::Result<&ItemTemplate> {
        self.item_template(item_id)
            .with_context(|| format!("No item_template in config with id={item_id}"))
    }

    fn mail_template(&self, template_id: uuid::Uuid) -> Option<&MailTemplate> {
        self.mail_templates.iter().find(|t| t.id == template_id)
    }

    fn require_mail_template(&self, template_id: uuid::Uuid) -> anyhow::Result<&MailTemplate> {
        self.mail_template(template_id)
            .with_context(|| format!("No mail_template in config with id={template_id}"))
    }

    fn patron_level_info(&self, level: i64) -> Option<&ReferralLevelInfo> {
        self.patron_levels.iter().find(|x| x.level == level)
    }

    fn require_patron_level_info(&self, level: i64) -> anyhow::Result<&ReferralLevelInfo> {
        self.patron_level_info(level)
            .with_context(|| format!("No patron_level_info in config with level={level}"))
    }

    fn projectile(&self, projectile_id: ProjectileId) -> Option<&Projectile> {
        self.projectiles.iter().find(|p| p.id == projectile_id)
    }

    fn require_projectile(&self, projectile_id: ProjectileId) -> anyhow::Result<&Projectile> {
        self.projectile(projectile_id)
            .with_context(|| format!("No projectile in config with id={projectile_id}"))
    }

    fn quest(&self, quest_id: uuid::Uuid) -> Option<&QuestTemplate> {
        self.quests.iter().find(|q| q.id == quest_id)
    }

    fn require_quest(&self, quest_id: uuid::Uuid) -> anyhow::Result<&QuestTemplate> {
        self.quest(quest_id)
            .with_context(|| format!("No quest in config with id={quest_id}"))
    }

    fn quest_by_code(&self, code: &str) -> Option<&QuestTemplate> {
        self.quests.iter().find(|q| q.code.as_deref() == Some(code))
    }

    fn skin(&self, skin_id: SkinId) -> Option<&ConfigSkin> {
        self.skins.iter().find(|s| s.id == skin_id)
    }

    fn require_skin(&self, skin_id: SkinId) -> anyhow::Result<&ConfigSkin> {
        self.skin(skin_id)
            .with_context(|| format!("No skin in config with id={skin_id}"))
    }

    fn vassal_task_template(&self, task_template_id: uuid::Uuid) -> Option<&VassalTaskTemplate> {
        self.vassal_tasks.iter().find(|t| t.id == task_template_id)
    }

    fn require_vassal_task_template(
        &self,
        task_template_id: uuid::Uuid,
    ) -> anyhow::Result<&VassalTaskTemplate> {
        self.vassal_task_template(task_template_id)
            .with_context(|| {
                format!("No vassal_task_template in config with id={task_template_id}")
            })
    }

    fn cheat_script(&self, cheat_script_id: CheatScriptId) -> Option<&CheatScript> {
        self.cheat_scripts.iter().find(|c| c.id == cheat_script_id)
    }

    fn talent(&self, talent_id: TalentId) -> Option<&TalentTemplate> {
        self.talents.iter().find(|t| t.id == talent_id)
    }

    fn require_talent(&self, talent_id: TalentId) -> anyhow::Result<&TalentTemplate> {
        self.talent(talent_id)
            .with_context(|| format!("No talent in config with id={talent_id}"))
    }

    fn allowed_wishlist_rarity_ids(&self, ability_case_level: i64) -> Vec<AbilityRarityId> {
        self.ability_case_settings_by_level(ability_case_level)
            .map(|settings| settings.allowed_wishlist_rarity_ids.clone())
            .unwrap_or_default()
    }

    fn pet_template(&self, pet_id: PetId) -> Option<&PetTemplate> {
        self.pet_templates.iter().find(|t| t.id == pet_id)
    }

    fn require_pet_template(&self, pet_id: PetId) -> anyhow::Result<&PetTemplate> {
        self.pet_template(pet_id)
            .with_context(|| format!("No pet_template in config with id={pet_id}"))
    }

    fn pet_rarity(&self, rarity_id: PetRarityId) -> Option<&PetRarity> {
        self.pet_rarities.iter().find(|r| r.id == rarity_id)
    }

    fn pet_level(&self, rarity_id: PetRarityId, level: i64) -> Option<&PetLevel> {
        self.pet_levels
            .iter()
            .find(|x| x.rarity_id == rarity_id && x.level == level)
    }

    fn pet_slots_for_chapter_level(&self, chapter_level: i64) -> Option<u64> {
        self.pet_slots_levels
            .iter()
            .rev()
            .find(|level| level.from_chapter_level <= chapter_level)
            .map(|level| level.pet_slots)
    }

    fn pet_case_settings_by_level(&self, level: i64) -> Option<&PetCasesSettingsByLevel> {
        self.pet_cases_settings.iter().find(|x| x.level == level)
    }

    fn require_pet_case_settings_by_level(
        &self,
        level: i64,
    ) -> anyhow::Result<&PetCasesSettingsByLevel> {
        self.pet_case_settings_by_level(level)
            .with_context(|| format!("No pet_case_settings with level={level}"))
    }

    fn allowed_pet_wishlist_rarity_ids(
        &self,
        pet_case_level: i64,
    ) -> Vec<essences::pets::PetRarityId> {
        self.pet_case_settings_by_level(pet_case_level)
            .map(|settings| settings.allowed_wishlist_rarity_ids.clone())
            .unwrap_or_default()
    }

    fn trigger_stone_template(
        &self,
        template_id: StoneTemplateId,
    ) -> Option<&TriggerStoneTemplate> {
        self.trigger_stones.iter().find(|t| t.id == template_id)
    }

    fn effect_stone_template(&self, template_id: StoneTemplateId) -> Option<&EffectStoneTemplate> {
        self.effect_stones.iter().find(|t| t.id == template_id)
    }
}