mirror of
https://github.com/Ukendio/jecs.git
synced 2025-04-24 17:10:03 +00:00
2061 lines
45 KiB
Text
2061 lines
45 KiB
Text
local jecs = require("@jecs")
|
|
|
|
local testkit = require("@testkit")
|
|
local BENCH, START = testkit.benchmark()
|
|
local __ = jecs.Wildcard
|
|
local ECS_ID, ECS_GENERATION = jecs.ECS_ID, jecs.ECS_GENERATION
|
|
local ECS_GENERATION_INC = jecs.ECS_GENERATION_INC
|
|
local IS_PAIR = jecs.IS_PAIR
|
|
local pair = jecs.pair
|
|
local ecs_pair_first = jecs.pair_first
|
|
local ecs_pair_second = jecs.pair_second
|
|
local entity_index_try_get_any = jecs.entity_index_try_get_any
|
|
local entity_index_get_alive = jecs.entity_index_get_alive
|
|
local entity_index_is_alive = jecs.entity_index_is_alive
|
|
local ChildOf = jecs.ChildOf
|
|
local world_new = jecs.World.new
|
|
|
|
local it = testkit.test()
|
|
local TEST, CASE = it.TEST, it.CASE
|
|
local CHECK, FINISH = it.CHECK, it.FINISH
|
|
local SKIP, FOCUS = it.SKIP, it.FOCUS
|
|
local CHECK_EXPECT_ERR = it.CHECK_EXPECT_ERR
|
|
|
|
local N = 2 ^ 8
|
|
|
|
type World = jecs.World
|
|
type Entity<T=nil> = jecs.Entity<T>
|
|
|
|
local c = {
|
|
white_underline = function(s: any)
|
|
return `\27[1;4m{s}\27[0m`
|
|
end,
|
|
|
|
white = function(s: any)
|
|
return `\27[37;1m{s}\27[0m`
|
|
end,
|
|
|
|
green = function(s: any)
|
|
return `\27[32;1m{s}\27[0m`
|
|
end,
|
|
|
|
red = function(s: any)
|
|
return `\27[31;1m{s}\27[0m`
|
|
end,
|
|
|
|
yellow = function(s: any)
|
|
return `\27[33;1m{s}\27[0m`
|
|
end,
|
|
|
|
red_highlight = function(s: any)
|
|
return `\27[41;1;30m{s}\27[0m`
|
|
end,
|
|
|
|
green_highlight = function(s: any)
|
|
return `\27[42;1;30m{s}\27[0m`
|
|
end,
|
|
|
|
gray = function(s: any)
|
|
return `\27[30;1m{s}\27[0m`
|
|
end,
|
|
}
|
|
|
|
local function pe(e)
|
|
local gen = ECS_GENERATION(e)
|
|
return c.green(`e{ECS_ID(e)}`)..c.yellow(`v{gen}`)
|
|
end
|
|
|
|
local function pp(e)
|
|
local gen = ECS_GENERATION(e)
|
|
return c.green(`e{ECS_ID(e)}`)..c.yellow(`v{jecs.ECS_ENTITY_T_HI(e)}`)
|
|
end
|
|
|
|
local function debug_world_inspect(world: World)
|
|
local function record(e): jecs.Record
|
|
return entity_index_try_get_any(world.entity_index, e) :: any
|
|
end
|
|
local function tbl(e)
|
|
return record(e).archetype
|
|
end
|
|
local function archetype(e)
|
|
return tbl(e).type
|
|
end
|
|
local function records(e)
|
|
return tbl(e).records
|
|
end
|
|
local function columns(e)
|
|
return tbl(e).columns
|
|
end
|
|
local function row(e)
|
|
return record(e).row
|
|
end
|
|
|
|
-- Important to order them in the order of their columns
|
|
local function tuple(e, ...)
|
|
for i, column in columns(e) do
|
|
if select(i, ...) ~= column[row(e)] then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
return {
|
|
record = record,
|
|
tbl = tbl,
|
|
archetype = archetype,
|
|
records = records,
|
|
row = row,
|
|
tuple = tuple,
|
|
columns = columns
|
|
}
|
|
end
|
|
|
|
local dwi = debug_world_inspect
|
|
|
|
local function name(world, e)
|
|
return world:get(e, jecs.Name)
|
|
end
|
|
|
|
|
|
local function worldReset(world)
|
|
local entity_index = world.entity_index
|
|
for i = jecs.Rest, entity_index.max_id do
|
|
local entity = entity_index.dense_array[i]
|
|
world:delete(entity)
|
|
end
|
|
for i = jecs.Rest, entity_index.max_id do
|
|
local sparse = entity_index.dense_array[i]
|
|
entity_index.sparse_array[sparse] = nil
|
|
entity_index.dense_array[i] = nil
|
|
end
|
|
entity_index.alive_count = jecs.Rest
|
|
entity_index.max_id = jecs.Rest
|
|
end
|
|
|
|
local lifetime_tracker_add = require("@tools/lifetime_tracker")
|
|
TEST("the great reset", function()
|
|
local world = world_new()
|
|
lifetime_tracker_add(world, {padding_enabled=false})
|
|
local A = world:component()
|
|
local B = world:component()
|
|
|
|
for i = 1, 10 do
|
|
local e = world:entity()
|
|
world:set(e, A, true)
|
|
world:set(e, B, true)
|
|
end
|
|
world:print_entity_index()
|
|
worldReset(world)
|
|
CHECK(world:contains(A))
|
|
CHECK(world:contains(B))
|
|
world:print_entity_index()
|
|
end)
|
|
|
|
TEST("#repro3", function()
|
|
local world = world_new()
|
|
local Model = world:component()
|
|
local ModelBase = world:component()
|
|
|
|
local systems = {}
|
|
|
|
local function progress()
|
|
for _, system in systems do
|
|
system()
|
|
end
|
|
end
|
|
|
|
local newQuery = nil
|
|
local oldQuery = nil
|
|
|
|
local function modelBase()
|
|
if not newQuery then
|
|
newQuery = world:query(Model):without(ModelBase):cached()
|
|
end
|
|
if not oldQuery then
|
|
oldQuery = world:query(ModelBase):without(Model):cached()
|
|
end
|
|
for e, model in newQuery do
|
|
world:set(e, ModelBase, { "part base" })
|
|
end
|
|
for e, model in oldQuery do
|
|
world:remove(e, ModelBase)
|
|
end
|
|
end
|
|
|
|
table.insert(systems, modelBase)
|
|
|
|
do CASE("should add the correct ModelBase for parts")
|
|
local e = world:entity()
|
|
world:set(e, Model, { instance = "Model" })
|
|
progress()
|
|
CHECK(world:get(e, ModelBase)[1] == "part base" )
|
|
end
|
|
|
|
do CASE("should add the correct ModelBase for parts")
|
|
local e = world:entity()
|
|
world:set(e, Model, { instance = "Model "})
|
|
progress()
|
|
CHECK(world:get(e, ModelBase)[1] == "part base")
|
|
end
|
|
|
|
|
|
|
|
do CASE("")
|
|
local e = world:entity()
|
|
world:set(e, Model, { instance = "Model "})
|
|
progress()
|
|
CHECK(world:get(e, ModelBase)[1] == "part base")
|
|
world:remove(e, Model)
|
|
progress()
|
|
CHECK(world:get(e, ModelBase) == nil)
|
|
|
|
|
|
end
|
|
end)
|
|
|
|
TEST("#adding a recycled target", function()
|
|
local world = world_new()
|
|
local R = world:component()
|
|
|
|
local e = world:entity()
|
|
local T = world:entity()
|
|
world:add(e, pair(R, T))
|
|
world:delete(T)
|
|
CHECK(not world:has(e, pair(R, T)))
|
|
local T2 = world:entity()
|
|
world:add(e, pair(R, T2))
|
|
CHECK(world:target(e, R) ~= T)
|
|
CHECK(world:target(e, R) ~= 0)
|
|
|
|
end)
|
|
|
|
local entity_visualizer = require("@tools/entity_visualiser")
|
|
|
|
TEST("#repro2", function()
|
|
local world = world_new()
|
|
local Lifetime = world:component() :: jecs.Id<number>
|
|
local Particle = world:entity()
|
|
local Beam = world:entity()
|
|
|
|
local entity = world:entity()
|
|
world:set(entity, pair(Lifetime, Particle), 1)
|
|
world:set(entity, pair(Lifetime, Beam), 2)
|
|
world:set(entity, pair(4, 5), 6) -- noise
|
|
|
|
-- entity_visualizer.components(world, entity)
|
|
|
|
for e in world:each(pair(Lifetime, __)) do
|
|
local i = 0
|
|
local nth = world:target(e, Lifetime, i)
|
|
while nth do
|
|
-- entity_visualizer.components(world, e)
|
|
|
|
local data = world:get(e, pair(Lifetime, nth))
|
|
data -= 1
|
|
if data <= 0 then
|
|
world:remove(e, pair(Lifetime, nth))
|
|
else
|
|
world:set(e, pair(Lifetime, nth), data)
|
|
end
|
|
i += 1
|
|
nth = world:target(e, Lifetime, i)
|
|
end
|
|
end
|
|
|
|
CHECK(not world:has(entity, pair(Lifetime, Particle)))
|
|
CHECK(world:get(entity, pair(Lifetime, Beam)) == 1)
|
|
end)
|
|
|
|
local lifetime_tracker_add = require("@tools/lifetime_tracker")
|
|
|
|
TEST("another", function()
|
|
local world = world_new()
|
|
-- world = lifetime_tracker_add(world, {padding_enabled=false})
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
local e3 = world:entity()
|
|
world:delete(e2)
|
|
local e2_e3 = pair(e2, e3)
|
|
CHECK(jecs.pair_first(world, e2_e3) == 0)
|
|
CHECK(jecs.pair_second(world, e2_e3) == e3)
|
|
CHECK_EXPECT_ERR(function()
|
|
world:add(e1, pair(e2, e3))
|
|
end)
|
|
end)
|
|
|
|
TEST("#repro", function()
|
|
local world = world_new()
|
|
|
|
local function getTargets(relation)
|
|
local tgts = {}
|
|
local pairwildcard = pair(relation, jecs.Wildcard)
|
|
for _, archetype in world:query(pairwildcard):archetypes() do
|
|
local tr = archetype.records[pairwildcard]
|
|
local count = archetype.counts[pairwildcard]
|
|
local types = archetype.types
|
|
for _, entity in archetype.entities do
|
|
for i = 0, count - 1 do
|
|
local tgt = jecs.pair_second(world, types[i + tr])
|
|
table.insert(tgts, tgt)
|
|
end
|
|
end
|
|
end
|
|
return tgts
|
|
end
|
|
|
|
local Attacks = world:component()
|
|
local Eats = world:component()
|
|
|
|
local function setAttacksAndEats(entity1, entity2)
|
|
world:add(entity1, pair(Attacks, entity2))
|
|
world:add(entity1, pair(Eats, entity2))
|
|
end
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
local e3 = world:entity()
|
|
setAttacksAndEats(e3, e1)
|
|
setAttacksAndEats(e3, e2)
|
|
setAttacksAndEats(e1, e2)
|
|
local d = dwi(world)
|
|
world:delete(e2)
|
|
local types1 = { pair(Attacks, e1), pair(Eats, e1) }
|
|
table.sort(types1)
|
|
|
|
|
|
CHECK(d.tbl(e1).type == "")
|
|
CHECK(d.tbl(e3).type == table.concat(types1, "_"))
|
|
|
|
for _, entity in getTargets(Attacks) do
|
|
CHECK(entity == e1)
|
|
end
|
|
for _, entity in getTargets(Eats) do
|
|
CHECK(entity == e1)
|
|
end
|
|
end)
|
|
|
|
TEST("archetype", function()
|
|
local archetype_traverse_add = jecs.archetype_traverse_add
|
|
local archetype_traverse_remove = jecs.archetype_traverse_remove
|
|
|
|
local world = world_new()
|
|
local root = world.ROOT_ARCHETYPE
|
|
local c1 = world:component()
|
|
local c2 = world:component()
|
|
local c3 = world:component()
|
|
|
|
local a1 = archetype_traverse_add(world, c1, nil :: any)
|
|
local a2 = archetype_traverse_remove(world, c1, a1)
|
|
-- CHECK(root.add[c1].to == a1)
|
|
CHECK(root == a2)
|
|
end)
|
|
|
|
TEST("world:cleanup()", function()
|
|
local world = world_new()
|
|
local A = world:component() :: jecs.Id<boolean>
|
|
local B = world:component() :: jecs.Id<boolean>
|
|
local C = world:component() :: jecs.Id<boolean>
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
local e3 = world:entity()
|
|
|
|
world:set(e1, A, true)
|
|
|
|
world:set(e2, A, true)
|
|
world:set(e2, B, true)
|
|
|
|
|
|
world:set(e3, A, true)
|
|
world:set(e3, B, true)
|
|
world:set(e3, C, true)
|
|
|
|
local archetype_index = world.archetype_index
|
|
|
|
CHECK(#archetype_index["1"].entities == 1)
|
|
CHECK(#archetype_index["1_2"].entities == 1)
|
|
CHECK(#archetype_index["1_2_3"].entities == 1)
|
|
|
|
world:delete(e1)
|
|
world:delete(e2)
|
|
world:delete(e3)
|
|
|
|
world:cleanup()
|
|
|
|
archetype_index = world.archetype_index
|
|
|
|
CHECK((archetype_index["1"] :: jecs.Archetype?) == nil)
|
|
CHECK((archetype_index["1_2"] :: jecs.Archetype?) == nil)
|
|
CHECK((archetype_index["1_2_3"] :: jecs.Archetype?) == nil)
|
|
|
|
local e4 = world:entity()
|
|
world:set(e4, A, true)
|
|
CHECK(#archetype_index["1"].entities == 1)
|
|
CHECK((archetype_index["1_2"] :: jecs.Archetype?) == nil)
|
|
CHECK((archetype_index["1_2_3"] :: jecs.Archetype?) == nil)
|
|
world:set(e4, B, true)
|
|
CHECK(#archetype_index["1"].entities == 0)
|
|
CHECK(#archetype_index["1_2"].entities == 1)
|
|
CHECK((archetype_index["1_2_3"] :: jecs.Archetype?) == nil)
|
|
world:set(e4, C, true)
|
|
CHECK(#archetype_index["1"].entities == 0)
|
|
CHECK(#archetype_index["1_2"].entities == 0)
|
|
CHECK(#archetype_index["1_2_3"].entities == 1)
|
|
end)
|
|
|
|
local pe = require("@tools/entity_visualiser").prettify
|
|
local lifetime_tracker_add = require("@tools/lifetime_tracker")
|
|
|
|
TEST("world:entity()", function()
|
|
do
|
|
CASE("unique IDs")
|
|
local world = jecs.World.new()
|
|
local set = {}
|
|
for i = 1, N do
|
|
local e = world:entity()
|
|
CHECK(not set[e])
|
|
set[e] = true
|
|
end
|
|
end
|
|
do
|
|
CASE("generations")
|
|
local world = jecs.World.new()
|
|
local e = world:entity() :: number
|
|
CHECK(ECS_ID(e) == 1 + jecs.Rest :: number)
|
|
CHECK(ECS_GENERATION(e) == 0) -- 0
|
|
e = ECS_GENERATION_INC(e)
|
|
CHECK(ECS_GENERATION(e) == 1) -- 1
|
|
end
|
|
|
|
do CASE "pairs"
|
|
local world = jecs.World.new()
|
|
local _e = world:entity()
|
|
local e2 = world:entity()
|
|
local e3 = world:entity()
|
|
|
|
-- Incomplete pair, must have a bit flag that notes it is a pair
|
|
CHECK(IS_PAIR(world:entity()) == false)
|
|
|
|
local p = pair(e2, e3)
|
|
CHECK(IS_PAIR(p) == true)
|
|
|
|
CHECK(ecs_pair_first(world, p) == e2 :: number)
|
|
CHECK(ecs_pair_second(world, p) == e3 :: number)
|
|
|
|
world:delete(e2)
|
|
local e2v2 = world:entity()
|
|
CHECK(IS_PAIR(e2v2) == false)
|
|
|
|
CHECK(IS_PAIR(pair(e2v2, e3)) == true)
|
|
end
|
|
|
|
do CASE "Recycling"
|
|
local world = world_new()
|
|
local e = world:entity()
|
|
world:delete(e)
|
|
local e1 = world:entity()
|
|
world:delete(e1)
|
|
local e2 = world:entity()
|
|
CHECK(ECS_ID(e2) == e :: number)
|
|
CHECK(ECS_GENERATION(e2) == 2)
|
|
CHECK(world:contains(e2))
|
|
CHECK(not world:contains(e1))
|
|
CHECK(not world:contains(e))
|
|
end
|
|
|
|
do CASE "Recycling max generation"
|
|
local world = world_new()
|
|
local pin = (jecs.Rest :: any) :: number + 1
|
|
for i = 1, 2^16-1 do
|
|
local e = world:entity()
|
|
world:delete(e)
|
|
end
|
|
local e = world:entity()
|
|
CHECK(ECS_ID(e) == pin)
|
|
CHECK(ECS_GENERATION(e) == 2^16-1)
|
|
world:delete(e)
|
|
e = world:entity()
|
|
CHECK(ECS_ID(e) == pin)
|
|
CHECK(ECS_GENERATION(e) == 0)
|
|
end
|
|
end)
|
|
|
|
TEST("world:set()", function()
|
|
do CASE "archetype move"
|
|
do
|
|
local world = jecs.World.new()
|
|
|
|
local d = debug_world_inspect(world)
|
|
|
|
local _1 = world:component()
|
|
local _2 = world:component()
|
|
local e = world:entity()
|
|
-- An entity starts without an archetype or row
|
|
-- should therefore not need to copy over data
|
|
CHECK(d.tbl(e) == nil)
|
|
CHECK(d.row(e) == nil)
|
|
|
|
local archetypes = #world.archetypes
|
|
-- This should create a new archetype since it is the first
|
|
-- entity to have moved there
|
|
world:set(e, _1, 1)
|
|
local oldRow = d.row(e)
|
|
local oldArchetype = d.archetype(e)
|
|
CHECK(#world.archetypes == archetypes + 1)
|
|
CHECK(oldArchetype == "1")
|
|
CHECK(d.tbl(e))
|
|
CHECK(oldRow == 1)
|
|
|
|
world:set(e, _2, 2)
|
|
CHECK(d.archetype(e) == "1_2")
|
|
-- Should have tuple of fields to the next archetype and set the component data
|
|
CHECK(d.tuple(e, 1, 2))
|
|
-- Should have moved the data from the old archetype
|
|
CHECK(world.archetype_index[oldArchetype].columns[_1][oldRow] == nil)
|
|
end
|
|
end
|
|
|
|
do CASE "pairs"
|
|
local world = jecs.World.new()
|
|
|
|
local C1 = world:component()
|
|
local C2 = world:component()
|
|
local T1 = world:entity()
|
|
local T2 = world:entity()
|
|
|
|
local e = world:entity()
|
|
|
|
world:set(e, pair(C1, C2), true)
|
|
world:set(e, pair(C1, T1), true)
|
|
world:set(e, pair(T1, C1), true)
|
|
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(e, pair(T1, T2), true :: any)
|
|
end)
|
|
|
|
CHECK(world:get(e, pair(C1, C2)))
|
|
CHECK(world:get(e, pair(C1, T1)))
|
|
CHECK(world:get(e, pair(T1, C1)))
|
|
CHECK(not world:get(e, pair(T1, T2)))
|
|
|
|
local e2 = world:entity()
|
|
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(e2, pair(jecs.ChildOf, e), true :: any)
|
|
end)
|
|
CHECK(not world:get(e2, pair(jecs.ChildOf, e)))
|
|
end
|
|
end)
|
|
|
|
TEST("world:remove()", function()
|
|
do
|
|
CASE("should allow remove a component that doesn't exist on entity")
|
|
local world = jecs.World.new()
|
|
|
|
local Health = world:component()
|
|
local Poison = world:component()
|
|
|
|
local id = world:entity()
|
|
do
|
|
world:remove(id, Poison)
|
|
CHECK(true) -- Didn't error
|
|
end
|
|
|
|
world:set(id, Health, 50)
|
|
world:remove(id, Poison)
|
|
|
|
CHECK(world:get(id, Poison) == nil)
|
|
CHECK(world:get(id, Health) == 50)
|
|
end
|
|
end)
|
|
|
|
TEST("world:add()", function()
|
|
do
|
|
CASE("idempotent")
|
|
local world = jecs.World.new()
|
|
local d = debug_world_inspect(world)
|
|
local _1, _2 = world:component(), world:component()
|
|
|
|
local e = world:entity()
|
|
world:add(e, _1)
|
|
world:add(e, _2)
|
|
|
|
print("----idempotent")
|
|
print(d.archetype(e))
|
|
world:add(e, _2) -- should have 0 effects
|
|
CHECK(d.archetype(e) == "1_2")
|
|
print(d.archetype(e))
|
|
end
|
|
|
|
do
|
|
CASE("archetype move")
|
|
do
|
|
local world = jecs.World.new()
|
|
|
|
local d = debug_world_inspect(world)
|
|
|
|
local _1 = world:component()
|
|
local e = world:entity()
|
|
-- An entity starts without an archetype or row
|
|
-- should therefore not need to copy over data
|
|
CHECK(d.tbl(e) == nil)
|
|
CHECK(d.row(e) == nil)
|
|
|
|
local archetypes = #world.archetypes
|
|
-- This should create a new archetype
|
|
world:add(e, _1)
|
|
CHECK(#world.archetypes == archetypes + 1)
|
|
|
|
CHECK(d.archetype(e) == "1")
|
|
CHECK(d.tbl(e))
|
|
end
|
|
end
|
|
end)
|
|
|
|
TEST("world:query()", function()
|
|
do CASE "cached"
|
|
local world = world_new()
|
|
local Foo = world:component()
|
|
local Bar = world:component()
|
|
local Baz = world:component()
|
|
local e = world:entity()
|
|
local q = world:query(Foo, Bar):without(Baz):cached()
|
|
world:set(e, Foo, true)
|
|
world:set(e, Bar, false)
|
|
local i = 0
|
|
|
|
local iter = 0
|
|
for _, e in q:iter() do
|
|
iter += 1
|
|
i=1
|
|
end
|
|
CHECK (iter == 1)
|
|
CHECK(i == 1)
|
|
for _, e in q:iter() do
|
|
i=2
|
|
end
|
|
CHECK(i == 2)
|
|
for _, e in q :: any do
|
|
i=3
|
|
end
|
|
CHECK(i == 3)
|
|
for _, e in q :: any do
|
|
i=4
|
|
end
|
|
CHECK(i == 4)
|
|
|
|
CHECK(#q:archetypes() == 1)
|
|
CHECK(not table.find(q:archetypes(), world.archetype_index[table.concat({Foo, Bar, Baz}, "_")]))
|
|
world:delete(Foo)
|
|
CHECK(#q:archetypes() == 0)
|
|
end
|
|
do CASE "multiple iter"
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local e = world:entity()
|
|
world:add(e, A)
|
|
world:add(e, B)
|
|
local q = world:query(A, B)
|
|
local counter = 0
|
|
for x in q:iter() do
|
|
counter += 1
|
|
end
|
|
for x in q:iter() do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 2)
|
|
end
|
|
do CASE "tag"
|
|
local world = jecs.World.new()
|
|
local A = world:entity()
|
|
local e = world:entity()
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(e, A, "test" :: any)
|
|
end)
|
|
local count = 0
|
|
for id, a in world:query(A) :: any do
|
|
count += 1
|
|
CHECK(a == nil)
|
|
end
|
|
CHECK(count == 1)
|
|
end
|
|
do CASE "pairs"
|
|
local world = jecs.World.new()
|
|
|
|
local C1 = world:component() :: jecs.Id<boolean>
|
|
local C2 = world:component() :: jecs.Id<boolean>
|
|
local T1 = world:entity()
|
|
local T2 = world:entity()
|
|
|
|
local e = world:entity()
|
|
|
|
local C1_C2 = pair(C1, C2)
|
|
world:set(e, C1_C2, true)
|
|
world:set(e, pair(C1, T1), true)
|
|
world:set(e, pair(T1, C1), true)
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(e, pair(T1, T2), true :: any)
|
|
end)
|
|
|
|
for id, a, b, c, d in world:query(pair(C1, C2), pair(C1, T1), pair(T1, C1), pair(T1, T2)):iter() do
|
|
CHECK(a == true)
|
|
CHECK(b == true)
|
|
CHECK(c == true)
|
|
CHECK(d == nil)
|
|
end
|
|
end
|
|
do
|
|
CASE("query single component")
|
|
do
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
|
|
local entities = {}
|
|
for i = 1, N do
|
|
local id = world:entity()
|
|
|
|
world:set(id, A, true)
|
|
if i > 5 then
|
|
world:set(id, B, true)
|
|
end
|
|
entities[i] = id
|
|
end
|
|
|
|
for id in world:query(A) :: any do
|
|
table.remove(entities, CHECK(table.find(entities, id)))
|
|
end
|
|
|
|
CHECK(#entities == 0)
|
|
end
|
|
|
|
do
|
|
local world = jecs.World.new() :: World
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local eA = world:entity()
|
|
world:set(eA, A, true)
|
|
local eB = world:entity()
|
|
world:set(eB, B, true)
|
|
local eAB = world:entity()
|
|
world:set(eAB, A, true)
|
|
world:set(eAB, B, true)
|
|
|
|
-- Should drain the iterator
|
|
local q = world:query(A)
|
|
|
|
local i = 0
|
|
local j = 0
|
|
for _ in q :: any do
|
|
i += 1
|
|
end
|
|
for _ in q :: any do
|
|
j += 1
|
|
end
|
|
CHECK(i == 2)
|
|
CHECK(j == 0)
|
|
end
|
|
end
|
|
|
|
do
|
|
CASE("query missing component")
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
|
|
world:set(e1, A, "abc")
|
|
world:set(e2, A, "def")
|
|
world:set(e1, B, 123)
|
|
world:set(e2, B, 457)
|
|
|
|
local counter = 0
|
|
for _ in world:query(B, C) :: any do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 0)
|
|
end
|
|
|
|
do
|
|
CASE("query more than 8 components")
|
|
local world = jecs.World.new()
|
|
local components = {}
|
|
|
|
for i = 1, 9 do
|
|
local id = world:component()
|
|
components[i] = id
|
|
end
|
|
local e = world:entity()
|
|
for i, id in components do
|
|
world:set(e, id, 13 ^ i)
|
|
end
|
|
|
|
for entity, a, b, c, d, e, f, g, h, i in world:query(unpack(components)) :: any do
|
|
CHECK(a == 13 ^ 1)
|
|
CHECK(b == 13 ^ 2)
|
|
CHECK(c == 13 ^ 3)
|
|
CHECK(d == 13 ^ 4)
|
|
CHECK(e == 13 ^ 5)
|
|
CHECK(f == 13 ^ 6)
|
|
CHECK(g == 13 ^ 7)
|
|
CHECK(h == 13 ^ 8)
|
|
CHECK(i == 13 ^ 9)
|
|
end
|
|
end
|
|
|
|
do
|
|
CASE("should be able to get next results")
|
|
local world = jecs.World.new() :: World
|
|
world:component()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local eA = world:entity()
|
|
world:set(eA, A, true)
|
|
local eB = world:entity()
|
|
world:set(eB, B, true)
|
|
local eAB = world:entity()
|
|
world:set(eAB, A, true)
|
|
world:set(eAB, B, true)
|
|
|
|
local it = world:query(A):iter()
|
|
|
|
local e: number, data = it()
|
|
while e do
|
|
if e == eA :: number then
|
|
CHECK(data)
|
|
elseif e == eAB :: number then
|
|
CHECK(data)
|
|
else
|
|
CHECK(false)
|
|
end
|
|
|
|
e, data = it()
|
|
end
|
|
CHECK(true)
|
|
end
|
|
|
|
do CASE "should query all matching entities when irrelevant component is removed"
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
|
|
local entities = {}
|
|
for i = 1, N do
|
|
local id = world:entity()
|
|
|
|
-- specifically put them in disorder to track regression
|
|
-- https://github.com/Ukendio/jecs/pull/15
|
|
world:set(id, B, true)
|
|
world:set(id, A, true)
|
|
if i > 5 then
|
|
world:remove(id, B)
|
|
end
|
|
entities[i] = id
|
|
end
|
|
|
|
local added = 0
|
|
for id in world:query(A) :: any do
|
|
added += 1
|
|
table.remove(entities, CHECK(table.find(entities, id)))
|
|
end
|
|
|
|
CHECK(added == N)
|
|
end
|
|
|
|
do
|
|
CASE("should query all entities without B")
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
|
|
local entities = {}
|
|
for i = 1, N do
|
|
local id = world:entity()
|
|
|
|
world:set(id, A, true)
|
|
if i < 5 then
|
|
entities[i] = id
|
|
else
|
|
world:set(id, B, true)
|
|
end
|
|
end
|
|
|
|
for id in world:query(A):without(B) :: any do
|
|
table.remove(entities, CHECK(table.find(entities, id)))
|
|
end
|
|
|
|
CHECK(#entities == 0)
|
|
end
|
|
|
|
do
|
|
CASE("should allow querying for relations")
|
|
local world = jecs.World.new()
|
|
local Eats = world:component()
|
|
local Apples = world:component()
|
|
local bob = world:entity()
|
|
|
|
world:set(bob, pair(Eats, Apples), true)
|
|
for e, bool in world:query(pair(Eats, Apples)) :: any do
|
|
CHECK(e == bob)
|
|
CHECK(bool)
|
|
end
|
|
end
|
|
|
|
do
|
|
CASE("should allow wildcards in queries")
|
|
local world = jecs.World.new()
|
|
local Eats = world:component()
|
|
local Apples = world:entity()
|
|
local bob = world:entity()
|
|
|
|
world:set(bob, pair(Eats, Apples), "bob eats apples")
|
|
|
|
local w = jecs.Wildcard
|
|
for e, data in world:query(pair(Eats, w)) :: any do
|
|
CHECK(e == bob)
|
|
CHECK(data == "bob eats apples")
|
|
end
|
|
for e, data in world:query(pair(w, Apples)) :: any do
|
|
CHECK(e == bob)
|
|
CHECK(data == "bob eats apples")
|
|
end
|
|
end
|
|
|
|
do
|
|
CASE("should match against multiple pairs")
|
|
local world = jecs.World.new()
|
|
local Eats = world:component()
|
|
local Apples = world:entity()
|
|
local Oranges = world:entity()
|
|
local bob = world:entity()
|
|
local alice = world:entity()
|
|
|
|
world:set(bob, pair(Eats, Apples), "bob eats apples")
|
|
world:set(alice, pair(Eats, Oranges), "alice eats oranges")
|
|
|
|
local w = jecs.Wildcard
|
|
local count = 0
|
|
for e, data in world:query(pair(Eats, w)) :: any do
|
|
count += 1
|
|
if e == bob then
|
|
CHECK(data == "bob eats apples")
|
|
else
|
|
CHECK(data == "alice eats oranges")
|
|
end
|
|
end
|
|
|
|
CHECK(count == 2)
|
|
count = 0
|
|
|
|
for e, data in world:query(pair(w, Apples)) :: any do
|
|
count += 1
|
|
CHECK(data == "bob eats apples")
|
|
end
|
|
CHECK(count == 1)
|
|
end
|
|
|
|
do CASE "should only relate alive entities"
|
|
local world = jecs.World.new()
|
|
local Eats = world:entity()
|
|
local Apples = world:component()
|
|
local Oranges = world:component()
|
|
local bob = world:entity()
|
|
local alice = world:entity()
|
|
|
|
world:set(bob, Apples, "apples")
|
|
world:set(bob, pair(Eats, Apples), "bob eats apples")
|
|
world:set(alice, pair(Eats, Oranges) :: Entity<string>, "alice eats oranges")
|
|
|
|
world:delete(Apples)
|
|
local Wildcard = jecs.Wildcard
|
|
|
|
local count = 0
|
|
for _, data in world:query(pair(Wildcard, Apples)) :: any do
|
|
count += 1
|
|
end
|
|
|
|
world:delete(pair(Eats, Apples))
|
|
|
|
CHECK(count == 0)
|
|
CHECK(world:get(bob, pair(Eats, Apples)) == nil)
|
|
|
|
end
|
|
|
|
do
|
|
CASE("should error when setting invalid pair")
|
|
local world = jecs.World.new()
|
|
local Eats = world:component()
|
|
local Apples = world:component()
|
|
local bob = world:entity()
|
|
|
|
world:delete(Apples)
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(bob, pair(Eats, Apples), "bob eats apples")
|
|
end)
|
|
end
|
|
|
|
do
|
|
CASE("should find target for ChildOf")
|
|
local world = jecs.World.new()
|
|
local ChildOf = jecs.ChildOf
|
|
|
|
local Name = world:component()
|
|
|
|
local bob = world:entity()
|
|
local alice = world:entity()
|
|
local sara = world:entity()
|
|
|
|
world:add(bob, pair(ChildOf, alice))
|
|
world:set(bob, Name, "bob")
|
|
world:add(sara, pair(ChildOf, alice))
|
|
world:set(sara, Name, "sara")
|
|
CHECK(world:parent(bob) :: number == alice :: number) -- O(1)
|
|
|
|
local count = 0
|
|
for _, name in world:query(Name, pair(ChildOf, alice)) :: any do
|
|
count += 1
|
|
end
|
|
CHECK(count == 2)
|
|
end
|
|
|
|
do
|
|
CASE("despawning while iterating")
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
world:add(e1, A)
|
|
world:add(e2, A)
|
|
world:add(e2, B)
|
|
|
|
local count = 0
|
|
for id in world:query(A) :: any do
|
|
world:clear(id)
|
|
count += 1
|
|
end
|
|
CHECK(count == 2)
|
|
end
|
|
|
|
do CASE("iterator invalidation")
|
|
do CASE("adding")
|
|
SKIP()
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
world:add(e1, A)
|
|
world:add(e2, A)
|
|
world:add(e2, B)
|
|
|
|
local count = 0
|
|
for id in world:query(A) :: any do
|
|
world:add(id, B)
|
|
|
|
count += 1
|
|
end
|
|
|
|
CHECK(count == 2)
|
|
end
|
|
|
|
do CASE("spawning")
|
|
local world = jecs.World.new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
world:add(e1, A)
|
|
world:add(e2, A)
|
|
world:add(e2, B)
|
|
|
|
for id in world:query(A) :: any do
|
|
local e = world:entity()
|
|
world:add(e, A)
|
|
world:add(e, B)
|
|
end
|
|
|
|
CHECK(true)
|
|
end
|
|
end
|
|
|
|
do CASE("should not find any entities")
|
|
local world = jecs.World.new()
|
|
|
|
local Hello = world:component()
|
|
local Bob = world:component()
|
|
|
|
local helloBob = world:entity()
|
|
world:add(helloBob, pair(Hello, Bob))
|
|
world:add(helloBob, Bob)
|
|
|
|
local withoutCount = 0
|
|
for _ in world:query(pair(Hello, Bob)):without(Bob) :: any do
|
|
withoutCount += 1
|
|
end
|
|
|
|
CHECK(withoutCount == 0)
|
|
end
|
|
|
|
do CASE("without")
|
|
-- REGRESSION TEST
|
|
local world = jecs.World.new()
|
|
local _1, _2, _3 = world:component(), world:component(), world:component()
|
|
|
|
local counter = 0
|
|
for e, a, b in world:query(_1, _2):without(_3) :: any do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 0)
|
|
end
|
|
end)
|
|
|
|
TEST("world:each", function()
|
|
local world = world_new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
|
|
local e3 = world:entity()
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
|
|
world:set(e1, A, true)
|
|
|
|
world:set(e2, A, true)
|
|
world:set(e2, B, true)
|
|
|
|
world:set(e3, A, true)
|
|
world:set(e3, B, true)
|
|
world:set(e3, C, true)
|
|
|
|
for entity: number in world:each(A) do
|
|
if entity == e1 :: number or entity == e2 :: number or entity == e3 :: number then
|
|
CHECK(true)
|
|
continue
|
|
end
|
|
CHECK(false)
|
|
end
|
|
end)
|
|
|
|
TEST("world:children", function()
|
|
local world = world_new()
|
|
local C = world:component()
|
|
local T = world:entity()
|
|
|
|
local e1 = world:entity()
|
|
world:set(e1, C, true)
|
|
|
|
local e2 = world:entity() :: number
|
|
|
|
world:add(e2, T)
|
|
world:add(e2, pair(ChildOf, e1))
|
|
|
|
local e3 = world:entity() :: number
|
|
world:add(e3, pair(ChildOf, e1))
|
|
|
|
local count = 0
|
|
for entity: number in world:children(e1) do
|
|
count += 1
|
|
if entity == e2 or entity == e3 then
|
|
CHECK(true)
|
|
continue
|
|
end
|
|
CHECK(false)
|
|
end
|
|
CHECK(count == 2)
|
|
|
|
world:remove(e2, pair(ChildOf, e1))
|
|
|
|
count = 0
|
|
for entity in world:children(e1) do
|
|
count += 1
|
|
end
|
|
|
|
CHECK(count == 1)
|
|
end)
|
|
|
|
TEST("world:clear()", function()
|
|
do CASE("should remove its components")
|
|
local world = jecs.World.new() :: World
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
local D = world:component()
|
|
|
|
local e = world:entity()
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
|
|
world:set(e, A, true)
|
|
world:set(e, B, true)
|
|
|
|
world:set(e1, A, true)
|
|
world:set(e1, B, true)
|
|
|
|
CHECK(world:get(e, A))
|
|
CHECK(world:get(e, B))
|
|
|
|
world:clear(A)
|
|
CHECK(world:get(e, A) == nil)
|
|
CHECK(world:get(e, B))
|
|
CHECK(world:get(e1, A) == nil)
|
|
CHECK(world:get(e1, B))
|
|
end
|
|
|
|
do CASE("remove cleared ID from entities")
|
|
local world = world_new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
|
|
do
|
|
local id1 = world:entity()
|
|
local id2 = world:entity()
|
|
local id3 = world:entity()
|
|
|
|
world:set(id1, A, true)
|
|
|
|
world:set(id2, A, true)
|
|
world:set(id2, B, true)
|
|
|
|
world:set(id3, A, true)
|
|
world:set(id3, B, true)
|
|
world:set(id3, C, true)
|
|
|
|
world:clear(A)
|
|
|
|
CHECK(not world:has(id1, A))
|
|
CHECK(not world:has(id2, A))
|
|
CHECK(not world:has(id3, A))
|
|
|
|
CHECK(world:has(id2, B))
|
|
CHECK(world:has(id3, B, C))
|
|
|
|
world:clear(C)
|
|
|
|
CHECK(world:has(id2, B))
|
|
CHECK(world:has(id3, B))
|
|
|
|
CHECK(world:contains(A))
|
|
CHECK(world:contains(C))
|
|
CHECK(world:has(A, jecs.Component))
|
|
CHECK(world:has(B, jecs.Component))
|
|
end
|
|
|
|
do
|
|
local id1 = world:entity()
|
|
local id2 = world:entity()
|
|
local id3 = world:entity()
|
|
|
|
local tgt = world:entity()
|
|
|
|
world:add(id1, pair(A, tgt))
|
|
world:add(id1, pair(B, tgt))
|
|
world:add(id1, pair(C, tgt))
|
|
|
|
world:add(id2, pair(A, tgt))
|
|
world:add(id2, pair(B, tgt))
|
|
world:add(id2, pair(C, tgt))
|
|
|
|
world:add(id3, pair(A, tgt))
|
|
world:add(id3, pair(B, tgt))
|
|
world:add(id3, pair(C, tgt))
|
|
|
|
world:clear(B)
|
|
CHECK(world:has(id1, pair(A, tgt), pair(C, tgt)))
|
|
CHECK(not world:has(id1, pair(B, tgt)))
|
|
CHECK(world:has(id2, pair(A, tgt), pair(C, tgt)))
|
|
CHECK(not world:has(id1, pair(B, tgt)))
|
|
CHECK(world:has(id3, pair(A, tgt), pair(C, tgt)))
|
|
|
|
end
|
|
|
|
end
|
|
end)
|
|
|
|
TEST("world:has()", function()
|
|
do CASE("should find Tag on entity")
|
|
local world = jecs.World.new()
|
|
|
|
local Tag = world:entity()
|
|
|
|
local e = world:entity()
|
|
world:add(e, Tag)
|
|
|
|
CHECK(world:has(e, Tag))
|
|
end
|
|
|
|
do CASE("should return false when missing one tag")
|
|
local world = jecs.World.new()
|
|
|
|
local A = world:entity()
|
|
local B = world:entity()
|
|
local C = world:entity()
|
|
local D = world:entity()
|
|
|
|
local e = world:entity()
|
|
world:add(e, A)
|
|
world:add(e, C)
|
|
world:add(e, D)
|
|
|
|
CHECK(world:has(e, A, B, C, D) == false)
|
|
end
|
|
end)
|
|
|
|
TEST("world:component()", function()
|
|
do CASE("only components should have EcsComponent trait")
|
|
local world = jecs.World.new() :: World
|
|
local A = world:component()
|
|
local e = world:entity()
|
|
|
|
CHECK(world:has(A, jecs.Component))
|
|
CHECK(not world:has(e, jecs.Component))
|
|
end
|
|
|
|
do CASE("tag")
|
|
local world = jecs.World.new() :: World
|
|
local A = world:component()
|
|
local B = world:entity()
|
|
local C = world:entity()
|
|
local e = world:entity()
|
|
world:set(e, A, "test")
|
|
world:add(e, B)
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(e, C, 11 :: any)
|
|
end)
|
|
|
|
CHECK(world:has(e, A))
|
|
CHECK(world:get(e, A) == "test")
|
|
CHECK(world:get(e, B) == nil)
|
|
CHECK(world:get(e, C) == nil)
|
|
end
|
|
end)
|
|
|
|
TEST("world:delete", function()
|
|
do CASE "invoke OnRemove hooks"
|
|
local world = world_new()
|
|
|
|
local e1 = world:entity()
|
|
local e2 = world:entity()
|
|
|
|
local Stable = world:component()
|
|
world:set(Stable, jecs.OnRemove, function(e)
|
|
CHECK(e == e1)
|
|
end)
|
|
|
|
world:set(e1, Stable, true)
|
|
world:set(e2, Stable, true)
|
|
|
|
world:delete(e1)
|
|
end
|
|
do CASE "delete recycled entity id used as component"
|
|
local world = world_new()
|
|
local id = world:entity()
|
|
world:add(id, jecs.Component)
|
|
|
|
local e = world:entity()
|
|
world:set(e, id, 1)
|
|
CHECK(world:get(e, id) == 1)
|
|
world:delete(id)
|
|
local recycled = world:entity()
|
|
world:add(recycled, jecs.Component)
|
|
world:set(e, recycled, 1)
|
|
CHECK(world:has(recycled, jecs.Component))
|
|
CHECK(world:get(e, recycled) == 1)
|
|
end
|
|
do
|
|
CASE("bug: Empty entity does not respect cleanup policy")
|
|
local world = world_new()
|
|
local parent = world:entity()
|
|
local tag = world:entity()
|
|
|
|
local child = world:entity()
|
|
world:add(child, jecs.pair(jecs.ChildOf, parent))
|
|
world:delete(parent)
|
|
|
|
CHECK(not world:contains(parent))
|
|
CHECK(not world:contains(child))
|
|
|
|
local entity = world:entity()
|
|
world:add(entity, tag)
|
|
world:delete(tag)
|
|
CHECK(world:contains(entity))
|
|
CHECK(not world:contains(tag))
|
|
CHECK(not world:has(entity, tag)) -- => true
|
|
end
|
|
do CASE("should allow deleting components")
|
|
local world = jecs.World.new()
|
|
|
|
local Health = world:component()
|
|
local Poison = world:component()
|
|
|
|
local id = world:entity()
|
|
world:set(id, Poison, 5)
|
|
world:set(id, Health, 50)
|
|
local id1 = world:entity()
|
|
world:set(id1, Poison, 500)
|
|
world:set(id1, Health, 50)
|
|
|
|
world:delete(id)
|
|
CHECK(not world:contains(id))
|
|
CHECK(world:get(id, Poison) == nil)
|
|
CHECK(world:get(id, Health) == nil)
|
|
|
|
CHECK(world:get(id1, Poison) == 500)
|
|
CHECK(world:get(id1, Health) == 50)
|
|
end
|
|
|
|
do CASE("delete entities using another Entity as component with Delete cleanup action")
|
|
local world = jecs.World.new()
|
|
|
|
local Health = world:entity()
|
|
world:add(Health, pair(jecs.OnDelete, jecs.Delete))
|
|
local Poison = world:component()
|
|
|
|
local id = world:entity()
|
|
world:set(id, Poison, 5)
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(id, Health, 50 :: any)
|
|
end)
|
|
local id1 = world:entity()
|
|
world:set(id1, Poison, 500)
|
|
CHECK_EXPECT_ERR(function()
|
|
world:set(id1, Health, 50 :: any)
|
|
end)
|
|
|
|
CHECK(world:has(id, Poison, Health))
|
|
CHECK(world:has(id1, Poison, Health))
|
|
world:delete(Poison)
|
|
|
|
CHECK(world:contains(id))
|
|
CHECK(not world:has(id, Poison))
|
|
CHECK(not world:has(id1, Poison))
|
|
|
|
world:delete(Health)
|
|
CHECK(not world:contains(id))
|
|
CHECK(not world:contains(id1))
|
|
CHECK(not world:has(id, Health))
|
|
CHECK(not world:has(id1, Health))
|
|
end
|
|
|
|
|
|
do CASE("delete children")
|
|
local world = jecs.World.new()
|
|
|
|
local Health = world:component()
|
|
local Poison = world:component()
|
|
local FriendsWith = world:component()
|
|
|
|
local e = world:entity()
|
|
world:set(e, Poison, 5)
|
|
world:set(e, Health, 50)
|
|
|
|
local children = {}
|
|
for i = 1, 10 do
|
|
local child = world:entity()
|
|
world:set(child, Poison, 9999)
|
|
world:set(child, Health, 100)
|
|
world:add(child, pair(jecs.ChildOf, e))
|
|
table.insert(children, child)
|
|
end
|
|
|
|
BENCH("delete children of entity", function()
|
|
world:delete(e)
|
|
end)
|
|
|
|
for i, child in children do
|
|
CHECK(not world:contains(child))
|
|
CHECK(not world:has(child, pair(jecs.ChildOf, e)))
|
|
CHECK(not world:has(child, Health))
|
|
end
|
|
|
|
e = world:entity()
|
|
|
|
local friends = {}
|
|
for i = 1, 10 do
|
|
local friend = world:entity()
|
|
world:set(friend, Poison, 9999)
|
|
world:set(friend, Health, 100)
|
|
world:add(friend, pair(FriendsWith, e))
|
|
table.insert(friends, friend)
|
|
end
|
|
|
|
BENCH("remove friends of entity", function()
|
|
world:delete(e)
|
|
end)
|
|
|
|
local d = debug_world_inspect(world)
|
|
for i, friend in friends do
|
|
CHECK(not world:has(friend, pair(FriendsWith, e)))
|
|
CHECK(world:has(friend, Health))
|
|
CHECK(world:contains(friend))
|
|
end
|
|
end
|
|
|
|
do CASE("remove deleted ID from entities")
|
|
local world = world_new()
|
|
do
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
local id1 = world:entity()
|
|
local id2 = world:entity()
|
|
local id3 = world:entity()
|
|
|
|
world:set(id1, A, true)
|
|
|
|
world:set(id2, A, true)
|
|
world:set(id2, B, true)
|
|
|
|
world:set(id3, A, true)
|
|
world:set(id3, B, true)
|
|
world:set(id3, C, true)
|
|
|
|
world:delete(A)
|
|
|
|
CHECK(not world:has(id1, A))
|
|
CHECK(not world:has(id2, A))
|
|
CHECK(not world:has(id3, A))
|
|
|
|
CHECK(world:has(id2, B))
|
|
CHECK(world:has(id3, B, C))
|
|
|
|
world:delete(C)
|
|
|
|
CHECK(world:has(id2, B))
|
|
CHECK(world:has(id3, B))
|
|
|
|
CHECK(not world:contains(A))
|
|
CHECK(not world:contains(C))
|
|
end
|
|
|
|
do
|
|
local A = world:component()
|
|
world:add(A, pair(jecs.OnDeleteTarget, jecs.Delete))
|
|
local B = world:component()
|
|
local C = world:component()
|
|
world:add(C, pair(jecs.OnDeleteTarget, jecs.Delete))
|
|
|
|
local id1 = world:entity()
|
|
local id2 = world:entity()
|
|
local id3 = world:entity()
|
|
|
|
world:set(id1, C, true)
|
|
|
|
world:set(id2, pair(A, id1), true)
|
|
world:set(id2, B, true)
|
|
|
|
world:set(id3, B, true)
|
|
world:set(id3, pair(C, id2), true)
|
|
|
|
world:delete(id1)
|
|
|
|
CHECK(not world:contains(id1))
|
|
CHECK(not world:contains(id2))
|
|
CHECK(not world:contains(id3))
|
|
end
|
|
|
|
|
|
do
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
local id1 = world:entity()
|
|
local id2 = world:entity()
|
|
local id3 = world:entity()
|
|
|
|
|
|
world:set(id2, A, true)
|
|
world:set(id2, pair(B, id1), true)
|
|
|
|
world:set(id3, A, true)
|
|
world:set(id3, pair(B, id1), true)
|
|
world:set(id3, C, true)
|
|
|
|
world:delete(id1)
|
|
|
|
CHECK(not world:contains(id1))
|
|
CHECK(world:contains(id2))
|
|
CHECK(world:contains(id3))
|
|
|
|
CHECK(world:has(id2, A))
|
|
CHECK(world:has(id3, A, C))
|
|
|
|
CHECK(not world:target(id2, B))
|
|
CHECK(not world:target(id3, B))
|
|
end
|
|
end
|
|
|
|
do
|
|
CASE("fast delete")
|
|
local world = jecs.World.new()
|
|
|
|
local entities = {}
|
|
local Health = world:component()
|
|
local Poison = world:component()
|
|
|
|
for i = 1, 100 do
|
|
local child = world:entity()
|
|
world:set(child, Poison, 9999)
|
|
world:set(child, Health, 100)
|
|
table.insert(entities, child)
|
|
end
|
|
|
|
BENCH("simple deletion of entity", function()
|
|
for i = 1, START(100) do
|
|
local e = entities[i]
|
|
world:delete(e)
|
|
end
|
|
end)
|
|
|
|
for _, entity in entities do
|
|
CHECK(not world:contains(entity))
|
|
end
|
|
end
|
|
|
|
do
|
|
CASE("cycle")
|
|
local world = jecs.World.new()
|
|
local Likes = world:component()
|
|
world:add(Likes, pair(jecs.OnDeleteTarget, jecs.Delete))
|
|
local bob = world:entity()
|
|
local alice = world:entity()
|
|
|
|
world:add(bob, pair(Likes, alice))
|
|
world:add(alice, pair(Likes, bob))
|
|
|
|
world:delete(bob)
|
|
CHECK(not world:contains(bob))
|
|
CHECK(not world:contains(alice))
|
|
end
|
|
end)
|
|
|
|
TEST("world:target", function()
|
|
do CASE("nth index")
|
|
local world = world_new()
|
|
local A = world:component()
|
|
world:set(A, jecs.Name, "A")
|
|
local B = world:component()
|
|
world:set(B, jecs.Name, "B")
|
|
local C = world:component()
|
|
world:set(C, jecs.Name, "C")
|
|
local D = world:component()
|
|
world:set(D, jecs.Name, "D")
|
|
local E = world:component()
|
|
world:set(E, jecs.Name, "E")
|
|
local e = world:entity()
|
|
|
|
world:add(e, pair(A, B))
|
|
world:add(e, pair(A, C))
|
|
world:add(e, pair(A, D))
|
|
world:add(e, pair(A, E))
|
|
world:add(e, pair(B, C))
|
|
world:add(e, pair(B, D))
|
|
world:add(e, pair(C, D))
|
|
|
|
CHECK(pair(A, B) < pair(A, C))
|
|
CHECK(pair(A, C) < pair(A, D))
|
|
CHECK(pair(C, A) < pair(C, D))
|
|
|
|
local records = debug_world_inspect(world).records(e)
|
|
CHECK(jecs.pair_first(world, pair(B, C)) == B)
|
|
local r = jecs.entity_index_try_get(world.entity_index, e)
|
|
local archetype = r.archetype
|
|
local counts = archetype.counts
|
|
CHECK(counts[pair(A, __)] == 4)
|
|
CHECK(records[pair(B, C)] > records[pair(A, E)])
|
|
CHECK(world:target(e, A, 0) == B)
|
|
CHECK(world:target(e, A, 1) == C)
|
|
CHECK(world:target(e, A, 2) == D)
|
|
CHECK(world:target(e, A, 3) == E)
|
|
CHECK(world:target(e, B, 0) == C)
|
|
CHECK(world:target(e, B, 1) == D)
|
|
CHECK(world:target(e, C, 0) == D)
|
|
CHECK(world:target(e, C, 1) == nil)
|
|
|
|
CHECK(archetype.records[pair(A, B)] == 1)
|
|
CHECK(archetype.records[pair(A, C)] == 2)
|
|
CHECK(archetype.records[pair(A, D)] == 3)
|
|
CHECK(archetype.records[pair(A, E)] == 4)
|
|
|
|
CHECK(world:target(e, C, 0) == D)
|
|
CHECK(world:target(e, C, 1) == nil)
|
|
end
|
|
|
|
do
|
|
CASE("infer index when unspecified")
|
|
local world = world_new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local C = world:component()
|
|
local D = world:component()
|
|
local e = world:entity()
|
|
|
|
world:add(e, pair(A, B))
|
|
world:add(e, pair(A, C))
|
|
world:add(e, pair(B, C))
|
|
world:add(e, pair(B, D))
|
|
world:add(e, pair(C, D))
|
|
|
|
CHECK(world:target(e, A) == world:target(e, A, 0))
|
|
CHECK(world:target(e, B) == world:target(e, B, 0))
|
|
CHECK(world:target(e, C) == world:target(e, C, 0))
|
|
end
|
|
|
|
do
|
|
CASE("loop until no target")
|
|
local world = world_new()
|
|
|
|
local ROOT = world:entity()
|
|
local e1 = world:entity()
|
|
local targets = {}
|
|
|
|
for i = 1, 10 do
|
|
local target = world:entity()
|
|
targets[i] = target
|
|
world:add(e1, pair(ROOT, target))
|
|
end
|
|
|
|
local i = 0
|
|
local target = world:target(e1, ROOT, 0)
|
|
while target do
|
|
i += 1
|
|
CHECK(targets[i] == target)
|
|
target = world:target(e1, ROOT, i)
|
|
end
|
|
|
|
CHECK(i == 10)
|
|
end
|
|
end)
|
|
|
|
TEST("world:contains", function()
|
|
local world = jecs.World.new()
|
|
local id = world:entity()
|
|
CHECK(world:contains(id))
|
|
|
|
do
|
|
CASE("should not exist after delete")
|
|
world:delete(id)
|
|
CHECK(not world:contains(id))
|
|
end
|
|
end)
|
|
|
|
TEST("Hooks", function()
|
|
do CASE "OnAdd"
|
|
local world = jecs.World.new()
|
|
local Transform = world:component()
|
|
local e1 = world:entity()
|
|
world:set(Transform, jecs.OnAdd, function(entity)
|
|
CHECK(e1 == entity)
|
|
end)
|
|
world:add(e1, Transform)
|
|
end
|
|
|
|
do CASE "OnSet"
|
|
local world = jecs.World.new()
|
|
local Number = world:component()
|
|
local e1 = world:entity()
|
|
|
|
local call = 0
|
|
world:set(Number, jecs.OnChange, function(entity, data)
|
|
CHECK(e1 == entity)
|
|
if call == 1 then
|
|
CHECK(false)
|
|
elseif call == 2 then
|
|
CHECK(world:get(entity, Number) == data)
|
|
end
|
|
CHECK(data == 1)
|
|
end)
|
|
|
|
call = 1
|
|
world:set(e1, Number, 1)
|
|
call = 2
|
|
world:set(e1, Number, 1)
|
|
end
|
|
|
|
do CASE("OnRemove")
|
|
do
|
|
-- basic
|
|
local world = jecs.World.new()
|
|
local A = world:component() :: Entity<boolean>
|
|
local e1 = world:entity()
|
|
world:set(A, jecs.OnRemove, function(entity)
|
|
CHECK(e1 == entity)
|
|
CHECK(world:has(e1, A))
|
|
end)
|
|
world:add(e1, A)
|
|
|
|
world:remove(e1, A)
|
|
CHECK(not world:has(e1, A))
|
|
end
|
|
do
|
|
-- [BUG] https://github.com/Ukendio/jecs/issues/118
|
|
local world = world_new()
|
|
local A = world:component()
|
|
local B = world:component()
|
|
local e = world:entity()
|
|
|
|
world:set(A, jecs.OnRemove, function(entity)
|
|
world:set(entity, B, true)
|
|
CHECK(world:get(entity, A))
|
|
CHECK(world:get(entity, B))
|
|
end)
|
|
|
|
world:set(e, A, true)
|
|
world:remove(e, A)
|
|
CHECK(not world:get(e, A))
|
|
CHECK(world:get(e, B))
|
|
end
|
|
end
|
|
end)
|
|
|
|
TEST("change tracking", function()
|
|
do CASE "#1"
|
|
local world = world_new()
|
|
local Foo = world:component() :: Entity<number>
|
|
local Previous = jecs.Rest
|
|
|
|
local q1 = world
|
|
:query(Foo)
|
|
:without(pair(Previous, Foo))
|
|
:cached()
|
|
|
|
local e1 = world:entity()
|
|
world:set(e1, Foo, 1)
|
|
local e2 = world:entity()
|
|
world:set(e2, Foo, 2)
|
|
|
|
local i = 0
|
|
for e, new in q1 :: any do
|
|
i += 1
|
|
world:set(e, pair(Previous, Foo), new)
|
|
end
|
|
|
|
CHECK(i == 2)
|
|
local j = 0
|
|
for e, new in q1 :: any do
|
|
j += 1
|
|
world:set(e, pair(Previous, Foo), new)
|
|
end
|
|
|
|
CHECK(j == 0)
|
|
end
|
|
|
|
do CASE "#2"
|
|
local world = world_new()
|
|
local component = world:component() :: Entity<number>
|
|
local tag = world:entity()
|
|
local previous = jecs.Rest
|
|
|
|
local q1 = world:query(component):without(pair(previous, component), tag):cached()
|
|
|
|
local testEntity = world:entity()
|
|
|
|
world:set(testEntity, component, 10)
|
|
|
|
local i = 0
|
|
for entity, number in q1 :: any do
|
|
i += 1
|
|
world:add(testEntity, tag)
|
|
end
|
|
|
|
CHECK(i == 1)
|
|
|
|
for e, n in q1 :: any do
|
|
world:set(e, pair(previous, component), n)
|
|
end
|
|
end
|
|
|
|
end)
|
|
|
|
TEST("repro", function()
|
|
do CASE "#1"
|
|
local world = world_new()
|
|
local reproEntity = world:component()
|
|
local components = { Cooldown = world:component() :: jecs.Entity<number> }
|
|
world:set(reproEntity, components.Cooldown, 2)
|
|
|
|
local function updateCooldowns(dt: number)
|
|
local toRemove = {}
|
|
|
|
local it = world:query(components.Cooldown):iter()
|
|
for id, cooldown in it do
|
|
cooldown -= dt
|
|
|
|
if cooldown <= 0 then
|
|
table.insert(toRemove, id)
|
|
-- world:remove(id, components.Cooldown)
|
|
else
|
|
world:set(id, components.Cooldown, cooldown)
|
|
end
|
|
end
|
|
|
|
for _, id in toRemove do
|
|
world:remove(id, components.Cooldown)
|
|
CHECK(not world:get(id, components.Cooldown))
|
|
end
|
|
end
|
|
|
|
updateCooldowns(1.5)
|
|
updateCooldowns(1.5)
|
|
end
|
|
|
|
do CASE "#2" -- ISSUE #171
|
|
local world = world_new()
|
|
local component1 = world:component()
|
|
local tag1 = world:entity()
|
|
|
|
local query = world:query(component1):with(tag1):cached()
|
|
|
|
local entity = world:entity()
|
|
world:set(entity, component1, "some data")
|
|
|
|
local counter = 0
|
|
for x in query:iter() do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 0)
|
|
end
|
|
end)
|
|
|
|
TEST("wildcard query", function()
|
|
do CASE "#1"
|
|
local world = world_new()
|
|
local pair = jecs.pair
|
|
|
|
local Relation = world:entity()
|
|
local Wildcard = jecs.Wildcard
|
|
local A = world:entity()
|
|
|
|
local relationship = pair(Relation, Wildcard)
|
|
local query = world:query(relationship):cached()
|
|
|
|
local entity = world:entity()
|
|
|
|
local p = pair(Relation, A)
|
|
CHECK(jecs.pair_first(world, p) == Relation)
|
|
CHECK(jecs.pair_second(world, p) == A)
|
|
local w = dwi(world)
|
|
world:add(entity, pair(Relation, A))
|
|
|
|
local counter = 0
|
|
for e in query:iter() do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 1)
|
|
end
|
|
do CASE "#2"
|
|
local world = world_new()
|
|
local pair = jecs.pair
|
|
|
|
local Relation = world:entity()
|
|
local Wildcard = jecs.Wildcard
|
|
local A = world:entity()
|
|
|
|
local relationship = pair(Relation, Wildcard)
|
|
|
|
local entity = world:entity()
|
|
|
|
world:add(entity, pair(Relation, A))
|
|
|
|
local counter = 0
|
|
for e in world:query(relationship):iter() do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 1)
|
|
end
|
|
do CASE "#3"
|
|
local world = world_new()
|
|
local pair = jecs.pair
|
|
|
|
local Relation = world:entity()
|
|
local Wildcard = jecs.Wildcard
|
|
local A = world:entity()
|
|
|
|
local entity = world:entity()
|
|
|
|
world:add(entity, pair(Relation, A))
|
|
|
|
local relationship = pair(Relation, Wildcard)
|
|
local query = world:query(relationship):cached()
|
|
|
|
local counter = 0
|
|
for e in query:iter() do
|
|
counter += 1
|
|
end
|
|
CHECK(counter == 1)
|
|
end
|
|
end)
|
|
|
|
TEST("world:delete() invokes OnRemove hook", function()
|
|
do CASE "#1"
|
|
local world = world_new()
|
|
|
|
local A = world:entity()
|
|
local entity = world:entity()
|
|
|
|
local called = false
|
|
world:set(A, jecs.OnRemove, function(e)
|
|
called = true
|
|
end)
|
|
|
|
world:add(entity, A)
|
|
world:delete(entity)
|
|
|
|
CHECK(called)
|
|
end
|
|
do CASE "#2"
|
|
local world = world_new()
|
|
local pair = jecs.pair
|
|
|
|
local Relation = world:entity()
|
|
local A = world:entity()
|
|
local B = world:entity()
|
|
|
|
world:add(Relation, pair(jecs.OnDelete, jecs.Delete))
|
|
|
|
local entity = world:entity()
|
|
|
|
local called = false
|
|
world:set(A, jecs.OnRemove, function(e)
|
|
called = true
|
|
end)
|
|
|
|
world:add(entity, A)
|
|
world:add(entity, pair(Relation, B))
|
|
|
|
world:delete(B)
|
|
|
|
CHECK(called)
|
|
end
|
|
do CASE "#3"
|
|
local world = world_new()
|
|
local pair = jecs.pair
|
|
|
|
local viewingContainer = world:entity()
|
|
local character = world:entity()
|
|
local container = world:entity()
|
|
|
|
local called = false
|
|
world:set(viewingContainer, jecs.OnRemove, function(e)
|
|
called = true
|
|
end)
|
|
|
|
world:add(character, pair(viewingContainer, container))
|
|
|
|
world:delete(container)
|
|
|
|
CHECK(called)
|
|
end
|
|
end)
|
|
FINISH()
|