overlord_event_system/

event.rs

use chrono::Utc;
use configs::cheats::CheatScriptId;
use essences::ability_presets::AbilityPresetId;
use essences::ad_usage::AdPlacement;
use essences::autochest::{AutoChestFilter, AutoChestFilterId};
use essences::currency::{CurrencyConsumer, CurrencySource, CurrencyUnit};
use essences::dungeons::DungeonTemplateId;
use essences::entity::{Coordinates, EntityAttributes, EntityId};
use essences::fighting::{EntityTeam, FightTemplateId};
use essences::game::EntityTemplateId;
use essences::gift::Gift;
use essences::items::{Item, ItemTemplateId, ItemType};
use essences::offers::{Offer, OfferId, OfferTemplateId};
use essences::pets::{EquippedPets, PetCaseRollType, PetDrop, PetId, PetSlotId, UpgradedPetsMap};
use essences::prelude::*;
use essences::pvp::PVPState;
use essences::quest::QuestGroupType;
use essences::skins::SkinId;
use essences::talent_tree::TalentId;
use essences::vassals::Suzerain;
use essences::vassals::VassalTask;
use essences::{
    abilities::{
        AbilityCaseRollType, AbilityDrop, AbilityId, AbilitySlotId, EquippedAbilities,
        UpgradedAbilitiesMap,
    },
    bundles::BundleId,
};
use event_system::derive::Event;
use event_system::derive::RhaiEnum;
pub use event_system::event::Event;
use event_system::event::{EventRhaiEnum, EventStruct, EventVec};
use event_system::script::scope::ScriptScope;
use schemars::JsonSchema;

use crate::script::CustomEventData;

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum AdRewardType {
    AfkInstant,
    AfkBoost,
    DailyBooster,
    UpgradeSpeedup,
    FreeAbilityCaseOpen,
    FreePetCaseOpen,
    DungeonRaid {
        dungeon_id: DungeonTemplateId,
        difficulty: i64,
    },
    ArenaRefresh,
    ClaimBirdReward {
        variant_id: configs::ads_settings::BirdVariantId,
    },
}

#[derive(
    PartialEq,
    Eq,
    Clone,
    Debug,
    Event,
    RhaiEnum,
    JsonSchema,
    Tsify,
    Serialize,
    Deserialize,
    strum_macros::Display,
    strum_macros::VariantNames,
)]
#[tsify(into_wasm_abi, from_wasm_abi, namespace)]
pub enum OverlordEvent {
    // Item Case
    #[event_type(client)]
    OpenItemCase {
        batch_size: i64,
    },
    AutoChestOpenItemCase {
        batch_size: i64,
    },
    PlayerNewItems {
        items: Vec<Item>,
    },
    #[event_type(client)]
    PlayerEquipItem {
        item_id: Uuid,
    },
    #[event_type(client)]
    SellItem {
        item_id: Uuid,
    },
    ItemSold {
        item_id: Uuid,
    },
    #[event_type(client, sync)]
    UpgradeItemCase {},
    ItemCaseUpgraded {},
    #[event_type(client, sync)]
    SpeedupUpgradeItemCase {},
    #[event_type(client, sync)]
    SkipUpgradeItemCase {},
    #[event_type(client, sync)]
    ClaimUpgradeItemCase {},

    #[event_type(client)]
    EnableAutoSell {},

    #[event_type(client)]
    DisableAutoSell {},

    #[event_type(client)]
    SetGearOverrideEnabled {
        item_type: ItemType,
        enabled: bool,
    },

    // Auto-chest
    #[event_type(client)]
    EnableAutoChest {},

    #[event_type(client)]
    DisableAutoChest {},

    #[event_type(client)]
    EnableAutoChestFilter {
        filter_id: AutoChestFilterId,
    },

    #[event_type(client)]
    DisableAutoChestFilter {},

    #[event_type(client)]
    EnableAutoChestPowerCompare {},

    #[event_type(client)]
    DisableAutoChestPowerCompare {},

    #[event_type(client)]
    UpdateAutoChestBatchSize {
        batch_size: i64,
    },

    #[event_type(client)]
    NewAutoChestFilter {
        filter: AutoChestFilter,
    },

    #[event_type(client)]
    UpdateAutoChestFilter {
        updated_filter: AutoChestFilter,
    },

    #[event_type(client)]
    RemoveAutoChestFilter {
        filter_id: AutoChestFilterId,
    },

    // Ability Case
    #[event_type(client, sync)]
    OpenAbilityCase {
        roll_type: AbilityCaseRollType,
    },

