feat(ecs): make components internally mutable

1 files changed, 46 insertions, 114 deletions

diff --git a/ecs/src/lib.rs b/ecs/src/lib.rs
index 6b9373c..d781b3e 100644
--- a/ecs/src/lib.rs
+++ b/ecs/src/lib.rs
@@ -1,10 +1,11 @@
 #![deny(clippy::all, clippy::pedantic)]
 
 use std::any::{Any, TypeId};
+use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Debug;
 use std::marker::PhantomData;
-use std::slice::{Iter as SliceIter, IterMut as SliceIterMut};
+use std::slice::Iter as SliceIter;
 
 use crate::actions::Action;
 use crate::component::{Component, Sequence as ComponentSequence};
@@ -28,7 +29,7 @@ pub use ecs_macros::Component;
 #[derive(Debug, Default)]
 struct Entity
 {
-    components: Vec<Box<dyn Component>>,
+    components: Vec<RefCell<Box<dyn Component>>>,
 }
 
 #[derive(Debug, Default)]
@@ -50,18 +51,20 @@ impl World
     where
         Comps: ComponentSequence,
     {
-        self.data
-            .component_storage
-            .entities
-            .push(Entity { components: components.into_vec() });
+        self.data.component_storage.entities.push(Entity {
+            components: components
+                .into_vec()
+                .into_iter()
+                .map(RefCell::new)
+                .collect(),
+        });
     }
 
