ecs: add WorldTick query, implement IntoSystem and FnSystem for funcs with 11 args

accidentially missed the macro call for 11 arguments

lyra-ecs/src/query/mod.rs

@@ -31,6 +31,10 @@ mod optional;
 #[allow(unused_imports)]
 pub use optional::*;
 
+mod world_tick;
+#[allow(unused_imports)]
+pub use world_tick::*;
+
 pub mod dynamic;
 
 pub mod filter;

lyra-ecs/src/query/world_tick.rs

@@ -0,0 +1,102 @@
+use std::ops::Deref;
+
+use crate::{system::FnArgFetcher, Tick, World};
+use super::{Fetch, Query, AsQuery};
+
+/// Fetcher used to fetch the current tick of the world.
+pub struct FetchWorldTick {
+    tick: Tick
+}
+
+impl<'a> Fetch<'a> for FetchWorldTick {
+    type Item = WorldTick;
+
+    fn dangling() -> Self {
+        unreachable!()
+    }
+
+    fn can_visit_item(&mut self, _entity: crate::ArchetypeEntityId) -> bool {
+        true
+    }
+
+    unsafe fn get_item(&mut self, _entity: crate::world::ArchetypeEntityId) -> Self::Item {
+        WorldTick(self.tick)
+    }
+}
+
+/// Query used to query the current tick of the world.
+#[derive(Clone, Copy)]
+pub struct QueryWorldTick;
+
+impl Default for QueryWorldTick {
+    fn default() -> Self {
+        Self
+    }
+}
+
+impl Query for QueryWorldTick {
+    type Item<'a> = WorldTick;
+
+    type Fetch<'a> = FetchWorldTick;
+
+    const ALWAYS_FETCHES: bool = true;
+
+    fn new() -> Self {
+        QueryWorldTick
+    }
+
+    fn can_visit_archetype(&self, _archetype: &crate::archetype::Archetype) -> bool {
+        true
+    }
+
+    unsafe fn fetch<'a>(&self, world: &'a World, _archetype: &'a crate::archetype::Archetype, _tick: crate::Tick) -> Self::Fetch<'a> {
+        FetchWorldTick {
+            tick: world.current_tick()
+        }
+    }
+
+    unsafe fn fetch_world<'a>(&self, world: &'a World) -> Option<Self::Fetch<'a>> {
+        Some(FetchWorldTick {
+            tick: world.current_tick()
+        })
+    }
+}
+
+impl AsQuery for QueryWorldTick {
+    type Query = Self;
+}
+
+/// Type that can be used in an fn system for fetching the current world tick.
+#[derive(Debug, Clone, Copy)]
+pub struct WorldTick(Tick);
+
+impl Deref for WorldTick {
+    type Target = Tick;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsQuery for WorldTick {
+    type Query = QueryWorldTick;
+}
+
+impl FnArgFetcher for WorldTick {
+    type State = ();
+
+    type Arg<'a, 'state> = WorldTick;
+
+    fn create_state(_: std::ptr::NonNull<World>) -> Self::State {
+        ()
+    }
+
+    unsafe fn get<'a, 'state>(_: &'state mut Self::State, world: std::ptr::NonNull<World>) -> Self::Arg<'a, 'state> {
+        let world = world.as_ref();
+        WorldTick(world.current_tick())
+    }
+
+    fn apply_deferred(_: Self::State, _: std::ptr::NonNull<World>) {
+        
+    }
+}

lyra-ecs/src/system/fn_sys.rs

@@ -130,6 +130,7 @@ impl_fn_system_tuple!{ A, B, C, D, E, F2, G }
 impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H }
 impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H, I }
 impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H, I, J }
+impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H, I, J, K }
 impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H, I, J, K, L }
 impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H, I, J, K, L, M }
 impl_fn_system_tuple!{ A, B, C, D, E, F2, G, H, I, J, K, L, M, N }