759 lines
19 KiB
C
759 lines
19 KiB
C
#include <addons.h>
|
|
|
|
static bool system_a_invoked;
|
|
static bool system_b_invoked;
|
|
static bool system_c_invoked;
|
|
|
|
static
|
|
void SystemA(ecs_iter_t *it) {
|
|
test_int(it->delta_time, 1.0);
|
|
test_int(it->delta_system_time, 3.0);
|
|
system_a_invoked = true;
|
|
}
|
|
|
|
static
|
|
void SystemB(ecs_iter_t *it) {
|
|
test_int(it->delta_time, 1.0);
|
|
test_int(it->delta_system_time, 3.0);
|
|
system_b_invoked = true;
|
|
}
|
|
|
|
void Timer_timeout(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_timeout(world, SystemA, 3.0);
|
|
test_assert(timer != 0);
|
|
test_assert(timer == SystemA);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
|
|
system_a_invoked = false;
|
|
|
|
/* Make sure this was a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_interval(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, SystemA, 3.0);
|
|
test_assert(timer != 0);
|
|
test_assert(timer == SystemA);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
|
|
system_a_invoked = false;
|
|
|
|
/* Make sure this was not a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_shared_timeout(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
ECS_SYSTEM(world, SystemB, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_timeout(world, 0, 3.0);
|
|
test_assert(timer != 0);
|
|
|
|
ecs_set_tick_source(world, SystemA, timer);
|
|
ecs_set_tick_source(world, SystemB, timer);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
test_bool(system_b_invoked, true);
|
|
|
|
system_a_invoked = false;
|
|
system_b_invoked = false;
|
|
|
|
/* Make sure this was a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_shared_interval(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
ECS_SYSTEM(world, SystemB, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, 0, 3.0);
|
|
test_assert(timer != 0);
|
|
|
|
ecs_set_tick_source(world, SystemA, timer);
|
|
ecs_set_tick_source(world, SystemB, timer);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
test_bool(system_b_invoked, true);
|
|
|
|
system_a_invoked = false;
|
|
system_b_invoked = false;
|
|
|
|
/* Make sure this was a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
test_bool(system_b_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
test_bool(system_b_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_start_stop_one_shot(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_timeout(world, SystemA, 3.0);
|
|
test_assert(timer != 0);
|
|
test_assert(timer == SystemA);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
/* Stop timer */
|
|
ecs_stop_timer(world, timer);
|
|
|
|
/* Timer is stopped, should not trigger system */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
/* Start timer, this should reset timer */
|
|
ecs_start_timer(world, timer);
|
|
|
|
/* Make sure this was a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
|
|
/* System should have been triggered */
|
|
test_bool(system_a_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_start_stop_interval(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, SystemA, 3.0);
|
|
test_assert(timer != 0);
|
|
test_assert(timer == SystemA);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
/* Stop timer */
|
|
ecs_stop_timer(world, timer);
|
|
|
|
/* Timer is stopped, should not trigger system */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
/* Start timer, this should reset timer */
|
|
ecs_start_timer(world, timer);
|
|
|
|
/* Make sure this was a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
|
|
/* System should have been triggered */
|
|
test_bool(system_a_invoked, true);
|
|
|
|
system_a_invoked = false;
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
|
|
/* Ensure that timer still triggers repeatedly */
|
|
test_bool(system_a_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_rate_filter(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t filter = ecs_set_rate(world, SystemA, 3, 0);
|
|
test_assert(filter != 0);
|
|
test_assert(filter == SystemA);
|
|
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
|
|
system_a_invoked = false;
|
|
|
|
/* Make sure this was a one-shot timer */
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, false);
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_a_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
static
|
|
void SystemC(ecs_iter_t *it) {
|
|
test_int(it->delta_time, 1.0);
|
|
test_int(it->delta_system_time, 6.0);
|
|
system_c_invoked = true;
|
|
}
|
|
|
|
void Timer_rate_filter_w_rate_filter_src(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemC, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
ecs_entity_t filter_a = ecs_set_rate(world, 0, 2, 0);
|
|
test_assert(filter_a != 0);
|
|
|
|
ecs_entity_t filter_b = ecs_set_rate(world, SystemC, 3, filter_a);
|
|
test_assert(filter_b != 0);
|
|
test_assert(filter_b == SystemC);
|
|
|
|
test_bool(system_c_invoked, false);
|
|
|
|
int i;
|
|
for (i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, false);
|
|
}
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, true);
|
|
|
|
system_c_invoked = false;
|
|
|
|
/* Make sure rate filter triggers repeatedly */
|
|
for (i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, false);
|
|
}
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_rate_filter_w_timer_src(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_SYSTEM(world, SystemC, EcsOnUpdate, Position);
|
|
ECS_ENTITY(world, E1, Position);
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, 0, 2.0);
|
|
test_assert(timer != 0);
|
|
|
|
ecs_entity_t filter = ecs_set_rate(world, SystemC, 3, timer);
|
|
test_assert(filter != 0);
|
|
test_assert(filter == SystemC);
|
|
|
|
test_bool(system_c_invoked, false);
|
|
|
|
int i;
|
|
for (i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, false);
|
|
}
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, true);
|
|
|
|
system_c_invoked = false;
|
|
|
|
/* Make sure rate filter triggers repeatedly */
|
|
for (i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, false);
|
|
}
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_rate_filter_with_empty_src(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ECS_SYSTEM(world, SystemC, EcsOnUpdate, Position);
|
|
|
|
ecs_new(world, Position);
|
|
|
|
// Not actually a tick source
|
|
ecs_entity_t filter_a = ecs_new_id(world);
|
|
test_assert(filter_a != 0);
|
|
|
|
ecs_entity_t filter_b = ecs_set_rate(world, SystemC, 6, filter_a);
|
|
test_assert(filter_b != 0);
|
|
test_assert(filter_b == SystemC);
|
|
|
|
test_bool(system_c_invoked, false);
|
|
|
|
int i;
|
|
for (i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, false);
|
|
}
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, true);
|
|
|
|
system_c_invoked = false;
|
|
|
|
/* Make sure rate filter triggers repeatedly */
|
|
for (i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, false);
|
|
}
|
|
|
|
ecs_progress(world, 1.0);
|
|
test_bool(system_c_invoked, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_one_shot_timer_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t timer = ecs_set_timeout(world, 0, 1.0);
|
|
|
|
int i;
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0.3);
|
|
const EcsTickSource *src = ecs_get(world, timer, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.3);
|
|
const EcsTickSource *src = ecs_get(world, timer, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
|
|
/* Ensure timer doesn't tick again */
|
|
for (i = 0; i < 12; i ++) {
|
|
ecs_progress(world, 0.3);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_interval_timer_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, 0, 1.0);
|
|
|
|
int i;
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0.3);
|
|
const EcsTickSource *src = ecs_get(world, timer, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.3);
|
|
const EcsTickSource *src = ecs_get(world, timer, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
|
|
for (i = 0; i < 2; i ++) {
|
|
ecs_progress(world, 0.3);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
/* Timer should tick again */
|
|
ecs_progress(world, 0.3);
|
|
test_bool(src->tick, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_rate_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
/* Specify 0 for source. This applies the rate to the frame ticks */
|
|
ecs_entity_t rate = ecs_set_rate(world, 0, 4, 0);
|
|
|
|
int i;
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
/* Filter should tick again */
|
|
ecs_progress(world, 0);
|
|
test_bool(src->tick, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_nested_rate_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
/* Nested rate filter */
|
|
ecs_entity_t parent = ecs_set_rate(world, 0, 2, 0);
|
|
ecs_entity_t rate = ecs_set_rate(world, 0, 2, parent);
|
|
|
|
int i;
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
/* Filter should tick again */
|
|
ecs_progress(world, 0);
|
|
test_bool(src->tick, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_nested_rate_entity_empty_src(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
/* Rate filter with source that is not a tick source */
|
|
ecs_entity_t parent = ecs_new(world, 0);
|
|
ecs_entity_t rate = ecs_set_rate(world, 0, 4, parent);
|
|
|
|
int i;
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
|
|
for (i = 0; i < 3; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
/* Filter should tick again */
|
|
ecs_progress(world, 0);
|
|
test_bool(src->tick, true);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_naked_tick_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t tick = ecs_set(world, 0, EcsTickSource, {0});
|
|
|
|
int i;
|
|
for (i = 0; i < 10; i ++) {
|
|
ecs_progress(world, 0);
|
|
const EcsTickSource *src = ecs_get(world, tick, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
|
|
/* Tick should always be true, no filter is applied */
|
|
test_bool(src->tick, true);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_stop_timer_w_rate(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, 0, 1.0);
|
|
ecs_entity_t rate = ecs_set_rate(world, 0, 3.0, timer);
|
|
|
|
for (int i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 0.5);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.5);
|
|
|
|
{
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
}
|
|
|
|
ecs_stop_timer(world, timer);
|
|
|
|
for (int i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 0.5);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.5);
|
|
|
|
{
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_start_timer(world, timer);
|
|
|
|
for (int i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 0.5);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.5);
|
|
|
|
{
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_stop_timer_w_rate_same_src(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t timer = ecs_set_interval(world, 0, 1.0);
|
|
ecs_entity_t rate = ecs_set_rate(world, timer, 3.0, timer);
|
|
test_assert(rate == timer);
|
|
|
|
for (int i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 0.5);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.5);
|
|
|
|
{
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
}
|
|
|
|
ecs_stop_timer(world, timer);
|
|
|
|
for (int i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 0.5);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.5);
|
|
|
|
{
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_start_timer(world, timer);
|
|
|
|
for (int i = 0; i < 5; i ++) {
|
|
ecs_progress(world, 0.5);
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, false);
|
|
}
|
|
|
|
ecs_progress(world, 0.5);
|
|
|
|
{
|
|
const EcsTickSource *src = ecs_get(world, rate, EcsTickSource);
|
|
test_assert(src != NULL);
|
|
test_bool(src->tick, true);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Timer_randomize_timers(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t timer_a = ecs_set_interval(world, 0, 1.0);
|
|
{
|
|
const EcsTimer *t = ecs_get(world, timer_a, EcsTimer);
|
|
test_assert(t != NULL);
|
|
test_assert(t->time == 0);
|
|
}
|
|
|
|
ecs_randomize_timers(world);
|
|
|
|
{
|
|
const EcsTimer *t = ecs_get(world, timer_a, EcsTimer);
|
|
test_assert(t != NULL);
|
|
test_assert(t->time != 0);
|
|
}
|
|
|
|
ecs_entity_t timer_b = ecs_set_interval(world, 0, 1.0);
|
|
{
|
|
const EcsTimer *t = ecs_get(world, timer_b, EcsTimer);
|
|
test_assert(t != NULL);
|
|
test_assert(t->time != 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|