1 files changed, 96 insertions, 105 deletions

diff --git a/ecs/src/component/storage.rs b/ecs/src/component/storage.rs
index c70e7e7..b27b552 100644
--- a/ecs/src/component/storage.rs
+++ b/ecs/src/component/storage.rs
@@ -1,4 +1,4 @@
-use std::any::type_name;
+use std::any::Any;
 use std::array::IntoIter as ArrayIter;
 use std::cell::RefCell;
 use std::vec::IntoIter as VecIntoIter;
@@ -7,7 +7,8 @@ use hashbrown::HashMap;
 
 use crate::component::storage::archetype::{
     Archetype,
-    ArchetypeEntity,
+    Entity as ArchetypeEntity,
+    EntityComponent as ArchetypeEntityComponent,
     Id as ArchetypeId,
 };
 use crate::component::storage::graph::{
@@ -16,11 +17,8 @@ use crate::component::storage::graph::{
     ArchetypeEdges,
     Graph,
 };
-use crate::component::Component;
-use crate::type_name::TypeName;
 use crate::uid::{Kind as UidKind, Uid};
 use crate::util::{BorrowedOrOwned, Either, StreamingIterator, VecExt};
-use crate::EntityComponent;
 
 pub mod archetype;
 
@@ -35,14 +33,43 @@ pub struct ArchetypeSearchTerms<'a>
 
 impl ArchetypeSearchTerms<'_>
 {
-    fn excluded_contains(&self, uid: Uid) -> bool
+    fn excluded_contains(&self, comp_id: Uid) -> bool
     {
-        self.excluded_components.binary_search(&uid).is_ok()
+        let comp_id_kind = comp_id.kind();
+
+        debug_assert!(
+            comp_id_kind == UidKind::Component
+                || (comp_id_kind == UidKind::Pair
+                    && comp_id.target_component() != Uid::wildcard())
+        );
+
+        let is_found = self.excluded_components.binary_search(&comp_id).is_ok();
+
+        if !is_found && comp_id_kind == UidKind::Pair {
+            return self.excluded_components.iter().any(|excluded_comp_id| {
+                excluded_comp_id.kind() == UidKind::Pair
+                    && excluded_comp_id.has_same_relation_as(comp_id)
+                    && excluded_comp_id.target_component() == Uid::wildcard()
+            });
+        }
+
+        is_found
+    }
+
+    fn contains_conflicting(&self) -> bool
+    {
+        self.excluded_components.iter().any(|excluded_comp_id| {
+            self.required_components
+                .binary_search(excluded_comp_id)
+                .is_ok()
+        })
     }
 
-    fn required_contains(&self, uid: Uid) -> bool
+    fn archetype_contains_all_required(&self, archetype: &Archetype) -> bool
     {
-        self.required_components.binary_search(&uid).is_ok()
+        self.required_components
+            .iter()
+            .all(|comp_id| archetype.contains_matching_component(*comp_id))
     }
 }
 
@@ -61,13 +88,9 @@ impl Storage
         search_terms: ArchetypeSearchTerms<'search_terms>,
     ) -> ArchetypeRefIter<'_, 'search_terms>
     {
-        let archetype_id = ArchetypeId::new(&search_terms.required_components);
+        let archetype_id = ArchetypeId::new(search_terms.required_components);
 
-        if search_terms
-            .excluded_components
-            .iter()
-            .any(|excluded_comp_id| search_terms.required_contains(*excluded_comp_id))
-        {
+        if search_terms.contains_conflicting() {
             return ArchetypeRefIter {
                 storage: self,
                 pre_iter: Either::B(Vec::new().into_iter()),
@@ -82,8 +105,21 @@ impl Storage
             self.imaginary_archetypes
                 .borrow_mut()
                 .push(ImaginaryArchetype {
-                    id: archetype_id,
-                    component_ids: search_terms.required_components.to_vec(),
+                    id: ArchetypeId::new(search_terms.required_components.iter().filter(
+                        |required_comp_id| {
+                            required_comp_id.kind() != UidKind::Pair
+                                || required_comp_id.target_component() != Uid::wildcard()
+                        },
+                    )),
+                    component_ids: search_terms
+                        .required_components
+                        .iter()
+                        .copied()
+                        .filter(|required_comp_id| {
+                            required_comp_id.kind() != UidKind::Pair
+                                || required_comp_id.target_component() != Uid::wildcard()
+                        })
+                        .collect(),
                 });
 
             let found_archetypes = self.find_all_archetype_with_comps(&search_terms);
@@ -117,23 +153,20 @@ impl Storage
             return Err(Error::EntityAlreadyExists(uid));
         }
 
-        let empty_archetype_id = ArchetypeId::from_components_metadata(&[]);
+        let empty_archetype_id = ArchetypeId::new_empty();
 
         let archetype_node = self.graph.get_or_create_node(empty_archetype_id, &[]);
 
         archetype_node
             .archetype_mut()
-            .push_entity(ArchetypeEntity { uid, components: vec![] });
+            .push_entity(ArchetypeEntity::new(uid, []));
 
         self.entity_archetype_lookup.insert(uid, empty_archetype_id);
 
         Ok(())
     }
 
-    pub fn remove_entity(
-        &mut self,
-        entity_uid: Uid,
-    ) -> Result<Vec<EntityComponent>, Error>
+    pub fn remove_entity(&mut self, entity_uid: Uid) -> Result<ArchetypeEntity, Error>
     {
         let Some(archetype_id) = self.entity_archetype_lookup.get(&entity_uid) else {
             return Err(Error::EntityDoesNotExist(entity_uid));
@@ -151,7 +184,7 @@ impl Storage
 
         self.entity_archetype_lookup.remove(&entity_uid);
 
-        Ok(entity.components)
+        Ok(entity)
     }
 
     pub fn get_entity_archetype(&self, entity_uid: Uid) -> Option<&Archetype>
@@ -164,16 +197,9 @@ impl Storage
     pub fn add_entity_component(
         &mut self,
         entity_uid: Uid,
-        component: (Uid, Box<dyn Component>),
+        (component_id, component_name, component): (Uid, &'static str, Box<dyn Any>),
     ) -> Result<(), Error>
     {
-        let (component_id, component) = component;
-
-        debug_assert!(
-            !component.self_is_optional(),
-            "Adding a optional component to a entity is not supported"
-        );
-
         let Some(archetype_id) = self.entity_archetype_lookup.get(&entity_uid) else {
             return Err(Error::EntityDoesNotExist(entity_uid));
         };
@@ -187,7 +213,7 @@ impl Storage
 
         if archetype_node
             .archetype()
-            .has_component_with_id(component_id)
+            .contains_component_with_exact_id(component_id)
         {
             return Err(Error::ComponentAlreadyInEntity {
                 entity: entity_uid,
@@ -195,41 +221,36 @@ impl Storage
             });
         }
 
-        let add_edge_archetype_id = archetype_node
+        let add_edge_archetype_id = if let Some(add_edge_id) = archetype_node
             .get_or_insert_edges(component_id, ArchetypeEdges::default)
             .add
-            .unwrap_or_else(|| {
-                let archetype_node = self
+        {
+            if !self.graph.contains_archetype(add_edge_id) {
+                let (_, add_edge_comp_ids) = self
                     .graph
-                    .get_node_by_id_mut(archetype_id)
-                    .expect("Archetype should exist");
-
-                let (add_edge_id, add_edge_comp_ids) =
-                    archetype_node.make_add_edge(component_id);
-
-                archetype_node
-                    .get_edges_mut(component_id)
-                    .expect("Edges for component in archetype should exist")
-                    .add = Some(add_edge_id);
-
-                if !self.graph.contains_archetype(add_edge_id) {
-                    self.graph.create_node(add_edge_id, &add_edge_comp_ids);
-                }
+                    .get_node_by_id(archetype_id)
+                    .expect("Archetype should exist")
+                    .make_add_edge(component_id);
 
-                add_edge_id
-            });
+                self.graph.create_node(add_edge_id, &add_edge_comp_ids);
+            }
 
-        {
-            let add_edge_archetype_node = self
+            add_edge_id
+        } else {
+            let archetype_node = self
                 .graph
-                .get_node_by_id_mut(add_edge_archetype_id)
-                .expect("Add edge archetype should exist");
+                .get_node_by_id(archetype_id)
+                .expect("Archetype should exist");
 
-            let add_edge_archetype_edges = add_edge_archetype_node
-                .get_or_insert_edges(component_id, ArchetypeEdges::default);
+            let (add_edge_id, add_edge_comp_ids) =
+                archetype_node.make_add_edge(component_id);
 
-            add_edge_archetype_edges.remove = Some(archetype_id);
-        }
+            if !self.graph.contains_archetype(add_edge_id) {
+                self.graph.create_node(add_edge_id, &add_edge_comp_ids);
+            }
+
+            add_edge_id
+        };
 
         let archetype_node = self
             .graph
@@ -247,13 +268,10 @@ impl Storage
             .expect("Add edge archetype should exist")
             .archetype_mut();
 
-        let component_index = add_edge_archetype
-            .get_index_for_component(component_id)
-            .expect("Archetype should have index for component");
-
-        entity.components.insert(
-            component_index,
-            EntityComponent::new(component_id, component),
+        entity.insert_component(
+            component_id,
+            ArchetypeEntityComponent::new(component, component_id, component_name),
+            add_edge_archetype,
         );
 
         add_edge_archetype.push_entity(entity);
@@ -283,7 +301,7 @@ impl Storage
 
         if !archetype_node
             .archetype()
-            .has_component_with_id(component_id)
+            .contains_component_with_exact_id(component_id)
         {
             return Err(Error::ComponentNotFoundInEntity {
                 entity: entity_uid,
@@ -303,11 +321,6 @@ impl Storage
                 let (remove_edge_id, remove_edge_comp_ids) =
                     archetype_node.make_remove_edge(component_id);
 
-                archetype_node
-                    .get_edges_mut(component_id)
-                    .expect("Edges for component in archetype should exist")
-                    .remove = Some(remove_edge_id);
-
                 if !self.graph.contains_archetype(remove_edge_id) {
                     self.graph
                         .create_node(remove_edge_id, &remove_edge_comp_ids);
@@ -326,14 +339,7 @@ impl Storage
             .remove_entity(entity_uid)
             .expect("Entity should exist in archetype");
 
-        let (comp_to_remove_index, _) = entity
-            .components
-            .iter()
-            .enumerate()
-            .find(|(_, comp)| comp.id == component_id)
-            .expect("Entity should contain component");
-
-        entity.components.remove(comp_to_remove_index);
+        entity.remove_component(component_id, archetype_node.archetype());
 
         self.graph
             .get_node_by_id_mut(remove_edge_id)
@@ -365,9 +371,12 @@ impl Storage
     ) -> Vec<ArchetypeId>
     {
         let Some(mut search_iter) =
-            self.graph.dfs_archetype_add_edges(ArchetypeId::new(&[]))
+            self.graph.dfs_archetype_add_edges(ArchetypeId::new_empty())
         else {
             // If the root archetype doesn't exist, no other archetype can exist either
+            //
+            // TODO: The above comment is not true. Cases where imaginary archetypes have
+            // been created should be handled as well
             return Vec::new();
         };
 
@@ -396,11 +405,7 @@ impl Storage
                 continue;
             }
 
-            if !search_terms
-                .required_components
-                .iter()
-                .all(|comp_id| node.archetype().has_component_with_id(*comp_id))
-            {
+            if !search_terms.archetype_contains_all_required(node.archetype()) {
                 continue;
             }
 
@@ -413,14 +418,6 @@ impl Storage
     }
 }
 
-impl TypeName for Storage
-{
-    fn type_name(&self) -> &'static str
-    {
-        type_name::<Self>()
-    }
-}
-
 #[cfg(feature = "vizoxide")]
 impl Storage
 {
@@ -600,8 +597,7 @@ pub struct ArchetypeRefIter<'storage, 'search_terms>
     search_terms: ArchetypeSearchTerms<'search_terms>,
 }
 
-impl<'component_storage, 'search_terms> Iterator
-    for ArchetypeRefIter<'component_storage, 'search_terms>
+impl<'component_storage> Iterator for ArchetypeRefIter<'component_storage, '_>
 {
     type Item = &'component_storage Archetype;
 
@@ -654,10 +650,7 @@ impl<'component_storage, 'search_terms> Iterator
                     self.storage.imaginary_archetypes.borrow_mut().push(
                         ImaginaryArchetype {
                             id: add_edge_archetype_id,
-                            component_ids: add_edge_archetype_comps
-                                .iter()
-                                .map(|comp_id| *comp_id)
-                                .collect::<Vec<_>>(),
+                            component_ids: add_edge_archetype_comps.clone(),
                         },
                     );
 
@@ -671,8 +664,6 @@ impl<'component_storage, 'search_terms> Iterator
                         )),
                         found.into_iter(),
                     ));
-
-                    continue;
                 }
                 _ => {
                     unreachable!();
@@ -782,7 +773,7 @@ mod tests
 
         let archetype_node = new_storage
             .graph
-            .get_node_by_id(ArchetypeId::from_components_metadata(&[]))
+            .get_node_by_id(ArchetypeId::new_empty())
             .expect("Archetype for entities with no component doesn't exist");
 
         assert_eq!(archetype_node.archetype().component_cnt(), 0);
@@ -790,7 +781,7 @@ mod tests
 
         assert_eq!(
             new_storage.entity_archetype_lookup.get(&uid).copied(),
-            Some(ArchetypeId::from_components_metadata(&[]))
+            Some(ArchetypeId::new_empty())
         );
     }
 }