1439 lines
41 KiB
C
1439 lines
41 KiB
C
#include <api.h>
|
|
#include <stdlib.h>
|
|
|
|
void EnabledComponents_is_component_enabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_empty_entity_disabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_0_entity_disabled(void) {
|
|
install_test_abort();
|
|
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
test_expect_abort();
|
|
|
|
test_bool(ecs_is_enabled_component(world, 0, Position), false);
|
|
}
|
|
|
|
void EnabledComponents_is_0_component_disabled(void) {
|
|
install_test_abort();
|
|
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
|
|
test_expect_abort();
|
|
|
|
test_bool(ecs_is_enabled_id(world, e, 0), false);
|
|
}
|
|
|
|
void EnabledComponents_is_nonexist_component_disabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t e = ecs_new(world, Velocity);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_component_enabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_disabled_component_enabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
ecs_enable_component(world, e, Position, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_has_enabled_component(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
|
|
test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_id(Position)), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_after_add(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_add(world, e, Position);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_id(Position)), true);
|
|
test_bool(ecs_has(world, e, Position), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_after_remove(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_remove(world, e, Position);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_id(Position)), true);
|
|
test_bool(ecs_has(world, e, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_after_disable(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_enable_component(world, e, Position, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_disabled_after_enable(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
ecs_enable_component(world, e, Position, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_enable_component(world, e, Position, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_randomized(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t entities[100000];
|
|
bool enabled[100000];
|
|
|
|
int32_t i;
|
|
for (i = 0; i < 100000; i ++) {
|
|
enabled[i] = rand() % 2;
|
|
entities[i] = ecs_new_id(world);
|
|
ecs_enable_component(world, entities[i], Position, enabled[i]);
|
|
}
|
|
|
|
for (i = 0; i < 100000; i ++) {
|
|
test_bool(
|
|
ecs_is_enabled_component(world, entities[i], Position), enabled[i]);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_after_add_randomized(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t entities[100000];
|
|
bool enabled[100000];
|
|
|
|
int32_t i;
|
|
for (i = 0; i < 100000; i ++) {
|
|
enabled[i] = rand() % 2;
|
|
entities[i] = ecs_new_id(world);
|
|
ecs_enable_component(world, entities[i], Position, enabled[i]);
|
|
}
|
|
|
|
for (i = 0; i < 100000; i ++) {
|
|
ecs_add(world, entities[i], Position);
|
|
}
|
|
|
|
for (i = 0; i < 100000; i ++) {
|
|
test_bool(
|
|
ecs_is_enabled_component(world, entities[i], Position), enabled[i]);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_after_randomized_add_randomized(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t entities[100000];
|
|
bool enabled[100000];
|
|
|
|
int32_t i;
|
|
for (i = 0; i < 100000; i ++) {
|
|
enabled[i] = rand() % 2;
|
|
entities[i] = ecs_new_id(world);
|
|
ecs_enable_component(world, entities[i], Position, enabled[i]);
|
|
}
|
|
|
|
for (i = 0; i < 100000; i ++) {
|
|
if (!(rand() % 5)) {
|
|
ecs_add(world, entities[i], Position);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < 100000; i ++) {
|
|
test_bool(
|
|
ecs_is_enabled_component(world, entities[i], Position), enabled[i]);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_2(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_3(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
|
|
ecs_enable_component(world, e, Mass, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
test_bool(ecs_is_enabled_component(world, e, Mass), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_2_after_add(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
|
|
ecs_add(world, e, Position);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_3_after_add(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
|
|
ecs_enable_component(world, e, Position, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
|
|
ecs_enable_component(world, e, Mass, true);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
test_bool(ecs_is_enabled_component(world, e, Mass), true);
|
|
|
|
ecs_add(world, e, Position);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e, Velocity), false);
|
|
test_bool(ecs_is_enabled_component(world, e, Mass), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
ecs_entity_t e = ecs_new_w_pair(world, ecs_id(Position), obj);
|
|
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_enabled_pair_enabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_disabled_pair_enabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_has_enabled_pair(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_pair(ecs_id(Position), obj)), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_after_add(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_add_pair(world, e, ecs_id(Position), obj);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_pair(ecs_id(Position), obj)), true);
|
|
test_bool(ecs_has_pair(world, e, ecs_id(Position), obj), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_after_remove(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_remove_pair(world, e, ecs_id(Position), obj);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_pair(ecs_id(Position), obj)), true);
|
|
test_bool(ecs_has_pair(world, e, ecs_id(Position), obj), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_after_disable(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_disabled_after_enable(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_2(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_enable_pair(world, e, Velocity, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_3(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_enable_pair(world, e, Velocity, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
|
|
ecs_enable_pair(world, e, Mass, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Mass, obj), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_2_after_add(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_enable_pair(world, e, Velocity, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
|
|
ecs_add_pair(world, e, ecs_id(Position), obj);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_is_pair_enabled_3_after_add(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
|
|
ecs_entity_t e = ecs_new(world, 0);
|
|
ecs_entity_t obj = ecs_new_id(world);
|
|
|
|
ecs_enable_pair(world, e, Position, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
|
|
ecs_enable_pair(world, e, Velocity, obj, false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
|
|
ecs_enable_pair(world, e, Mass, obj, true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Mass, obj), true);
|
|
|
|
ecs_add_pair(world, e, ecs_id(Position), obj);
|
|
test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
|
|
test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
|
|
test_bool(ecs_is_enabled_pair(world, e, Mass, obj), true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_disabled(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e1 = ecs_new(world, Position);
|
|
ecs_entity_t e2 = ecs_new(world, Position);
|
|
ecs_entity_t e3 = ecs_new(world, Position);
|
|
|
|
ecs_enable_component(world, e1, Position, true);
|
|
ecs_enable_component(world, e2, Position, false);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t table_count = 0, count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != e2);
|
|
test_assert(it.entities[i] == e1 || it.entities[i] == e3);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
table_count ++;
|
|
}
|
|
|
|
test_int(count, 2);
|
|
test_int(table_count, 2);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_disabled_pair(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_TAG(world, Tgt);
|
|
|
|
ecs_entity_t e1 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
|
|
ecs_entity_t e2 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
|
|
ecs_entity_t e3 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
|
|
|
|
ecs_enable_pair(world, e1, Position, Tgt, true);
|
|
ecs_enable_pair(world, e2, Position, Tgt, false);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "(Position, Tgt)");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t table_count = 0, count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != e2);
|
|
test_assert(it.entities[i] == e1 || it.entities[i] == e3);
|
|
test_assert(ecs_is_enabled_pair(world, it.entities[i], Position, Tgt));
|
|
}
|
|
count += it.count;
|
|
table_count ++;
|
|
}
|
|
|
|
test_int(count, 2);
|
|
test_int(table_count, 2);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_disabled_skip_initial(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e1 = ecs_new(world, Position);
|
|
ecs_entity_t e2 = ecs_new(world, Position);
|
|
ecs_entity_t e3 = ecs_new(world, Position);
|
|
|
|
ecs_enable_component(world, e1, Position, false);
|
|
ecs_enable_component(world, e2, Position, true);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != e1);
|
|
test_assert(it.entities[i] == e2 || it.entities[i] == e3);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, 2);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_disabled_pair_skip_initial(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_TAG(world, Tgt);
|
|
|
|
ecs_entity_t e1 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
|
|
ecs_entity_t e2 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
|
|
ecs_entity_t e3 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
|
|
|
|
ecs_enable_pair(world, e1, Position, Tgt, false);
|
|
ecs_enable_pair(world, e2, Position, Tgt, true);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "(Position, Tgt)");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != e1);
|
|
test_assert(it.entities[i] == e2 || it.entities[i] == e3);
|
|
test_assert(ecs_is_enabled_pair(world, it.entities[i], Position, Tgt));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, 2);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_2(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 64; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
if (!(e % 2)) {
|
|
ecs_enable_component(world, e, Position, false);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, true);
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] % 2);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_8(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
if (!(e % 8)) {
|
|
ecs_enable_component(world, e, Position, false);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, true);
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] % 8);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_64(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
if (!(e % 64)) {
|
|
ecs_enable_component(world, e, Position, false);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, true);
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] % 64);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_256(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
if (!(e % 256)) {
|
|
ecs_enable_component(world, e, Position, false);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, true);
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] % 256);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_1024(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 100000; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
if (!(e % 1024)) {
|
|
ecs_enable_component(world, e, Position, false);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, true);
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] % 1024);
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_enable_mod_10(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
if (!(e % 10)) {
|
|
ecs_enable_component(world, e, Position, true);
|
|
total_count ++;
|
|
} else {
|
|
ecs_enable_component(world, e, Position, false);
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(!(it.entities[i] % 10));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_2_2_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
if (!(e % 2)) {
|
|
ecs_enable_component(world, e, Position, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, false);
|
|
}
|
|
|
|
if (!(e % 3)) {
|
|
ecs_enable_component(world, e, Velocity, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
}
|
|
|
|
if (!(e % 2) && !(e % 3)) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(!(it.entities[i] % 2) && !(it.entities[i] % 3));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_8_2_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
if (!(e % 8)) {
|
|
ecs_enable_component(world, e, Position, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, false);
|
|
}
|
|
|
|
if (!(e % 4)) {
|
|
ecs_enable_component(world, e, Velocity, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
}
|
|
|
|
if (!(e % 8) && !(e % 4)) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(!(it.entities[i] % 8) && !(it.entities[i] % 4));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_64_2_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
if (!(e % 64)) {
|
|
ecs_enable_component(world, e, Position, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, false);
|
|
}
|
|
|
|
if (!(e % 16)) {
|
|
ecs_enable_component(world, e, Velocity, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
}
|
|
|
|
if (!(e % 64) && !(e % 16)) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(!(it.entities[i] % 64) && !(it.entities[i] % 16));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_256_2_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
if (!(e % 256)) {
|
|
ecs_enable_component(world, e, Position, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, false);
|
|
}
|
|
|
|
if (!(e % 64)) {
|
|
ecs_enable_component(world, e, Velocity, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
}
|
|
|
|
if (!(e % 256) && !(e % 64)) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(!(it.entities[i] % 256) && !(it.entities[i] % 64));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_mod_1024_2_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
if (!(e % 1024)) {
|
|
ecs_enable_component(world, e, Position, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Position, false);
|
|
}
|
|
|
|
if (!(e % 128)) {
|
|
ecs_enable_component(world, e, Velocity, true);
|
|
} else {
|
|
ecs_enable_component(world, e, Velocity, false);
|
|
}
|
|
|
|
if (!(e % 1024) && !(e % 128)) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(!(it.entities[i] % 1024) && !(it.entities[i] % 128));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_randomized_2_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
|
|
bool enable_1 = rand() % 2;
|
|
ecs_enable_component(world, e, Position, enable_1);
|
|
bool enable_2 = rand() % 2;
|
|
ecs_enable_component(world, e, Velocity, enable_2);
|
|
|
|
if (enable_1 && enable_2) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_randomized_3_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
ecs_add(world, e, Mass);
|
|
|
|
bool enable_1 = rand() % 2;
|
|
ecs_enable_component(world, e, Position, enable_1);
|
|
bool enable_2 = rand() % 2;
|
|
ecs_enable_component(world, e, Velocity, enable_2);
|
|
bool enable_3 = rand() % 2;
|
|
ecs_enable_component(world, e, Mass, enable_3);
|
|
|
|
if (enable_1 && enable_2 && enable_3) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity, Mass");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Mass));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_query_randomized_4_bitsets(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
ECS_COMPONENT(world, Rotation);
|
|
|
|
int32_t i, total_count = 0;
|
|
for (i = 0; i < 65536; i ++) {
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
ecs_add(world, e, Velocity);
|
|
ecs_add(world, e, Mass);
|
|
ecs_add(world, e, Rotation);
|
|
|
|
bool enable_1 = rand() % 2;
|
|
ecs_enable_component(world, e, Position, enable_1);
|
|
bool enable_2 = rand() % 2;
|
|
ecs_enable_component(world, e, Velocity, enable_2);
|
|
bool enable_3 = rand() % 2;
|
|
ecs_enable_component(world, e, Mass, enable_3);
|
|
bool enable_4 = rand() % 2;
|
|
ecs_enable_component(world, e, Rotation, enable_4);
|
|
|
|
if (enable_1 && enable_2 && enable_3 && enable_4) {
|
|
total_count ++;
|
|
}
|
|
}
|
|
|
|
test_assert(total_count != 0);
|
|
|
|
ecs_query_t *q = ecs_query_new(world, "Position, Velocity, Mass, Rotation");
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
|
|
int32_t count = 0;
|
|
|
|
while (ecs_query_next(&it)) {
|
|
int32_t i;
|
|
for (i = 0; i < it.count; i ++) {
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Mass));
|
|
test_assert(ecs_is_enabled_component(world, it.entities[i], Rotation));
|
|
}
|
|
count += it.count;
|
|
}
|
|
|
|
test_int(count, total_count);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_defer_enable(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
|
|
ecs_defer_begin(world);
|
|
ecs_enable_component(world, e, Position, false);
|
|
test_bool(ecs_is_enabled_component(world, e, Position), true);
|
|
ecs_defer_end(world);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
static
|
|
int compare_position(ecs_entity_t e1, const void *ptr1, ecs_entity_t e2, const void *ptr2) {
|
|
const Position *p1 = ptr1;
|
|
const Position *p2 = ptr2;
|
|
return (p1->x > p2->x) - (p1->x < p2->x);
|
|
}
|
|
|
|
void EnabledComponents_sort(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 2});
|
|
ecs_entity_t e2 = ecs_set(world, 0, Position, {2, 2});
|
|
ecs_entity_t e3 = ecs_set(world, 0, Position, {1, 2});
|
|
ecs_entity_t e4 = ecs_set(world, 0, Position, {0, 2});
|
|
|
|
ecs_enable_component(world, e1, Position, true);
|
|
ecs_enable_component(world, e2, Position, true);
|
|
ecs_enable_component(world, e3, Position, false);
|
|
ecs_enable_component(world, e4, Position, false);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e1, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e2, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e3, Position), false);
|
|
test_bool(ecs_is_enabled_component(world, e4, Position), false);
|
|
|
|
ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
|
|
.filter.expr = "Position",
|
|
.order_by_component = ecs_id(Position),
|
|
.order_by = compare_position
|
|
});
|
|
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
test_assert(ecs_query_next(&it));
|
|
test_int(it.count, 2);
|
|
test_assert(it.entities[0] == e2);
|
|
test_assert(it.entities[1] == e1);
|
|
test_assert(!ecs_query_next(&it));
|
|
|
|
/* Entities will have shuffled around, ensure bits got shuffled too */
|
|
test_bool(ecs_is_enabled_component(world, e1, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e2, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e3, Position), false);
|
|
test_bool(ecs_is_enabled_component(world, e4, Position), false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void EnabledComponents_table_move_2_from_3(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_query_t *q = ecs_query(world, { .filter.expr = "Position" });
|
|
|
|
ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
|
|
ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
|
|
ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
|
|
|
|
ecs_enable_component(world, e1, Position, true);
|
|
ecs_enable_component(world, e2, Position, false);
|
|
ecs_enable_component(world, e3, Position, true);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e1, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e2, Position), false);
|
|
test_bool(ecs_is_enabled_component(world, e3, Position), true);
|
|
|
|
ecs_add(world, e3, Tag);
|
|
ecs_add(world, e2, Tag);
|
|
|
|
test_bool(ecs_is_enabled_component(world, e1, Position), true);
|
|
test_bool(ecs_is_enabled_component(world, e2, Position), false);
|
|
test_bool(ecs_is_enabled_component(world, e3, Position), true);
|
|
|
|
ecs_iter_t it = ecs_query_iter(world, q);
|
|
{
|
|
test_bool(true, ecs_query_next(&it));
|
|
test_int(1, it.count);
|
|
test_uint(e1, it.entities[0]);
|
|
Position *p = ecs_field(&it, Position, 1);
|
|
test_int(p->x, 10); test_int(p->y, 20);
|
|
}
|
|
{
|
|
test_bool(true, ecs_query_next(&it));
|
|
test_int(1, it.count);
|
|
test_uint(e3, it.entities[0]);
|
|
Position *p = ecs_field(&it, Position, 1);
|
|
test_int(p->x, 30); test_int(p->y, 40);
|
|
}
|
|
test_bool(false, ecs_query_next(&it));
|
|
|
|
ecs_fini(world);
|
|
}
|