    /// Обновляет вишлист гачи способностей.
    /// Список ограничен числом слотов и разрешенными редкостями текущего уровня гачи.
    #[event_type(client, sync)]
    SetAbilityGachaWishlist {
        ability_ids: Vec<AbilityId>,
    },

    /// Повышает уровень указанного слота способностей за Stardust.
    #[event_type(client, sync)]
    UpgradeAbilitySlot {
        slot_id: u64,
    },

    AbilityCaseOpened {
        batch_size: u8,
    },

    // For frontend display and quest progression
    NewAbilities {
        abilities: Vec<AbilityDrop>,
    },

    #[event_type(client, sync)]
    FastEquipAbilities {},

    #[event_type(client)]
    EquipAbility {
        slot_id: u64,
        ability_id: AbilityId,
    },

    #[event_type(client)]
    UnequipAbility {
        slot_id: AbilitySlotId,
    },

    EquipAbilities {
        equipped_abilities: EquippedAbilities,
    },

    #[event_type(client, sync)]
    UpgradeAbility {
        ability_id: AbilityId,
    },

    #[event_type(client, sync)]
    UpgradeAllAbilities {},

    // For frontend display and quests progression
    UpgradedAbilities {
        upgraded_abilities: UpgradedAbilitiesMap,
    },

    UpgradeAbilityCase {},

    CurrencyIncrease {
        currencies: Vec<CurrencyUnit>,
        currency_source: CurrencySource,
    },

    CurrencyDecrease {
        currencies: Vec<CurrencyUnit>,
        currency_consumer: CurrencyConsumer,
    },

    // Level
    NewCharacterLevel {
        level: i64,
    },

    // Fight management
    #[event_type(client, sync)]
    StartGame {},
    #[event_type(client)]
    PrepareFight {
        prepare_fight_type: PrepareFightType,
    },
    #[event_type(client)]
    StartFight {
        fight_id: Uuid,
    },
    #[event_type(client)]
    FightProgress {},
    EndFight {
        fight_id: Uuid,
        is_win: bool,
        pvp_state: Option<PVPState>,
    },
    StageCleared {},

    #[event_type(client, sync)]
    RaidDungeon {
        dungeon_id: DungeonTemplateId,
        difficulty: i64,
        amount: i64,
    },

    WaveCleared {},

    // PVP
    #[event_type(client, sync)]
    StartVassalPVPSync {
        opponent_id: Uuid,
        opponent_suzerain_id: Option<Uuid>,
    },

    #[event_type(client, sync)]
    StartArenaPVPSync {
        opponent_id: Uuid,
        is_bot: bool,
    },

    #[event_type(client, sync)]
    StartArenaRematchSync {
        match_id: Uuid,
    },

    #[event_type(client, sync)]
    RefreshArenaMatchmaking {},

    #[event_type(client, sync)]
    BuyArenaTicket {},

    // Moving
    StartMove {
        entity_id: Uuid,
        to: Coordinates,
        duration_ticks: u64,
    },
    // Event is delayed, so it must be non_deterministic
    EndMove {
        entity_id: Uuid,
    },

    // Fighting
    SpawnEntity {
        id: EntityId,
        entity_template_id: EntityTemplateId,
        position: Coordinates,
        entity_team: EntityTeam,
        has_big_hp_bar: bool,
        entity_attributes: EntityAttributes,
    },

    StartCastAbility {
        by_entity_id: Uuid,
        ability_id: AbilityId,
        pet_id: Option<PetId>,
    },
    // Event is delayed, so it must be non_deterministic
    StartedCastAbility {
        by_entity_id: Uuid,
        ability_id: AbilityId,
        duration_ticks: u64,
    },
    CastAbility {
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        ability_id: AbilityId,
    },
    StartCastProjectile {
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        level: i64,
        delay: u64,
    },
    StartedCastProjectile {
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        duration_ticks: u64,
    },
    // TODO move all projectiles into state, and make fight_progress manage them, so we dont need deterministic
    // Event is delayed, so it must be non_deterministic
    CastProjectile {
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        level: i64,
        projectile_data: CustomEventData,
    },
    Damage {
        entity_id: Uuid,
        damage: u64,
        damage_data: CustomEventData,
    },
    Heal {
        entity_id: Uuid,
        heal: u64,
    },
    CounterAttack {
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        duration_ticks: u64,
    },
    Multicast {
        entity_id: Uuid,
        amount: u64,
    },
    Evasion {
        entity_id: Uuid,
    },
    PlayerDeath {},
    EntityDeath {
        entity_id: Uuid,
        reward: Vec<CurrencyUnit>,
    },
    EntityIncrAttribute {
        entity_id: Uuid,
        attribute: String,
        delta: i64,
    },
    EntityApplyEffect {
        entity_id: Uuid,
        effect_id: Uuid,
    },
    CastEffect {
        entity_id: Uuid,
        effect_id: Uuid,
    },
    CastEffectFromEvent {
        entity_id: Uuid,
        effect_id: Uuid,
        caller_event: Box<OverlordEvent>,
    },
    FightCustomEvent {
        entity_id: u64,
        value: String,
    },
    FightVisualEvent {
        effect_type: String,
        effect_data: CustomEventData,
    },

