From e229b104593d3afede47cc07e9917a42d6d13e60 Mon Sep 17 00:00:00 2001
From: HampusM <hampus@hampusmat.com>
Date: Fri, 15 Aug 2025 13:38:27 +0200
Subject: refactor(ecs): store local components as system entity components

---
 ecs/src/query.rs | 66 ++++++++++++++++++++++++--------------------------------
 1 file changed, 28 insertions(+), 38 deletions(-)

(limited to 'ecs/src/query.rs')

diff --git a/ecs/src/query.rs b/ecs/src/query.rs
index dfe9dad..1f281f1 100644
--- a/ecs/src/query.rs
+++ b/ecs/src/query.rs
@@ -10,7 +10,7 @@ use crate::component::{
 };
 use crate::entity::Handle as EntityHandle;
 use crate::query::flexible::{Iter as FlexibleQueryIter, Query as FlexibleQuery};
-use crate::system::{Param as SystemParam, System};
+use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
 use crate::uid::{Kind as UidKind, Uid, With as WithUid};
 use crate::util::array_vec::ArrayVec;
 use crate::util::Array;
@@ -19,15 +19,16 @@ use crate::World;
 pub mod flexible;
 pub mod term;
 
+// A term tuple type can have a maximum of 17 elements
+pub const MAX_TERM_CNT: usize = 17;
+
 #[derive(Debug)]
 pub struct Query<'world, FieldTerms, FieldlessTerms = ()>
 where
     FieldTerms: TermWithFieldTuple,
     FieldlessTerms: TermWithoutFieldTuple,
 {
-    world: &'world World,
-    // A term tuple type can have a maximum of 17 elements
-    inner: FlexibleQuery<'world, 17>,
+    inner: FlexibleQuery<'world, MAX_TERM_CNT>,
     _pd: PhantomData<(FieldTerms, FieldlessTerms)>,
 }
 
@@ -46,7 +47,7 @@ where
         tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
 
         Iter {
-            world: self.world,
+            world: self.inner.world(),
             iter: self.inner.iter(),
             comps_pd: PhantomData,
         }
@@ -62,7 +63,7 @@ where
         tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
 
         ComponentAndEuidIter {
-            world: self.world,
+            world: self.inner.world(),
             iter: self.inner.iter(),
             comps_pd: PhantomData,
         }
@@ -84,7 +85,7 @@ where
         tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
 
         Iter {
-            world: self.world,
+            world: self.inner.world(),
             iter: func(self.inner.iter()),
             comps_pd: PhantomData,
         }
@@ -97,6 +98,25 @@ where
         Some(self.inner.iter().nth(entity_index)?.uid())
     }
 
+    /// Returns a new `Query` created from a [`FlexibleQuery`].
+    ///
+    /// # Important notes
+    /// The terms in `FieldTerms` and `FieldlessTerms` must be compatible with the terms
+    /// in the given [`FlexibleQuery`], otherwise any method call or iterating might
+    /// panic.
+    #[must_use]
+    pub fn from_flexible_query(
+        flexible_query: FlexibleQuery<'world, MAX_TERM_CNT>,
+    ) -> Self
+    {
+        // TODO: Check compatability of terms
+
+        Self {
+            inner: flexible_query,
+            _pd: PhantomData,
+        }
+    }
+
     pub(crate) fn new(world: &'world World) -> Self
     {
         let mut terms_builder = Terms::builder();
@@ -105,7 +125,6 @@ where
         FieldlessTerms::apply_terms_to_builder(&mut terms_builder);
 
         Self {
-            world,
             inner: world.flexible_query(terms_builder.build()),
             _pd: PhantomData,
         }
@@ -135,17 +154,7 @@ where
 {
     type Input = ();
 
-    fn initialize<SystemImpl>(
-        _system: &mut impl System<'world, SystemImpl>,
-        _input: Self::Input,
-    )
-    {
-    }
-
-    fn new<SystemImpl>(
-        _system: &'world impl System<'world, SystemImpl>,
-        world: &'world World,
-    ) -> Self
+    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
     {
         Self::new(world)
     }
@@ -441,25 +450,6 @@ where
     comps_pd: PhantomData<FieldTerms>,
 }
 
-impl<'query, 'world, FieldTerms, EntityHandleIter>
-    Iter<'query, 'world, FieldTerms, EntityHandleIter>
-where
-    FieldTerms: TermWithFieldTuple,
-    EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
-    'world: 'query,
-{
-    /// Creates a new iterator from the given entity handle iterator.
-    ///
-    /// # Important
-    /// All of the yielded entities of the entity handle iterator should match the
-    /// terms `Terms`. The [`Self::next`] function will panic if it encounters a
-    /// entity that does not match the terms `Terms`.
-    pub fn new(world: &'world World, iter: EntityHandleIter) -> Self
-    {
-        Self { world, iter, comps_pd: PhantomData }
-    }
-}
-
 impl<'query, 'world, FieldTerms, EntityHandleIter> Iterator
     for Iter<'query, 'world, FieldTerms, EntityHandleIter>
 where
-- 
cgit v1.2.3-18-g5258