rpg_base/character_window/src/inventory/item_right_side.rs

use anyhow::Result;
use assetpath::AssetPath;
use rpg_components::{
    components::{
        attributes::Attributes, character_status::CharacterStatus, inventory::Inventory,
        item_slots::ItemSlotContainer, statistics::Statistics,
    },
    config::{attributes::AttributeSettings, items::ItemSettings},
    items::{Item, ItemAffix, Tooltip},
};

use crate::*;

use std::sync::{Arc, Weak};

use super::{
    super::traits::*,
    jewel_right_side::{ReferenceItemSource, ReferenceObject},
};

pub struct ItemRightSide {
    snippet: Arc<GuiSnippet>,

    empty_icons: InventoryEmptyIcons,
}

impl ItemRightSide {
    pub fn new<A: Ability + 'static>(
        world: &mut World,
        file: &str,
        reference: &Weak<CharacterWindow>,
        hero: Entity,
    ) -> Result<Self> {
        let snippet = GuiSnippet::from_str(world, file)?;
        let icons = InventoryEmptyIcons::new(world)?;

        let me = Self {
            snippet,
            empty_icons: icons,
        };

        me.setup::<A>(reference, hero)?;

        Ok(me)
    }

    fn setup<A: Ability + 'static>(
        &self,
        reference: &Weak<CharacterWindow>,
        hero: Entity,
    ) -> Result<()> {
        button_setup!(self, reference, hero, helmet, "helmet");
        button_setup!(self, reference, hero, chest, "chest");
        button_setup!(self, reference, hero, gloves, "gloves");
        button_setup!(self, reference, hero, belt, "belt");
        button_setup!(self, reference, hero, boots, "boots");
        #[rustfmt::skip]
        button_setup!(self, reference, hero, primary_hand, "main hand");
        #[rustfmt::skip]
        button_setup!(self, reference, hero, secondary_hand, "off hand");

        #[rustfmt::skip]
        button_setup!(self, reference, hero, amulet, "amulet_0", 0);
        #[rustfmt::skip]
        button_setup!(self, reference, hero, amulet, "amulet_1", 1);

        #[rustfmt::skip]
        button_setup!(self, reference, hero, ring, "ring_0", 0);
        #[rustfmt::skip]
        button_setup!(self, reference, hero, ring, "ring_1", 1);
        #[rustfmt::skip]
        button_setup!(self, reference, hero, ring, "ring_2", 2);
        #[rustfmt::skip]
        button_setup!(self, reference, hero, ring, "ring_3", 3);

        Ok(())
    }

    fn update_icons(&self, gui_handler: &mut GuiHandler, items: &ItemSlotContainer) -> Result<()> {
        let ui = &self.snippet;
        let empty_icons = &self.empty_icons;

        equip_update!(ui, gui_handler, items, helmet, empty_icons);
        equip_update!(ui, gui_handler, items, chest, empty_icons);
        equip_update!(ui, gui_handler, items, boots, empty_icons);
        equip_update!(ui, gui_handler, items, gloves, empty_icons);
        equip_update!(ui, gui_handler, items, belt, empty_icons);

        #[rustfmt::skip]
        equip_update!(ui,gui_handler, items, primary_hand, empty_icons, "main hand");
        #[rustfmt::skip]
        equip_update!(ui, gui_handler,items, secondary_hand, empty_icons, "off hand");

        equip_update!(ui, gui_handler, items, ring, empty_icons, "ring_0", 0);
        equip_update!(ui, gui_handler, items, ring, empty_icons, "ring_1", 1);
        equip_update!(ui, gui_handler, items, ring, empty_icons, "ring_2", 2);
        equip_update!(ui, gui_handler, items, ring, empty_icons, "ring_3", 3);

        equip_update!(ui, gui_handler, items, amulet, empty_icons, "amulet_0", 0);
        equip_update!(ui, gui_handler, items, amulet, empty_icons, "amulet_1", 1);

        Ok(())
    }

    fn create_tooltip(
        world: &mut World,
        item: &Item,
        attributes: &Attributes,
        (x, y, w, _h): (i32, i32, u32, u32),
    ) -> Result<Tooltip> {
        let target_x = x + w as i32;
        let target_y = y;

        let gui = item.create_tooltip(world, attributes, (target_x, target_y))?;
        gui.enable(world)?;
        gui.perform_single_check(world.resources.get_mut()?, x, y)?;

        Ok(gui)
    }
}

impl RightSide for ItemRightSide {
    fn refresh(&mut self, world: &mut World, hero: Entity) -> Result<()> {
        let (hero_object, resources) = world.entity_resources(hero)?;
        let items = hero_object.get_component::<ItemSlotContainer>()?;

        self.update_icons(resources.get_mut()?, items)
    }

    fn base(&self) -> &Arc<GuiSnippet> {
        &self.snippet
    }
}

struct InventoryEmptyIcons {
    helmet: Arc<Image>,
    chest: Arc<Image>,
    belt: Arc<Image>,
    boots: Arc<Image>,
    gloves: Arc<Image>,

