overlord_event_system/

state.rs

use std::collections::HashMap;

use configs::game_config::GameConfig;
use essences::abilities::{
    Ability, AbilityRarity, AbilityTemplate, EquippedAbilities, UpgradedAbilitiesMap,
};
use essences::arena::Arena;
use essences::autochest::AutoChest;
use essences::bots::Bot;
use essences::bundles::{BundleElement, BundleId};
use essences::character_state::CharacterState;
use essences::characters::Character;
use essences::currency::CurrencyUnit;
use essences::dungeons::Dungeons;
use essences::effect::Effect;
use essences::entity::{Entity, EntityAttributes};
use essences::fighting::{ActiveDungeon, ActiveFight, EntityTeam};
use essences::game::{Chapter, EntityAttribute};
use essences::gift::Gift;
use essences::items::{Attribute, Item, ItemAttribute, ItemRarity, ItemType};
use essences::mail::Mail;
use essences::offers::OffersInfo;
use essences::opponents::RatingCalculationData;
use essences::pets::{
    EquippedPets, Pet, PetComputedSecondaryStat, PetRarity, PetTemplate, UpgradedPetsMap,
};
use essences::prelude::*;
use essences::pvp::PVPState;
use essences::quest::{QuestInstance, QuestsGroups};
use essences::referrals::Patron;
use essences::talent_tree::TalentLevelsMap;
use essences::types::CustomValuesMap;
use essences::vassals::{Suzerain, Vassal, VassalTask};

use event_system::state::State;

use crate::bundles::{bundle_raw_afk_step_to_element, bundle_raw_step_to_element};
use crate::event::OverlordEvent;
use crate::game_config_helpers::GameConfigLookup;
use crate::party::Party;
use crate::script::ScriptRunner;
use schemars::JsonSchema;
use strum::{EnumIter, IntoEnumIterator};

/// Status value stored in the `user_accesses` table (e.g. admin). Used when querying DB.
#[derive(
    Clone, Copy, PartialEq, Eq, Debug, Tsify, Serialize, Deserialize, JsonSchema, EnumIter,
)]
#[serde(rename_all = "lowercase")]
pub enum UserStatus {
    Admin,
    Banned,
}

impl UserStatus {
    /// String stored in the database.
    pub fn as_str(self) -> &'static str {
        match self {
            UserStatus::Admin => "admin",
            UserStatus::Banned => "banned",
        }
    }
}

/// Permission flags for the current user (e.g. cheats, logout).
/// Populated from the `user_accesses` table when state is loaded; e.g. status `admin` grants all.
#[derive(Clone, PartialEq, Eq, Debug, Tsify, Serialize, Deserialize, JsonSchema, EnumIter)]
pub enum UserPermissions {
    CheatsAccess,
    LogOutAccess,
}

impl UserPermissions {
    /// All permission variants. Admin users receive this full list so new variants are included automatically.
    pub fn all() -> Vec<Self> {
        Self::iter().collect()
    }
}

#[derive(
    Clone, PartialEq, Eq, Default, Debug, CustomType, Tsify, Serialize, Deserialize, JsonSchema,
)]
#[tsify(into_wasm_abi)]
pub struct OverlordState {
    pub character_state: CharacterState,
    pub blocked_character_ids: Vec<uuid::Uuid>,
    pub active_fight: Option<ActiveFight>,
    pub pvp_state: Option<PVPState>,
    pub connection_store: HashMap<String, i64>,
    pub quest_groups: QuestsGroups,
    pub incoming_gifts: Vec<Gift>,
    pub incoming_mails: Vec<Mail>,
    pub patron: Option<Patron>,
    pub referral_daily_reward_claimed: Option<bool>,
    pub auto_chest: AutoChest,
    pub arena: Arena,
    pub dungeons: Dungeons,
    pub offers_info: OffersInfo,
    pub permissions: Vec<UserPermissions>,
    pub party: Party,
}

impl State for OverlordState {
    /// Compares version from database with local
    fn cmp_db_updated(&self, db_updated: &Self) -> bool {
        self.character_state.character == db_updated.character_state.character
            && self.character_state.inventory == db_updated.character_state.inventory
    }

