From 2a6a7e156a1f5dfb72fea6a59e84ad2fac4e3720 Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 19:39:20 +0200
Subject: [PATCH 1/7] Added IEnumerable iterator

---
 SimpleECS/QueryForeachFunctions.cs | 289 +++++++++++++++++++++++++++++
 1 file changed, 289 insertions(+)

diff --git a/SimpleECS/QueryForeachFunctions.cs b/SimpleECS/QueryForeachFunctions.cs
index 7aacb7f..72fb202 100644
--- a/SimpleECS/QueryForeachFunctions.cs
+++ b/SimpleECS/QueryForeachFunctions.cs
@@ -3278,5 +3278,294 @@ public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11
                 world_info.StructureEvents.EnqueueEvents--;
             }
         }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1>> Foreach<C1>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e]);
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2>> Foreach<C1, C2>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e]);
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3>> Foreach<C1, C2, C3>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e]);
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4>> Foreach<C1, C2, C3, C4>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e]);
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5>> Foreach<C1, C2, C3, C4, C5>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e]);
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, C6>> Foreach<C1, C2, C3, C4, C5, C6>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], c6[e]);
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7>>> Foreach<C1, C2, C3, C4, C5, C6, C7>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], Tuple.Create(c6[e], c7[e]));
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8>>> Foreach<C1, C2, C3, C4, C5, C6, C7, C8>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], Tuple.Create(c6[e], c7[e], c8[e]));
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9>>> Foreach<C1, C2, C3, C4, C5, C6, C7, C8, C9>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], Tuple.Create(c6[e], c7[e], c8[e], c9[e]));
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10>>> Foreach<C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], Tuple.Create(c6[e], c7[e], c8[e], c9[e], c10[e]));
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10, C11>>> Foreach<C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], Tuple.Create(c6[e], c7[e], c8[e], c9[e], c10[e], c11[e]));
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
+        /// <summary>
+        /// iterates over the entities that match the query and returns a tuple of the entity and the components
+        /// possible to use continue and break
+        /// NOTE: it is only possible to modity a refernce type in the tuple, like a class. You can not modify a value type, like int, float, bool, etc.
+        /// </summary>
+        public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10, C11, C12>>> Foreach<C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>()
+        {
+            if (Update(out var world_info))
+            {
+                world_info.StructureEvents.EnqueueEvents++;
+                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                {
+                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
+                    int count = archetype.entity_count;
+                    var entities = archetype.entities;
+                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
+                    {
+                        for (int e = 0; e < count; ++e)
+                            yield return Tuple.Create(entities[e], c1[e], c2[e], c3[e], c4[e], c5[e], Tuple.Create(c6[e], c7[e], c8[e], c9[e], c10[e], c11[e], c12[e]));
+                    }
+                }
+                world_info.StructureEvents.EnqueueEvents--;
+            }
+        }
     }
 }
\ No newline at end of file

From 109be46496ae266b3ee7a66ce2a3b361428d3f7f Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 20:06:27 +0200
Subject: [PATCH 2/7] updated README to have foreach iterator

---
 README.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/README.md b/README.md
index ab5da9f..67381fe 100644
--- a/README.md
+++ b/README.md
@@ -156,6 +156,28 @@ query.Foreach( (Entity entity, ref int value ) =>         // you can access the
   Console.WriteLine($"{entity} value is {value}");        
 });
 
+foreach ((Entity entity, int value) in query.Foreach<int>()) // foreach makes so you can use continue and break
+{
+    if (aa.x > 0)
+    {
+        continue;
+    }
+
+    if (bb.x > 0)
+    {
+        break;
+    }
+
+    Console.WriteLine($"value x is {aa.x} value y is {aa.y}");
+}
+
+// having more then 5 components makes so you have to put double parenthesis.
+// the reason is that a tuple only can hold in 8 values, so you create a second tuple in the tuple
+foreach ((var entity, A aa, B bb, C cc, D dd, E ee, (F ff, G gg, H hh, I ii, J jj)) in query.Foreach<A, B, C, D, E, F, G, H, I, J>())   
+{                     
+    Console.WriteLine($"value x is {aa.x} value y is {aa.y}");
+}
+
 var all_entities = world.CreateQuery();   // a simple way to match against all entities is to make a query with no filters
 
 query.GetEntities();    // returns a copy of all entities currently matching the query

From a02e4da29dbaadcc75b85a80f4df05bfb26af240 Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 20:22:47 +0200
Subject: [PATCH 3/7] changed var to Entity

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 67381fe..c96563b 100644
--- a/README.md
+++ b/README.md
@@ -173,7 +173,7 @@ foreach ((Entity entity, int value) in query.Foreach<int>()) // foreach makes so
 
 // having more then 5 components makes so you have to put double parenthesis.
 // the reason is that a tuple only can hold in 8 values, so you create a second tuple in the tuple