    primary_hand: Arc<Image>,
    secondary_hand: Arc<Image>,

    ring: Arc<Image>,
    amulet: Arc<Image>,
}

impl InventoryEmptyIcons {
    fn new(world: &World) -> Result<Self> {
        let place_holder_settings = &world
            .resources
            .get::<ItemSettings>()
            .icon_place_holder_paths;

        let context = world.resources.get::<Context>();

        Ok(Self {
            helmet: Self::image(context, &place_holder_settings.helmet)?,
            chest: Self::image(context, &place_holder_settings.chest)?,
            belt: Self::image(context, &place_holder_settings.belt)?,
            boots: Self::image(context, &place_holder_settings.boots)?,
            gloves: Self::image(context, &place_holder_settings.gloves)?,

            primary_hand: Self::image(context, &place_holder_settings.main_hand)?,
            secondary_hand: Self::image(context, &place_holder_settings.off_hand)?,

            ring: Self::image(context, &place_holder_settings.ring)?,
            amulet: Self::image(context, &place_holder_settings.amulet)?,
        })
    }

    fn image(context: &Context, path: &AssetPath) -> Result<Arc<Image>> {
        Image::from_file(path.clone())?
            .max_mip_map_levels()
            .attach_pretty_sampler(context.device())?
            .build(context.device(), context.queue())
    }
}

