Update Rust crate quick-xml to 0.37.0

src/builder/builder.rs

@@ -23,31 +23,31 @@ pub struct GuiBuilder {
 }
 
 impl GuiBuilder {
-    pub fn new(gui_handler: &mut GuiHandler, path: &AssetPath) -> Result<Arc<Self>> {
+    pub fn new(world: &mut World, path: &AssetPath) -> Result<Arc<Self>> {
         let validator = Validator::new(
             #[cfg(feature = "audio")]
-            gui_handler,
+            world.resources.get::<GuiHandler>(),
             path,
         )
         .with_context(|| format!("validator for {}", path.full_path()))?;
 
-        Ok(Arc::new(Self::_new(gui_handler, validator).with_context(
+        Ok(Arc::new(Self::_new(world, validator).with_context(
             || format!("for file {}", path.full_path()),
         )?))
     }
 
-    pub fn from_str(gui_handler: &mut GuiHandler, s: &str) -> Result<Arc<Self>> {
+    pub fn from_str(world: &mut World, s: &str) -> Result<Arc<Self>> {
         let validator = Validator::from_str(
             #[cfg(feature = "audio")]
-            gui_handler,
+            world.resources.get::<GuiHandler>(),
             s,
         )?;
 
-        Ok(Arc::new(Self::_new(gui_handler, validator)?))
+        Ok(Arc::new(Self::_new(world, validator)?))
     }
 
     pub fn merge<'a>(
-        gui_handler: &mut GuiHandler,
+        world: &mut World,
         pathes: impl IntoIterator<Item = &'a AssetPath>,
     ) -> Result<Arc<Self>> {
         let mut me = Self {
@@ -62,11 +62,11 @@ impl GuiBuilder {
         for path in pathes.into_iter() {
             let validator = Validator::new(
                 #[cfg(feature = "audio")]
-                gui_handler,
+                world.resources.get::<GuiHandler>(),
                 path,
             )?;
 
-            let builder = Self::_new(gui_handler, validator)
+            let builder = Self::_new(world, validator)
                 .with_context(|| format!("for file {}", path.full_path()))?;
 
             me.grids.extend(builder.grids);
@@ -86,7 +86,7 @@ impl GuiBuilder {
     }
 
     #[inline]
-    fn _new(gui_handler: &mut GuiHandler, validator: Validator) -> Result<Self> {
+    fn _new(world: &mut World, validator: Validator) -> Result<Self> {
         let root = validator.root();
 
         let mut ids = HashMap::new();
@@ -95,8 +95,11 @@ impl GuiBuilder {
 
         let mut grids = Vec::new();
 
+        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
+
         for child in &root.children {
             let tree = Self::create_tree(
+                world,
                 gui_handler,
                 &mut ids,
                 child,
@@ -179,7 +182,7 @@ impl GuiBuilder {
 impl Functionality for GuiBuilder {
     fn set_click_callbacks(
         &self,
-        functions: Vec<(&str, Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>)>,
+        functions: Vec<(&str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>,
     ) -> Result<()> {
         for (function_name, callback) in functions {
             let suffix_less_function_name = handle_function_suffix(function_name);
@@ -195,7 +198,7 @@ impl Functionality for GuiBuilder {
         &self,
         _functions: Vec<(
             &str,
-            Box<dyn Fn(&mut Commands, &dyn Any) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>,
         )>,
     ) -> Result<()> {
         Ok(())
@@ -205,7 +208,7 @@ impl Functionality for GuiBuilder {
         &self,
         callbacks: Vec<(
             &str,
-            Box<dyn Fn(&mut Commands, bool) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut World, bool) -> Result<()> + Send + Sync>,
         )>,
     ) -> Result<()> {
         for (function_name, callback) in callbacks {
@@ -222,7 +225,7 @@ impl Functionality for GuiBuilder {
         &self,
         callbacks: Vec<(
             &str,
-            Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>,
+            Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>,
         )>,
     ) -> Result<()> {
         for (function_name, callback) in callbacks {
@@ -342,6 +345,7 @@ impl_element!(MultiLineTextField);
 // private
 impl GuiBuilder {
     fn create_tree(
+        world: &mut World,
         gui_handler: &mut GuiHandler,
         ids: &mut HashMap<String, UiElement>,
         root_grid_info: &Arc<GridInfo>,
@@ -394,6 +398,7 @@ impl GuiBuilder {
 
         for child in root_grid_info.children.read().unwrap().iter() {
             Self::create_child(
+                world,
                 gui_handler,
                 child,
                 &root_grid,
@@ -408,6 +413,7 @@ impl GuiBuilder {
     }
 
     fn create_child(
+        world: &mut World,
         gui_handler: &mut GuiHandler,
         child: &UiInfoElement,
         grid: &Grid,
@@ -423,7 +429,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &button_info.id, &button)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     button.clone(),
                     button_info
                         .x_slot
@@ -458,7 +464,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &label_info.id, &label)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     label.clone(),
                     label_info.x_slot.get().with_context(|| "x_slot of label")?,
                     label_info.y_slot.get().with_context(|| "y_slot of label")?,
@@ -470,12 +476,12 @@ impl GuiBuilder {
             }
             UiInfoElement::MultiLineLabel(multi_line_label_info) => {
                 let multi_line_label =
-                    MultiLineLabel::try_from(multi_line_label_info, gui_handler)?;
+                    MultiLineLabel::try_from(multi_line_label_info, world, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_label_info.id, &multi_line_label)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     multi_line_label.clone(),
                     multi_line_label_info
                         .x_slot
@@ -493,12 +499,12 @@ impl GuiBuilder {
             }
             UiInfoElement::MultiLineTextField(multi_line_text_field_info) => {
                 let multi_line_text_field =
-                    MultiLineTextField::try_from(multi_line_text_field_info, gui_handler)?;
+                    MultiLineTextField::try_from(multi_line_text_field_info, world, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_text_field_info.id, &multi_line_text_field)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     multi_line_text_field.clone(),
                     multi_line_text_field_info
                         .x_slot
@@ -520,7 +526,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &text_field_info.id, &text_field)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     text_field.clone(),
                     text_field_info
                         .x_slot
@@ -542,7 +548,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &icon_info.id, UiElement::Icon(Arc::downgrade(&icon)))?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     icon.clone(),
                     icon_info.x_slot.get().with_context(|| "x_slot of icon")?,
                     icon_info.y_slot.get().with_context(|| "y_slot of icon")?,
@@ -558,7 +564,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &progress_bar_info.id, &progress_bar)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     progress_bar.clone(),
                     progress_bar_info
                         .x_slot
@@ -580,7 +586,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &grid_info.id, &sub_grid)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     sub_grid.clone(),
                     grid_info.x_slot.get().with_context(|| "x_slot of grid")?,
                     grid_info.y_slot.get().with_context(|| "y_slot of grid")?,
@@ -593,6 +599,7 @@ impl GuiBuilder {
 
                 for child in grid_info.children.read().unwrap().iter() {
                     Self::create_child(
+                        world,
                         gui_handler,
                         child,
                         &sub_grid,

src/builder/snippet.rs

@@ -18,27 +18,27 @@ pub struct GuiSnippet {
 }
 
 impl GuiSnippet {
-    pub fn new(gui_handler: &mut GuiHandler, path: &AssetPath) -> Result<Arc<Self>> {
+    pub fn new(world: &mut World, path: &AssetPath) -> Result<Arc<Self>> {
         let validator = Validator::new(
             #[cfg(feature = "audio")]
-            gui_handler,
+            world.resources.get::<GuiHandler>(),
             path,
         )?;
 
-        Self::_new(gui_handler, validator)
+        Self::_new(world, validator)
     }
 
-    pub fn from_str(gui_handler: &mut GuiHandler, s: &str) -> Result<Arc<Self>> {
+    pub fn from_str(world: &mut World, s: &str) -> Result<Arc<Self>> {
         let validator = Validator::from_str(
             #[cfg(feature = "audio")]
-            gui_handler,
+            world.resources.get::<GuiHandler>(),
             s,
         )?;
 
-        Self::_new(gui_handler, validator)
+        Self::_new(world, validator)
     }
 
-    fn _new(gui_handler: &mut GuiHandler, validator: Validator) -> Result<Arc<Self>> {
+    fn _new(world: &mut World, validator: Validator) -> Result<Arc<Self>> {
         let root = validator.root();
 
         let mut ids = HashMap::new();
@@ -51,13 +51,22 @@ impl GuiSnippet {
             )));
         }
 
+        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
+
         let grid_info = &root.children[0];
         let grid = Grid::try_from(gui_handler, grid_info, false)?;
 
         GuiBuilder::insert_id(&mut ids, &grid_info.id, &grid)?;
 
         for child in grid_info.children.read().unwrap().iter() {
-            Self::create_child(gui_handler, child, &grid, &mut ids, &mut custom_neighbours)?;
+            Self::create_child(
+                world,
+                gui_handler,
+                child,
+                &grid,
+                &mut ids,
+                &mut custom_neighbours,
+            )?;
         }
 
         GuiBuilder::connect_custom_neighbours(&ids, custom_neighbours)?;
@@ -207,6 +216,7 @@ impl Functionality for GuiSnippet {
 
 impl GuiSnippet {
     fn create_child(
+        world: &mut World,
         gui_handler: &mut GuiHandler,
         child: &UiInfoElement,
         grid: &Grid,
@@ -220,7 +230,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &button_info.id, &button)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     button.clone(),
                     button_info.x_slot.get()?,
                     button_info.y_slot.get()?,
@@ -236,7 +246,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &label_info.id, &label)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     label,
                     label_info.x_slot.get()?,
                     label_info.y_slot.get()?,
@@ -246,12 +256,12 @@ impl GuiSnippet {
             }
             UiInfoElement::MultiLineLabel(multi_line_label_info) => {
                 let multi_line_label =
-                    MultiLineLabel::try_from(multi_line_label_info, gui_handler)?;
+                    MultiLineLabel::try_from(multi_line_label_info, world, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_label_info.id, &multi_line_label)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     multi_line_label,
                     multi_line_label_info.x_slot.get()?,
                     multi_line_label_info.y_slot.get()?,
@@ -261,12 +271,12 @@ impl GuiSnippet {
             }
             UiInfoElement::MultiLineTextField(multi_line_text_field_info) => {
                 let multi_line_text_field =
-                    MultiLineTextField::try_from(multi_line_text_field_info, gui_handler)?;
+                    MultiLineTextField::try_from(multi_line_text_field_info, world, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_text_field_info.id, &multi_line_text_field)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     multi_line_text_field,
                     multi_line_text_field_info.x_slot.get()?,
                     multi_line_text_field_info.y_slot.get()?,
@@ -280,7 +290,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &text_field_info.id, &text_field)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     text_field,
                     text_field_info.x_slot.get()?,
                     text_field_info.y_slot.get()?,
@@ -294,7 +304,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &icon_info.id, UiElement::Icon(Arc::downgrade(&icon)))?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     icon,
                     icon_info.x_slot.get()?,
                     icon_info.y_slot.get()?,
@@ -308,7 +318,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &progress_bar_info.id, &progress_bar)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     progress_bar,
                     progress_bar_info.x_slot.get()?,
                     progress_bar_info.y_slot.get()?,
@@ -322,7 +332,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &grid_info.id, &sub_grid)?;
 
                 grid.attach(
-                    gui_handler,
+                    world,
                     sub_grid.clone(),
                     grid_info.x_slot.get()?,
                     grid_info.y_slot.get()?,
@@ -331,7 +341,7 @@ impl GuiSnippet {
                 )?;
 
                 for child in grid_info.children.read().unwrap().iter() {
-                    Self::create_child(gui_handler, child, &sub_grid, ids, neighbour_infos)?;
+                    Self::create_child(world, gui_handler, child, &sub_grid, ids, neighbour_infos)?;
                 }
             }
         }

src/elements/button.rs

@@ -315,23 +315,23 @@ impl Button {
 
     pub fn set_callback<F>(&self, callback: F)
     where
-        F: Fn(&mut Commands) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut World) -> Result<()> + Send + Sync + 'static,
     {
         self.click_executable
-            .set_callback(move |commands: &mut Commands, _: ()| callback(commands));
+            .set_callback(move |world: &mut World, _: ()| callback(world));
     }
 
     pub fn set_select_callback<F>(&self, callback: F)
     where
-        F: Fn(&mut Commands, bool) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut World, bool) -> Result<()> + Send + Sync + 'static,
     {
         self.on_select_executable
-            .set_callback(move |commands: &mut Commands, select: bool| callback(commands, select));
+            .set_callback(move |world: &mut World, select: bool| callback(world, select));
     }
 
     pub fn set_custom_callback<F>(&self, callback: F)
     where
-        F: Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync + 'static,
+        F: Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync + 'static,
     {
         self.selectable.set_custom_callback(callback);
     }
@@ -448,8 +448,10 @@ impl Visibility for Button {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
+            let gui_handler: &mut GuiHandler = world.resources.get_mut()?;
+
             self.visible.store(visibility, SeqCst);
 
             if visibility {
@@ -579,7 +581,7 @@ impl Button {
     fn create_selected_changed_callback(button: Arc<Button>) {
         let button_weak = Arc::downgrade(&button);
 
-        let selected_changed = move |commands: &mut Commands, selected: bool| {
+        let selected_changed = move |world: &mut World, selected: bool| {
             if let Some(button) = button_weak.upgrade() {
                 let gui_handler = world.resources.get_mut()?;
 

src/elements/grid.rs

@@ -1,5 +1,6 @@
 use crate::prelude::*;
 use anyhow::Result;
+use ecs::*;
 
 use crate::builder::validator::gridinfo::GridInfo;
 
@@ -199,7 +200,7 @@ impl Grid {
 
     pub fn detach(
         &self,
-        gui_handler: &mut GuiHandler,
+        world: &mut World,
         pos_x: usize,
         pos_y: usize,
     ) -> Result<Option<Arc<dyn GuiElementTraits>>> {
@@ -231,7 +232,7 @@ impl Grid {
             Some((child, _x, _y)) => {
                 if self.visible() {
                     if let Some(child_visibility) = child.visibility() {
-                        child_visibility.set_visibility(gui_handler, false)?;
+                        child_visibility.set_visibility(world, false)?;
                     }
                 }
 
@@ -242,11 +243,7 @@ impl Grid {
     }
 
     /// Returns `true` if item got detached
-    pub fn detach_item(
+    pub fn detach_item(&self, world: &mut World, item: Arc<dyn GuiElementTraits>) -> Result<bool> {
-        &self,
-        gui_handler: &mut GuiHandler,
-        item: Arc<dyn GuiElementTraits>,
-    ) -> Result<bool> {
         let mut grid = self.children.write().unwrap();
         let mut removed = false;
 
@@ -265,7 +262,7 @@ impl Grid {
 
                         if self.visible() {
                             if let Some(child_visibility) = child.visibility() {
-                                child_visibility.set_visibility(gui_handler, false)?;
+                                child_visibility.set_visibility(world, false)?;
                             }
                         }
                     }
@@ -408,7 +405,7 @@ impl Grid {
 
     pub fn attach(
         &self,
-        gui_handler: &mut GuiHandler,
+        world: &mut World,
         child: Arc<dyn GuiElementTraits>,
         pos_x: usize,
         pos_y: usize,
@@ -447,7 +444,14 @@ impl Grid {
             }
 
             if self.framable.is_framed() {
-                self.child_position(gui_handler, child_gridable, pos_x, pos_y, dim_x, dim_y)?;
+                self.child_position(
+                    world.resources.get_mut()?,
+                    child_gridable,
+                    pos_x,
+                    pos_y,
+                    dim_x,
+                    dim_y,
+                )?;
             }
 
             child_gridable.set_layer(self.framable.ui_layer())?;
@@ -458,7 +462,7 @@ impl Grid {
             ChildState::Some { child, .. } => {
                 if self.visible() {
                     if let Some(child_visibility) = child.visibility() {
-                        child_visibility.set_visibility(gui_handler, false)?;
+                        child_visibility.set_visibility(world, false)?;
                     }
                 }
             }
@@ -468,7 +472,7 @@ impl Grid {
 
         if self.visible() {
             if let Some(child_visibility) = child.visibility() {
-                child_visibility.set_visibility(gui_handler, true)?;
+                child_visibility.set_visibility(world, true)?;
             }
         }
 
@@ -622,26 +626,26 @@ impl Grid {
         }
     }
 
-    fn disable_tree(&self, gui_handler: &mut GuiHandler) -> Result<()> {
+    fn disable_tree(&self, world: &mut World, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
 
         if let Some(background) = self.background.read().unwrap().as_ref() {
             background.disable(gui_handler)?;
         }
 
-        self.set_tree_visibility(gui_handler, false)?;
+        self.set_tree_visibility(world, false)?;
 
         Ok(())
     }
 
-    fn set_tree_visibility(&self, gui_handler: &mut GuiHandler, visible: bool) -> Result<()> {
+    fn set_tree_visibility(&self, world: &mut World, visible: bool) -> Result<()> {
         let tree = self.children.read().unwrap();
 
         for row in tree.deref() {
             for child_state in row {
                 if let Some((child, ..)) = child_state.get_some() {
                     if let Some(visibility) = child.visibility() {
-                        visibility.set_visibility(gui_handler, visible)?;
+                        visibility.set_visibility(world, visible)?;
                     }
                 }
             }
@@ -793,8 +797,10 @@ impl Visibility for Grid {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
+            let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
+
             self.visible.store(visibility, SeqCst);
 
             if visibility {
@@ -804,9 +810,9 @@ impl Visibility for Grid {
                     background.enable(gui_handler)?;
                 }
 
-                self.set_tree_visibility(gui_handler, true)?;
+                self.set_tree_visibility(world, true)?;
             } else {
-                self.disable_tree(gui_handler)?;
+                self.disable_tree(world, gui_handler)?;
             }
         }
 

src/elements/multi_line_label.rs

@@ -57,7 +57,11 @@ impl MultiLineLabelBuilder {
         self
     }
 
-    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<MultiLineLabel>> {
+    pub fn build(
+        self,
+        world: &mut World,
+        gui_handler: &mut GuiHandler,
+    ) -> Result<Arc<MultiLineLabel>> {
         let base_grid = Grid::new(gui_handler, 1, self.line_count as usize, false)?;
         base_grid.set_margin(0);
         base_grid.set_padding(0);
@@ -73,7 +77,7 @@ impl MultiLineLabelBuilder {
                 .set_text_alignment(self.text_alignment)
                 .build(gui_handler)?;
 
-            base_grid.attach(gui_handler, label, 0, i as usize, 1, 1)?;
+            base_grid.attach(world, label, 0, i as usize, 1, 1)?;
         }
 
         Ok(Arc::new(MultiLineLabel {
@@ -185,6 +189,7 @@ impl MultiLineLabel {
 
     pub fn try_from(
         multi_line_label_info: &MultiLineLabelInfo,
+        world: &mut World,
         gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let text = multi_line_label_info.text.read().unwrap().clone();
@@ -213,7 +218,7 @@ impl MultiLineLabel {
             multi_line_label_builder = multi_line_label_builder.set_text(text);
         }
 
-        multi_line_label_builder.build(gui_handler)
+        multi_line_label_builder.build(world, gui_handler)
     }
 
     fn iter_label<F>(&self, mut f: F) -> Result<()>

src/elements/multi_line_textfield.rs

@@ -63,7 +63,11 @@ impl MultiLineTextFieldBuilder {
         self
     }
 
-    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<MultiLineTextField>> {
+    pub fn build(
+        self,
+        world: &mut World,
+        gui_handler: &mut GuiHandler,
+    ) -> Result<Arc<MultiLineTextField>> {
         let base_grid = Grid::new(gui_handler, 1, self.line_count as usize, false)?;
         base_grid.set_margin(0);
         base_grid.set_padding(0);
@@ -79,7 +83,7 @@ impl MultiLineTextFieldBuilder {
                 .set_text_alignment(self.text_alignment)
                 .build(gui_handler)?;
 
-            base_grid.attach(gui_handler, label, 0, i as usize, 1, 1)?;
+            base_grid.attach(world, label, 0, i as usize, 1, 1)?;
         }
 
         let text = Arc::new(SplittedText::new(self.text));
@@ -97,7 +101,7 @@ impl MultiLineTextFieldBuilder {
         multi_line_text_field.text_changed_exec.set_callback({
             let weak_tf = Arc::downgrade(&multi_line_text_field);
 
-            move |commands: &mut Commands, _text| {
+            move |world: &mut World, _text| {
                 if let Some(tf) = weak_tf.upgrade() {
                     tf.update_text(world.resources.get_mut()?)?;
                 }
@@ -305,6 +309,7 @@ impl MultiLineTextField {
 
     pub fn try_from(
         multi_line_text_field_info: &MultiLineTextFieldInfo,
+        world: &mut World,
         gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let text = multi_line_text_field_info.text.read().unwrap().clone();
@@ -333,7 +338,7 @@ impl MultiLineTextField {
             multi_line_text_field_builder = multi_line_text_field_builder.set_text(text);
         }
 
-        multi_line_text_field_builder.build(gui_handler)
+        multi_line_text_field_builder.build(world, gui_handler)
     }
 
     fn iter_label<F>(&self, mut f: F) -> Result<()>

src/elements/textfield.rs

@@ -170,7 +170,7 @@ impl TextField {
 
     pub fn set_text_changed_callback<F>(&self, f: F)
     where
-        F: Fn(&mut Commands, Option<String>) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut World, Option<String>) -> Result<()> + Send + Sync + 'static,
     {
         self.text_changed_executable.set_callback(f);
     }

src/elements/traits.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 use anyhow::Result;
-use ecs::*;
+use ecs::World;
 
 use std::{any::Any, collections::HashMap, sync::Arc};
 
@@ -10,8 +10,8 @@ pub trait TopLevelGui: Send + Sync {
     fn top_gui(&self) -> Option<&dyn TopGui>;
     fn elements(&self) -> Option<&HashMap<String, UiElement>>;
     fn functionality(&self) -> Option<&dyn Functionality>;
-    fn enable(&self, commands: &mut Commands) -> Result<()>;
+    fn enable(&self, world: &mut World) -> Result<()>;
-    fn disable(&self, commands: &mut Commands) -> Result<()>;
+    fn disable(&self, world: &mut World) -> Result<()>;
 }
 
 pub fn any_to<T>(any: &dyn Any) -> Result<&T>
@@ -27,14 +27,14 @@ where
 pub trait Functionality {
     fn set_click_callbacks(
         &self,
-        callbacks: Vec<(&str, Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>)>,
+        callbacks: Vec<(&str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>,
     ) -> Result<()>;
 
     fn set_select_callbacks(
         &self,
         callbacks: Vec<(
             &str,
-            Box<dyn Fn(&mut Commands, bool) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut World, bool) -> Result<()> + Send + Sync>,
         )>,
     ) -> Result<()>;
 
@@ -42,7 +42,7 @@ pub trait Functionality {
         &self,
         callbacks: Vec<(
             &str,
-            Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>,
+            Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>,
         )>,
     ) -> Result<()>;
 
@@ -50,7 +50,7 @@ pub trait Functionality {
         &self,
         callbacks: Vec<(
             &str,
-            Box<dyn Fn(&mut Commands, &dyn Any) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>,
         )>,
     ) -> Result<()>;
 }
@@ -84,7 +84,7 @@ pub trait Gridable {
 
 pub trait Visibility {
     fn visible(&self) -> bool;
-    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()>;
+    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()>;
 }
 
 pub enum GuiElement<'a> {

src/gui_handler/gui/executable.rs

@@ -1,7 +1,7 @@
 //! `Executable` is a property to execute a closure
 
 use anyhow::Result;
-use ecs::*;
+use ecs::World;
 
 use std::sync::{Arc, RwLock};
 
@@ -9,7 +9,7 @@ use crate::prelude::*;
 
 /// `Executable` holds a closure which can be executed
 pub struct Executable<I: Send + Sync> {
-    callback: RwLock<Option<Arc<dyn Fn(&mut Commands, I) -> Result<()> + Send + Sync>>>,
+    callback: RwLock<Option<Arc<dyn Fn(&mut World, I) -> Result<()> + Send + Sync>>>,
 }
 
 impl<I: Send + Sync + 'static> Executable<I> {
@@ -27,7 +27,7 @@ impl<I: Send + Sync + 'static> Executable<I> {
     /// * `callback` is a `Option<Callback>` closure
     pub fn set_callback<F>(&self, callback: impl Into<Option<F>>)
     where
-        F: Fn(&mut Commands, I) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut World, I) -> Result<()> + Send + Sync + 'static,
     {
         let mut function = self.callback.write().unwrap();
 
@@ -42,7 +42,7 @@ impl<I: Send + Sync + 'static> Executable<I> {
         if let Some(callback) = self.callback.read().unwrap().as_ref() {
             let callback = callback.clone();
 
-            gui_handler.add_callback(move |commands| (callback)(commands, input));
+            gui_handler.add_callback(move |gui_handler| (callback)(gui_handler, input));
         }
 
         Ok(())

src/gui_handler/gui/selectable.rs

@@ -3,7 +3,7 @@
 use super::executable::Executable;
 use crate::prelude::*;
 use anyhow::Result;
-use ecs::*;
+use ecs::World;
 
 use std::sync::{
     Arc, RwLock, Weak,
@@ -41,7 +41,7 @@ pub struct Selectable {
 
     // used for custom buttons
     custom_callback:
-        RwLock<Option<Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>>>,
+        RwLock<Option<Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>>>,
 }
 
 impl Selectable {
@@ -117,7 +117,7 @@ impl Selectable {
 
     pub fn set_custom_callback<F>(&self, custom_callback: F)
     where
-        F: Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync + 'static,
+        F: Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync + 'static,
     {
         *self.custom_callback.write().unwrap() = Some(Box::new(custom_callback));
     }
@@ -180,11 +180,11 @@ impl Selectable {
 
     pub(crate) fn custom_click_event(
         &self,
-        commands: &mut Commands,
+        world: &mut World,
         button: ControllerButton,
     ) -> Result<bool> {
         if let Some(custom_callback) = self.custom_callback.read().unwrap().as_ref() {
-            if custom_callback(commands, button)? {
+            if custom_callback(world, button)? {
                 #[cfg(feature = "audio")]
                 {
                     if let Some(audible) = self.click_audible.read().unwrap().as_ref() {

src/gui_handler/gui/topgui.rs

@@ -1,20 +1,20 @@
 /// A trait that is used by the gui handler as the target for input
 use anyhow::Result;
-use ecs::Commands;
+use ecs::World;
 
 pub trait TopGui: Send + Sync {
     /// Decline method which is executed on `InputMap::B` press
-    fn decline(&self, commands: &mut Commands) -> Result<()>;
+    fn decline(&self, world: &mut World) -> Result<()>;
 
     /// Method which is executed on `InputMap::RightButton` press
     ///
     /// # Arguments
     /// * `second_level` adds support for multiple tab layers, e.g. RB and RT press on controller
-    fn next_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()>;
+    fn next_tab(&self, world: &mut World, second_level: bool) -> Result<()>;
 
     /// Method which is executed on `InputMap::LeftButton` press
     /// ///
     /// # Arguments
     /// * `second_level` adds support for multiple tab layers, e.g. RB and RT press on controller
-    fn previous_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()>;
+    fn previous_tab(&self, world: &mut World, second_level: bool) -> Result<()>;
 }

src/gui_handler/gui_handler.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use anyhow::{Result, anyhow};
 use assetpath::AssetPath;
 
-use ecs::*;
+use ecs::{Resource, World};
 use serde::{Deserialize, Serialize};
 use utilities::{impl_reprc, prelude::*};
 use vulkan_rs::{prelude::*, render_target::sub_pass::InputAttachmentInfo};
@@ -245,7 +245,7 @@ pub struct GuiHandler {
 
     text_sample_count: VkSampleCountFlags,
 
-    callback_list: Vec<Box<dyn FnOnce(&mut Commands) -> Result<()> + Send + Sync>>,
+    callback_list: Vec<Box<dyn FnOnce(&mut World) -> Result<()> + Send + Sync>>,
 }
 
 impl GuiHandler {
@@ -866,17 +866,17 @@ impl GuiHandler {
 
     pub fn set_top_gui(
         &mut self,
-        commands: &mut Commands,
+        world: &mut World,
         top_gui: Option<Arc<dyn TopLevelGui>>,
     ) -> Result<()> {
         match (&self.top_ui, &top_gui) {
             (Some(current), Some(incoming)) => {
                 if !Arc::ptr_eq(current, incoming) {
-                    current.disable(commands)?;
+                    current.disable(world)?;
                 }
             }
             (Some(current), None) => {
-                current.disable(commands)?;
+                current.disable(world)?;
             }
 
             _ => (),
@@ -889,17 +889,17 @@ impl GuiHandler {
 
     pub fn set_tooltip(
         &mut self,
-        commands: &mut Commands,
+        world: &mut World,
         tooltip: Option<Arc<dyn TopLevelGui>>,
     ) -> Result<()> {
         match (&self.tooltip_ui, &tooltip) {
             (Some(current), Some(incoming)) => {
                 if !Arc::ptr_eq(current, incoming) {
-                    current.disable(commands)?;
+                    current.disable(world)?;
                 }
             }
             (Some(current), None) => {
-                current.disable(commands)?;
+                current.disable(world)?;
             }
 
             _ => (),
@@ -910,19 +910,19 @@ impl GuiHandler {
         Ok(())
     }
 
-    pub(crate) fn add_callback<F: FnOnce(&mut Commands) -> Result<()> + Send + Sync + 'static>(
+    pub(crate) fn add_callback<F: FnOnce(&mut World) -> Result<()> + Send + Sync + 'static>(
         &mut self,
         f: F,
     ) {
         self.callback_list.push(Box::new(f));
     }
 
-    pub fn process_callbacks(&mut self, commands: &mut Commands) -> Result<()> {
+    pub fn process_callbacks(&mut self, world: &mut World) -> Result<()> {
         let callbacks = mem::take(&mut self.callback_list);
 
         callbacks
             .into_iter()
-            .try_for_each(|callback| callback(commands))
+            .try_for_each(|callback| callback(world))
     }
 
     fn render(

src/state.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 use anyhow::{Result, anyhow};
-use ecs::*;
+use ecs::World;
 
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock, Weak};
@@ -100,23 +100,22 @@ pub(crate) struct State {
 
     pub(crate) top_level_gui: Arc<dyn TopLevelGui>,
 
-    pub(crate) on_activate: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
+    pub(crate) on_activate: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
-    pub(crate) on_deactivate:
+    pub(crate) on_deactivate: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
-        RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
 
-    pub(crate) next_tab: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
+    pub(crate) next_tab: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
-    pub(crate) previous_tab: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
+    pub(crate) previous_tab: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
-    pub(crate) decline: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
+    pub(crate) decline: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
 }
 
 impl State {
     pub(crate) fn new<'a>(
-        gui_handler: &mut GuiHandler,
+        world: &mut World,
         name: &str,
         creation_type: CreationType<'a>,
     ) -> Result<Arc<Self>> {
         let gui = match creation_type {
-            CreationType::File(path) => GuiBuilder::new(gui_handler, path)?,
+            CreationType::File(path) => GuiBuilder::new(world, path)?,
             CreationType::TopGui(top_gui) => top_gui,
         };
 
@@ -180,49 +179,49 @@ impl State {
 
     pub(crate) fn set_on_activate(
         &self,
-        on_activate: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
+        on_activate: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
     ) {
         *self.on_activate.write().unwrap() = on_activate;
     }
 
     pub(crate) fn set_on_deactivate(
         &self,
-        on_deactivate: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
+        on_deactivate: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
     ) {
         *self.on_deactivate.write().unwrap() = on_deactivate;
     }
 
     pub(crate) fn set_previous_tab(
         &self,
-        previous_tab: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
+        previous_tab: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
     ) {
         *self.previous_tab.write().unwrap() = previous_tab;
     }
 
     pub(crate) fn set_next_tab(
         &self,
-        next_tab: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
+        next_tab: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
     ) {
         *self.next_tab.write().unwrap() = next_tab;
     }
 
     pub(crate) fn set_decline(
         &self,
-        decline: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
+        decline: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
     ) {
         *self.decline.write().unwrap() = decline;
     }
 }
 
 impl TopGui for State {
-    fn decline(&self, commands: &mut Commands) -> Result<()> {
+    fn decline(&self, world: &mut World) -> Result<()> {
         match self.decline.read().unwrap().as_ref() {
             Some(decline) => {
-                (decline)(commands)?;
+                (decline)(world)?;
             }
             None => {
                 if let Some(top_gui) = self.top_level_gui.top_gui() {
-                    top_gui.decline(commands)?;
+                    top_gui.decline(world)?;
                 }
             }
         }
@@ -230,14 +229,14 @@ impl TopGui for State {
         Ok(())
     }
 
-    fn next_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()> {
+    fn next_tab(&self, world: &mut World, second_level: bool) -> Result<()> {
         match self.next_tab.read().unwrap().as_ref() {
             Some(next_tab) => {
-                (next_tab)(commands)?;
+                (next_tab)(world)?;
             }
             None => {
                 if let Some(top_gui) = self.top_level_gui.top_gui() {
-                    top_gui.next_tab(commands, second_level)?;
+                    top_gui.next_tab(world, second_level)?;
                 }
             }
         }
@@ -245,14 +244,14 @@ impl TopGui for State {
         Ok(())
     }
 
-    fn previous_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()> {
+    fn previous_tab(&self, world: &mut World, second_level: bool) -> Result<()> {
         match self.previous_tab.read().unwrap().as_ref() {
             Some(previous_tab) => {
-                (previous_tab)(commands)?;
+                (previous_tab)(world)?;
             }
             None => {
                 if let Some(top_gui) = self.top_level_gui.top_gui() {
-                    top_gui.previous_tab(commands, second_level)?;
+                    top_gui.previous_tab(world, second_level)?;
                 }
             }
         }
@@ -278,21 +277,21 @@ impl TopLevelGui for State {
         self.top_level_gui.functionality()
     }
 
-    fn enable(&self, commands: &mut Commands) -> Result<()> {
+    fn enable(&self, world: &mut World) -> Result<()> {
-        self.top_level_gui.enable(commands)?;
+        self.top_level_gui.enable(world)?;
 
         if let Some(activate) = self.on_activate.read().unwrap().as_ref() {
-            (activate)(commands)?;
+            (activate)(world)?;
         }
 
         Ok(())
     }
 
-    fn disable(&self, commands: &mut Commands) -> Result<()> {
+    fn disable(&self, world: &mut World) -> Result<()> {
-        self.top_level_gui.disable(commands)?;
+        self.top_level_gui.disable(world)?;
 
         if let Some(deactivate) = self.on_deactivate.read().unwrap().as_ref() {
-            (deactivate)(commands)?;
+            (deactivate)(world)?;
         }
 
         Ok(())

src/states.rs

@@ -7,14 +7,12 @@ use std::collections::HashMap;
 
 use std::sync::{Arc, Mutex};
 
-pub trait FutureStateChange:
+pub trait FutureStateChange: Fn(&mut World) -> Result<()> + Send + Sync {
-    Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Send + Sync
-{
     fn clone_box<'a>(&self) -> Box<dyn 'a + FutureStateChange>
     where
         Self: 'a;
 
-    fn as_fn(&self) -> &(dyn Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Send + Sync)
+    fn as_fn(&self) -> &(dyn Fn(&mut World) -> Result<()> + Send + Sync)
     where
         Self: Sized,
     {
@@ -23,7 +21,7 @@ pub trait FutureStateChange:
 
     fn as_static(
         &'static self,
-    ) -> &'static (dyn Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Send + Sync + 'static)
+    ) -> &'static (dyn Fn(&mut World) -> Result<()> + Send + Sync + 'static)
     where
         Self: Sized,
     {
@@ -31,9 +29,7 @@ pub trait FutureStateChange:
     }
 }
 
-impl<F: Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Clone + Send + Sync> FutureStateChange
+impl<F: Fn(&mut World) -> Result<()> + Clone + Send + Sync> FutureStateChange for F {
-    for F
-{
     fn clone_box<'a>(&self) -> Box<dyn 'a + FutureStateChange>
     where
         Self: 'a,
@@ -51,27 +47,22 @@ impl<'a> Clone for Box<dyn 'a + FutureStateChange> {
 /// Update type
 pub enum StateUpdateType<'a> {
     /// Updates the callback which is executed on next tab event
-    NextTab(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
+    NextTab(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
 
     /// Updates the callback which is executed on previous tab event
-    PreviousTab(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
+    PreviousTab(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
 
     /// Updates the callback which is executed on decline event
-    Decline(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
+    Decline(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
 
     /// Updates callbacks by identifier
-    ClickCallbacks(
+    ClickCallbacks(Vec<(&'a str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>),
-        Vec<(
-            &'a str,
-            Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>,
-        )>,
-    ),
 
     /// Updates callbacks by identifier
     SelectCallbacks(
         Vec<(
             &'a str,
-            Box<dyn Fn(&mut Commands, bool) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut World, bool) -> Result<()> + Send + Sync>,
         )>,
     ),
 
@@ -79,7 +70,7 @@ pub enum StateUpdateType<'a> {
     CustomClickCallbacks(
         Vec<(
             &'a str,
-            Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>,
+            Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>,
         )>,
     ),
 
@@ -87,15 +78,15 @@ pub enum StateUpdateType<'a> {
     VecCallbacks(
         Vec<(
             &'a str,
-            Box<dyn Fn(&mut Commands, &dyn Any) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>,
         )>,
     ),
 
     /// Updates the callback which is executed when this state gets activated on state change
-    OnActivate(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
+    OnActivate(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
 
     /// Updates the callback which is executed when this state gets deactivated on state change
-    OnDeactivate(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
+    OnDeactivate(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
 }
 
 /// Type of the state to be created
@@ -166,14 +157,12 @@ impl States {
     /// Adds a single state
     pub fn add_state<'a>(
         &mut self,
-        gui_handler: &mut GuiHandler,
+        world: &mut World,
         id: &str,
         creation_type: impl Into<CreationType<'a>>,
     ) -> Result<()> {
-        self.states.insert(
+        self.states
-            id.to_string(),
+            .insert(id.to_string(), State::new(world, id, creation_type.into())?);
-            State::new(gui_handler, id, creation_type.into())?,
-        );
 
         Ok(())
     }
@@ -191,16 +180,13 @@ impl States {
     /// # Arguments
     ///
     /// * `id` - Set state with the given identifier or None
-    pub fn set_state<'b>(
+    pub fn set_state<'b>(&self, world: &mut World, id: impl Into<Option<&'b str>>) -> Result<()> {
-        &self,
+        let gui_handler: &mut GuiHandler = world.resources.get_mut_unchecked();
-        commands: &mut Commands,
+
-        gui_handler: &mut GuiHandler,
-        id: impl Into<Option<&'b str>>,
-    ) -> Result<()> {
         Self::_set_state(
             id.into().map(|id| self.get_state(id)).transpose()?,
             &mut *self.current_state.lock().unwrap(),
-            commands,
+            world,
             gui_handler,
             self.log_state_change,
         )
@@ -209,7 +195,7 @@ impl States {
     fn _set_state(
         state: Option<Arc<State>>,
         current: &mut Option<Arc<State>>,
-        commands: &mut Commands,
+        world: &mut World,
         gui_handler: &mut GuiHandler,
         logging: bool,
     ) -> Result<()> {
@@ -222,14 +208,14 @@ impl States {
             }
 
             // execute deactivate on old state
-            old_state.disable(commands)?;
+            old_state.disable(world)?;
         }
 
         // set new state, either no state or requested state
         match state {
             Some(state) => {
-                state.enable(commands)?;
+                state.enable(world)?;
-                gui_handler.set_top_gui(commands, Some(state.clone()))?;
+                gui_handler.set_top_gui(world, Some(state.clone()))?;
 
                 if logging {
                     println!("Change UI State to {}", state.name);
@@ -238,7 +224,7 @@ impl States {
                 *current = Some(state);
             }
             None => {
-                gui_handler.set_top_gui(commands, None)?;
+                gui_handler.set_top_gui(world, None)?;
 
                 if logging {
                     println!("Change UI State to None");
@@ -272,20 +258,20 @@ impl States {
         let weak_current_state = Arc::downgrade(&self.current_state);
         let logging = self.log_state_change;
 
-        Ok(Box::new(
+        Ok(Box::new(move |world: &mut World| {
-            move |commands: &mut Commands, gui_handler: &mut GuiHandler| {
+            if let Some(current) = weak_current_state.upgrade() {
-                if let Some(current) = weak_current_state.upgrade() {
+                let gui_handler: &mut GuiHandler = world.resources.get_mut_unchecked();
-                    Self::_set_state(
-                        weak_state.as_ref().map(|w| w.upgrade()).flatten(),
-                        &mut *current.lock().unwrap(),
-                        commands,
-                        gui_handler,
-                        logging,
-                    )?;
-                }
 
-                Ok(())
+                Self::_set_state(
-            },
+                    weak_state.as_ref().map(|w| w.upgrade()).flatten(),
-        ))
+                    &mut *current.lock().unwrap(),
+                    world,
+                    gui_handler,
+                    logging,
+                )?;
+            }
+
+            Ok(())
+        }))
     }
 }