overlord_event_system/logic/

items.rs

use crate::{
    event::OverlordEvent, game_config_helpers::GameConfigLookup, logic::handler::OverlordLogic,
    state::OverlordState,
};

use essences::currency::check_can_decrease_currencies;

use configs::buffs::{apply_buff_multiplier, currency_exp_buff_multiplier};
use essences::{
    autochest::{AutoChestFilter, filter_items},
    currency::{CurrencyConsumer, CurrencySource, CurrencyUnit, increase_currencies},
    items::{Item, ItemType},
};

use event_system::{event::EventPluginized, script::random::GameRng, system::EventHandleResult};

use uuid::Uuid;

impl OverlordLogic {
    /// `max_batch` is passed in rather than read here: the manual and auto
    /// paths share this body but are subject to DIFFERENT caps. Reading one
    /// field for both is what let the auto ladder inherit the manual one.
    pub(crate) fn open_item_case(
        &self,
        batch_size: i64,
        max_batch: i64,
        rng: &mut rand::rngs::StdRng,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        tracing::debug!("Open case handler !frontend");

        let character_item_case_level = state.character_state.character.item_case_level;
        let Ok(case_settings) =
            game_config.require_item_case_settings_by_level(character_item_case_level)
        else {
            tracing::error!(
                "Couldn't find item_case_settings with level = {character_item_case_level}"
            );
            return EventHandleResult::fail(state);
        };
        if batch_size > max_batch {
            tracing::error!("Batch size {batch_size} is bigger than max allowed {max_batch}");
            return EventHandleResult::fail(state);
        }

        use crate::{cases, gacha};

        // Пачка катится по одному предмету, и каждый следующий бросок видит уже
        // выпавшие: инвентарь обновится только позже, в `PlayerNewItems`, а
        // гарантия на пустой слот считает по инвентарю. Без этого открытие
        // пачкой выдало бы `batch_size` одинаковых гарантированных предметов.
        let mut items: Vec<Item> = Vec::with_capacity(batch_size.max(0) as usize);
        for _ in 0..batch_size {
            // Seeded from the session stream, not OS entropy: `try_open_item_case`
            // has always taken a seed, but the only production caller passed
            // `None` and fell through to `SysRng`. That, plus the attribute rolls
            // below, is why no seed reproduced a run.
            let case_seed: u64 = rand::RngExt::random(rng);
            let mut item = match gacha::item_case::try_open_item_case(
                &state.character_state,
                &game_config,
                Some(case_seed),
                &self.behaviors,
                &items,
            ) {
                Ok(x) => x,
                Err(e) => {
                    tracing::error!("Couldn't open case: {e}");
                    continue;
                }
            };

            // Its own sub-stream, drawn from the session rng: attribute values
            // used to come from a `GameRng::from_entropy()` minted per item, so
            // no seed could reproduce them.
            let attr_seed: u64 = rand::RngExt::random(rng);
            let attr_rng = GameRng::new(rand::SeedableRng::seed_from_u64(attr_seed));
            match cases::try_finalize_item(&mut item, &game_config, &self.behaviors, &attr_rng) {
                Ok(()) => items.push(item),
                Err(e) => {
                    tracing::error!("Failed to finalize item: {}", e);
                }
            }
        }

        // Путь шарика решает сервер: слот определяет подпись редкости под
        // шариком, а значит и награду. Доска берётся под уровень сундука
        // игрока — набор выпадающих редкостей зависит от уровня. Катим путь
        // тем же RNG, что и остальная серверная случайность этого события
        // (сид сессии + логическое время), поэтому он воспроизводим и
        // тестируем.
        //
        // Порядок событий важен: сперва `PlayerNewItems` (кладёт предмет в
        // инвентарь), затем `PlinkoBallDropped` на каждый предмет.
        let ball_events: Vec<_> = items
            .iter()
            .filter_map(|item| {
                match crate::mechanics::plinko::roll_path_for_rarity(
                    &game_config.plinko_settings,
                    character_item_case_level,
                    &case_settings.rarity_weights,
                    item.rarity.id,
                    rng,
                ) {
                    Ok(path) => Some(EventPluginized::now(OverlordEvent::PlinkoBallDropped {
                        item_id: item.id,
                        path,
                    })),
                    Err(e) => {
                        tracing::error!("Couldn't roll plinko path for item {}: {e}", item.id);
                        None
                    }
                }
            })
            .collect();

        // Камни здесь больше не падают: их источник переехал на убийства мобов
        // (`OverlordLogic::roll_stone_kill_drop`, вызов в `logic::fighting`).
        // Сундуки — покупаемый канал, и привязанный к ним фаусет давал киту на
        // два порядка больше камней, чем игроку, который их выбивает.
        let mut events = vec![EventPluginized::now(OverlordEvent::PlayerNewItems {
            items,
        })];
        events.extend(ball_events);

        EventHandleResult::ok_events(state, events)
    }

