1229 lines
27 KiB
C++
1229 lines
27 KiB
C++
#include <cpp_api.h>
|
|
|
|
typedef struct Pair {
|
|
float value;
|
|
} Pair;
|
|
|
|
void Pairs_add_component_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto entity = ecs.entity()
|
|
.add<Pair, Position>();
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert((entity.has<Pair, Position>()));
|
|
test_assert((!entity.has<Position, Pair>()));
|
|
|
|
test_str(entity.type().str().c_str(), "(Pair,Position)");
|
|
}
|
|
|
|
void Pairs_add_tag_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.component<Position>();
|
|
auto Pair = ecs.entity("Pair");
|
|
|
|
auto entity = ecs.entity()
|
|
.add_second<Position>(Pair);
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert(entity.has_second<Position>(Pair));
|
|
test_assert(!entity.has<Position>(Pair));
|
|
test_str(entity.type().str().c_str(), "(Pair,Position)");
|
|
}
|
|
|
|
void Pairs_add_tag_pair_to_tag(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Tag = ecs.entity("Tag");
|
|
auto Pair = ecs.entity("Pair");
|
|
|
|
auto entity = ecs.entity()
|
|
.add(Pair, Tag);
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert(entity.has(Pair, Tag));
|
|
test_str(entity.type().str().c_str(), "(Pair,Tag)");
|
|
}
|
|
|
|
void Pairs_remove_component_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.component<Position>();
|
|
ecs.component<Pair>();
|
|
|
|
auto entity = ecs.entity()
|
|
.add<Pair, Position>();
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert((entity.has<Pair, Position>()));
|
|
test_assert((!entity.has<Position, Pair>()));
|
|
|
|
test_str(entity.type().str().c_str(), "(Pair,Position)");
|
|
|
|
entity.remove<Position, Pair>();
|
|
test_assert(!(entity.has<Position, Pair>()));
|
|
}
|
|
|
|
void Pairs_remove_tag_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.component<Position>();
|
|
auto Pair = ecs.entity("Pair");
|
|
|
|
auto entity = ecs.entity()
|
|
.add_second<Position>(Pair);
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert(entity.has_second<Position>(Pair));
|
|
test_assert(!entity.has<Position>(Pair));
|
|
test_str(entity.type().str().c_str(), "(Pair,Position)");
|
|
|
|
entity.remove<Position>(Pair);
|
|
test_assert(!entity.has<Position>(Pair));
|
|
}
|
|
|
|
void Pairs_remove_tag_pair_to_tag(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Tag = ecs.entity("Tag");
|
|
auto Pair = ecs.entity("Pair");
|
|
|
|
auto entity = ecs.entity()
|
|
.add(Pair, Tag);
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert(entity.has(Pair, Tag));
|
|
test_str(entity.type().str().c_str(), "(Pair,Tag)");
|
|
|
|
entity.remove(Tag, Pair);
|
|
test_assert(!entity.has(Tag, Pair));
|
|
}
|
|
|
|
void Pairs_set_component_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto entity = ecs.entity()
|
|
.set<Pair, Position>({10});
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert((entity.has<Pair, Position>()));
|
|
test_assert((!entity.has<Position, Pair>()));
|
|
|
|
test_str(entity.type().str().c_str(), "(Pair,Position)");
|
|
|
|
const Pair *t = entity.get<Pair, Position>();
|
|
test_int(t->value, 10);
|
|
}
|
|
|
|
void Pairs_set_tag_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Pair = ecs.entity("Pair");
|
|
|
|
auto entity = ecs.entity()
|
|
.set_second<Position>(Pair, {10, 20});
|
|
|
|
test_assert(entity.id() != 0);
|
|
test_assert(entity.has_second<Position>(Pair));
|
|
test_str(entity.type().str().c_str(), "(Pair,Position)");
|
|
|
|
const Position *p = entity.get_second<Position>(Pair);
|
|
test_assert(p != NULL);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
}
|
|
|
|
void Pairs_system_1_pair_instance(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.entity()
|
|
.set<Pair, Position>({10});
|
|
|
|
int invoke_count = 0;
|
|
int entity_count = 0;
|
|
int trait_value = 0;
|
|
|
|
ecs.system<>()
|
|
.expr("(Pair, *)")
|
|
.iter([&](flecs::iter it) {
|
|
flecs::column<Pair> tr(it, 1);
|
|
invoke_count ++;
|
|
for (auto i : it) {
|
|
entity_count ++;
|
|
trait_value = tr[i].value;
|
|
}
|
|
});
|
|
|
|
ecs.progress();
|
|
|
|
test_int(invoke_count, 1);
|
|
test_int(entity_count, 1);
|
|
test_int(trait_value, 10);
|
|
}
|
|
|
|
void Pairs_system_2_pair_instances(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.entity()
|
|
.set<Pair, Position>({10})
|
|
.set<Pair, Velocity>({20});
|
|
|
|
int invoke_count = 0;
|
|
int entity_count = 0;
|
|
int trait_value = 0;
|
|
|
|
ecs.system<>()
|
|
.expr("(Pair, *)")
|
|
.iter([&](flecs::iter it) {
|
|
flecs::column<Pair> tr(it, 1);
|
|
invoke_count ++;
|
|
for (auto i : it) {
|
|
entity_count ++;
|
|
trait_value += tr[i].value;
|
|
}
|
|
});
|
|
|
|
ecs.progress();
|
|
|
|
test_int(invoke_count, 2);
|
|
test_int(entity_count, 2);
|
|
test_int(trait_value, 30);
|
|
}
|
|
|
|
void Pairs_override_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto base = ecs.entity()
|
|
.set<Pair, Position>({10});
|
|
|
|
auto instance = ecs.entity()
|
|
.add(flecs::IsA, base);
|
|
|
|
test_assert((instance.has<Pair, Position>()));
|
|
const Pair *t = instance.get<Pair, Position>();
|
|
test_int(t->value, 10);
|
|
|
|
const Pair *t_2 = base.get<Pair, Position>();
|
|
test_assert(t == t_2);
|
|
|
|
instance.add<Pair, Position>();
|
|
t = instance.get<Pair, Position>();
|
|
test_int(t->value, 10);
|
|
test_assert(t != t_2);
|
|
|
|
instance.remove<Pair, Position>();
|
|
t = instance.get<Pair, Position>();
|
|
test_int(t->value, 10);
|
|
test_assert(t == t_2);
|
|
}
|
|
|
|
void Pairs_override_tag_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Pair = ecs.entity();
|
|
|
|
auto base = ecs.entity()
|
|
.set_second<Position>(Pair, {10, 20});
|
|
|
|
auto instance = ecs.entity()
|
|
.add(flecs::IsA, base);
|
|
|
|
test_assert((instance.has_second<Position>(Pair)));
|
|
const Position *t = instance.get_second<Position>(Pair);
|
|
test_int(t->x, 10);
|
|
test_int(t->y, 20);
|
|
|
|
const Position *t_2 = base.get_second<Position>(Pair);
|
|
test_assert(t == t_2);
|
|
|
|
instance.add_second<Position>(Pair);
|
|
t = instance.get_second<Position>(Pair);
|
|
test_int(t->x, 10);
|
|
test_int(t->y, 20);
|
|
test_assert(t != t_2);
|
|
|
|
instance.remove_second<Position>(Pair);
|
|
t = instance.get_second<Position>(Pair);
|
|
test_int(t->x, 10);
|
|
test_int(t->y, 20);
|
|
test_assert(t == t_2);
|
|
}
|
|
|
|
void Pairs_get_mut_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity();
|
|
|
|
Pair *t = e.get_mut<Pair, Position>();
|
|
test_assert(t != NULL);
|
|
t->value = 10;
|
|
|
|
const Pair *t_2 = e.get<Pair, Position>();
|
|
test_assert(t == t_2);
|
|
test_int(t->value, 10);
|
|
}
|
|
|
|
void Pairs_get_mut_pair_existing(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set<Pair, Position>({20});
|
|
|
|
Pair *t = e.get_mut<Pair, Position>();
|
|
test_assert(t != NULL);
|
|
test_int(t->value, 20);
|
|
t->value = 10;
|
|
|
|
const Pair *t_2 = e.get<Pair, Position>();
|
|
test_assert(t == t_2);
|
|
test_int(t->value, 10);
|
|
}
|
|
|
|
void Pairs_get_mut_pair_tag(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Pair = ecs.entity();
|
|
|
|
auto e = ecs.entity();
|
|
|
|
Position *p = e.get_mut_second<Position>(Pair);
|
|
test_assert(p != NULL);
|
|
p->x = 10;
|
|
p->y = 20;
|
|
|
|
const Position *p_2 = e.get_second<Position>(Pair);
|
|
test_assert(p == p_2);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
}
|
|
|
|
void Pairs_get_mut_pair_tag_existing(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Pair = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set_second<Position>(Pair, {10, 20});
|
|
|
|
Position *p = e.get_mut_second<Position>(Pair);
|
|
test_assert(p != NULL);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
|
|
const Position *p_2 = e.get_second<Position>(Pair);
|
|
test_assert(p == p_2);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
}
|
|
|
|
void Pairs_get_mut_R_tag_O(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set<Tag, Position>({10, 20});
|
|
|
|
Position *t = e.get_mut<Tag, Position>();
|
|
test_assert(t != NULL);
|
|
test_int(t->x, 10);
|
|
test_int(t->y, 20);
|
|
t->x = 30;
|
|
t->y = 40;
|
|
|
|
const Position *t_2 = e.get<Tag, Position>();
|
|
test_assert(t == t_2);
|
|
test_int(t->x, 30);
|
|
test_int(t->y, 40);
|
|
}
|
|
|
|
void Pairs_get_relation_from_id(void) {
|
|
flecs::world ecs;
|
|
|
|
auto rel = ecs.entity();
|
|
auto obj = ecs.entity();
|
|
|
|
flecs::id pair(rel, obj);
|
|
|
|
test_assert(pair.first() == rel);
|
|
test_assert(pair.second() != rel);
|
|
|
|
test_assert(pair.first().is_alive());
|
|
test_assert(pair.first().is_valid());
|
|
}
|
|
|
|
void Pairs_get_second_from_id(void) {
|
|
flecs::world ecs;
|
|
|
|
auto rel = ecs.entity();
|
|
auto obj = ecs.entity();
|
|
|
|
flecs::id pair(rel, obj);
|
|
|
|
test_assert(pair.first() != obj);
|
|
test_assert(pair.second() == obj);
|
|
|
|
test_assert(pair.second().is_alive());
|
|
test_assert(pair.second().is_valid());
|
|
}
|
|
|
|
void Pairs_get_recycled_relation_from_id(void) {
|
|
flecs::world ecs;
|
|
|
|
auto rel = ecs.entity();
|
|
auto obj = ecs.entity();
|
|
|
|
rel.destruct();
|
|
obj.destruct();
|
|
|
|
rel = ecs.entity();
|
|
obj = ecs.entity();
|
|
|
|
// Make sure ids are recycled
|
|
test_assert((uint32_t)rel.id() != rel.id());
|
|
test_assert((uint32_t)obj.id() != obj.id());
|
|
|
|
flecs::id pair(rel, obj);
|
|
|
|
test_assert(pair.first() == rel);
|
|
test_assert(pair.second() != rel);
|
|
|
|
test_assert(pair.first().is_alive());
|
|
test_assert(pair.first().is_valid());
|
|
}
|
|
|
|
void Pairs_get_recycled_object_from_id(void) {
|
|
flecs::world ecs;
|
|
|
|
auto rel = ecs.entity();
|
|
auto obj = ecs.entity();
|
|
|
|
rel.destruct();
|
|
obj.destruct();
|
|
|
|
rel = ecs.entity();
|
|
obj = ecs.entity();
|
|
|
|
// Make sure ids are recycled
|
|
test_assert((uint32_t)rel.id() != rel.id());
|
|
test_assert((uint32_t)obj.id() != obj.id());
|
|
|
|
flecs::id pair(rel, obj);
|
|
|
|
test_assert(pair.first() == rel);
|
|
test_assert(pair.second() != rel);
|
|
|
|
test_assert(pair.second().is_alive());
|
|
test_assert(pair.second().is_valid());
|
|
}
|
|
|
|
void Pairs_get_rel_obj(void) {
|
|
flecs::world ecs;
|
|
|
|
auto rel = ecs.component<Position>();
|
|
auto obj = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>(obj, {10, 20});
|
|
|
|
test_assert(e.has<Position>(obj));
|
|
test_assert(e.has(rel, obj));
|
|
|
|
const void *ptr = e.get(rel, obj);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(static_cast<const Position*>(ptr)->x, 10);
|
|
test_int(static_cast<const Position*>(ptr)->y, 20);
|
|
}
|
|
|
|
void Pairs_get_rel_obj_id(void) {
|
|
flecs::world ecs;
|
|
|
|
flecs::id rel = ecs.component<Position>();
|
|
flecs::id obj = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>(obj, {10, 20});
|
|
|
|
test_assert(e.has<Position>(obj));
|
|
test_assert(e.has(rel, obj));
|
|
|
|
const void *ptr = e.get(rel, obj);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(static_cast<const Position*>(ptr)->x, 10);
|
|
test_int(static_cast<const Position*>(ptr)->y, 20);
|
|
}
|
|
|
|
void Pairs_get_rel_obj_id_t(void) {
|
|
flecs::world ecs;
|
|
|
|
flecs::id_t rel = ecs.component<Position>();
|
|
flecs::id_t obj = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>(obj, {10, 20});
|
|
|
|
test_assert(e.has<Position>(obj));
|
|
test_assert(e.has(rel, obj));
|
|
|
|
const void *ptr = e.get(rel, obj);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(static_cast<const Position*>(ptr)->x, 10);
|
|
test_int(static_cast<const Position*>(ptr)->y, 20);
|
|
}
|
|
|
|
void Pairs_get_R_obj(void) {
|
|
flecs::world ecs;
|
|
|
|
auto obj = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>(obj, {10, 20});
|
|
|
|
test_assert(e.has<Position>(obj));
|
|
|
|
const Position *ptr = e.get<Position>(obj);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_R_obj_id(void) {
|
|
flecs::world ecs;
|
|
|
|
flecs::id obj = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>(obj, {10, 20});
|
|
|
|
test_assert(e.has<Position>(obj));
|
|
|
|
const Position *ptr = e.get<Position>(obj);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_R_obj_id_t(void) {
|
|
flecs::world ecs;
|
|
|
|
flecs::id_t obj = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>(obj, {10, 20});
|
|
|
|
test_assert(e.has<Position>(obj));
|
|
|
|
const Position *ptr = e.get<Position>(obj);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_R_O(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().set<Position, Tag>({10, 20});
|
|
|
|
test_assert((e.has<Position, Tag>()));
|
|
|
|
const Position *ptr = e.get<Position, Tag>();
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_R_tag_O(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().set<Tag, Position>({10, 20});
|
|
|
|
test_assert((e.has<Tag, Position>()));
|
|
|
|
const Position *ptr = e.get<Tag, Position>();
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_second(void) {
|
|
flecs::world ecs;
|
|
|
|
auto rel = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set_second<Position>(rel, {10, 20});
|
|
|
|
test_assert(e.has_second<Position>(rel));
|
|
|
|
const Position *ptr = e.get_second<Position>(rel);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_second_id(void) {
|
|
flecs::world ecs;
|
|
|
|
flecs::id rel = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set_second<Position>(rel, {10, 20});
|
|
|
|
test_assert(e.has_second<Position>(rel));
|
|
|
|
const Position *ptr = e.get_second<Position>(rel);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_get_second_id_t(void) {
|
|
flecs::world ecs;
|
|
|
|
flecs::id_t rel = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set_second<Position>(rel, {10, 20});
|
|
|
|
test_assert(e.has_second<Position>(rel));
|
|
|
|
const Position *ptr = e.get_second<Position>(rel);
|
|
test_assert(ptr != nullptr);
|
|
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|
|
|
|
void Pairs_each(void) {
|
|
flecs::world ecs;
|
|
|
|
auto p_1 = ecs.entity();
|
|
auto p_2 = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.add(p_1)
|
|
.add(p_2);
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each([&](flecs::id e) {
|
|
if (count == 0) {
|
|
test_assert(e == p_1);
|
|
} else if (count == 1) {
|
|
test_assert(e == p_2);
|
|
} else {
|
|
test_assert(false);
|
|
}
|
|
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_each_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto pair = ecs.component<Pair>();
|
|
auto pos = ecs.component<Position>();
|
|
auto vel = ecs.component<Velocity>();
|
|
|
|
auto e = ecs.entity()
|
|
.add<Pair, Position>()
|
|
.add<Pair, Velocity>();
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each(pair, [&](flecs::entity object) {
|
|
if (count == 0) {
|
|
test_assert(object == pos);
|
|
} else if (count == 1) {
|
|
test_assert(object == vel);
|
|
} else {
|
|
test_assert(false);
|
|
}
|
|
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_each_pair_by_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto pos = ecs.component<Position>();
|
|
auto vel = ecs.component<Velocity>();
|
|
|
|
auto e = ecs.entity()
|
|
.add<Pair, Position>()
|
|
.add<Pair, Velocity>();
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each<Pair>([&](flecs::entity object) {
|
|
if (count == 0) {
|
|
test_assert(object == pos);
|
|
} else if (count == 1) {
|
|
test_assert(object == vel);
|
|
} else {
|
|
test_assert(false);
|
|
}
|
|
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_each_pair_w_isa(void) {
|
|
flecs::world ecs;
|
|
|
|
auto p_1 = ecs.entity();
|
|
auto p_2 = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.is_a(p_1)
|
|
.is_a(p_2);
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each(flecs::IsA, [&](flecs::entity object) {
|
|
if (count == 0) {
|
|
test_assert(object == p_1);
|
|
} else if (count == 1) {
|
|
test_assert(object == p_2);
|
|
} else {
|
|
test_assert(false);
|
|
}
|
|
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_each_pair_w_recycled_rel(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e_1 = ecs.entity();
|
|
auto e_2 = ecs.entity();
|
|
|
|
ecs.entity().destruct(); // force recycling
|
|
|
|
auto pair = ecs.entity();
|
|
|
|
test_assert((uint32_t)pair.id() != pair.id()); // ensure recycled
|
|
|
|
auto e = ecs.entity()
|
|
.add(pair, e_1)
|
|
.add(pair, e_2);
|
|
|
|
int32_t count = 0;
|
|
|
|
// should work correctly
|
|
e.each(pair, [&](flecs::entity object) {
|
|
if (count == 0) {
|
|
test_assert(object == e_1);
|
|
} else if (count == 1) {
|
|
test_assert(object == e_2);
|
|
} else {
|
|
test_assert(false);
|
|
}
|
|
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_each_pair_w_recycled_obj(void) {
|
|
flecs::world ecs;
|
|
|
|
auto pair = ecs.component<Pair>();
|
|
|
|
ecs.entity().destruct(); // force recycling
|
|
auto e_1 = ecs.entity();
|
|
test_assert((uint32_t)e_1.id() != e_1.id()); // ensure recycled
|
|
|
|
ecs.entity().destruct();
|
|
auto e_2 = ecs.entity();
|
|
test_assert((uint32_t)e_2.id() != e_2.id());
|
|
|
|
auto e = ecs.entity()
|
|
.add<Pair>(e_1)
|
|
.add<Pair>(e_2);
|
|
|
|
int32_t count = 0;
|
|
|
|
// should work correctly
|
|
e.each(pair, [&](flecs::entity object) {
|
|
if (count == 0) {
|
|
test_assert(object == e_1);
|
|
} else if (count == 1) {
|
|
test_assert(object == e_2);
|
|
} else {
|
|
test_assert(false);
|
|
}
|
|
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_match_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Eats = ecs.entity();
|
|
auto Dislikes = ecs.entity();
|
|
|
|
auto Apples = ecs.entity();
|
|
auto Pears = ecs.entity();
|
|
auto Bananas = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>({10, 20}) // should not be matched
|
|
.add(Eats, Apples)
|
|
.add(Eats, Pears)
|
|
.add(Dislikes, Bananas);
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each(Eats, Apples,
|
|
[&](flecs::id id) {
|
|
test_assert(id.first() == Eats);
|
|
test_assert(id.second() == Apples);
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 1);
|
|
}
|
|
|
|
void Pairs_match_pair_obj_wildcard(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Eats = ecs.entity();
|
|
auto Dislikes = ecs.entity();
|
|
|
|
auto Apples = ecs.entity();
|
|
auto Pears = ecs.entity();
|
|
auto Bananas = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>({10, 20}) // should not be matched
|
|
.add(Eats, Apples)
|
|
.add(Eats, Pears)
|
|
.add(Dislikes, Bananas);
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each(Eats, flecs::Wildcard,
|
|
[&](flecs::id id) {
|
|
test_assert(id.first() == Eats);
|
|
test_assert(id.second() == Apples || id.second() == Pears);
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Pairs_match_pair_rel_wildcard(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Eats = ecs.entity();
|
|
auto Dislikes = ecs.entity();
|
|
|
|
auto Apples = ecs.entity();
|
|
auto Pears = ecs.entity();
|
|
auto Bananas = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>({10, 20}) // should not be matched
|
|
.add(Eats, Apples)
|
|
.add(Eats, Pears)
|
|
.add(Dislikes, Bananas);
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each(flecs::Wildcard, Pears,
|
|
[&](flecs::id id) {
|
|
test_assert(id.first() == Eats);
|
|
test_assert(id.second() == Pears);
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 1);
|
|
}
|
|
|
|
void Pairs_match_pair_both_wildcard(void) {
|
|
flecs::world ecs;
|
|
|
|
auto Eats = ecs.entity();
|
|
auto Dislikes = ecs.entity();
|
|
|
|
auto Apples = ecs.entity();
|
|
auto Pears = ecs.entity();
|
|
auto Bananas = ecs.entity();
|
|
|
|
auto e = ecs.entity()
|
|
.set<Position>({10, 20}) // should not be matched
|
|
.add(Eats, Apples)
|
|
.add(Eats, Pears)
|
|
.add(Dislikes, Bananas);
|
|
|
|
int32_t count = 0;
|
|
|
|
e.each(flecs::Wildcard, flecs::Wildcard,
|
|
[&](flecs::id id) {
|
|
count ++;
|
|
});
|
|
|
|
test_int(count, 3);
|
|
}
|
|
|
|
void Pairs_has_tag_w_object(void) {
|
|
flecs::world ecs;
|
|
|
|
struct Likes { };
|
|
|
|
auto Bob = ecs.entity();
|
|
auto e = ecs.entity().add<Likes>(Bob);
|
|
test_assert(e.has<Likes>(Bob));
|
|
}
|
|
|
|
void Pairs_has_second_tag(void) {
|
|
flecs::world ecs;
|
|
|
|
struct Bob { };
|
|
|
|
auto Likes = ecs.entity();
|
|
auto e = ecs.entity().add_second<Bob>(Likes);
|
|
test_assert(e.has_second<Bob>(Likes));
|
|
}
|
|
|
|
struct Eats { int amount; };
|
|
struct Apples { };
|
|
struct Pears { };
|
|
|
|
using EatsApples = flecs::pair<Eats, Apples>;
|
|
using EatsPears = flecs::pair<Eats, Pears>;
|
|
|
|
void Pairs_add_pair_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().add<EatsApples>();
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
}
|
|
|
|
void Pairs_remove_pair_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().add<EatsApples>();
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
|
|
e.remove<EatsApples>();
|
|
test_assert(!(e.has<Eats, Apples>()));
|
|
test_assert(!(e.has<EatsApples>()));
|
|
}
|
|
|
|
void Pairs_set_pair_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().set<EatsApples>({10});
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
|
|
const Eats *ptr = e.get<EatsApples>();
|
|
test_int(ptr->amount, 10);
|
|
|
|
test_assert((ptr == e.get<Eats, Apples>()));
|
|
}
|
|
|
|
void Pairs_has_pair_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().add<Eats, Apples>();
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
}
|
|
|
|
void Pairs_get_1_pair_arg(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().set<EatsApples>({10});
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
|
|
test_bool(e.get([](const EatsApples& a) {
|
|
test_int(a->amount, 10);
|
|
}), true);
|
|
}
|
|
|
|
void Pairs_get_2_pair_arg(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set<EatsApples>({10})
|
|
.set<EatsPears>({20});
|
|
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<Eats, Pears>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
test_assert((e.has<EatsPears>()));
|
|
|
|
test_bool(e.get([](const EatsApples& a, const EatsPears& p) {
|
|
test_int(a->amount, 10);
|
|
test_int(p->amount, 20);
|
|
}), true);
|
|
}
|
|
|
|
void Pairs_set_1_pair_arg(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set([](EatsApples&& a) {
|
|
a->amount = 10;
|
|
});
|
|
|
|
auto eats = e.get<EatsApples>();
|
|
test_int(eats->amount, 10);
|
|
}
|
|
|
|
void Pairs_set_2_pair_arg(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set([](EatsApples&& a, EatsPears&& p) {
|
|
a->amount = 10;
|
|
p->amount = 20;
|
|
});
|
|
|
|
auto eats = e.get<EatsApples>();
|
|
test_int(eats->amount, 10);
|
|
|
|
eats = e.get<EatsPears>();
|
|
test_int(eats->amount, 20);
|
|
}
|
|
|
|
void Pairs_get_inline_pair_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().set<EatsApples>({10});
|
|
test_assert((e.has<Eats, Apples>()));
|
|
test_assert((e.has<EatsApples>()));
|
|
|
|
test_bool(e.get([](const flecs::pair<Eats, Apples>& a) {
|
|
test_int(a->amount, 10);
|
|
}), true);
|
|
}
|
|
|
|
void Pairs_set_inline_pair_type(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set([](flecs::pair<Eats, Apples>&& a) {
|
|
a->amount = 10;
|
|
});
|
|
|
|
auto eats = e.get<EatsApples>();
|
|
test_int(eats->amount, 10);
|
|
}
|
|
|
|
void Pairs_get_pair_type_object(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity().set_second<Apples, Eats>({10});
|
|
test_assert((e.has<Apples, Eats>()));
|
|
|
|
test_bool(e.get([](const flecs::pair_object<Apples, Eats>& a) {
|
|
test_int(a->amount, 10);
|
|
}), true);
|
|
}
|
|
|
|
void Pairs_set_pair_type_object(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e = ecs.entity()
|
|
.set([](flecs::pair_object<Apples, Eats>&& a) {
|
|
a->amount = 10;
|
|
});
|
|
|
|
auto eats = e.get_second<Apples, Eats>();
|
|
test_int(eats->amount, 10);
|
|
}
|
|
|
|
struct Event {
|
|
const char *value;
|
|
};
|
|
|
|
struct Begin { };
|
|
struct End { };
|
|
|
|
using BeginEvent = flecs::pair<Begin, Event>;
|
|
using EndEvent = flecs::pair<End, Event>;
|
|
|
|
void Pairs_set_get_second_variants(void) {
|
|
flecs::world ecs;
|
|
|
|
auto e1 = ecs.entity().set_second<Begin, Event>({"Big Bang"});
|
|
test_assert((e1.has<Begin, Event>()));
|
|
const Event* v = e1.get_second<Begin, Event>();
|
|
test_assert(v != NULL);
|
|
test_str(v->value, "Big Bang");
|
|
|
|
auto e2 = ecs.entity().set<Begin, Event>({"Big Bang"});
|
|
test_assert((e2.has<Begin, Event>()));
|
|
v = e2.get<Begin, Event>();
|
|
test_assert(v != NULL);
|
|
test_str(v->value, "Big Bang");
|
|
|
|
auto e3 = ecs.entity().set<flecs::pair<Begin, Event>>({"Big Bang"});
|
|
test_assert((e3.has<flecs::pair<Begin, Event>>()));
|
|
v = e3.get<flecs::pair<Begin, Event>>();
|
|
test_assert(v != NULL);
|
|
test_str(v->value, "Big Bang");
|
|
|
|
auto e4 = ecs.entity().set<BeginEvent>({"Big Bang"});
|
|
test_assert((e4.has<BeginEvent>()));
|
|
v = e4.get<BeginEvent>();
|
|
test_assert(v != NULL);
|
|
test_str(v->value, "Big Bang");
|
|
}
|
|
|
|
void Pairs_get_object_for_type_self(void) {
|
|
flecs::world ecs;
|
|
|
|
auto base = ecs.entity().add<Tag>();
|
|
auto self = ecs.entity().is_a(base).add<Tag>();
|
|
|
|
auto obj = self.target_for<Tag>(flecs::IsA);
|
|
test_assert(obj != 0);
|
|
test_assert(obj == self);
|
|
}
|
|
|
|
void Pairs_get_object_for_type_base(void) {
|
|
flecs::world ecs;
|
|
|
|
auto base = ecs.entity().add<Tag>();
|
|
auto self = ecs.entity().is_a(base);
|
|
|
|
auto obj = self.target_for<Tag>(flecs::IsA);
|
|
test_assert(obj != 0);
|
|
test_assert(obj == base);
|
|
}
|
|
|
|
void Pairs_get_object_for_id_self(void) {
|
|
flecs::world ecs;
|
|
|
|
auto tag = ecs.entity();
|
|
auto base = ecs.entity().add(tag);
|
|
auto self = ecs.entity().is_a(base).add(tag);
|
|
|
|
auto obj = self.target_for(flecs::IsA, tag);
|
|
test_assert(obj != 0);
|
|
test_assert(obj == self);
|
|
}
|
|
|
|
void Pairs_get_object_for_id_base(void) {
|
|
flecs::world ecs;
|
|
|
|
auto tag = ecs.entity();
|
|
auto base = ecs.entity().add(tag);
|
|
auto self = ecs.entity().is_a(base);
|
|
|
|
auto obj = self.target_for(flecs::IsA, tag);
|
|
test_assert(obj != 0);
|
|
test_assert(obj == base);
|
|
}
|
|
|
|
void Pairs_get_object_for_id_not_found(void) {
|
|
flecs::world ecs;
|
|
|
|
auto tag = ecs.entity();
|
|
auto base = ecs.entity();
|
|
auto self = ecs.entity().is_a(base);
|
|
|
|
auto obj = self.target_for(flecs::IsA, tag);
|
|
test_assert(obj == 0);
|
|
}
|
|
|
|
void Pairs_deref_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
Position v = {10, 20};
|
|
|
|
flecs::pair<Position, Tag> p(v);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
|
|
Position pos = *p;
|
|
test_int(pos.x, 10);
|
|
test_int(pos.y, 20);
|
|
}
|
|
|
|
void Pairs_deref_const_pair(void) {
|
|
flecs::world ecs;
|
|
|
|
Position v = {10, 20};
|
|
|
|
const flecs::pair<Position, Tag> p(v);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
|
|
Position pos = *p;
|
|
test_int(pos.x, 10);
|
|
test_int(pos.y, 20);
|
|
}
|
|
|
|
void Pairs_deref_pair_obj(void) {
|
|
flecs::world ecs;
|
|
|
|
Position v = {10, 20};
|
|
|
|
flecs::pair<Tag, Position> p(v);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
|
|
Position pos = *p;
|
|
test_int(pos.x, 10);
|
|
test_int(pos.y, 20);
|
|
}
|
|
|
|
void Pairs_deref_const_pair_obj(void) {
|
|
flecs::world ecs;
|
|
|
|
Position v = {10, 20};
|
|
|
|
const flecs::pair<Tag, Position> p(v);
|
|
test_int(p->x, 10);
|
|
test_int(p->y, 20);
|
|
|
|
Position pos = *p;
|
|
test_int(pos.x, 10);
|
|
test_int(pos.y, 20);
|
|
}
|
|
|
|
void Pairs_set_R_existing_value(void) {
|
|
flecs::world ecs;
|
|
|
|
Position p{10, 20};
|
|
flecs::entity e = ecs.entity().set<Position, Tag>(p);
|
|
|
|
const Position *ptr = e.get<Position, Tag>();
|
|
test_assert(ptr != nullptr);
|
|
test_int(ptr->x, 10);
|
|
test_int(ptr->y, 20);
|
|
}
|