    SetMaxHp {
        entity_id: EntityId,
        new_max_hp: u64,
        new_hp: u64,
    },

    // Vassal Links
    #[event_type(client, sync)]
    ClaimVassalReward {
        character_id: Uuid,
    },

    #[event_type(client, sync)]
    ClaimSuzerainReward {},

    NewSuzerain {
        new_suzerain: Option<Suzerain>,
    },

    RemoveVassal {
        vassal_id: Uuid,
    },

    // Vassal Tasks
    #[event_type(client, sync)]
    GiveTask {
        vassal_id: Uuid,
        template_task_id: Uuid,
    },

    NewTask {
        new_task: VassalTask,
    },

    #[event_type(client)]
    AcceptTask {
        task_id: Uuid,
        is_good: bool,
    },

    TaskAccepted {
        task_id: Uuid,
        started_good: bool,
        started_at: chrono::DateTime<Utc>,
        finish_at: chrono::DateTime<Utc>,
    },

    #[event_type(client)]
    HitHands {
        task_id: Uuid,
    },

    HandsHitted {
        task_id: Uuid,
    },

    TaskFinished {
        task_id: Uuid,
    },

    #[event_type(client)]
    ClaimTaskReward {
        task_id: Uuid,
    },

    // Resist Task
    GiveResistTask {
        new_resist_task: VassalTask,
    },

    #[event_type(client, sync)]
    AcceptResistTask {},

    ResistTaskAccepted {
        new_resist_task: VassalTask,
    },

    #[event_type(client)]
    CatchResistTask {
        task_id: Uuid,
    },

    ResistTaskCatched {
        task_id: Uuid,
    },

    ResistTaskFinished {
        task_id: Uuid,
    },

    #[event_type(client)]
    ClaimResistTaskReward {
        task_id: Uuid,
    },

    // Custom value
    SetCustomValue {
        key: String,
        value: i64,
    },

    // Connection store
    SetConnectionStore {
        key: String,
        value: i64,
    },

    // Quest
    #[event_type(client)]
    ClaimQuest {
        quest_id: Uuid,
    },

    #[event_type(client, sync)]
    ClaimAllQuests {
        quest_group_type: QuestGroupType,
    },

    PatronQuestCompleted {
        quest_id: Uuid,
    },

    HiddenQuestCompleted {
        quest_id: Uuid,
    },

    QuestCompleted {
        quest_id: Uuid,
    },

    NewQuests {
        quest_ids: Vec<Uuid>,
    },

    // Triggered when loop task flow breaks
    UpdateActiveLoopTaskId {
        quest_id: Uuid,
    },

    ResetRepeatingQuests {
        quest_ids: Vec<Uuid>,
    },

    #[event_type(client)]
    ClaimQuestProgressionReward {
        quest_group_type: QuestGroupType,
    },

    // Referrals
    #[event_type(client)]
    ClaimReferralLvlUpReward {
        level: i64,
    },

    #[event_type(client)]
    ClaimReferralDailyReward {},

    ReferralDailyRewardStatusUpdate {
        referral_daily_reward_status: bool,
    },

    // Gifts
    #[event_type(client)]
    SendGift {
        receiver_id: Uuid,
        config_gift_id: Uuid,
    },

    NewGift {
        new_gift: Gift,
    },

    #[event_type(client)]
    AcceptGift {
        gift_id: Uuid,
    },

    // AfkReward
    #[event_type(client, sync)]
    ClaimAfkReward {},

    AfkRewardClaimed {},

    /// Emitted when the player crosses the AFK rewards unlock chapter threshold
    /// and the async handler has adjusted `last_afk_reward_claimed_at` so that
    /// the elapsed time is not less than `min_required_time_sec`.
    /// The side effect handler persists the new value to the database.
    AfkRewardsGatingUnlocked {},

    #[event_type(client, sync)]
    ClaimAfkInstantRewardGems {},

    // Ad Rewards
    #[event_type(client, sync)]
    WatchAd {
        ad_reward_type: AdRewardType,
    },

    ShowBird {
        variant_id: configs::ads_settings::BirdVariantId,
    },

