Further steps towards new ecs

Cargo.toml

@@ -7,7 +7,7 @@ members = ["character_window", "map", "rpg_components"]
 destructure_traitobject = "0.3.0"
 itertools = "0.14.0"
 serde = { version = "1.0.203", features = ["derive"] }
-ron = "0.10.0"
+ron = "0.9.0"
 paste = "1.0.15"
 rayon = "1.10.0"
 chrono = { version = "0.4.35", features = ["serde"] }

character_window/src/abilities/ability_right_side.rs

@@ -28,23 +28,22 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
         "fourth_ability",
     ];
 
-    pub fn new(world: &mut World, hero: Entity, reference: &Weak<CharacterWindow>) -> Result<Self> {
+    pub fn new(
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        item_settings: &mut ItemSettings,
+        engine_settings: &mut EngineSettings,
+        context: &mut Context,
+        hero: Entity,
+        reference: &Weak<CharacterWindow>,
+    ) -> Result<Self> {
         let snippet = GuiSnippet::from_str(
-            world,
+            commands,
+            gui_handler,
             include_str!("../../resources/abilities/right_side.xml"),
         )?;
 
-        let color_settings = world
+        let color_settings = item_settings.rarity_color_settings.clone();
-            .resources
-            .get::<ItemSettings>()
-            .rarity_color_settings
-            .clone();
-
-        let (gui_handler, engine_settings, context): (
-            &mut GuiHandler,
-            &mut EngineSettings,
-            &mut Context,
-        ) = world.resources.get_mut()?;
 
         Self::rarity_icon_background(gui_handler, &snippet, "common", color_settings.common)?;
         Self::rarity_icon_background(gui_handler, &snippet, "uncommon", color_settings.uncommon)?;
@@ -64,7 +63,7 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
             button.set_callback({
                 let reference = reference.clone();
 
-                move |world: &mut World| {
+                move |commands, gui_handler| {
                     if let Some(menu) = reference.upgrade() {
                         let mut tabs = menu.tabs_mut();
                         let abilities = tabs.abilities::<A>();

character_window/src/abilities/content.rs

@@ -17,7 +17,8 @@ use super::AbilityPage;
 
 impl<A: Ability + 'static> Content<A, AbilityAddon> {
     fn show_addon_tooltip(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         hero: Entity,
         addon_index: usize,
         reference: &Weak<CharacterWindow>,
@@ -30,7 +31,7 @@ impl<A: Ability + 'static> Content<A, AbilityAddon> {
         let target_y = y;
 
         let addon = inventory.addon_at(addon_index);
-        let gui = addon.create_tooltip(world, (target_x, target_y))?;
+        let gui = addon.create_tooltip(commands, gui_handler, (target_x, target_y))?;
         gui.enable(world)?;
         gui.perform_single_check(world.resources.get_mut()?, x, y)?;
 

character_window/src/abilities/mod.rs

@@ -35,20 +35,21 @@ pub struct AbilityPage<A: Ability + 'static> {
 
 impl<A: Ability + 'static> AbilityPage<A> {
     pub fn new(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         hero: Entity,
         reference: Weak<CharacterWindow>,
         close: &Arc<Button>,
     ) -> Result<Self> {
-        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
         let grid = Grid::new(gui_handler, 2, 1, false)?;
 
         let left_base = GuiSnippet::from_str(
-            world,
+            commands,
+            gui_handler,
             include_str!("../../resources/abilities/left_side.xml"),
         )?;
 
-        grid.attach(world, left_base.clone(), 0, 0, 1, 1)?;
+        grid.attach(commands, gui_handler, left_base.clone(), 0, 0, 1, 1)?;
 
         Self::setup_content_switch(&left_base, reference.clone())?;
 
@@ -57,7 +58,7 @@ impl<A: Ability + 'static> AbilityPage<A> {
 
         // abilities
         let ability_mode = PageContent::new(
-            Content::new::<_, Self>(world, reference.clone(), {
+            Content::new::<_, Self>(commands, gui_handler, reference.clone(), {
                 let hero = hero.clone();
 
                 move |world| {
@@ -71,16 +72,11 @@ impl<A: Ability + 'static> AbilityPage<A> {
             })?,
             {
                 let ui = GuiSnippet::from_str(
-                    world,
+                    commands,
+                    gui_handler,
                     include_str!("../../resources/abilities/ability_tooltip.xml"),
                 )?;
 
-                let (gui_handler, engine_settings, context): (
-                    &mut GuiHandler,
-                    &mut EngineSettings,
-                    &mut Context,
-                ) = world.resources.get_mut()?;
-
                 let equip: Arc<Label> = ui.element("equip")?;
                 equip.set_info_icon(
                     gui_handler,
@@ -179,7 +175,7 @@ impl<A: Ability + 'static> AbilityPage<A> {
         })
     }
 
-    fn update_page(&mut self, world: &mut World) -> Result<()> {
+    fn update_page(&mut self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()> {
         match self.current_mode {
             0 => println!("update ability view"),
             1 => println!("update addon view"),
@@ -191,13 +187,27 @@ impl<A: Ability + 'static> AbilityPage<A> {
         mode.content_mut().update(world, self.hero)?;
 
         self.tooltip
-            .attach(world, mode.tooltip().clone(), 0, 0, 1, 1)?;
+            .attach(commands, gui_handler, mode.tooltip().clone(), 0, 0, 1, 1)?;
-        self.content
+        self.content.attach(
-            .attach(world, mode.content_mut().base().clone(), 0, 0, 1, 1)?;
+            commands,
+            gui_handler,
+            mode.content_mut().base().clone(),
+            0,
+            0,
+            1,
+            1,
+        )?;
 
-        self.right_side.refresh(world, self.hero)?;
+        self.right_side.refresh(commands, gui_handler, self.hero)?;
-        self.grid
+        self.grid.attach(
-            .attach(world, self.right_side.base().clone(), 1, 0, 1, 1)?;
+            commands,
+            gui_handler,
+            self.right_side.base().clone(),
+            1,
+            0,
+            1,
+            1,
+        )?;
 
         Ok(())
     }

character_window/src/character/mod.rs

@@ -23,26 +23,28 @@ pub struct CharacterPage {
 
 impl CharacterPage {
     pub fn new(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         hero: Entity,
         hero_name: &str,
         reference: &Weak<CharacterWindow>,
     ) -> Result<Self> {
         let snippet = GuiSnippet::from_str(
-            world,
+            commands,
+            gui_handler,
             include_str!("../../resources/character/statistics.xml"),
         )?;
 
         let grid: Arc<Grid> = snippet.element("statistic_tab")?;
         let name: Arc<Label> = snippet.element("character_name")?;
 
-        name.set_text(world.resources.get_mut()?, hero_name)?;
+        name.set_text(gui_handler, hero_name)?;
 
         let strength: Arc<Button> = snippet.element("strength_field")?;
         strength.set_callback({
             let update_stats = Self::create_update_stats(hero, reference.clone());
 
-            move |world| {
+            move |commands, gui_handler| {
                 update_stats(world, |attributes: &mut Attributes| {
                     attributes.add_strength(Strength::from(1));
                 })

character_window/src/content.rs

@@ -33,7 +33,8 @@ pub struct Content<A: Ability + 'static, T: Send + Sync> {
 
 impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
     pub fn new<F, P>(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         reference: Weak<CharacterWindow>,
         on_enable: F,
     ) -> Result<Self>
@@ -41,7 +42,11 @@ impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
         F: Fn(&mut World) -> Result<Vec<T>> + Send + Sync + 'static,
         P: Page,
     {
-        let base = GuiSnippet::from_str(world, include_str!("../resources/content.xml"))?;
+        let base = GuiSnippet::from_str(
+            commands,
+            gui_handler,
+            include_str!("../resources/content.xml"),
+        )?;
 
         let (gui_handler, engine_settings, context): (
             &mut GuiHandler,
@@ -58,12 +63,12 @@ impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
         left.set_callback({
             let reference = reference.clone();
 
-            move |world| {
+            move |commands, gui_handler| {
                 if let Some(window) = reference.upgrade() {
                     let mut tab = window.tab_mut();
                     let page = tab.downcast_mut::<P>();
 
-                    page.previous_tab(world)?;
+                    page.previous_tab(commands, gui_handler)?;
                 }
 
                 Ok(())
@@ -79,12 +84,12 @@ impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
         right.set_callback({
             let reference = reference.clone();
 
-            move |world| {
+            move |commands, gui_handler| {
                 if let Some(window) = reference.upgrade() {
                     let mut tab = window.tab_mut();
                     let page = tab.downcast_mut::<P>();
 
-                    page.next_tab(world)?;
+                    page.next_tab(commands, gui_handler)?;
                 }
 
                 Ok(())
@@ -105,12 +110,16 @@ impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
         })
     }
 
-    fn clear_grid(world: &mut World, grid: &Arc<Grid>) -> Result<()> {
+    fn clear_grid(
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        grid: &Arc<Grid>,
+    ) -> Result<()> {
         let (rows, columns) = grid.dimensions();
 
         for x in 0..columns {
             for y in 0..rows {
-                grid.detach(world, x, y)?;
+                grid.detach(commands, gui_handler, x, y)?;
             }
         }
 
@@ -121,18 +130,23 @@ impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
         label.set_text(gui_handler, format!("{} / {}", self.page + 1, self.pages))
     }
 
-    pub fn update_base<F>(&mut self, world: &mut World, setup: F) -> Result<()>
+    pub fn update_base<F>(
+        &mut self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        setup: F,
+    ) -> Result<()>
     where
         Self: ContentWrapper,
-        F: Fn(&mut World, &Arc<Button>, &T, usize) -> Result<()>,
+        F: Fn(&mut Commands, &mut GuiHandler, &Arc<Button>, &T, usize) -> Result<()>,
     {
         self.refresh(world)?;
 
         let grid: Arc<Grid> = self.base.element("content")?;
         let label: Arc<Label> = self.base.element("tab_info")?;
 
-        Self::clear_grid(world, &grid)?;
+        Self::clear_grid(commands, gui_handler, &grid)?;
-        self.set_tab(world.resources.get_mut()?, &label)?;
+        self.set_tab(gui_handler, &label)?;
 
         let (rows, columns) = grid.dimensions();
 
@@ -143,13 +157,14 @@ impl<A: Ability + 'static, T: Send + Sync> Content<A, T> {
                 match self.data.get(index) {
                     Some(t) => {
                         let snippet = GuiSnippet::from_str(
-                            world,
+                            commands,
+                            gui_handler,
                             include_str!("../resources/content_button.xml"),
                         )?;
 
                         let button: Arc<Button> = snippet.element("button")?;
-                        setup(world, &button, t, index)?;
+                        setup(commands, gui_handler, &button, t, index)?;
-                        grid.attach(world, button, x, y, 1, 1)?;
+                        grid.attach(commands, gui_handler, button, x, y, 1, 1)?;
                     }
                     None => break 'outer,
                 }

character_window/src/inventory/item_right_side.rs

@@ -27,13 +27,16 @@ pub struct ItemRightSide {
 
 impl ItemRightSide {
     pub fn new<A: Ability + 'static>(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        item_settings: &ItemSettings,
+        context: &Context,
         file: &str,
         reference: &Weak<CharacterWindow>,
         hero: Entity,
     ) -> Result<Self> {
-        let snippet = GuiSnippet::from_str(world, file)?;
+        let snippet = GuiSnippet::from_str(commands, gui_handler, file)?;
-        let icons = InventoryEmptyIcons::new(world)?;
+        let icons = InventoryEmptyIcons::new(context, item_settings)?;
 
         let me = Self {
             snippet,
@@ -121,7 +124,12 @@ impl ItemRightSide {
 }
 
 impl RightSide for ItemRightSide {
-    fn refresh(&mut self, world: &mut World, hero: Entity) -> Result<()> {
+    fn refresh(
+        &mut self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        hero: Entity,
+    ) -> Result<()> {
         let (hero_object, resources) = world.entity_resources(hero)?;
         let items = hero_object.get_component::<ItemSlotContainer>()?;
 
@@ -148,13 +156,8 @@ struct InventoryEmptyIcons {
 }
 
 impl InventoryEmptyIcons {
-    fn new(world: &World) -> Result<Self> {
+    fn new(context: &Context, item_settings: &ItemSettings) -> Result<Self> {
-        let place_holder_settings = &world
+        let place_holder_settings = &item_settings.icon_place_holder_paths;
-            .resources
-            .get::<ItemSettings>()
-            .icon_place_holder_paths;
-
-        let context = world.resources.get::<Context>();
 
         Ok(Self {
             helmet: Self::image(context, &place_holder_settings.helmet)?,

character_window/src/inventory/jewel_right_side.rs

@@ -59,19 +59,19 @@ pub struct JewelRightSide {
 
 impl JewelRightSide {
     pub fn new<A: Ability + 'static>(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        engine_settings: &EngineSettings,
+        context: &Context,
         file: &str,
         hero: Entity,
         reference: &Weak<CharacterWindow>,
     ) -> Result<Self> {
-        let snippet = GuiSnippet::from_str(world, file)?;
+        let snippet = GuiSnippet::from_str(commands, gui_handler, file)?;
 
         let combine: Arc<Label> = snippet.element("combine")?;
-        let icon = world.resources.get::<EngineSettings>().controller_icon(
+        let icon = engine_settings.controller_icon(context, ControllerButton::RightStick)?;
-            world.resources.get::<Context>(),
+        combine.set_info_icon(gui_handler, &icon)?;
-            ControllerButton::RightStick,
-        )?;
-        combine.set_info_icon(world.resources.get_mut()?, &icon)?;
 
         world.resources.insert_if_not_exists::<ReferenceObject>();
         world.resources.insert_if_not_exists::<LowerJewels>();
@@ -93,7 +93,7 @@ impl JewelRightSide {
             let weak_top = Arc::downgrade(&top);
             let reference = reference.clone();
 
-            move |world, selected| {
+            move |commands, gui_handler, selected| {
                 let menu = reference.upgrade().unwrap();
 
                 if selected {
@@ -108,27 +108,37 @@ impl JewelRightSide {
                     if let Some(reference_info) = reference_info.some() {
                         let tooltip = match reference_info {
                             ReferenceObject::Item { item, .. } => {
-                                let attributes = unsafe { remove_life_time(world.entity(hero)?) }
+                                let attributes =
-                                    .get_component::<Attributes>()?;
+                                    world.entity(hero)?.get_component::<Attributes>()?;
 
-                                item.create_tooltip(world, attributes, (x + w as i32, y))?
+                                item.create_tooltip(
+                                    commands,
+                                    gui_handler,
+                                    attributes,
+                                    (x + w as i32, y),
+                                )?
                             }
                             ReferenceObject::Jewel { jewel, .. } => {
                                 let item_settings = world.resources.get_unchecked::<ItemSettings>();
 
-                                jewel.create_tooltip(world, item_settings, (x + w as i32, y))?
+                                jewel.create_tooltip(
+                                    commands,
+                                    gui_handler,
+                                    item_settings,
+                                    (x + w as i32, y),
+                                )?
                             }
 
                             ReferenceObject::Empty => unreachable!(),
                         };
 
-                        tooltip.enable(world)?;
+                        tooltip.enable(commands, gui_handler)?;
-                        tooltip.perform_single_check(world.resources.get_mut()?, x, y)?;
+                        tooltip.perform_single_check(gui_handler, x, y)?;
 
                         menu.add_tooltip("upper", tooltip);
                     }
                 } else {
-                    menu.remove_tooltip(world, "upper")?;
+                    menu.remove_tooltip(commands, gui_handler, "upper")?;
                 }
 
                 Ok(())
@@ -140,7 +150,7 @@ impl JewelRightSide {
                 let weak_top = Arc::downgrade(&lower);
                 let reference = reference.clone();
 
-                move |world, selected| {
+                move |commands, gui_handler, selected| {
                     let menu = reference.upgrade().unwrap();
 
                     if selected {
@@ -167,7 +177,7 @@ impl JewelRightSide {
                             menu.add_tooltip(format!("lower_{index}",), tooltip);
                         }
                     } else {
-                        menu.remove_tooltip(world, format!("lower_{index}"))?;
+                        menu.remove_tooltip(commands, gui_handler, format!("lower_{index}"))?;
                     }
 
                     Ok(())
@@ -177,7 +187,7 @@ impl JewelRightSide {
             lower.set_callback({
                 let reference = reference.clone();
 
-                move |world| {
+                move |commands, gui_handler| {
                     let lower_info: &mut LowerJewels = world.resources.get_mut()?;
 
                     if lower_info.jewels[index].is_some() {
@@ -187,7 +197,7 @@ impl JewelRightSide {
                             let mut tabs = menu.tabs_mut();
                             let inventory = tabs.inventory::<A>();
 
-                            inventory.update_page(world, true)?;
+                            inventory.update_page(commands, gui_handler, true)?;
                         }
                     }
 

character_window/src/inventory/map_right_side.rs

@@ -9,15 +9,20 @@ pub struct MapRightSide {
 }
 
 impl MapRightSide {
-    pub fn new(world: &mut World, file: &str) -> Result<Self> {
+    pub fn new(commands: &mut Commands, gui_handler: &mut GuiHandler, file: &str) -> Result<Self> {
-        let snippet = GuiSnippet::from_str(world, file)?;
+        let snippet = GuiSnippet::from_str(commands, gui_handler, file)?;
 
         Ok(Self { snippet })
     }
 }
 
 impl RightSide for MapRightSide {
-    fn refresh(&mut self, _world: &mut World, _hero: Entity) -> Result<()> {
+    fn refresh(
+        &mut self,
+        _commands: &mut Commands,
+        _gui_handler: &mut GuiHandler,
+        _hero: Entity,
+    ) -> Result<()> {
         Ok(())
     }
 

character_window/src/inventory/mod.rs

@@ -10,6 +10,7 @@ use anyhow::Result;
 use ecs::*;
 use engine::prelude::*;
 use rpg_components::components::inventory::Inventory;
+use rpg_components::config::items::ItemSettings;
 use rpg_components::items::ability_book::Ability;
 
 use super::page_content::PageContent;
@@ -38,20 +39,24 @@ pub struct InventoryPage<A: Ability + 'static> {
 
 impl<A: Ability + 'static> InventoryPage<A> {
     pub fn new(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        engine_settings: &EngineSettings,
+        item_settings: &ItemSettings,
+        context: &Context,
         hero: Entity,
         reference: Weak<CharacterWindow>,
         close: &Arc<Button>,
     ) -> Result<Self> {
-        let gui_handler: &mut GuiHandler = world.resources.get_mut()?;
         let grid = Grid::new(gui_handler, 2, 1, false)?;
 
         let left_base = GuiSnippet::from_str(
-            world,
+            commands,
+            gui_handler,
             include_str!("../../resources/inventory/left_side.xml"),
         )?;
 
-        grid.attach(world, left_base.clone(), 0, 0, 1, 1)?;
+        grid.attach(commands, gui_handler, left_base.clone(), 0, 0, 1, 1)?;
         Self::setup_content_switch(&left_base, reference.clone())?;
 
         let tooltip = left_base.element("tooltip")?;
@@ -59,10 +64,10 @@ impl<A: Ability + 'static> InventoryPage<A> {
 
         // items
         let item_mode = PageContent::<A, _>::new(
-            Content::new::<_, Self>(world, reference.clone(), {
+            Content::new::<_, Self>(commands, gui_handler, reference.clone(), {
                 let hero = hero.clone();
 
-                move |world: &mut World| {
+                move |world| {
                     let hero_object = world.entity(hero)?;
                     let inventory = hero_object.get_component::<Inventory<A>>()?;
 
@@ -73,16 +78,11 @@ impl<A: Ability + 'static> InventoryPage<A> {
             })?,
             {
                 let ui = GuiSnippet::from_str(
-                    world,
+                    commands,
+                    gui_handler,
                     include_str!("../../resources/inventory/items/tooltip.xml"),
                 )?;
 
-                let (gui_handler, engine_settings, context): (
-                    &mut GuiHandler,
-                    &mut EngineSettings,
-                    &mut Context,
-                ) = world.resources.get_mut()?;
-
                 let equip: Arc<Label> = ui.element("equip")?;
                 equip.set_info_icon(
                     gui_handler,
@@ -110,7 +110,10 @@ impl<A: Ability + 'static> InventoryPage<A> {
                 ui
             },
             ItemRightSide::new::<A>(
-                world,
+                commands,
+                gui_handler,
+                item_settings,
+                context,
                 include_str!("../../resources/inventory/items/right_side.xml"),
                 &reference,
                 hero,
@@ -119,7 +122,7 @@ impl<A: Ability + 'static> InventoryPage<A> {
 
         // jewels
         let jewel_mode = PageContent::<A, _>::new(
-            Content::new::<_, Self>(world, reference.clone(), {
+            Content::new::<_, Self>(commands, gui_handler, reference.clone(), {
                 let hero = hero.clone();
 
                 move |world| {
@@ -133,16 +136,11 @@ impl<A: Ability + 'static> InventoryPage<A> {
             })?,
             {
                 let ui = GuiSnippet::from_str(
-                    world,
+                    commands,
+                    gui_handler,
                     include_str!("../../resources/inventory/jewels/tooltip.xml"),
                 )?;
 
-                let (gui_handler, engine_settings, context): (
-                    &mut GuiHandler,
-                    &mut EngineSettings,
-                    &mut Context,
-                ) = world.resources.get_mut()?;
-
                 let socket: Arc<Label> = ui.element("socket")?;
                 socket.set_info_icon(
                     gui_handler,
@@ -164,7 +162,10 @@ impl<A: Ability + 'static> InventoryPage<A> {
                 ui
             },
             JewelRightSide::new::<A>(
-                world,
+                commands,
+                gui_handler,
+                engine_settings,
+                context,
                 include_str!("../../resources/inventory/jewels/right_side.xml"),
                 hero,
                 &reference,
@@ -173,7 +174,7 @@ impl<A: Ability + 'static> InventoryPage<A> {
 
         // maps
         let map_mode = PageContent::<A, _>::new(
-            Content::new::<_, Self>(world, reference.clone(), {
+            Content::new::<_, Self>(commands, gui_handler, reference.clone(), {
                 move |world| {
                     let hero_object = world.entity(hero)?;
                     let inventory = hero_object.get_component::<Inventory<A>>()?;
@@ -185,16 +186,11 @@ impl<A: Ability + 'static> InventoryPage<A> {
             })?,
             {
                 let ui = GuiSnippet::from_str(
-                    world,
+                    commands,
+                    gui_handler,
                     include_str!("../../resources/inventory/maps/tooltip.xml"),
                 )?;
 
-                let (gui_handler, engine_settings, context): (
-                    &mut GuiHandler,
-                    &mut EngineSettings,
-                    &mut Context,
-                ) = world.resources.get_mut()?;
-
                 let select: Arc<Label> = ui.element("select")?;
                 select.set_info_icon(
                     gui_handler,
@@ -216,7 +212,8 @@ impl<A: Ability + 'static> InventoryPage<A> {
                 ui
             },
             MapRightSide::new(
-                world,
+                commands,
+                gui_handler,
                 include_str!("../../resources/inventory/maps/right_side.xml"),
             )?,
         );
@@ -243,12 +240,21 @@ impl<A: Ability + 'static> InventoryPage<A> {
         })
     }
 
-    fn switch_to_jewels(&mut self, world: &mut World) -> Result<()> {
+    fn switch_to_jewels(
+        &mut self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+    ) -> Result<()> {
         self.current_mode = 1;
-        self.update_page(world, true)
+        self.update_page(commands, gui_handler, true)
     }
 
-    fn update_page(&mut self, world: &mut World, select: bool) -> Result<()> {
+    fn update_page(
+        &mut self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        select: bool,
+    ) -> Result<()> {
         match self.current_mode {
             0 => println!("update item view"),
             1 => println!("update jewel view"),
@@ -261,11 +267,27 @@ impl<A: Ability + 'static> InventoryPage<A> {
             let mode = &mut self.modes[self.current_mode];
 
             self.tooltip
-                .attach(world, mode.tooltip().clone(), 0, 0, 1, 1)?;
+                .attach(commands, gui_handler, mode.tooltip().clone(), 0, 0, 1, 1)?;
-            self.content
+
-                .attach(world, mode.content_mut().base().clone(), 0, 0, 1, 1)?;
+            self.content.attach(
-            self.grid
+                commands,
-                .attach(world, mode.right_side_mut().base().clone(), 1, 0, 1, 1)?;
+                gui_handler,
+                mode.content_mut().base().clone(),
+                0,
+                0,
+                1,
+                1,
+            )?;
+
+            self.grid.attach(
+                commands,
+                gui_handler,
+                mode.right_side_mut().base().clone(),
+                1,
+                0,
+                1,
+                1,
+            )?;
 
             mode.content_mut().update(world, self.hero)?;
             mode.right_side_mut().refresh(world, self.hero)?;

character_window/src/lib.rs

@@ -30,12 +30,22 @@ use std::{
 use self::{abilities::AbilityPage, character::CharacterPage, inventory::InventoryPage};
 
 trait Page: Any + Send + Sync + Downcast {
-    fn enable(&mut self, world: &mut World) -> Result<Arc<Grid>>;
+    fn enable(
-    fn disable(&mut self, world: &mut World) -> Result<()>;
+        &mut self,
-    fn select(&self, world: &mut World) -> Result<()>;
+        commands: &mut Commands,
-    fn next_tab(&mut self, world: &mut World) -> Result<()>;
+        gui_handler: &mut GuiHandler,
-    fn previous_tab(&mut self, world: &mut World) -> Result<()>;
+    ) -> Result<Arc<Grid>>;
-    fn event(&mut self, world: &mut World, button: ControllerButton) -> Result<bool>;
+    fn disable(&mut self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()>;
+    fn select(&self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()>;
+    fn next_tab(&mut self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()>;
+    fn previous_tab(&mut self, commands: &mut Commands, gui_handler: &mut GuiHandler)
+    -> Result<()>;
+    fn event(
+        &mut self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        button: ControllerButton,
+    ) -> Result<bool>;
 }
 
 impl_downcast!(Page);
@@ -130,12 +140,17 @@ pub struct CharacterWindow {
 
 impl CharacterWindow {
     pub fn new<A: Ability + 'static>(
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        engine_settings: &EngineSettings,
+        item_settings: &ItemSettings,
+        context: &Context,
         hero: Entity,
         name: &str,
         close: Box<dyn FutureStateChange>,
     ) -> Result<Arc<Self>> {
-        let menu_gui = GuiBuilder::from_str(world, include_str!("../resources/menu.xml"))?;
+        let menu_gui =
+            GuiBuilder::from_str(commands, gui_handler, include_str!("../resources/menu.xml"))?;
 
         let content_grid = menu_gui.element("tab_content")?;
         let open_character_page: Arc<Button> = menu_gui.element("open_statistics")?;
@@ -152,9 +167,15 @@ impl CharacterWindow {
             tooltips: Mutex::default(),
 
             tabs: RwLock::new([
-                Box::new(CharacterPage::new(world, hero, name, me).unwrap()),
+                Box::new(CharacterPage::new(commands, gui_handler, hero, name, me).unwrap()),
-                Box::new(InventoryPage::<A>::new(world, hero, me.clone(), &close_button).unwrap()),
+                Box::new(
-                Box::new(AbilityPage::<A>::new(world, hero, me.clone(), &close_button).unwrap()),
+                    InventoryPage::<A>::new(commands, gui_handler, hero, me.clone(), &close_button)
+                        .unwrap(),
+                ),
+                Box::new(
+                    AbilityPage::<A>::new(commands, gui_handler, hero, me.clone(), &close_button)
+                        .unwrap(),
+                ),
             ]),
             tab: AtomicUsize::new(0),
         });
@@ -162,13 +183,14 @@ impl CharacterWindow {
         let open_tab = {
             let weak_me = Arc::downgrade(&character_window);
 
-            move |world: &mut World, index| {
+            move |commands: &mut Commands, gui_handler: &mut GuiHandler, index| {
                 if let Some(me) = weak_me.upgrade() {
                     me.tab.store(index, SeqCst);
 
-                    let child = me.tab_mut().enable(world)?;
+                    let child = me.tab_mut().enable(commands, gui_handler)?;
-                    me.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
+                    me.tab_content_grid
-                    me.tab().select(world)?;
+                        .attach(commands, gui_handler, child, 0, 0, 1, 1)?;
+                    me.tab().select(commands, gui_handler)?;
                 }
 
                 Ok(())
@@ -178,19 +200,19 @@ impl CharacterWindow {
         open_character_page.set_callback({
             let open_tab = open_tab.clone();
 
-            move |world| open_tab(world, 0)
+            move |commands, gui_handler| open_tab(commands, gui_handler, 0)
         });
 
         open_inventory_page.set_callback({
             let open_tab = open_tab.clone();
 
-            move |world| open_tab(world, 1)
+            move |commands, gui_handler| open_tab(commands, gui_handler, 1)
         });
 
         open_ability_page.set_callback({
             let open_tab = open_tab.clone();
 
-            move |world| open_tab(world, 2)
+            move |commands, gui_handler| open_tab(commands, gui_handler, 2)
         });
 
         Self::setup_menu(&character_window)?;
@@ -198,8 +220,13 @@ impl CharacterWindow {
         Ok(character_window)
     }
 
-    pub fn event(&self, world: &mut World, button: ControllerButton) -> Result<bool> {
+    pub fn event(
-        self.tabs.write().unwrap()[self.tab.load(SeqCst)].event(world, button)
+        &self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        button: ControllerButton,
+    ) -> Result<bool> {
+        self.tabs.write().unwrap()[self.tab.load(SeqCst)].event(commands, gui_handler, button)
     }
 
     pub fn tabs<'a>(&'a self) -> Tabs<'a> {
@@ -235,9 +262,14 @@ impl CharacterWindow {
             .insert(name.to_string(), gui.into());
     }
 
-    pub fn remove_tooltip(&self, world: &mut World, name: impl ToString) -> Result<()> {
+    pub fn remove_tooltip(
+        &self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        name: impl ToString,
+    ) -> Result<()> {
         if let Some(tooltip) = self.tooltips.lock().unwrap().remove(&name.to_string()) {
-            tooltip.disable(world)?;
+            tooltip.disable(commands, gui_handler)?;
         }
 
         Ok(())
@@ -280,12 +312,13 @@ impl TopLevelGui for CharacterWindow {
         None
     }
 
-    fn enable(&self, world: &mut World) -> Result<()> {
+    fn enable(&self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.menu_gui.enable(world)?;
+        self.menu_gui.enable(commands, gui_handler)?;
 
-        let child = self.tab_mut().enable(world)?;
+        let child = self.tab_mut().enable(commands, gui_handler)?;
-        self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
+        self.tab_content_grid
-        self.tab().select(world)?;
+            .attach(commands, gui_handler, child, 0, 0, 1, 1)?;
+        self.tab().select(commands, gui_handler)?;
 
         let (gui_handler, engine_settings, context): (
             &mut GuiHandler,
@@ -314,8 +347,8 @@ impl TopLevelGui for CharacterWindow {
         Ok(())
     }
 
-    fn disable(&self, world: &mut World) -> Result<()> {
+    fn disable(&self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.menu_gui.disable(world)?;
+        self.menu_gui.disable(commands, gui_handler)?;
 
         Ok(())
     }
@@ -336,37 +369,48 @@ impl GuiElementTraits for CharacterWindow {
 }
 
 impl TopGui for CharacterWindow {
-    fn decline(&self, world: &mut World) -> Result<()> {
+    fn decline(&self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()> {
-        (self.close)(world)
+        (self.close)(commands, gui_handler)
     }
 
-    fn next_tab(&self, world: &mut World, second_level: bool) -> Result<()> {
+    fn next_tab(
+        &self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        second_level: bool,
+    ) -> Result<()> {
         match second_level {
             false => {
                 // disable old tab
-                self.tab_mut().disable(world)?;
+                self.tab_mut().disable(commands, gui_handler)?;
 
                 // add to tab index
                 self.tab.store((self.tab.load(SeqCst) + 1) % 3, SeqCst);
 
                 // update tab content
-                let child = self.tab_mut().enable(world)?;
+                let child = self.tab_mut().enable(commands, gui_handler)?;
-                self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
+                self.tab_content_grid
-                self.tab().select(world)?;
+                    .attach(commands, gui_handler, child, 0, 0, 1, 1)?;
+                self.tab().select(commands, gui_handler)?;
             }
             true => {
-                self.tab_mut().next_tab(world)?;
+                self.tab_mut().next_tab(commands, gui_handler)?;
             }
         }
 
         Ok(())
     }
 
-    fn previous_tab(&self, world: &mut World, second_level: bool) -> Result<()> {
+    fn previous_tab(
+        &self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        second_level: bool,
+    ) -> Result<()> {
         match second_level {
             false => {
                 // disable old tab
-                self.tab_mut().disable(world)?;
+                self.tab_mut().disable(commands, gui_handler)?;
 
                 // subtract from tab index
                 if self.tab.load(SeqCst) == 0 {
@@ -376,12 +420,13 @@ impl TopGui for CharacterWindow {
                 }
 
                 // update tab content
-                let child = self.tab_mut().enable(world)?;
+                let child = self.tab_mut().enable(commands, gui_handler)?;
-                self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
+                self.tab_content_grid
-                self.tab().select(world)?;
+                    .attach(commands, gui_handler, child, 0, 0, 1, 1)?;
+                self.tab().select(commands, gui_handler)?;
             }
             true => {
-                self.tab_mut().previous_tab(world)?;
+                self.tab_mut().previous_tab(commands, gui_handler)?;
             }
         }
 
@@ -402,7 +447,9 @@ impl CharacterWindow {
                 // .add("open_statistics", open_statistics)
                 // .add("open_abilities", open_abilities)
                 // .add("open_inventory", open_inventory)
-                .add("close", move |world| close(world))
+                .add("close", move |commands, gui_handler| {
+                    close(commands, gui_handler)
+                })
                 .into(),
         )?;
 

character_window/src/page_content.rs

@@ -8,7 +8,12 @@ use super::traits::*;
 pub struct EmptyRightSide;
 
 impl RightSide for EmptyRightSide {
-    fn refresh(&mut self, _world: &mut World, _hero: Entity) -> Result<()> {
+    fn refresh(
+        &mut self,
+        _commands: &mut Commands,
+        _gui_handler: &mut GuiHandler,
+        _hero: Entity,
+    ) -> Result<()> {
         unreachable!()
     }
 

character_window/src/traits.rs

@@ -14,9 +14,19 @@ pub trait PageContentWrapper: Send + Sync {
 }
 
 pub trait RightSide: Send + Sync {
-    fn refresh(&mut self, world: &mut World, hero: Entity) -> Result<()>;
+    fn refresh(
+        &mut self,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
+        hero: Entity,
+    ) -> Result<()>;
 
-    fn disable(&mut self, _world: &mut World, _hero: Entity) -> Result<()> {
+    fn disable(
+        &mut self,
+        _commands: &mut Commands,
+        _gui_handler: &mut GuiHandler,
+        _hero: Entity,
+    ) -> Result<()> {
         Ok(())
     }
 

rpg_components/src/items/ability_addon.rs

@@ -245,10 +245,17 @@ impl AbilityAddon {
         Ok(item_system.addon(rarity, addon_type))
     }
 
-    pub fn create_tooltip(&self, world: &mut World, position: (i32, i32)) -> Result<Tooltip> {
+    pub fn create_tooltip(
-        let gui = GuiBuilder::from_str(world, include_str!("../../resources/addon_snippet.xml"))?;
+        &self,
-
+        commands: &mut Commands,
-        let gui_handler: &mut GuiHandler = world.resources.get_mut()?;
+        gui_handler: &mut GuiHandler,
+        position: (i32, i32),
+    ) -> Result<Tooltip> {
+        let gui = GuiBuilder::from_str(
+            commands,
+            gui_handler,
+            include_str!("../../resources/addon_snippet.xml"),
+        )?;
 
         let icon: Arc<Icon> = gui.element("addon_icon")?;
         let rarity_label: Arc<Label> = gui.element("rarity_label")?;

rpg_components/src/items/ability_book.rs

@@ -298,13 +298,16 @@ impl<A: Ability> AbilityBook<A> {
 
     pub fn create_tooltip(
         &self,
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         statistics: &Statistics,
         position: (i32, i32),
     ) -> Result<Tooltip> {
-        let gui = GuiBuilder::from_str(world, include_str!("../../resources/book_snippet.xml"))?;
+        let gui = GuiBuilder::from_str(
-
+            commands,
-        let gui_handler: &mut GuiHandler = world.resources.get_mut()?;
+            gui_handler,
+            include_str!("../../resources/book_snippet.xml"),
+        )?;
 
         let ability_name: Arc<Label> = gui.element("ability_name")?;
         let rarity_label: Arc<Label> = gui.element("rarity_label")?;

rpg_components/src/items/item.rs

@@ -233,16 +233,15 @@ impl Item {
 
     pub fn create_tooltip(
         &self,
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         attributes: &Attributes,
         position: (i32, i32),
     ) -> Result<Tooltip> {
         let (stats, jewels) = ItemAffix::squash(self.affixes.iter());
         let count = stats.len() + jewels.len();
 
-        let inspector_snippet = GuiBuilder::from_str(world, &ITEM_SNIPPETS[count])?;
+        let inspector_snippet = GuiBuilder::from_str(commands, gui_handler, &ITEM_SNIPPETS[count])?;
-
-        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
 
         let item_icon: Arc<Icon> = inspector_snippet.element("item_icon")?;
         let slot_label: Arc<Label> = inspector_snippet.element("slot_label")?;
@@ -289,8 +288,11 @@ impl Item {
         let mut index = Self::INSPECTOR_OFFSET;
 
         for stat in stats {
-            let stat_type_snippet =
+            let stat_type_snippet = GuiSnippet::from_str(
-                GuiSnippet::from_str(world, include_str!("../../resources/stat_type_snippet.xml"))?;
+                commands,
+                gui_handler,
+                include_str!("../../resources/stat_type_snippet.xml"),
+            )?;
 
             let stat_type_label: Arc<Label> = stat_type_snippet.element("stat_type")?;
             let stat_value_label: Arc<Label> = stat_type_snippet.element("stat_value")?;
@@ -298,14 +300,15 @@ impl Item {
             stat_type_label.set_text(gui_handler, &format!("{}", stat))?;
             stat_value_label.set_text(gui_handler, &stat.display_value())?;
 
-            inspector_grid.attach(world, stat_type_snippet, 0, index, 1, 1)?;
+            inspector_grid.attach(commands, gui_handler, stat_type_snippet, 0, index, 1, 1)?;
 
             index += 1;
         }
 
         for jewel in jewels {
             let socket_snippet = GuiSnippet::from_str(
-                world,
+                commands,
+                gui_handler,
                 include_str!("../../resources/item_socket_snippet.xml"),
             )?;
 
@@ -329,7 +332,7 @@ impl Item {
                 }
             }
 
-            inspector_grid.attach(world, socket_snippet, 0, index, 1, 1)?;
+            inspector_grid.attach(commands, gui_handler, socket_snippet, 0, index, 1, 1)?;
 
             index += 1;
         }

rpg_components/src/items/jewel.rs

@@ -60,14 +60,16 @@ impl Jewel {
 
     pub fn create_tooltip(
         &self,
-        world: &mut World,
+        commands: &mut Commands,
+        gui_handler: &mut GuiHandler,
         item_settings: &ItemSettings,
         position: (i32, i32),
     ) -> Result<Tooltip> {
-        let inspector_snippet: Arc<GuiBuilder> =
+        let inspector_snippet: Arc<GuiBuilder> = GuiBuilder::from_str(
-            GuiBuilder::from_str(world, include_str!("../../resources/jewel_tooltip.xml"))?;
+            commands,
-
+            gui_handler,
-        let gui_handler: &mut GuiHandler = world.resources.get_mut()?;
+            include_str!("../../resources/jewel_tooltip.xml"),
+        )?;
 
         let main_grid: Arc<Grid> = inspector_snippet.element("main_grid")?;
         main_grid.change_position_unscaled(gui_handler, position.0, position.1)?;

rpg_components/src/items/tooltip.rs

@@ -18,8 +18,8 @@ impl Tooltip {
         Self { grid, gui }
     }
 
-    pub fn enable(&self, world: &mut World) -> Result<()> {
+    pub fn enable(&self, commands: &mut Commands, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.gui.enable(world)
+        self.gui.enable(commands, gui_handler)
     }
 
     pub fn check_fitting(