1 files changed, 51 insertions, 30 deletions

diff --git a/ecs/src/actions.rs b/ecs/src/actions.rs
index f7b00d3..3dd8755 100644
--- a/ecs/src/actions.rs
+++ b/ecs/src/actions.rs
@@ -1,12 +1,8 @@
 use std::marker::PhantomData;
-use std::sync::{Arc, Weak};
-
-use crate::component::{
-    Component,
-    Metadata as ComponentMetadata,
-    Sequence as ComponentSequence,
-};
-use crate::system::{NoInitParamFlag, Param as SystemParam, System};
+use std::rc::{Rc, Weak};
+
+use crate::component::{Parts as ComponentParts, Sequence as ComponentSequence};
+use crate::system::{Param as SystemParam, System};
 use crate::uid::{Kind as UidKind, Uid};
 use crate::{ActionQueue, World};
 
@@ -20,36 +16,61 @@ pub struct Actions<'world>
 
 impl<'world> Actions<'world>
 {
-    /// Adds a spawning a new entity to the action queue.
+    /// Queues up a entity to spawn at the end of the current tick.
     pub fn spawn<Comps: ComponentSequence>(&mut self, components: Comps)
     {
-        self.action_queue.push(Action::Spawn(components.into_vec()));
+        self.action_queue
+            .push(Action::Spawn(components.into_parts_array().into()));
     }
 
-    /// Adds component(s) to a entity.
+    /// Queues up despawning a entity at the end of the **next** tick.
+    pub fn despawn(&mut self, entity_uid: Uid)
+    {
+        debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
+
+        self.action_queue.push(Action::Despawn(entity_uid));
+    }
+
+    /// Queues up adding component(s) to a entity at the end of the current tick.
     pub fn add_components<Comps>(&mut self, entity_uid: Uid, components: Comps)
     where
         Comps: ComponentSequence,
     {
         debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
 
-        self.action_queue
-            .push(Action::AddComponents(entity_uid, components.into_vec()));
+        if Comps::COUNT == 0 {
+            return;
+        }
+
+        self.action_queue.push(Action::AddComponents(
+            entity_uid,
+            components.into_parts_array().into(),
+        ));
     }
 
-    /// Removes component(s) from a entity.
-    pub fn remove_components<Comps>(&mut self, entity_uid: Uid)
-    where
-        Comps: ComponentSequence,
+    /// Queues up removing component(s) from a entity at the end of the **next** tick.
+    pub fn remove_components(
+        &mut self,
+        entity_uid: Uid,
+        component_ids: impl IntoIterator<Item = Uid>,
+    )
     {
         debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
 
-        self.action_queue
-            .push(Action::RemoveComponents(entity_uid, Comps::metadata()));
+        let mut component_ids = component_ids.into_iter().peekable();
+
+        if component_ids.peek().is_none() {
+            return;
+        }
+
+        self.action_queue.push(Action::RemoveComponents(
+            entity_uid,
+            component_ids.collect(),
+        ));
     }
 
-    /// Adds stopping the loop in [`Engine::event_loop`] at the next opportune time to the
-    /// action queue.
+    /// Stops the [`World`]. The world will finish the current tick and that tick will be
+    /// the last.
     pub fn stop(&mut self)
     {
         self.action_queue.push(Action::Stop);
@@ -66,18 +87,17 @@ impl<'world> Actions<'world>
         }
     }
 
-    fn new(action_queue: &'world Arc<ActionQueue>) -> Self
+    fn new(action_queue: &'world Rc<ActionQueue>) -> Self
     {
         Self {
             action_queue,
-            action_queue_weak: Arc::downgrade(action_queue),
+            action_queue_weak: Rc::downgrade(action_queue),
         }
     }
 }
 
-unsafe impl<'world> SystemParam<'world> for Actions<'world>
+impl<'world> SystemParam<'world> for Actions<'world>
 {
-    type Flags = NoInitParamFlag;
     type Input = ();
 
     fn initialize<SystemImpl>(
@@ -122,11 +142,11 @@ impl WeakRef
 #[derive(Debug, Clone)]
 pub struct Ref<'weak_ref>
 {
-    action_queue: Arc<ActionQueue>,
+    action_queue: Rc<ActionQueue>,
     _pd: PhantomData<&'weak_ref ()>,
 }
 
-impl<'weak_ref> Ref<'weak_ref>
+impl Ref<'_>
 {
     #[must_use]
     pub fn to_actions(&self) -> Actions<'_>
@@ -139,8 +159,9 @@ impl<'weak_ref> Ref<'weak_ref>
 #[derive(Debug)]
 pub(crate) enum Action
 {
-    Spawn(Vec<Box<dyn Component>>),
-    AddComponents(Uid, Vec<Box<dyn Component>>),
-    RemoveComponents(Uid, Vec<ComponentMetadata>),
+    Spawn(Vec<ComponentParts>),
+    Despawn(Uid),
+    AddComponents(Uid, Vec<ComponentParts>),
+    RemoveComponents(Uid, Vec<Uid>),
     Stop,
 }