    /// Начисляет постоянные прибавки к статам за колышки, задетые шариком.
    ///
    /// Колышки выводятся из пути детерминированно (`pins_touched_by_path`),
    /// поэтому один и тот же путь всегда даёт один и тот же набор колышков.
    /// Прибавки складываются в `character_state.plinko_pin_bonuses`, откуда
    /// их подхватывает общий агрегатор атрибутов — тем же путём, что таланты
    /// и статуя, так что бонус попадает и в бой, и в отображаемые статы, и в
    /// Power.
    pub fn handle_plinko_ball_dropped(
        &self,
        item_id: uuid::Uuid,
        path: &[essences::plinko::PlinkoDirection],
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let settings = &game_config.plinko_settings;

        if path.len() as i64 != settings.rows {
            tracing::error!(
                "Plinko path for item {item_id} has {} steps, expected {}",
                path.len(),
                settings.rows
            );
            return EventHandleResult::fail(state);
        }

        // The chest level is what decides which tranche the ball is filling —
        // the board and its prices belong to the level the player is on
        // (BAL-021).
        let chest_level = state.character_state.character.item_case_level;
        crate::mechanics::plinko::apply_pin_bonuses(
            settings,
            chest_level,
            path,
            &mut state.character_state.plinko_pin_bonuses,
        );

        EventHandleResult::ok(state)
    }

    pub fn handle_open_item_case(
        &self,
        batch_size: i64,
        mut rng: rand::rngs::StdRng,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        if state.character_state.character.auto_chest_enabled {
            tracing::error!("Can't open item case when auto_chest is enabled");
            return EventHandleResult::fail(state);
        }

        let required_currency = vec![CurrencyUnit {
            currency_id: game_config.game_settings.item_case_currency_id,
            amount: batch_size,
        }];

        if !check_can_decrease_currencies(&state.character_state.currencies, &required_currency) {
            tracing::error!(
                "Not enough currency for open_item_case opening\nGot = {:?}\nRequired = {:?}",
                state.character_state.currencies,
                required_currency
            );

            return EventHandleResult::fail(state);
        };

        if !self.frontend {
            // Ручная лестница: batch_size приходит от клиента, и эта проверка —
            // единственная граница перед аллокацией и циклом гачи.
            let max_batch = game_config
                .item_case_settings_by_level(state.character_state.character.item_case_level)
                .map(|s| s.auto_chest_settings.max_batch_size)
                .unwrap_or(0);
            return self.open_item_case(batch_size, max_batch, &mut rng, state);
        }
        EventHandleResult::ok(state)
    }

    pub fn handle_auto_chest_open_item_case(
        &self,
        batch_size: i64,
        mut rng: rand::rngs::StdRng,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        if !state.character_state.character.auto_chest_enabled {
            tracing::error!("Can't open auto_chest item case when auto_chest is disabled");
            return EventHandleResult::fail(state);
        }

        let required_currency = vec![CurrencyUnit {
            currency_id: game_config.game_settings.item_case_currency_id,
            amount: batch_size,
        }];

        if !check_can_decrease_currencies(&state.character_state.currencies, &required_currency) {
            tracing::error!(
                "Not enough currency for auto_chest_item_case opening\nGot = {:?}\nRequired = {:?}",
                state.character_state.currencies,
                required_currency
            );

            return EventHandleResult::ok_events(
                state,
                vec![EventPluginized::now(OverlordEvent::DisableAutoChest {})],
            );
        };

        if !self.frontend {
            // Авто-лестница: отдельная и более низкая, потому что авто-режим
            // работает непрерывно. Не заменять на max_batch_size.
            let max_batch = game_config
                .item_case_settings_by_level(state.character_state.character.item_case_level)
                .map(|s| s.auto_chest_settings.auto_only_max_batch_size)
                .unwrap_or(0);
            return self.open_item_case(batch_size, max_batch, &mut rng, state);
        }
        EventHandleResult::ok(state)
    }

