Merge pull request #5 from BlackMATov/dev

Dev

README.md

@@ -115,49 +115,37 @@ debug_mode :: boolean -> ()
 collect_garbage :: ()
 ```
 
-## Builders
+## Builder
 
 ```
-entity :: entity_builder
-entity_builder:set :: fragment, component -> entity_builder
-entity_builder:build :: entity
-```
-
-```
-fragment :: fragment_builder
-fragment_builder:tag :: fragment_builder
-fragment_builder:name :: string -> fragment_builder
-fragment_builder:single :: component -> fragment_builder
-fragment_builder:default :: component -> fragment_builder
-fragment_builder:duplicate :: {component -> component} -> fragment_builder
-fragment_builder:on_set :: {entity, fragment, component, component?} -> fragment_builder
-fragment_builder:on_assign :: {entity, fragment, component, component} -> fragment_builder
-fragment_builder:on_insert :: {entity, fragment, component} -> fragment_builder
-fragment_builder:on_remove :: {entity, fragment} -> fragment_builder
-fragment_builder:destroy_policy :: id -> fragment_builder
-fragment_builder:build :: fragment
-```
-
-```
-query :: query_builder
-query_builder:name :: string -> query_builder
-query_builder:single :: component -> query_builder
-query_builder:include :: fragment... -> query_builder
-query_builder:exclude :: fragment... -> query_builder
-query_builder:build :: query
-```
-
-```
-system :: system_builder
-system_builder:name :: string -> system_builder
-system_builder:single :: component -> system_builder
-system_builder:group :: system -> system_builder
-system_builder:query :: query -> system_builder
-system_builder:execute :: {chunk, entity[], integer} -> system_builder
-system_builder:prologue :: {} -> system_builder
-system_builder:epilogue :: {} -> system_builder
-system_builder:disabled :: system_builder
-system_builder:build :: system
+builder :: builder
+builder:has :: fragment -> boolean
+builder:has_all :: fragment... -> boolean
+builder:has_any :: fragment... -> boolean
+builder:get :: fragment... -> component...
+builder:set :: fragment, component -> builder
+builder:remove :: fragment... -> builder
+builder:clear :: builder
+builder:tag :: builder
+builder:name :: string -> builder
+builder:prefab :: entity -> builder
+builder:single :: component -> builder
+builder:default :: component -> builder
+builder:duplicate :: {component -> component} -> builder
+builder:include :: fragment... -> builder
+builder:exclude :: fragment... -> builder
+builder:on_set :: {entity, fragment, component, component?} -> builder
+builder:on_assign :: {entity, fragment, component, component} -> builder
+builder:on_insert :: {entity, fragment, component} -> builder
+builder:on_remove :: {entity, fragment} -> builder
+builder:group :: system -> builder
+builder:query :: query -> builder
+builder:execute :: {chunk, entity[], integer} -> builder
+builder:prologue :: {} -> builder
+builder:epilogue :: {} -> builder
+builder:disabled :: builder
+builder:destroy_policy :: id -> builder
+builder:build :: boolean -> entity
 ```
 
 ## [License (MIT)](./LICENSE.md)

ROADMAP.md

@@ -3,6 +3,7 @@
 ## Backlog
 
 - builders should be rewritten :/
+- add PREFAB entity trait
 - is/has_all/any for lists?
 
 ## After first release

develop/example.lua

@@ -2,6 +2,8 @@
 
 local evo = require 'evolved'
 
+evo.debug_mode(true)
+
 ---@class evolved.vector2
 ---@field x number
 ---@field y number
@@ -16,41 +18,41 @@ local function vector2(x, y)
 end
 
 local groups = {
-    awake = evo.system():build(),
-    physics = evo.system():build(),
-    graphics = evo.system():build(),
-    shutdown = evo.system():build(),
+    awake = evo.builder():build(),
+    physics = evo.builder():build(),
+    graphics = evo.builder():build(),
+    shutdown = evo.builder():build(),
 }
 
 local singles = {
-    delta_time = evo.fragment():single(0.016):build(),
-    physics_gravity = evo.fragment():single(vector2(0, 9.81)):build(),
+    delta_time = evo.builder():single(0.016):build(),
+    physics_gravity = evo.builder():single(vector2(0, 9.81)):build(),
 }
 
 local fragments = {
-    force = evo.fragment():build(),
-    position = evo.fragment():build(),
-    velocity = evo.fragment():build(),
+    force = evo.builder():build(),
+    position = evo.builder():build(),
+    velocity = evo.builder():build(),
 }
 
 local queries = {
-    physics_bodies = evo.query()
+    physics_bodies = evo.builder()
         :include(fragments.force, fragments.position, fragments.velocity)
         :build(),
 }
 
-local awake_system = evo.system()
+local awake_system = evo.builder()
     :group(groups.awake)
     :prologue(function()
         print '-= | Awake | =-'
-        evo.entity()
+        evo.builder()
             :set(fragments.force, vector2(0, 0))
             :set(fragments.position, vector2(0, 0))
             :set(fragments.velocity, vector2(0, 0))
             :build()
     end):build()
 
-local integrate_forces_system = evo.system()
+local integrate_forces_system = evo.builder()
     :group(groups.physics)
     :query(queries.physics_bodies)
     :execute(function(chunk, entities, entity_count)
@@ -71,7 +73,7 @@ local integrate_forces_system = evo.system()
         end
     end):build()
 
-local integrate_velocities_system = evo.system()
+local integrate_velocities_system = evo.builder()
     :group(groups.physics)
     :query(queries.physics_bodies)
     :execute(function(chunk, entities, entity_count)
@@ -94,7 +96,7 @@ local integrate_velocities_system = evo.system()
         end
     end):build()
 
-local graphics_system = evo.system()
+local graphics_system = evo.builder()
     :group(groups.graphics)
     :query(queries.physics_bodies)
     :execute(function(chunk, entities, entity_count)
@@ -111,7 +113,7 @@ local graphics_system = evo.system()
         end
     end):build()
 
-local shutdown_system = evo.system()
+local shutdown_system = evo.builder()
     :group(groups.shutdown)
     :epilogue(function()
         print '-= | Shutdown | =-'

develop/fuzzing/batch_destroy_fuzz.lua

@@ -81,7 +81,7 @@ end
 
 do
     local r = math.random(1, 2)
-    local q = evo.query():include(__table_unpack(destroying_include_list)):build()
+    local q = evo.builder():include(__table_unpack(destroying_include_list)):build()
 
     if r == 1 then
         evo.batch_destroy(q)
@@ -98,7 +98,7 @@ end
 ---
 ---
 
-local all_chunk_query = evo.query():build()
+local all_chunk_query = evo.builder():build()
 
 for chunk in evo.execute(all_chunk_query) do
     assert(not evo.has_any(chunk, __table_unpack(should_be_destroyed_entity_list)))

develop/fuzzing/destroy_fuzz.lua

@@ -102,7 +102,7 @@ end
 ---
 ---
 
-local all_chunk_query = evo.query():build()
+local all_chunk_query = evo.builder():build()
 
 for chunk in evo.execute(all_chunk_query) do
     assert(not evo.has_any(chunk, __table_unpack(destroying_entity_list)))

develop/unbench.lua

@@ -4,9 +4,9 @@ basics.unload 'evolved'
 local evo = require 'evolved'
 
 local N = 1000
-local B = evo.entity()
+local B = evo.builder()
 local F1, F2, F3, F4, F5 = evo.id(5)
-local Q1 = evo.query():include(F1):build()
+local Q1 = evo.builder():include(F1):build()
 
 print '----------------------------------------'
 

develop/usbench.lua

@@ -54,11 +54,11 @@ basics.describe_bench(string.format('Evolved Entity Cycle (Defer): %d entities',
         local a, b = evo.id(2)
 
         for i = 1, N do
-            evo.entity():set(a, i):build()
+            evo.builder():set(a, i):build()
         end
 
-        local A = evo.query():include(a):build()
-        local B = evo.query():include(b):build()
+        local A = evo.builder():include(a):build()
+        local B = evo.builder():include(b):build()
 
         return a, b, A, B
     end, function(_, _, A, _)
@@ -86,11 +86,11 @@ basics.describe_bench(string.format('Evolved Entity Cycle (Manual): %d entities'
         local a, b = evo.id(2)
 
         for i = 1, N do
-            evo.entity():set(a, i):build()
+            evo.builder():set(a, i):build()
         end
 
-        local A = evo.query():include(a):build()
-        local B = evo.query():include(b):build()
+        local A = evo.builder():include(a):build()
+        local B = evo.builder():include(b):build()
 
         return a, b, A, B
     end, function(_, _, A, _)
@@ -167,15 +167,15 @@ basics.describe_bench(string.format('Evolved Simple Iteration: %d entities', N),
         local a, b, c, d, e = evo.id(5)
 
         for i = 1, N do
-            evo.entity():set(a, i):set(b, i):build()
-            evo.entity():set(a, i):set(b, i):set(c, i):build()
-            evo.entity():set(a, i):set(b, i):set(c, i):set(d, i):build()
-            evo.entity():set(a, i):set(b, i):set(c, i):set(e, i):build()
+            evo.builder():set(a, i):set(b, i):build()
+            evo.builder():set(a, i):set(b, i):set(c, i):build()
+            evo.builder():set(a, i):set(b, i):set(c, i):set(d, i):build()
+            evo.builder():set(a, i):set(b, i):set(c, i):set(e, i):build()
         end
 
-        local AB = evo.query():include(a, b):build()
-        local CD = evo.query():include(c, d):build()
-        local CE = evo.query():include(c, e):build()
+        local AB = evo.builder():include(a, b):build()
+        local CD = evo.builder():include(c, d):build()
+        local CE = evo.builder():include(c, e):build()
 
         return a, b, c, d, e, AB, CD, CE
     end, function(_, _, _, _, _, AB, CD, CE)
@@ -277,14 +277,14 @@ basics.describe_bench(string.format('Evolved Packed Iteration: %d entities', N),
         local a, b, c, d, e = evo.id(5)
 
         for i = 1, N do
-            evo.entity():set(a, i):set(b, i):set(c, i):set(d, i):set(e, i):build()
+            evo.builder():set(a, i):set(b, i):set(c, i):set(d, i):set(e, i):build()
         end
 
-        local A = evo.query():include(a):build()
-        local B = evo.query():include(b):build()
-        local C = evo.query():include(c):build()
-        local D = evo.query():include(d):build()
-        local E = evo.query():include(e):build()
+        local A = evo.builder():include(a):build()
+        local B = evo.builder():include(b):build()
+        local C = evo.builder():include(c):build()
+        local D = evo.builder():include(d):build()
+        local E = evo.builder():include(e):build()
 
         return a, b, c, d, e, A, B, C, D, E
     end, function(_, _, _, _, _, A, _, _, _, _)
@@ -359,12 +359,12 @@ basics.describe_bench(string.format('Evolved Fragmented Iteration: %d entities',
 
         for _, char in ipairs(chars) do
             for i = 1, N do
-                evo.entity():set(char, i):set(data, i):build()
+                evo.builder():set(char, i):set(data, i):build()
             end
         end
 
-        local Data = evo.query():include(data):build()
-        local Last = evo.query():include(chars[#chars]):build()
+        local Data = evo.builder():include(data):build()
+        local Last = evo.builder():include(chars[#chars]):build()
 
         return data, chars[#chars], Data, Last
     end, function(_, _, Data, _)