    /// Отправляется клиентом, когда птица была успешно показана игроку.
    /// Переводит птицу в полный кулдаун.
    #[event_type(client)]
    BirdShown {},

    ResetAdUsage {
        placements: Vec<AdPlacement>,
    },

    ResetInstantRewardGemsPressCount {},

    // Bundles
    #[event_type(client, sync)]
    ClaimBundleStepGeneric {},

    AddBundleGroup {
        bundle_ids: Vec<BundleId>,
        // Origin of the bundle — propagates through claim so currency analytics
        // sees the real source (e.g. `QuestClaim`) instead of the generic
        // `BundleClaim`.
        //
        // `#[serde(skip)]` keeps this server-only. The event still flows
        // through `ServerTick.events` over bincode to the client, but the field
        // is omitted from the wire so the layout matches what pre-PR clients
        // already know. The server always constructs this event with `source`
        // populated at the call site, then consumes it in
        // `handle_add_bundle_group` before any wire encoding happens, so the
        // skip never loses real data.
        #[serde(skip)]
        source: essences::currency::CurrencySource,
    },

    // Classes
    #[event_type(client, sync)]
    ChangeClass {
        new_class_id: uuid::Uuid,
    },

    // User Account
    #[event_type(client, sync)]
    LinkGuestAccount {
        token: String,
    },

    #[event_type(client, sync)]
    SetUsername {
        username: String,
    },

    #[event_type(client, sync)]
    SetCharacterBlocked {
        character_id: Uuid,
        blocked: bool,
    },

    // Ability Presets
    #[event_type(client, sync)]
    CreateAbilityPreset {
        name: Option<String>,
        ability_ids: Vec<AbilityId>,
        index: i64,
    },

    #[event_type(client, sync)]
    EditAbilityPreset {
        preset_id: AbilityPresetId,
        name: String,
        ability_ids: Vec<AbilityId>,
    },

    EnableCaseUpgradePopUp {},

    #[event_type(client)]
    DisableCaseUpgradePopUp {},

    // Skins
    #[event_type(client, sync)]
    BuySkins {
        skin_ids: Vec<SkinId>,
        equip: bool,
    },

    #[event_type(client, sync)]
    EquipAndUnequipSkins {
        equip_skin_ids: Vec<SkinId>,
        unequip_skin_ids: Vec<SkinId>,
    },

    // Cheat
    #[event_type(client)]
    RunCheat {
        cheat: Cheat,
    },

    // Mail
    #[event_type(client, sync)]
    ClaimMail {
        mail_id: essences::mail::MailId,
    },

    #[event_type(client, sync)]
    ClaimAllMails {},

    #[event_type(client, sync)]
    MakeRead {
        mail_id: essences::mail::MailId,
    },

    #[event_type(client, sync)]
    MakeAllRead {},

    #[event_type(client, sync)]
    DeleteMail {
        mail_id: essences::mail::MailId,
    },

    #[event_type(client, sync)]
    DeleteAllMails {},

    NewMail {
        new_mail: essences::mail::Mail,
    },

    // Offers
    #[event_type(client, sync)]
    NewOffer {
        offer_template_id: OfferTemplateId,
    },

    #[event_type(client, sync)]
    BuyOffer {
        purchase_token: Option<String>,
        offer_id: OfferId,
    },

    OfferPurchaseCompleted {
        purchase_token: String,
        offer_id: OfferId,
    },

    OfferPurchaseFailed {
        purchase_token: String,
        offer_id: OfferId,
    },

    PurchasesBanned {},

    ResetOffers {
        new_offers: Vec<Offer>,
    },

    // Pets
    #[event_type(client)]
    EquipPet {
        slot_id: u64,
        pet_id: PetId,
    },

    #[event_type(client)]
    UnequipPet {
        slot_id: PetSlotId,
    },

    #[event_type(client, sync)]
    FastEquipPets {},

    EquipPets {
        equipped_pets: EquippedPets,
    },

    #[event_type(client, sync)]
    UpgradePet {
        pet_id: PetId,
    },

    #[event_type(client, sync)]
    UpgradeAllPets {},

    // For frontend display and quests progression
    UpgradedPets {
        upgraded_pets: UpgradedPetsMap,
    },

    #[event_type(client)]
    UpgradePetSlot {
        slot_id: u64,
    },

    // Pet Case (Gacha)
    #[event_type(client, sync)]
    OpenPetCase {
        roll_type: PetCaseRollType,
    },

    /// Обновляет вишлист гачи петов.
    #[event_type(client, sync)]
    SetPetGachaWishlist {
        pet_ids: Vec<PetId>,
    },

    PetCaseOpened {
        batch_size: u8,
    },