mod macros {
    #[macro_export]
    macro_rules! button_setup {
        ($self:ident, $reference:ident, $hero:ident, $item:ident, $button:literal) => {
            paste::expr! {
                let [<$item _button>]: Arc<Button> = $self.snippet.element($button)?;

                [<$item _button>].set_select_callback({
                    let reference = $reference.clone();
                    let weak_button = Arc::downgrade(&[<$item _button>]);

                    move |world, selected| {
                        if selected {
                            let entity = unsafe { remove_life_time(world.entity($hero)?) };

                            let attributes = entity.get_component::<Attributes>()?;
                            let items = entity.get_component::<ItemSlotContainer>()?;

                            match items.$item() {
                                Some($item) => {
                                    let button_pos =
                                        weak_button.upgrade().unwrap().position_extent();

                                    let gui = Self::create_tooltip(
                                        world,
                                        $item,
                                        attributes,
                                        button_pos,
                                    )?;

                                    reference.upgrade().unwrap().add_tooltip("equip", gui);
                                }
                                None => {
                                    reference.upgrade().unwrap().remove_tooltip(world, "equip")?;
                                }
                            }
                        } else {
                            reference.upgrade().unwrap().remove_tooltip(world, "equip")?;
                        }

                        Ok(())
                    }
                });

                [<$item _button>].set_callback({
                    let reference = $reference.clone();

                    move |world| {
                        let mut found_item = false;

                        let (entity, resources) = world.entity_resources($hero)?;

                        let (
                            items,
                            inventory,
                            statistics,
                            attributes,
                            status
                        ): (
                            &mut ItemSlotContainer,
                            &mut Inventory<A>,
                            &mut Statistics,
                            &mut Attributes,
                            &mut CharacterStatus
                        ) = entity.get_components_mut()?;

                        if let Some($item) = items.[<$item>]() {
                            inventory.add_item($item.clone());
                            found_item = true;
                        }

                        if found_item {
                            items.[<unset_ $item>](entity)?;

                            statistics.update(
                                attributes,
                                resources.get::<AttributeSettings>(),
                                (&*items, resources.get::<ItemSettings>())
                            );

                            if status.current_health > statistics.health {
                                status.current_health = statistics.health.clone();
                            }

                            if let Some(menu) = reference.upgrade() {
                                let mut tabs = menu.tabs_mut();
                                let inventory = tabs.inventory::<A>();

                                inventory.update_page(world, true)?;
                            }
                        }

                        Ok(())
                    }
                });

                [<$item _button>].set_custom_callback({
                    let reference = $reference.clone();

                    move |world, controller_button| {
                        Ok(match controller_button {
                            ControllerButton::Y => {
                                let mut empty_affixes_found = false;

                                let entity = world.entity_mut($hero)?;
                                let items = entity.get_component::<ItemSlotContainer>()?;

                                if let Some(item) = items.$item().clone() {
                                    if item.affixes.iter().any(|affix| {
                                        if let ItemAffix::Socket(None) = affix {
                                            true
                                        } else {
                                            false
                                        }
                                    }) {
                                        let socket_object = world.resources.get_mut::<Option<ReferenceObject>>();

                                        *socket_object = Some(ReferenceObject::Item {
                                            item,
                                            source: ReferenceItemSource::Slots(None),
                                        });

                                        empty_affixes_found = true;
                                    }
                                }

                                if empty_affixes_found {
                                    let window = reference.upgrade().unwrap();
                                    let mut tabs = window.tabs_mut();
                                    let inventory = tabs.inventory::<A>();

                                    inventory.switch_to_jewels(world)?;
                                }

                                true
                            }

                            _ => false,
                        })
                    }
                });
            }
        };
        ($self:ident, $reference:ident, $hero:ident, $item:ident, $button:literal, $index:literal) => {
            paste::expr! {
                let [<$item _button>]: Arc<Button> = $self.snippet.element($button)?;

                [<$item _button>].set_select_callback({
                    let reference = $reference.clone();
                    let weak_button = Arc::downgrade(&[<$item _button>]);

                    move |world, selected| {
                        if selected {
                            let entity = unsafe { remove_life_time(world.entity($hero)?) };

                            let attributes = entity.get_component::<Attributes>()?;
                            let items = entity.get_component::<ItemSlotContainer>()?;

                            match items.$item($index) {
                                Some($item) => {
                                    let button_pos =
                                        weak_button.upgrade().unwrap().position_extent();

                                    let gui = Self::create_tooltip(
                                        world,
                                        $item,
                                        attributes,
                                        button_pos,
                                    )?;

                                    reference.upgrade().unwrap().add_tooltip("equip", gui);
                                }
                                None => {
                                    reference.upgrade().unwrap().remove_tooltip(world, "equip")?;
                                }
                            }
                        } else {
                            reference.upgrade().unwrap().remove_tooltip(world, "equip")?;
                        }

                        Ok(())
                    }
                });

                [<$item _button>].set_callback({
                    let reference = $reference.clone();

                    move |world| {
                        let mut found_item = false;

                        let (entity, resources) = world.entity_resources($hero)?;

                        let items = multi_mut.get::<ItemSlotContainer>()?;
                        let inventory = multi_mut.get::<Inventory<A>>()?;

                        if let Some($item) = items.[<$item>]($index) {
                            inventory.add_item($item.clone());
                            found_item = true;
                        }

                        if found_item {
                            items.[<unset_ $item>]($index)?;

                            let statistics = multi_mut.get::<Statistics>()?;
                            let attributes = multi_mut.get::<Attributes>()?;

                            statistics.update(
                                attributes,
                                resources.get::<AttributeSettings>(),
                                (&*items, resources.get::<ItemSettings>())
                            );

                            let status = multi_mut.get::<CharacterStatus>()?;

                            if status.current_health > statistics.health {
                                status.current_health = statistics.health.clone();
                            }

                            if let Some(menu) = reference.upgrade() {
                                let mut tabs = menu.tabs_mut();
                                let inventory = tabs.inventory::<A>();

                                inventory.update_page(world, true)?;
                            }
                        }

                        Ok(())
                    }
                });

                [<$item _button>].set_custom_callback({
                    let reference = $reference.clone();

                    move |world, controller_button| {
                        Ok(match controller_button {
                            ControllerButton::Y => {
                                let mut empty_affixes_found = false;

                                let entity = world.entity_mut($hero)?;
                                let items = entity.get_component::<ItemSlotContainer>()?;

                                if let Some(item) = items.$item($index).clone() {
                                    if item.affixes.iter().any(|affix| {
                                        if let ItemAffix::Socket(None) = affix {
                                            true
                                        } else {
                                            false
                                        }
                                    }) {
                                        let socket_object = world.resources.get_mut::<Option<ReferenceObject>>();

                                        *socket_object = Some(ReferenceObject::Item {
                                            item,
                                            source: ReferenceItemSource::Slots(Some($index)),
                                        });

                                        empty_affixes_found = true;
                                    }
                                }

                                if empty_affixes_found {
                                    let window = reference.upgrade().unwrap();
                                    let mut tabs = window.tabs_mut();
                                    let inventory = tabs.inventory::<A>();

                                    inventory.switch_to_jewels(world)?;
                                }

                                true
                            }

                            _ => false,
                        })
                    }
                });
            }
        };
    }

    #[macro_export]
    macro_rules! equip_update {
        ($gui:ident, $gui_handler:ident, $items:ident, $part:ident, $icons:ident) => {{
            let button: Arc<Button> = $gui.element(stringify!($part))?;

            match $items.$part() {
                Some($part) => button.set_icon($gui_handler, &$part.icon)?,
                None => button.set_icon($gui_handler, &$icons.$part)?,
            }
        }};
        ($gui:ident, $gui_handler:ident, $items:ident, $part:ident, $icons:ident, $name:literal) => {{
            let button: Arc<Button> = $gui.element($name)?;

            match $items.$part() {
                Some($part) => button.set_icon($gui_handler, &$part.icon)?,
                None => button.set_icon($gui_handler, &$icons.$part)?,
            }
        }};
        ($gui:ident, $gui_handler:ident, $items:ident, $part:ident, $icons:ident, $name:literal, $index:literal) => {{
            let button: Arc<Button> = $gui.element($name)?;

            match $items.$part($index) {
                Some($part) => button.set_icon($gui_handler, &$part.icon)?,
                None => button.set_icon($gui_handler, &$icons.$part)?,
            }
        }};
    }
}