overlord_event_system/

state.rs

use std::collections::HashMap;

use configs::game_config::GameConfig;
use essences::abilities::{Ability, AbilityTemplate};
use essences::arena::Arena;
use essences::autochest::AutoChest;
use essences::bundles::{BundleElement, BundleId};
use essences::character_state::CharacterState;
use essences::dungeons::Dungeons;
use essences::entity::Entity;
use essences::fighting::ActiveFight;
use essences::gift::Gift;
use essences::items::Item;
use essences::mail::Mail;
use essences::offers::OffersInfo;
use essences::prelude::*;
use essences::progress_pass::ProgressPassState;
use essences::pvp::PVPState;
use essences::quest::QuestsGroups;
use essences::referrals::Patron;

use event_system::state::State;

use crate::BehaviorRegistry;
use crate::bundles::{bundle_raw_afk_step_to_element, bundle_raw_step_to_element};
use crate::game_config_helpers::GameConfigLookup;
use crate::party::Party;
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, 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,
    pub progress_pass: ProgressPassState,
}

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 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(suzerain) = self.character_state.suzerain.as_mut() else {
            anyhow::bail!("No suzerain to update")
        };
        suzerain.claim_reward(claim_time);
        Ok(())
    }

    pub fn compute_description_values_for_ability(
        &self,
        ability: &Ability,
        behaviors: &BehaviorRegistry,
        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![];
        };

        match crate::behaviors::ui_values::description_values(
            &crate::behaviors::ui_values::DescriptionValuesCtx {
                ability_level: ability.level,
                ability_template_id: ability.template_id,
                script: description_script,
                config,
                lookups: behaviors.lookups(),
            },
        ) {
            Ok(values) => values,
            Err(err) => {
                tracing::error!("Error computing description values: {err}");
                vec![]
            }
        }
    }

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

        match crate::behaviors::ui_values::talent_description_values(
            &crate::behaviors::ui_values::TalentDescriptionValuesCtx {
                talent_level: level,
                script: description_script,
            },
        ) {
            Ok(values) => values,
            Err(err) => {
                tracing::error!("Error computing talent description values: {err}");
                vec![]
            }
        }
    }

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

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

    pub fn compute_afk_reward(
        &self,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> 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,
                behaviors,
                game_config,
            ));
        }

        elements
    }

    pub fn compute_afk_instant_reward(
        &self,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> 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,
                behaviors,
                game_config,
            ));
        }

        elements
    }

    pub fn compute_bundle_reward(
        &self,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
        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,
                behaviors,
                game_config,
            ));
        }

        elements
    }

    pub fn calculate_item_power(
        &self,
        item: Item,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        crate::behaviors::power::item_power(&crate::behaviors::power::ItemPowerCtx {
            character: &self.character_state,
            item: &item,
            config: game_config,
            lookups: behaviors.lookups(),
        })
    }

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