    // For frontend display and quest progression
    NewPets {
        pets: Vec<PetDrop>,
    },

    UpgradePetCase {},

    // Tutorial
    #[event_type(client)]
    TutorialShown {
        step_number: i16,
    },
    #[event_type(client)]
    TutorialStepCompleted {
        step_number: i16,
    },

    /// Client lifecycle transition used for churn diagnostics.
    /// Sent when the Unity app is paused/resumed or loses/regains focus.
    #[event_type(client)]
    ClientLifecycle {
        lifecycle_status: String,
        active_screen_code: String,
        session_uptime_secs: i64,
        current_chapter_level: i64,
        current_character_level: i64,
        current_power: i64,
        active_fight: bool,
        active_fight_current_wave: i64,
    },

    // Party
    #[event_type(client, sync)]
    AddCharacterToParty {
        character_id: uuid::Uuid,
    },
    #[event_type(client, sync)]
    RemoveCharacterFromParty {},
    #[event_type(client, sync)]
    RefreshPartyPlayers {},
    #[event_type(sync)]
    RefreshPartyMemberState {},

    // Talent Tree
    /// Начать изучение следующего уровня таланта (клиент -> бэкенд).
    #[event_type(client, sync)]
    StartTalentResearch {
        talent_id: TalentId,
    },
    /// Бэкенд подтверждает начало изучения таланта.
    TalentResearchStarted {
        talent_id: TalentId,
        finish_at: chrono::DateTime<chrono::Utc>,
    },
    /// Ускорить изучение таланта с помощью таймскип-билетика.
    #[event_type(client, sync)]
    SpeedupTalentResearch {},
    /// Пропустить оставшееся время изучения за валюту (брюли/таймскипы).
    #[event_type(client, sync)]
    SkipTalentResearch {},
    /// Забрать завершённый талант (после истечения таймера). Эмитируется бэкендом автоматически.
    ClaimTalentResearch {},

    // Statue
    /// Откатить незаблокированные слоты статуи. Списывает валюту, начисляет опыт статуе.
    #[event_type(client, sync)]
    StatueRoll {
        set_index: u8,
        locked_slot_indices: Vec<u8>,
    },
    /// Сделать указанный сет статуи активным ("In Use").
    #[event_type(client, sync)]
    StatueActivateSet {
        set_index: u8,
    },
    /// Добавить новый сет статуи (если уровень статуи позволяет).
    #[event_type(client, sync)]
    StatueAddSet {},
    /// Переименовать сет статуи.
    #[event_type(client, sync)]
    StatueRenameSet {
        set_index: u8,
        name: String,
    },
    /// Заблокировать или разблокировать слот статуи.
    #[event_type(client, sync)]
    StatueLockSlot {
        set_index: u8,
        slot_index: u8,
        is_locked: bool,
    },
    /// Бесплатный первичный ролл для нового слота на любом сете (после создания сета или повышения уровня статуи).
    #[event_type(client, sync)]
    StatueRollNewSlot {
        set_index: u8,
        slot_index: u8,
    },

    // User Rating
    /// User rated the game (1–5) or declined to rate (rating = None).
    #[event_type(client)]
    UserRating {
        rating: Option<i8>,
    },

    // Error
    Error {
        code: String,
        message: String,
    },

    // Debug purposes for rhai
    #[event_type(client)]
    CustomRhai {
        event_type: String,
        data: CustomEventData,
    },
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum PrepareFightType {
    PVEFight,
    PVPFight {
        fight_id: FightTemplateId,
        pvp_state: Box<PVPState>,
    },
    RetryBossFight,
    DungeonFight {
        dungeon_id: DungeonTemplateId,
        difficulty: i64,
    },
    ForfeitDungeonFight,
    SingleFight {
        fight_templated_id: FightTemplateId,
    },
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum Cheat {
    PauseCombat,
    UnpauseCombat,
    GodModeOn,
    GodModeOff,
    GetRich,
    ClearInventory,
    ClearSlot {
        item_id: Uuid,
    },
    GetAllSpells,
    SetChapter {
        chapter: i64,
    },
    StartFight {
        templated_id: FightTemplateId,
    },
    SpawnEntity {
        entity_id: EntityTemplateId,
        x: i64,
        y: i64,
        team: EntityTeam,
        attributes: Vec<(String, i64)>,
    },
    WearItems {
        items_ids: Vec<ItemTemplateId>,
    },
    EquipSkin {
        skin_id: SkinId,
    },
    UnequipSkin {
        skin_id: SkinId,
    },
    NewLevel {
        level: i64,
    },
    Script {
        script_id: CheatScriptId,
    },
}