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::EssencesCustomEventData;
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::EventTypeName;
pub use event_system::event::Event;
use event_system::event::EventStruct;
use schemars::JsonSchema;
use std::collections::BTreeMap;

#[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,
    EventTypeName,
    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,
    },
    /// Сервер→клиент: предметы с истёкшим TTL удалены (само удаление — в патче).
    ItemsExpired {
        item_ids: Vec<Uuid>,
    },
    #[event_type(client)]
    UpgradeItemCase {},
    ItemCaseUpgraded {},
    #[event_type(client)]
    SpeedupUpgradeItemCase {},
    #[event_type(client)]
    SkipUpgradeItemCase {},
    #[event_type(client)]
    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 {
        // Boxed: `AutoChestFilter` is ~104 bytes — keeping it inline pushes the
        // enum's stack size up across all 191 variants. Serde sees `Box<T>` as
        // `T`, so the wire format is unchanged.
        filter: Box<AutoChestFilter>,
    },

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

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

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

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

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

    AbilityCaseOpened {
        batch_size: u8,
    },

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

    #[event_type(client)]
    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)]
    UpgradeAbility {
        ability_id: AbilityId,
    },

    #[event_type(client)]
    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
    // Server-only: emitted by the backend on the `ClientReady` handshake,
    // never accepted from a client `ClientEvents` envelope.
    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,
        // Boxed: `PVPState` is 256 bytes, which alone determined sizeof
        // OverlordEvent (~280 bytes including discriminant). Boxing this one
        // field shrinks the enum's footprint across every queue/Vec/future
        // that carries an OverlordEvent. Serde-transparent over Box.
        pvp_state: Option<Box<PVPState>>,
    },
    StageCleared {},

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

    WaveCleared {},

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

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

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

    #[event_type(client)]
    RefreshArenaMatchmaking {},

    #[event_type(client)]
    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,
    },
    EntityAddAbilityCooldown {
        entity_id: Uuid,
        ability_id: Uuid,
        delta_ticks: i64,
    },
    EntityCancelCastWithCooldown {
        entity_id: Uuid,
        ability_id: Uuid,
    },
    /// Stuns an entity for `duration_ticks`. Internally cancels any in-flight cast (sending it
    /// to its full cooldown), and freezes every ability's cooldown progression by extending
    /// each one by `duration_ticks`. Off-cooldown abilities get a fresh stun-only cooldown.
    /// Designers fire this from the `stun` effect's apply script — no per-ability iteration in
    EntityStun {
        entity_id: Uuid,
        duration_ticks: u64,
    },
    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)]
    ClaimVassalReward {
        character_id: Uuid,
    },

    #[event_type(client)]
    ClaimSuzerainReward {},

    NewSuzerain {
        new_suzerain: Option<Box<Suzerain>>,
    },

    RemoveVassal {
        vassal_id: Uuid,
    },

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

    NewTask {
        new_task: Box<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: Box<VassalTask>,
    },

    #[event_type(client)]
    AcceptResistTask {},

    ResistTaskAccepted {
        new_resist_task: Box<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)]
    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: Box<Gift>,
    },

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

    // AfkReward
    #[event_type(client)]
    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)]
    ClaimAfkInstantRewardGems {},

    // Ad Rewards
    #[event_type(client)]
    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)]
    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 postcard 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)]
    LevelUpClass {
        class_id: uuid::Uuid,
    },

    #[event_type(client)]
    Respec {
        new_class_id: uuid::Uuid,
    },

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

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

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

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

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

    EnableCaseUpgradePopUp {},

    #[event_type(client)]
    DisableCaseUpgradePopUp {},

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

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

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

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

    #[event_type(client)]
    ClaimAllMails {},

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

    #[event_type(client)]
    MakeAllRead {},

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

    #[event_type(client)]
    DeleteAllMails {},

    NewMail {
        new_mail: Box<essences::mail::Mail>,
    },

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

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

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

    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)]
    FastEquipPets {},

    EquipPets {
        equipped_pets: EquippedPets,
    },

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

    #[event_type(client)]
    UpgradeAllPets {},

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

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

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

    /// Обновляет вишлист гачи петов.
    #[event_type(client)]
    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)]
    AddCharacterToParty {
        character_id: uuid::Uuid,
    },
    #[event_type(client)]
    RemoveCharacterFromParty {},
    #[event_type(client)]
    RefreshPartyPlayers {},
    RefreshPartyMemberState {},

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

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

    // Progress Pass
    #[event_type(client)]
    ClaimProgressPassFreeReward {
        tier: u32,
    },

    #[event_type(client)]
    ClaimProgressPassPaidReward {
        tier: u32,
    },

    #[event_type(client)]
    ClaimAllProgressPassRewards {
        is_paid: bool,
    },

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

    /// Server tells the client to display the rate-us prompt.
    /// Emitted whenever `current_chapter_level >= game_settings.rate_us_chapter`
    /// and `character.rate_us_shown` is still false. Re-emitted on every new
    /// session start until the client acknowledges with `RateUsShown`.
    ShowRateUs {},

    /// Client confirms the rate-us prompt was displayed.
    /// Flips `character.rate_us_shown` to true so the server stops emitting.
    #[event_type(client)]
    RateUsShown {},

    /// Client reports the rate-us star selection (1–5).
    #[event_type(client)]
    RateUs {
        stars: i32,
    },

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

    #[event_type(client)]
    CustomEvent {
        event_type: String,
        data: CustomEventData,
    },

    /// Server-only: a multi-cell run passes its next cell. Keeps the runner's
    /// coordinates ticking cell-by-cell during a single `StartMove` so
    /// opponents target the cell he is actually passing, not the run's
    /// destination. Scheduled by `handle_start_move`; appended at the enum
    /// tail to keep postcard variant tags of older events stable.
    MoveProgress {
        entity_id: Uuid,
        to: Coordinates,
    },
}

#[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,
    },
}

#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
pub struct CustomEventData(pub BTreeMap<String, i64>);

impl CustomEventData {
    pub fn add(&mut self, key: &str, delta: i64) {
        let value = self
            .0
            .entry(key.to_owned())
            .and_modify(|x| *x += delta)
            .or_insert(delta);
        if *value == 0 {
            self.0.remove(key);
        }
    }
}

impl From<EssencesCustomEventData> for CustomEventData {
    fn from(value: EssencesCustomEventData) -> Self {
        CustomEventData(value.0)
    }
}

impl From<CustomEventData> for EssencesCustomEventData {
    fn from(value: CustomEventData) -> Self {
        EssencesCustomEventData(value.0)
    }
}