-foreach ((var entity, A aa, B bb, C cc, D dd, E ee, (F ff, G gg, H hh, I ii, J jj)) in query.Foreach<A, B, C, D, E, F, G, H, I, J>())   
+foreach ((Entity entity, A aa, B bb, C cc, D dd, E ee, (F ff, G gg, H hh, I ii, J jj)) in query.Foreach<A, B, C, D, E, F, G, H, I, J>())   
 {                     
     Console.WriteLine($"value x is {aa.x} value y is {aa.y}");
 }

From 60b4cdfdf0cfe55b02a95c2c6b1eb9e0a739f948 Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 20:39:15 +0200
Subject: [PATCH 4/7] removed all foreach with world data

---
 SimpleECS/QueryForeachFunctions.cs | 2688 ----------------------------
 1 file changed, 2688 deletions(-)

diff --git a/SimpleECS/QueryForeachFunctions.cs b/SimpleECS/QueryForeachFunctions.cs
index 72fb202..dbd3278 100644
--- a/SimpleECS/QueryForeachFunctions.cs
+++ b/SimpleECS/QueryForeachFunctions.cs
@@ -590,2694 +590,6 @@ public void Foreach<C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in ec12_q
                 world_info.StructureEvents.EnqueueEvents--;
             }
         }
-        public delegate void w1c1_query<W1, C1>(in W1 w1, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1>(in w1c1_query<W1, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c1_query<W1, W2, C1>(in W1 w1, in W2 w2, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1>(in w2c1_query<W1, W2, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c1_query<W1, W2, W3, C1>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1>(in w3c1_query<W1, W2, W3, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c1_query<W1, W2, W3, W4, C1>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1>(in w4c1_query<W1, W2, W3, W4, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c2_query<W1, C1, C2>(in W1 w1, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2>(in w1c2_query<W1, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c2_query<W1, W2, C1, C2>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2>(in w2c2_query<W1, W2, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c2_query<W1, W2, W3, C1, C2>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2>(in w3c2_query<W1, W2, W3, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c2_query<W1, W2, W3, W4, C1, C2>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2>(in w4c2_query<W1, W2, W3, W4, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c3_query<W1, C1, C2, C3>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3>(in w1c3_query<W1, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c3_query<W1, W2, C1, C2, C3>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3>(in w2c3_query<W1, W2, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c3_query<W1, W2, W3, C1, C2, C3>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3>(in w3c3_query<W1, W2, W3, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c3_query<W1, W2, W3, W4, C1, C2, C3>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3>(in w4c3_query<W1, W2, W3, W4, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c4_query<W1, C1, C2, C3, C4>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4>(in w1c4_query<W1, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c4_query<W1, W2, C1, C2, C3, C4>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4>(in w2c4_query<W1, W2, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c4_query<W1, W2, W3, C1, C2, C3, C4>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4>(in w3c4_query<W1, W2, W3, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c4_query<W1, W2, W3, W4, C1, C2, C3, C4>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4>(in w4c4_query<W1, W2, W3, W4, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c5_query<W1, C1, C2, C3, C4, C5>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5>(in w1c5_query<W1, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c5_query<W1, W2, C1, C2, C3, C4, C5>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5>(in w2c5_query<W1, W2, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c5_query<W1, W2, W3, C1, C2, C3, C4, C5>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5>(in w3c5_query<W1, W2, W3, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c5_query<W1, W2, W3, W4, C1, C2, C3, C4, C5>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5>(in w4c5_query<W1, W2, W3, W4, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c6_query<W1, C1, C2, C3, C4, C5, C6>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6>(in w1c6_query<W1, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c6_query<W1, W2, C1, C2, C3, C4, C5, C6>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6>(in w2c6_query<W1, W2, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c6_query<W1, W2, W3, C1, C2, C3, C4, C5, C6>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6>(in w3c6_query<W1, W2, W3, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c6_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6>(in w4c6_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c7_query<W1, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7>(in w1c7_query<W1, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c7_query<W1, W2, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7>(in w2c7_query<W1, W2, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c7_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7>(in w3c7_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c7_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7>(in w4c7_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c8_query<W1, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8>(in w1c8_query<W1, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c8_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8>(in w2c8_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c8_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8>(in w3c8_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c8_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8>(in w4c8_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c9_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w1c9_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c9_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w2c9_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c9_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w3c9_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c9_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w4c9_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c10_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w1c10_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c10_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w2c10_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c10_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w3c10_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c10_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w4c10_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c11_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w1c11_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c11_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w2c11_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c11_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w3c11_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c11_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w4c11_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1c12_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w1c12_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2c12_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, in W2 w2, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w2c12_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3c12_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, in W2 w2, in W3 w3, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w3c12_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4c12_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w4c12_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec1_query<W1, C1>(in W1 w1, Entity entity, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1>(in w1ec1_query<W1, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec1_query<W1, W2, C1>(in W1 w1, in W2 w2, Entity entity, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1>(in w2ec1_query<W1, W2, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec1_query<W1, W2, W3, C1>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1>(in w3ec1_query<W1, W2, W3, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec1_query<W1, W2, W3, W4, C1>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1>(in w4ec1_query<W1, W2, W3, W4, C1> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec2_query<W1, C1, C2>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2>(in w1ec2_query<W1, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec2_query<W1, W2, C1, C2>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2>(in w2ec2_query<W1, W2, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec2_query<W1, W2, W3, C1, C2>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2>(in w3ec2_query<W1, W2, W3, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec2_query<W1, W2, W3, W4, C1, C2>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2>(in w4ec2_query<W1, W2, W3, W4, C1, C2> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec3_query<W1, C1, C2, C3>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3>(in w1ec3_query<W1, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec3_query<W1, W2, C1, C2, C3>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3>(in w2ec3_query<W1, W2, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec3_query<W1, W2, W3, C1, C2, C3>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3>(in w3ec3_query<W1, W2, W3, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec3_query<W1, W2, W3, W4, C1, C2, C3>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3>(in w4ec3_query<W1, W2, W3, W4, C1, C2, C3> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec4_query<W1, C1, C2, C3, C4>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4>(in w1ec4_query<W1, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec4_query<W1, W2, C1, C2, C3, C4>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4>(in w2ec4_query<W1, W2, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec4_query<W1, W2, W3, C1, C2, C3, C4>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4>(in w3ec4_query<W1, W2, W3, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec4_query<W1, W2, W3, W4, C1, C2, C3, C4>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4>(in w4ec4_query<W1, W2, W3, W4, C1, C2, C3, C4> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec5_query<W1, C1, C2, C3, C4, C5>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5>(in w1ec5_query<W1, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec5_query<W1, W2, C1, C2, C3, C4, C5>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5>(in w2ec5_query<W1, W2, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec5_query<W1, W2, W3, C1, C2, C3, C4, C5>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5>(in w3ec5_query<W1, W2, W3, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec5_query<W1, W2, W3, W4, C1, C2, C3, C4, C5>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5>(in w4ec5_query<W1, W2, W3, W4, C1, C2, C3, C4, C5> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec6_query<W1, C1, C2, C3, C4, C5, C6>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6>(in w1ec6_query<W1, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec6_query<W1, W2, C1, C2, C3, C4, C5, C6>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6>(in w2ec6_query<W1, W2, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec6_query<W1, W2, W3, C1, C2, C3, C4, C5, C6>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6>(in w3ec6_query<W1, W2, W3, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec6_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6>(in w4ec6_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec7_query<W1, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7>(in w1ec7_query<W1, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec7_query<W1, W2, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7>(in w2ec7_query<W1, W2, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec7_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7>(in w3ec7_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec7_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7>(in w4ec7_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec8_query<W1, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8>(in w1ec8_query<W1, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec8_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8>(in w2ec8_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec8_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8>(in w3ec8_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec8_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8>(in w4ec8_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec9_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w1ec9_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec9_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w2ec9_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec9_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w3ec9_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec9_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9>(in w4ec9_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec10_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w1ec10_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec10_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w2ec10_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec10_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w3ec10_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec10_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10>(in w4ec10_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec11_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w1ec11_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec11_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w2ec11_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec11_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w3ec11_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec11_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11>(in w4ec11_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w1ec12_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w1ec12_query<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w2ec12_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, in W2 w2, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w2ec12_query<W1, W2, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w3ec12_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, in W2 w2, in W3 w3, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w3ec12_query<W1, W2, W3, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
-        public delegate void w4ec12_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in W1 w1, in W2 w2, in W3 w3, in W4 w4, Entity entity, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6, ref C7 c7, ref C8 c8, ref C9 c9, ref C10 c10, ref C11 c11, ref C12 c12);
-        /// <summary>
-        /// performs the action on all entities that match the query.
-        /// query must be in the form of '(in world_data', entity, ref components)'.
-        /// query can add up to 4 world data and 12 components
-        /// </summary>
-        public void Foreach<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>(in w4ec12_query<W1, W2, W3, W4, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> action)
-        {
-            if (Update(out var world_info))
-            {
-                ref W1 w1 = ref world.GetData<W1>();
-                ref W2 w2 = ref world.GetData<W2>();
-                ref W3 w3 = ref world.GetData<W3>();
-                ref W4 w4 = ref world.GetData<W4>();
-
-                world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
-                {
-                    var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
-                    int count = archetype.entity_count;
-                    var entities = archetype.entities;
-                    if (count > 0 && archetype.TryGetArray(out C1[] c1) && archetype.TryGetArray(out C2[] c2) && archetype.TryGetArray(out C3[] c3) && archetype.TryGetArray(out C4[] c4) && archetype.TryGetArray(out C5[] c5) && archetype.TryGetArray(out C6[] c6) && archetype.TryGetArray(out C7[] c7) && archetype.TryGetArray(out C8[] c8) && archetype.TryGetArray(out C9[] c9) && archetype.TryGetArray(out C10[] c10) && archetype.TryGetArray(out C11[] c11) && archetype.TryGetArray(out C12[] c12))
-                    {
-                        for (int e = 0; e < count; ++e)
-                            action(in w1, in w2, in w3, in w4, entities[e], ref c1[e], ref c2[e], ref c3[e], ref c4[e], ref c5[e], ref c6[e], ref c7[e], ref c8[e], ref c9[e], ref c10[e], ref c11[e], ref c12[e]);
-                    }
-                }
-                world_info.StructureEvents.EnqueueEvents--;
-            }
-        }
         /// <summary>
         /// iterates over the entities that match the query and returns a tuple of the entity and the components
         /// possible to use continue and break

From 0732126f46f46ce8778a35506621a2171d5b006b Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 20:57:48 +0200
Subject: [PATCH 5/7] moved the ++ to the other side

---
 SimpleECS/QueryForeachFunctions.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/SimpleECS/QueryForeachFunctions.cs b/SimpleECS/QueryForeachFunctions.cs
index dbd3278..baf7b64 100644
--- a/SimpleECS/QueryForeachFunctions.cs
+++ b/SimpleECS/QueryForeachFunctions.cs
@@ -793,7 +793,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9>>> For
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;
@@ -817,7 +817,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10>>
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;
@@ -841,7 +841,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10,
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;
@@ -865,7 +865,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10,
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;

From d0f6a499138ef2ce8afd64cf3af64efec9280d2e Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 21:00:43 +0200
Subject: [PATCH 6/7] moved ++ to the other side

---
 SimpleECS/QueryForeachFunctions.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/SimpleECS/QueryForeachFunctions.cs b/SimpleECS/QueryForeachFunctions.cs
index 72fb202..f090c75 100644
--- a/SimpleECS/QueryForeachFunctions.cs
+++ b/SimpleECS/QueryForeachFunctions.cs
@@ -3481,7 +3481,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9>>> For
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;
@@ -3505,7 +3505,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10>>
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;
@@ -3529,7 +3529,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10,
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;
@@ -3553,7 +3553,7 @@ public IEnumerable<Tuple<Entity, C1, C2, C3, C4, C5, Tuple<C6, C7, C8, C9, C10,
             if (Update(out var world_info))
             {
                 world_info.StructureEvents.EnqueueEvents++;
-                for (int archetype_index = 0; archetype_index < archetype_count; archetype_index++)
+                for (int archetype_index = 0; archetype_index < archetype_count; ++archetype_index)
                 {
                     var archetype = world_info.archetypes[matching_archetypes[archetype_index]].data;
                     int count = archetype.entity_count;

From ce3173cadb595edb3b14f51a92b795a5dd6bb94c Mon Sep 17 00:00:00 2001
From: Marcus Cazzola <marcus.cazzola@gmail.com>
Date: Wed, 13 Sep 2023 21:07:21 +0200
Subject: [PATCH 7/7] updated README to be correct

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index c96563b..86a2161 100644
--- a/README.md
+++ b/README.md
@@ -158,17 +158,17 @@ query.Foreach( (Entity entity, ref int value ) =>         // you can access the
 
 foreach ((Entity entity, int value) in query.Foreach<int>()) // foreach makes so you can use continue and break
 {
-    if (aa.x > 0)
+    if (value > 0)
     {
         continue;
     }
 
-    if (bb.x > 0)
+    if (value < 0)
     {
         break;
     }
 
-    Console.WriteLine($"value x is {aa.x} value y is {aa.y}");
+    Console.WriteLine($"{entity} value is {value}"); 
 }
 
 // having more then 5 components makes so you have to put double parenthesis.