overlord_event_system/async_handler/

items.rs

use crate::{
    async_handler::handler::OverlordAsyncEventHandler, event::OverlordEvent,
    game_config_helpers::GameConfigLookup, state::OverlordState,
};

#[allow(unused_imports)]
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, return_if_frontend, system::EventHandleResult};

use uuid::Uuid;

impl OverlordAsyncEventHandler {
    #[allow(dead_code)]
    fn open_item_case(
        &self,
        batch_size: i64,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        tracing::debug!("Open case handler !frontend");
        if state
            .character_state
            .inventory
            .iter()
            .any(|x| !x.is_equipped)
        {
            tracing::error!("Can't open item_case, inventory contains unequipped items");
            return EventHandleResult::fail(state);
        }

        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 > case_settings.auto_chest_settings.max_batch_size {
            tracing::error!(
                "Batch size {} is bigger than max allowed {}",
                batch_size,
                case_settings.auto_chest_settings.max_batch_size
            );
            return EventHandleResult::fail(state);
        }

        let items = (0..batch_size)
            .filter_map(|_| {
                use crate::{cases, gacha};

                let mut item = match gacha::item_case::try_open_item_case(
                    &state.character_state,
                    &game_config,
                    None,
                    &self.script_runner,
                ) {
                    Ok(x) => x,
                    Err(e) => {
                        tracing::error!("Couldn't open case: {e}");
                        return None;
                    }
                };

                match cases::try_finalize_item(&mut item, &game_config, &self.script_runner) {
                    Ok(()) => Some(item),
                    Err(e) => {
                        tracing::error!("Failed to finalize item: {}", e);
                        None
                    }
                }
            })
            .collect();

        EventHandleResult::ok_events(
            state,
            vec![EventPluginized::now(OverlordEvent::PlayerNewItems {
                items,
            })],
        )
    }

    #[allow(unused_variables)]
    pub fn handle_open_item_case(
        &self,
        batch_size: i64,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        return_if_frontend!(state);

        #[cfg(not(feature = "frontend"))]
        {
            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 {
                return self.open_item_case(batch_size, state);
            }
            EventHandleResult::ok(state)
        }
    }

    #[allow(unused_variables)]
    pub fn handle_auto_chest_open_item_case(
        &self,
        batch_size: i64,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        return_if_frontend!(state);

        #[cfg(not(feature = "frontend"))]
        {
            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 {
                return self.open_item_case(batch_size, 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);
                }
            };

            if items_to_equip.is_empty() {
                events.push(EventPluginized::delayed(
                    OverlordEvent::AutoChestOpenItemCase {
                        batch_size: state.auto_chest.batch_size,
                    },
                    game_config.game_settings.auto_chest_pause_duration_ticks,
                ));
                return EventHandleResult::ok_events(state, events);
            };

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

        // Calculate power for new items
        let mut item_powers = std::collections::HashMap::new();
        for item in items {
            let power =
                state.calculate_item_power(item.clone(), &game_config, &self.script_runner)?;
            item_powers.insert(item.id, power);
        }

        // Build map of equipped item powers by type
        let mut equipped_item_powers = std::collections::HashMap::new();
        for item in &state.character_state.inventory {
            if item.is_equipped {
                let power =
                    state.calculate_item_power(item.clone(), &game_config, &self.script_runner)?;
                equipped_item_powers.insert(item.item_type, power);
            }
        }

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

    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 prev_item = state
            .character_state
            .inventory
            .iter()
            .find(|inv_item| {
                inv_item.item_type == item.item_type
                    && inv_item.id != item.id
                    && inv_item.is_equipped
            })
            .cloned();

        state
            .character_state
            .inventory
            .iter_mut()
            .map(|inv_item| {
                if inv_item.item_type == item.item_type {
                    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,
            }));
        }

        if state.character_state.character.auto_chest_enabled {
            if state
                .character_state
                .inventory
                .iter()
                .any(|item| !item.is_equipped)
            {
                return EventHandleResult::ok_events(state, events);
            };
            events.push(EventPluginized::delayed(
                OverlordEvent::AutoChestOpenItemCase {
                    batch_size: state.auto_chest.batch_size,
                },
                game_config.game_settings.auto_chest_pause_duration_ticks,
            ));
        }

        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);

        if state.character_state.character.auto_chest_enabled {
            if state
                .character_state
                .inventory
                .iter()
                .any(|item| !item.is_equipped)
            {
                return EventHandleResult::ok_events(state, events);
            };
            events.push(EventPluginized::delayed(
                OverlordEvent::AutoChestOpenItemCase {
                    batch_size: state.auto_chest.batch_size,
                },
                game_config.game_settings.auto_chest_pause_duration_ticks,
            ));
        }

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