    fn register_rhai_type(engine: &mut rhai::Engine) {
        engine.build_type::<Self>();
        engine.register_iterator::<Vec<QuestInstance>>();
        engine.register_iterator::<Vec<Ability>>();
        engine.register_iterator::<Vec<CurrencyUnit>>();
        engine.register_iterator::<Vec<Entity>>();
        engine.register_iterator::<Vec<EntityAttribute>>();
        engine.register_iterator::<Vec<Gift>>();
        engine.register_iterator::<Vec<Mail>>();
        engine.register_iterator::<Vec<Item>>();
        engine.register_iterator::<Vec<ItemAttribute>>();
        engine.register_iterator::<Vec<Suzerain>>();
        engine.register_iterator::<Vec<Vassal>>();
        engine.register_iterator::<Vec<VassalTask>>();
        engine.register_iterator::<Vec<Pet>>();
        engine.register_iterator::<Vec<PetComputedSecondaryStat>>();

        engine.register_indexer_get::<Vec<Entity>, i64, false, Entity, true>(
            |this: &mut Vec<Entity>, idx: i64| -> Result<Entity, Box<rhai::EvalAltResult>> {
                match this.get(idx as usize) {
                    Some(value) => Ok(value.clone()),
                    None => Err(Box::new(
                        format!("index out of bounds: {} > {}", idx, this.len()).into(),
                    )),
                }
            },
        );
        engine.register_get::<Vec<Entity>, false, i64, false>(
            "len",
            |this: &mut Vec<Entity>| -> i64 { this.len() as i64 },
        );
        engine.register_get::<Vec<Item>, false, i64, false>("len", |this: &mut Vec<Item>| -> i64 {
            this.len() as i64
        });

        engine.build_type::<Ability>();
        engine.build_type::<AbilityRarity>();
        engine.build_type::<ActiveFight>();
        engine.build_type::<ActiveDungeon>();
        engine.build_type::<QuestInstance>();
        engine.build_type::<QuestsGroups>();
        engine.build_type::<Attribute>();
        engine.build_type::<Chapter>();
        engine.build_type::<CurrencyUnit>();
        engine.build_type::<Effect>();
        engine.build_type::<Entity>();
        engine.build_type::<EntityAttribute>();
        engine.build_type::<EntityAttributes>();
        engine.build_type::<EntityTeam>();
        engine.build_type::<EquippedAbilities>();
        engine.build_type::<CustomValuesMap>();
        engine.build_type::<Gift>();
        engine.build_type::<Mail>();
        engine.build_type::<Item>();
        engine.build_type::<ItemType>();
        engine.build_type::<ItemAttribute>();
        engine.build_type::<ItemRarity>();
        engine.build_type::<Patron>();
        engine.build_type::<Suzerain>();
        engine.build_type::<Character>();
        engine.build_type::<CharacterState>();
        engine.build_type::<Vassal>();
        engine.build_type::<VassalTask>();
        engine.build_type::<RatingCalculationData>();
        engine.build_type::<Bot>();
        engine.build_type::<UpgradedAbilitiesMap>();
        engine.build_type::<Pet>();
        engine.build_type::<PetRarity>();
        engine.build_type::<PetTemplate>();
        engine.build_type::<EquippedPets>();
        engine.build_type::<UpgradedPetsMap>();
        engine.build_type::<PetComputedSecondaryStat>();
        engine.build_type::<Party>();
        engine.build_type::<TalentLevelsMap>();
    }

    fn is_ticker_paused(&self) -> bool {
        self.active_fight.as_ref().is_some_and(|fight| fight.paused)
    }
}

impl OverlordState {
    pub fn claim_vassal_reward(
        &mut self,
        vassal_id: uuid::Uuid,
        claim_time: chrono::DateTime<chrono::Utc>,
    ) -> anyhow::Result<()> {
        match self
            .character_state
            .vassals
            .iter_mut()
            .find(|vassal| vassal.character_id == vassal_id)
        {
            Some(vassal) => {
                vassal.claim_reward(claim_time);
                Ok(())
            }
            None => anyhow::bail!("No vassal with given id={}", vassal_id),
        }
    }

    pub fn claim_suzerain_reward(
        &mut self,
        claim_time: chrono::DateTime<chrono::Utc>,
    ) -> anyhow::Result<()> {
        let Some(mut suzerain) = self.character_state.suzerain.clone() else {
            anyhow::bail!("No suzerain to update")
        };
        suzerain.claim_reward(claim_time);
        Ok(())
    }