    pub fn handle_player_new_items(
        &self,
        items: &[Item],
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let required_currency = vec![CurrencyUnit {
            currency_id: game_config.game_settings.item_case_currency_id,
            amount: items.len() as i64,
        }];

        let mut events = vec![];

        let Some(currency_event) =
            Self::currency_decrease(&state, &required_currency, CurrencyConsumer::ItemCaseOpen)
        else {
            return EventHandleResult::fail(state);
        };
        events.push(currency_event);

        let mut items = items.to_owned();

        if state.character_state.character.auto_chest_enabled {
            let filter = state.auto_chest.active_filter.clone();
            let power_compare_enabled = state.auto_chest.power_compare_enabled;
            let items_to_equip = match self.filter_new_items(
                &filter,
                power_compare_enabled,
                &items,
                &mut state,
                &mut events,
            ) {
                Ok(items_to_equip) => items_to_equip,
                Err(e) => {
                    tracing::error!("Something went wrong while filtering = {}", e);
                    return EventHandleResult::fail(state);
                }
            };

            // The stack accumulates: keepers never pause the auto chain. Each
            // logical slot banks at most one candidate — the strongest — and
            // weaker same-slot candidates are auto-sold on arrival.
            let items_to_equip =
                match self.merge_auto_stack(items_to_equip, &mut state, &mut events) {
                    Ok(winners) => winners,
                    Err(e) => {
                        tracing::error!(
                            "Something went wrong while merging the auto stack = {}",
                            e
                        );
                        return EventHandleResult::fail(state);
                    }
                };

            // The client presents every rolled ball of this batch one by one
            // (auto-sold ones included), so the pause before the next open
            // grows with the DELIVERED batch size — otherwise the server
            // outruns the animation and the client's launch queue grows
            // without bound.
            let delivered_balls = items.len() as u64;
            let pause_ticks = game_config
                .game_settings
                .auto_chest_pause_duration_ticks
                .saturating_add(
                    delivered_balls
                        .saturating_mul(game_config.game_settings.auto_chest_per_ball_pause_ticks),
                );
            events.push(EventPluginized::delayed(
                OverlordEvent::AutoChestOpenItemCase {
                    batch_size: state.auto_chest.batch_size,
                },
                pause_ticks,
            ));

            items = items_to_equip;
        }

        for item in &items {
            if let Some(item_template) = game_config.item_template(item.item_template_id)
                && let Some(skin_id) = item_template.skin_id
            {
                if game_config.require_skin(skin_id).is_err() {
                    tracing::error!(
                        "Skin with id={} not found in config for item_template_id={}",
                        skin_id,
                        item.item_template_id
                    );
                    return EventHandleResult::fail(state);
                }

                if !state
                    .character_state
                    .character_skins
                    .is_already_unlocked(skin_id)
                {
                    state
                        .character_state
                        .character_skins
                        .blocked
                        .retain(|s| *s != skin_id);
                    state
                        .character_state
                        .character_skins
                        .available
                        .push(skin_id);
                }
            }
        }

        state.character_state.inventory.append(&mut items);

        EventHandleResult::ok_events(state, events)
    }

