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::fight_breakdown::FightBreakdown;
use essences::fighting::ActiveFight;
use essences::flip::FlipState;
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::ratings::RatingRewardAvailability;
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>,
    /// Persistent global side and gauge shared by every flip equipment slot.
    pub flip_state: FlipState,
    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,
    /// Authoritative unclaimed Daily/Weekly rating reward flags for every
    /// rating type. Hydrated from entitlement storage and changed by server
    /// events; the client never derives these flags from local time or rank.
    pub rating_reward_availability: Vec<RatingRewardAvailability>,
    /// Per-source damage/heal breakdown of the LAST completed fight — campaign
    /// stage, arena match or dungeon run alike. Written once, in
    /// `handle_end_fight`, and replaced by the next fight's summary.
    ///
    /// A state field rather than an `EndFight` payload for two reasons: it
    /// survives `StateResync` (a carried-over one-shot event does not), and the
    /// documented within-tick ordering — the state patch applies on the client
    /// BEFORE that tick's events reach handlers — means it is already readable
    /// when `EndFight` arrives, so the existing event doubles as the
    /// "breakdown is ready" signal with no race.
    ///
    /// Not persisted: storage hydrates `None`, like `active_fight`.
    pub last_fight_breakdown: Option<FightBreakdown>,
}

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,
                // Ordinary-claim preview: a pending ad charge is part of what
                // the player is about to receive.
                true,
                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,
                // Instant grant: the pending charge is neither spent nor
                // applied here (BAL-016).
                false,
                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> {
        Self::calculate_item_power_for_character_state(
            &self.character_state,
            item,
            game_config,
            behaviors,
        )
    }

    /// Item power against an arbitrary character rather than the local player.
    /// Item power is loadout-relative (the marginal power an item adds to a
    /// character's equipped set), so viewing another player's item — e.g. in
    /// their profile — must evaluate it against that player's own state.
    pub fn calculate_item_power_for_character_state(
        character_state: &CharacterState,
        item: Item,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        crate::behaviors::power::item_power(&crate::behaviors::power::ItemPowerCtx {
            character: character_state,
            item: &item,
            config: game_config,
            lookups: behaviors.lookups(),
        })
    }

    /// `character.power` recomputed with inventory item `item_id`
    /// hypothetically equipped: applies the same `is_equipped` mutation as
    /// `handle_player_equip_item` to a copy of the character state and runs the
    /// authoritative full-aggregation power path
    /// ([`crate::behaviors::power::character_power`]). The `item_power`
    /// marginal path is NOT equivalent: it composes attrs from level+items+pets
    /// only (no class/talents/statue, no armor deflation) and drifts from the
    /// authoritative value under the nonlinear power formula.
    ///
    /// Evaluating BOTH sides of a gear comparison through this function makes
    /// stale `is_equipped` flags (an optimistic equip whose patch is still in
    /// flight) cancel out of the difference.
    pub fn calculate_power_with_item_equipped(
        &self,
        item_id: Uuid,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        let item = self
            .character_state
            .inventory
            .iter()
            .find(|item| item.id == item_id)
            .ok_or_else(|| anyhow::anyhow!("item {item_id} not found in inventory"))?;

        self.calculate_power_with_candidate_equipped(item, game_config, behaviors)
    }

    /// [`Self::calculate_power_with_item_equipped`] for a candidate that need
    /// not be in the inventory yet — the auto-chest filter ranks freshly
    /// dropped items before they are appended to `character_state.inventory`,
    /// so it cannot look them up by id.
    pub fn calculate_power_with_candidate_equipped(
        &self,
        candidate: &Item,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        let equipment_slot_key = candidate.equipment_slot_key();

        let mut character_state = self.character_state.clone();
        for inv_item in &mut character_state.inventory {
            if inv_item.equipment_slot_key() == equipment_slot_key {
                inv_item.is_equipped = false;
            }
        }

        match character_state
            .inventory
            .iter_mut()
            .find(|inv_item| inv_item.id == candidate.id)
        {
            Some(inv_item) => inv_item.is_equipped = true,
            None => {
                let mut candidate = candidate.clone();
                candidate.is_equipped = true;
                character_state.inventory.push(candidate);
            }
        }

        crate::behaviors::power::character_power(&crate::behaviors::power::CharacterPowerCtx {
            character: &character_state,
            config: game_config,
            lookups: behaviors.lookups(),
        })
    }

    /// `character.power` for the loadout exactly as it stands — the baseline
    /// every auto-chest comparison is made against.
    pub fn calculate_current_power(
        &self,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        crate::behaviors::power::character_power(&crate::behaviors::power::CharacterPowerCtx {
            character: &self.character_state,
            config: game_config,
            lookups: behaviors.lookups(),
        })
    }

    /// The two power maps [`essences::autochest::filter_items`] compares.
    ///
    /// Both sides are scored as "character power with that item equipped"
    /// through the authoritative aggregation — the SAME comparison the client
    /// makes in `IsItemUpgrade` and on the gear-compare cards. The marginal
    /// `item_power` category must not be used here: it composes attrs from
    /// level+items+pets only (no class/talents/statue, no armor deflation) and
    /// `power_from_attrs` is nonlinear, so the two paths genuinely rank
    /// same-slot items differently — e.g. a `+crit_chance` item is worth
    /// nothing once class and talents have pushed the clamped crit term to its
    /// cap, which the marginal baseline never sees.
    ///
    /// Every occupied slot maps to the same baseline: hypothetically
    /// re-equipping an already-equipped item is a no-op, so "power with the
    /// equipped item" IS current power. One aggregation covers them all
    /// instead of one per equipped item.
    pub fn auto_chest_power_maps(
        &self,
        candidates: &[Item],
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<(
        HashMap<Uuid, i64>,
        HashMap<essences::items::EquipmentSlotKey, i64>,
    )> {
        let mut candidate_powers = HashMap::new();
        for candidate in candidates {
            let power =
                self.calculate_power_with_candidate_equipped(candidate, game_config, behaviors)?;
            candidate_powers.insert(candidate.id, power);
        }

        let baseline = self.calculate_current_power(game_config, behaviors)?;
        let mut equipped_powers = HashMap::new();
        for item in &self.character_state.inventory {
            if item.is_equipped {
                equipped_powers.insert(item.equipment_slot_key(), baseline);
            }
        }

        Ok((candidate_powers, equipped_powers))
    }

    /// Predicted `character.power` change from equipping inventory item
    /// `item_id` ([`Self::calculate_power_with_item_equipped`] minus the stored
    /// authoritative power), so a client-side prediction reconciles exactly
    /// against the server's recalculated power.
    pub fn calculate_equip_power_delta(
        &self,
        item_id: Uuid,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        let power_after =
            self.calculate_power_with_item_equipped(item_id, game_config, behaviors)?;
        Ok(power_after - self.character_state.character.power)
    }

    /// Full-path item power for inventory item `item_id`: `character.power`
    /// with the item equipped minus `character.power` with the item's
    /// equipment slot empty, both through the authoritative aggregation
    /// ([`crate::behaviors::power::character_power`]). Unlike the marginal
    /// `item_power` category (level+items+pets only), two of these share the
    /// slot-empty baseline, so their difference equals
    /// [`Self::calculate_equip_power_delta`] exactly — gear-compare card
    /// scores stay arithmetically consistent with the displayed delta.
    pub fn calculate_item_power_full(
        &self,
        item_id: Uuid,
        game_config: &GameConfig,
        behaviors: &BehaviorRegistry,
    ) -> anyhow::Result<i64> {
        let equipment_slot_key = self
            .character_state
            .inventory
            .iter()
            .find(|item| item.id == item_id)
            .map(Item::equipment_slot_key)
            .ok_or_else(|| anyhow::anyhow!("item {item_id} not found in inventory"))?;

        let power_with =
            self.calculate_power_with_item_equipped(item_id, game_config, behaviors)?;

        let mut character_state = self.character_state.clone();
        for inv_item in &mut character_state.inventory {
            if inv_item.equipment_slot_key() == equipment_slot_key {
                inv_item.is_equipped = false;
            }
        }
        let power_slot_empty = crate::behaviors::power::character_power(
            &crate::behaviors::power::CharacterPowerCtx {
                character: &character_state,
                config: game_config,
                lookups: behaviors.lookups(),
            },
        )?;

        Ok(power_with - power_slot_empty)
    }

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