-    pub fn register_system<TSystem, SystemImpl>(
-        &mut self,
+    pub fn register_system<'this, SystemImpl>(
+        &'this mut self,
         event: &impl Event,
-        system: TSystem,
-    ) where
-        TSystem: System<SystemImpl>,
+        system: impl System<'this, SystemImpl>,
+    )
     {
         self.systems.push(system.into_type_erased());
 
@@ -77,36 +80,38 @@ impl World
     ///
     /// # Panics
     /// Will panic if a system has dissapeared.
-    pub fn emit(&mut self, event: &impl Event)
+    pub fn emit(&self, event: &impl Event)
     {
         let Some(system_indices) = self.data.events.get(&event.id()).cloned() else {
             return;
         };
 
         for system_index in system_indices {
-            let system = self.systems.get_mut(system_index).unwrap();
+            let system = self.systems.get(system_index).unwrap();
 
-            system.run(&mut self.data);
+            // SAFETY: The world data lives long enough
+            unsafe {
+                system.run(&self.data);
+            }
         }
     }
 
-    pub fn query<Comps>(&mut self) -> Query<Comps>
+    pub fn query<Comps>(&self) -> Query<Comps>
     where
         Comps: ComponentSequence,
     {
-        Query::new(&mut self.data)
+        Query::new(&self.data)
     }
 
     /// Peforms the actions that have been queued up using [`Actions`].
     pub fn perform_queued_actions(&mut self)
     {
-        for action in self.data.action_queue.drain(..) {
+        for action in self.data.action_queue.borrow_mut().drain(..) {
             match action {
                 Action::Spawn(components) => {
-                    self.data
-                        .component_storage
-                        .entities
-                        .push(Entity { components });
+                    self.data.component_storage.entities.push(Entity {
+                        components: components.into_iter().map(RefCell::new).collect(),
+                    });
                 }
             }
         }
@@ -118,7 +123,7 @@ pub struct WorldData
 {
     events: HashMap<EventId, Vec<usize>>,
     component_storage: ComponentStorage,
-    action_queue: Vec<Action>,
+    action_queue: RefCell<Vec<Action>>,
 }
 
 #[derive(Debug)]
@@ -126,7 +131,7 @@ pub struct Query<'world, Comps>
 where
     Comps: ComponentSequence,
 {
-    world_data: &'world mut WorldData,
+    world_data: &'world WorldData,
     comps_pd: PhantomData<Comps>,
 }
 
@@ -134,17 +139,7 @@ impl<'world, Comps> Query<'world, Comps>
 where
     Comps: ComponentSequence,
 {
-    fn new(world_data: &'world mut WorldData) -> Self
-    {
-        Self { world_data, comps_pd: PhantomData }
-    }
-}
-
-impl<'world, Comps> Query<'world, Comps>
-where
-    Comps: ComponentSequence,
-{
-    pub fn iter(&self) -> QueryComponentIter<Comps>
+    pub fn iter(&self) -> QueryComponentIter<'world, Comps>
     {
         QueryComponentIter {
             entity_iter: self.world_data.component_storage.entities.iter(),
@@ -153,13 +148,9 @@ where
         }
     }
 
-    pub fn iter_mut(&mut self) -> QueryComponentMutIter<Comps>
+    fn new(world_data: &'world WorldData) -> Self
     {
-        QueryComponentMutIter {
-            entity_iter: self.world_data.component_storage.entities.iter_mut(),
-            component_type_ids: Comps::type_ids(),
-            comps_pd: PhantomData,
-        }
+        Self { world_data, comps_pd: PhantomData }
     }
 }
 
@@ -176,19 +167,6 @@ where
     }
 }
 
-impl<'world, Comps> IntoIterator for &'world mut Query<'world, Comps>
-where
-    Comps: ComponentSequence,
-{
-    type IntoIter = QueryComponentMutIter<'world, Comps>;
-    type Item = Comps::MutRefs<'world>;
-
-    fn into_iter(self) -> Self::IntoIter
-    {
-        self.iter_mut()
-    }
-}
-
 unsafe impl<'world, Comps> SystemParam<'world> for Query<'world, Comps>
 where
     Comps: ComponentSequence,
@@ -196,13 +174,16 @@ where
     type Flags = NoInitSystemParamFlag;
     type Input = TupleFilterExclude;
 
-    fn initialize<SystemImpl>(_system: &mut impl System<SystemImpl>, _input: Self::Input)
+    fn initialize<SystemImpl>(
+        _system: &mut impl System<'world, SystemImpl>,
+        _input: Self::Input,
+    )
     {
     }
 
     fn new<SystemImpl>(
-        _system: &'world mut impl System<SystemImpl>,
-        world_data: &'world mut WorldData,
+        _system: &'world impl System<'world, SystemImpl>,
+        world_data: &'world WorldData,
     ) -> Self
     {
         Self::new(world_data)
@@ -268,75 +249,26 @@ where
 
     fn next(&mut self) -> Option<Self::Item>
     {
-        let matching_entity = find_entity_with_components::<&Entity>(
-            &mut self.entity_iter,
-            &self.component_type_ids,
-        )?;
+        let matching_entity =
+            find_entity_with_components(&mut self.entity_iter, &self.component_type_ids)?;
 
         Some(Comps::from_components(&matching_entity.components))
     }
 }
 
-pub struct QueryComponentMutIter<'world, Comps>
-{
-    entity_iter: SliceIterMut<'world, Entity>,
-    component_type_ids: Vec<TypeId>,
-    comps_pd: PhantomData<Comps>,
-}
-
-impl<'world, Comps> Iterator for QueryComponentMutIter<'world, Comps>
-where
-    Comps: ComponentSequence + 'world,
-{
-    type Item = Comps::MutRefs<'world>;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let matching_entity = find_entity_with_components::<&mut Entity>(
-            &mut self.entity_iter,
-            &self.component_type_ids,
-        )?;
-
-        Some(Comps::from_components_mut(&mut matching_entity.components))
-    }
-}
-
-trait EntityRef
-{
-    fn components(&self) -> &[Box<dyn Component>];
-}
-
-impl EntityRef for &Entity
-{
-    fn components(&self) -> &[Box<dyn Component>]
-    {
-        &self.components
-    }
-}
-
-impl EntityRef for &mut Entity
-{
-    fn components(&self) -> &[Box<dyn Component>]
-    {
-        &self.components
-    }
-}
-
-fn find_entity_with_components<EntityRefT>(
-    entity_iter: &mut impl Iterator<Item = EntityRefT>,
+fn find_entity_with_components<'world>(
+    entity_iter: &mut impl Iterator<Item = &'world Entity>,
     component_type_ids: &[TypeId],
-) -> Option<EntityRefT>
-where
-    EntityRefT: EntityRef,
+) -> Option<&'world Entity>
 {
     // TODO: This is a really dumb and slow way to do this. Refactor the world
     // to store components in archetypes
     entity_iter.find(|entity| {
-        let entity_components: HashSet<_> = entity
-            .components()
+        let entity_components = entity
+            .components
             .iter()
-            .map(|component| component.as_ref().type_id())
-            .collect();
+            .filter_map(|component| Some(component.try_borrow().ok()?.as_ref().type_id()))
+            .collect::<HashSet<_>>();
 
         if component_type_ids
             .iter()