    fn filter_new_items(
        &self,
        filter: &Option<AutoChestFilter>,
        power_compare_enabled: bool,
        items: &[Item],
        state: &mut OverlordState,
        events: &mut Vec<EventPluginized<OverlordEvent, OverlordState>>,
    ) -> anyhow::Result<Vec<Item>> {
        let game_config = self.game_config.get();

        let (item_powers, equipped_item_powers) =
            state.auto_chest_power_maps(items, &game_config, &self.behaviors)?;

        let (items_to_sell, items_to_equip) = filter_items(
            items,
            filter,
            power_compare_enabled,
            &game_config.item_rarities,
            &item_powers,
            &equipped_item_powers,
        )?;

        let buff_mult = currency_exp_buff_multiplier(
            &state.character_state.active_buffs,
            &game_config.buff_templates,
            ::time::utc_now(),
        );

        let mut gained_currencies = vec![];

        for item in items_to_sell {
            let scaled_price: Vec<CurrencyUnit> = item
                .price
                .iter()
                .map(|c| CurrencyUnit {
                    currency_id: c.currency_id,
                    amount: apply_buff_multiplier(c.amount, buff_mult),
                })
                .collect();
            increase_currencies(&mut gained_currencies, &scaled_price);
            state.character_state.character.character_experience +=
                apply_buff_multiplier(item.experience, buff_mult);
            events.push(EventPluginized::now(OverlordEvent::ItemSold {
                item_id: item.id,
            }));
        }

        events.push(Self::currency_increase(
            &gained_currencies,
            CurrencySource::AutoItemSell,
        ));

        Ok(items_to_equip)
    }

    /// Auto-chest stack maintenance: the stack (unequipped inventory) holds at
    /// most ONE candidate per logical slot — the strongest. Every incoming
    /// keeper challenges the prior batch pick and the items already banked for
    /// its slot; every loser is auto-sold with the same pricing as the
    /// filter's rejects.
    ///
    /// Deterministic on purpose (this code replays on the client): candidates
    /// are ordered prior-batch pick, then banked stack items in inventory
    /// order, then the new drop, and a tie keeps the earliest candidate.
    fn merge_auto_stack(
        &self,
        incoming: Vec<Item>,
        state: &mut OverlordState,
        events: &mut Vec<EventPluginized<OverlordEvent, OverlordState>>,
    ) -> anyhow::Result<Vec<Item>> {
        let game_config = self.game_config.get();

        let mut winners: Vec<Item> = Vec::new();
        let mut losers: Vec<Item> = Vec::new();

        for item in incoming {
            let key = item.equipment_slot_key();

            let mut candidates: Vec<Item> = Vec::new();
            let mut i = 0;
            while i < winners.len() {
                if winners[i].equipment_slot_key() == key {
                    candidates.push(winners.remove(i));
                } else {
                    i += 1;
                }
            }
            let mut i = 0;
            while i < state.character_state.inventory.len() {
                let inv_item = &state.character_state.inventory[i];
                if !inv_item.is_equipped && inv_item.equipment_slot_key() == key {
                    candidates.push(state.character_state.inventory.remove(i));
                } else {
                    i += 1;
                }
            }
            candidates.push(item);

            // Same metric as the filter above and as the client's own compare:
            // character power with that candidate in the slot.
            let mut best_idx = 0;
            let mut best_power = state.calculate_power_with_candidate_equipped(
                &candidates[0],
                &game_config,
                &self.behaviors,
            )?;
            for (idx, candidate) in candidates.iter().enumerate().skip(1) {
                let power = state.calculate_power_with_candidate_equipped(
                    candidate,
                    &game_config,
                    &self.behaviors,
                )?;
                if power > best_power {
                    best_idx = idx;
                    best_power = power;
                }
            }

            for (idx, candidate) in candidates.into_iter().enumerate() {
                if idx == best_idx {
                    winners.push(candidate);
                } else {
                    losers.push(candidate);
                }
            }
        }

        if !losers.is_empty() {
            let buff_mult = currency_exp_buff_multiplier(
                &state.character_state.active_buffs,
                &game_config.buff_templates,
                ::time::utc_now(),
            );
            let mut gained_currencies = vec![];
            for item in losers {
                let scaled_price: Vec<CurrencyUnit> = item
                    .price
                    .iter()
                    .map(|c| CurrencyUnit {
                        currency_id: c.currency_id,
                        amount: apply_buff_multiplier(c.amount, buff_mult),
                    })
                    .collect();
                increase_currencies(&mut gained_currencies, &scaled_price);
                state.character_state.character.character_experience +=
                    apply_buff_multiplier(item.experience, buff_mult);
                events.push(EventPluginized::now(OverlordEvent::ItemSold {
                    item_id: item.id,
                }));
            }
            events.push(Self::currency_increase(
                &gained_currencies,
                CurrencySource::AutoItemSell,
            ));
        }

        Ok(winners)
    }