    pub fn compute_description_values_for_ability(
        &self,
        ability: &Ability,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
        config: &GameConfig,
    ) -> Vec<f64> {
        let Some(template) = config.ability_template(ability.template_id) else {
            tracing::error!(
                "Failed to get template for ability template_id={}",
                ability.template_id
            );
            return vec![];
        };

        let Some(ref description_script) = template.description_values_script else {
            return vec![];
        };

        script_runner.run_description_values_calculate(
            |scope_setter| scope_setter,
            description_script,
            ability.level,
        )
    }

    pub fn compute_description_values_for_talent(
        &self,
        talent_template: &essences::talent_tree::TalentTemplate,
        level: i64,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
    ) -> Vec<f64> {
        let Some(ref description_script) = talent_template.description_values_script else {
            return vec![];
        };

        script_runner.run_talent_description_values_calculate(
            |scope_setter| scope_setter,
            description_script,
            level,
        )
    }

    pub fn compute_description_values_template(
        &self,
        ability_template: &AbilityTemplate,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
        config: &GameConfig,
    ) -> Vec<f64> {
        let ability = Ability::from_template(ability_template, None, None);

        self.compute_description_values_for_ability(&ability, script_runner, config)
    }

    pub fn compute_afk_reward(
        &self,
        game_config: &GameConfig,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
    ) -> Vec<BundleElement> {
        let mut elements = vec![];

        let Some(bundle) = game_config.bundle(game_config.afk_rewards_settings.bundle_id) else {
            tracing::error!(
                "Couldn't find afk bundle with id = {}",
                game_config.afk_rewards_settings.bundle_id
            );
            return vec![];
        };

        let now = ::time::utc_now();

        for step in &bundle.steps {
            elements.push(bundle_raw_afk_step_to_element(
                step,
                &self.character_state,
                now,
                script_runner,
                game_config,
            ));
        }

        elements
    }

    pub fn compute_afk_instant_reward(
        &self,
        game_config: &GameConfig,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
    ) -> Vec<BundleElement> {
        let mut elements = vec![];

        let Some(bundle) = game_config.bundle(game_config.afk_rewards_settings.bundle_id) else {
            tracing::error!(
                "Couldn't find afk bundle with id = {}",
                game_config.afk_rewards_settings.bundle_id
            );
            return vec![];
        };

        let afk_settings = &game_config.afk_rewards_settings;
        let duration_sec = afk_settings
            .instant_reward_duration_sec
            .min(afk_settings.max_possible_time_sec);
        let fake_now = self.character_state.character.last_afk_reward_claimed_at
            + chrono::Duration::seconds(duration_sec as i64);

        for step in &bundle.steps {
            elements.push(bundle_raw_afk_step_to_element(
                step,
                &self.character_state,
                fake_now,
                script_runner,
                game_config,
            ));
        }

        elements
    }

    pub fn compute_bundle_reward(
        &self,
        game_config: &GameConfig,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
        bundle_id: BundleId,
    ) -> Vec<BundleElement> {
        let mut elements = vec![];

        let Some(bundle) = game_config.bundle(bundle_id) else {
            tracing::error!(
                "Couldn't find bundle with id = {}",
                game_config.afk_rewards_settings.bundle_id
            );
            return vec![];
        };

        for step in &bundle.steps {
            elements.push(bundle_raw_step_to_element(
                step,
                &self.character_state,
                script_runner,
                game_config,
            ));
        }

        elements
    }

    pub fn calculate_item_power(
        &self,
        item: Item,
        game_config: &GameConfig,
        script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
    ) -> anyhow::Result<i64> {
        let Ok(power) = script_runner.run_expression(
            |mut scope_setter| {
                scope_setter.set_const("CharacterState", self.character_state.clone());
                scope_setter.set_const("Item", item);
                scope_setter
            },
            &game_config.game_settings.item_power_calculate_script,
        ) else {
            anyhow::bail!("Couldn't calculate item power");
        };
        Ok(power)
    }

    pub fn get_active_fight_player(&self) -> Option<&Entity> {
        self.active_fight
            .as_ref()
            .and_then(|fight| fight.get_player())
    }

    pub fn get_active_fight_player_mut(&mut self) -> Option<&mut Entity> {
        self.active_fight
            .as_mut()
            .and_then(|fight| fight.get_player_mut())
    }
}