    pub fn handle_player_equip_item(
        &self,
        item_id: Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(item) = state
            .character_state
            .inventory
            .iter()
            .find(|x| x.id == item_id)
            .cloned()
        else {
            tracing::error!("Tried equiping non-existing item_id={}", item_id);
            return EventHandleResult::fail(state);
        };

        let equipment_slot_key = item.equipment_slot_key();
        let slot_is_unlocked = game_config
            .inventory_levels
            .iter()
            .rev()
            .find(|level| {
                level.from_chapter_level <= state.character_state.character.current_chapter_level
            })
            .is_some_and(|level| {
                level
                    .slots
                    .iter()
                    .any(|slot| slot.equipment_slot_key() == equipment_slot_key)
            });
        if !slot_is_unlocked {
            tracing::warn!(
                item_id = %item.id,
                item_type = %item.item_type,
                world_side = ?item.world_side,
                chapter_level = state.character_state.character.current_chapter_level,
                "Rejected equip into a locked logical equipment slot"
            );
            return EventHandleResult::fail(state);
        }

        let prev_item = state
            .character_state
            .inventory
            .iter()
            .find(|inv_item| {
                inv_item.equipment_slot_key() == equipment_slot_key
                    && inv_item.id != item.id
                    && inv_item.is_equipped
            })
            .cloned();
        let displaced_item_id = prev_item.as_ref().map(|prev| prev.id);

        state
            .character_state
            .inventory
            .iter_mut()
            .map(|inv_item| {
                if inv_item.equipment_slot_key() == equipment_slot_key {
                    inv_item.is_equipped = false;
                }
                if inv_item.id == item.id {
                    inv_item.is_equipped = true;
                }
            })
            .count();

        let mut equip_skin_ids = vec![];
        let mut unequip_skin_ids = vec![];

        let gear_override_enabled = state
            .character_state
            .character_settings
            .gear_override_enabled_item_types
            .contains(&item.item_type);

        if !gear_override_enabled {
            let currently_equipped = &state.character_state.character_skins.equipped;

            // Unequip the prev item's skin only if it is still actually equipped.
            // If the player has customized away from it, there is nothing to unequip.
            if let Some(prev_item) = prev_item
                && let Some(prev_item_template) =
                    game_config.item_template(prev_item.item_template_id)
                && let Some(prev_skin_id) = prev_item_template.skin_id
                && currently_equipped.contains(&prev_skin_id)
            {
                unequip_skin_ids.push(prev_skin_id);
            }

            // Equip the new item's skin unless it is already equipped. If it is,
            // make sure we do not also unequip it via the prev-item path above
            // (e.g. when two items share a skin_id and that skin is equipped).
            if let Some(item_template) = game_config.item_template(item.item_template_id)
                && let Some(skin_id) = item_template.skin_id
            {
                if game_config.require_skin(skin_id).is_err() {
                    tracing::error!(
                        "Skin with id={} not found in config for item_template_id={}",
                        skin_id,
                        item.item_template_id
                    );
                    return EventHandleResult::fail(state);
                }

                if currently_equipped.contains(&skin_id) {
                    unequip_skin_ids.retain(|id| *id != skin_id);
                } else {
                    equip_skin_ids.push(skin_id);
                }
            }
        }

        let mut events = vec![];
        if !equip_skin_ids.is_empty() || !unequip_skin_ids.is_empty() {
            events.push(EventPluginized::now(OverlordEvent::EquipAndUnequipSkins {
                equip_skin_ids,
                unequip_skin_ids,
            }));
        }

        // A2-BAL-003 §3.4: the displaced item is sold HERE, at the moment of the
        // upgrade.
        //
        // This handler used to only unequip it. Auto Chest would then sell it
        // later, whenever the next same-slot conflict happened to come along,
        // and the manual path sold it at a different moment again — so the Gold
        // and item XP from one roll landed at an unpredictable time, and the
        // signed "one sale per post-fill roll" ledger could not be checked.
        // Selling at equip time makes both paths identical and the moment exact.
        //
        // An equip into an empty slot displaces nothing and therefore sells
        // nothing, which is what keeps the pre-fill phase free of sales.
        if let Some(displaced) = displaced_item_id {
            events.push(EventPluginized::now(OverlordEvent::SellItem {
                item_id: displaced,
            }));
        }

        // No auto-chest resume here: the chain never pauses on keepers (see
        // merge_auto_stack), so re-scheduling from an equip would fork it.

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_sell_item(
        &self,
        item_id: Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(inv_item_idx) = state
            .character_state
            .inventory
            .iter()
            .position(|x| x.id == item_id)
        else {
            tracing::error!("Tried selling undefined item: item_id={}", item_id);
            return EventHandleResult::fail(state);
        };

        let removed_item = state.character_state.inventory.remove(inv_item_idx);

        let mut events = Vec::new();

        let buff_mult = currency_exp_buff_multiplier(
            &state.character_state.active_buffs,
            &game_config.buff_templates,
            ::time::utc_now(),
        );
        let scaled_price: Vec<CurrencyUnit> = removed_item
            .price
            .iter()
            .map(|c| CurrencyUnit {
                currency_id: c.currency_id,
                amount: apply_buff_multiplier(c.amount, buff_mult),
            })
            .collect();

        events.push(Self::currency_increase(
            &scaled_price,
            CurrencySource::ItemSell,
        ));
        events.push(EventPluginized::now(OverlordEvent::ItemSold { item_id }));
        state.character_state.character.character_experience +=
            apply_buff_multiplier(removed_item.experience, buff_mult);

        // No auto-chest resume here either — the chain never pauses on keepers.

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_enable_auto_sell(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.character_state.character_settings.auto_sell_enabled = true;

        EventHandleResult::ok(state)
    }

    pub fn handle_disable_auto_sell(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.character_state.character_settings.auto_sell_enabled = false;

        EventHandleResult::ok(state)
    }

    pub fn handle_set_gear_override_enabled(
        &self,
        item_type: ItemType,
        enabled: bool,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let overrides = &mut state
            .character_state
            .character_settings
            .gear_override_enabled_item_types;

        if enabled {
            if !overrides.contains(&item_type) {
                overrides.push(item_type);
            }
            return EventHandleResult::ok(state);
        }

        overrides.retain(|t| *t != item_type);

        let game_config = self.game_config.get();
        let skin_ids: Vec<Uuid> = state
            .character_state
            .inventory
            .iter()
            .filter(|item| item.is_equipped && item.item_type == item_type)
            .filter_map(|item| {
                game_config
                    .item_template(item.item_template_id)
                    .and_then(|template| template.skin_id)
            })
            .collect();

        if skin_ids.is_empty() {
            return EventHandleResult::ok(state);
        }

        EventHandleResult::ok_events(
            state,
            vec![EventPluginized::now(OverlordEvent::EquipAndUnequipSkins {
                equip_skin_ids: skin_ids,
                unequip_skin_ids: vec![],
            })],
        )
    }

    pub fn handle_enable_case_upgrade_pop_up(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state
            .character_state
            .character_settings
            .dont_show_case_upgrade_popup_today = false;

        EventHandleResult::ok(state)
    }

    pub fn handle_disable_case_upgrade_pop_up(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state
            .character_state
            .character_settings
            .dont_show_case_upgrade_popup_today = true;

        EventHandleResult::ok(state)
    }
}

/// Удаляет предметы с истёкшим TTL (`expires_at <= now`), возвращает
/// `ItemsExpired` (пустой — если нечего). В отличие от продажи ничего не
/// начисляет; экипированные тоже удаляются, силу пересчитает `compute_fields`.
pub fn sweep_expired_items(
    state: &mut OverlordState,
    now: chrono::DateTime<chrono::Utc>,
) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
    let expired_ids: Vec<Uuid> = state
        .character_state
        .inventory
        .iter()
        .filter(|item| item.expires_at.is_some_and(|exp| exp <= now))
        .map(|item| item.id)
        .collect();

    if expired_ids.is_empty() {
        return Vec::new();
    }

    state
        .character_state
        .inventory
        .retain(|item| !expired_ids.contains(&item.id));

    vec![EventPluginized::now(OverlordEvent::ItemsExpired {
        item_ids: expired_ids,
    })]
}