A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest.h>
#include <esengine/ESEngine.hpp>
#include <esengine/ecs/TransformSystem.hpp>
#include <unordered_set>
#include <vector>
namespace test {
struct Position {
float x = 0.0f;
float y = 0.0f;
Position() = default;
Position(float x_, float y_) : x(x_), y(y_) {}
};
struct Velocity {
float dx = 0.0f;
float dy = 0.0f;
Velocity() = default;
Velocity(float dx_, float dy_) : dx(dx_), dy(dy_) {}
};
struct Health {
int value = 0;
Health() = default;
Health(int v) : value(v) {}
};
} // namespace test
TEST_CASE("entity_creation") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
esengine::Entity e2 = registry.create();
esengine::Entity e3 = registry.create();
CHECK(registry.valid(e1));
CHECK(registry.valid(e2));
CHECK(registry.valid(e3));
CHECK_NE(e1, e2);
CHECK_NE(e2, e3);
CHECK_EQ(registry.entityCount(), 3u);
}
TEST_CASE("entity_destruction") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
esengine::Entity e2 = registry.create();
registry.destroy(e1);
CHECK(!registry.valid(e1));
CHECK(registry.valid(e2));
CHECK_EQ(registry.entityCount(), 1u);
}
TEST_CASE("entity_recycling") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
registry.destroy(e1);
esengine::Entity e2 = registry.create();
CHECK_EQ(e1.index(), e2.index());
CHECK_NE(e1, e2);
CHECK(registry.valid(e2));
}
TEST_CASE("component_emplace") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
auto& pos = registry.emplace<test::Position>(entity, 10.0f, 20.0f);
CHECK(registry.has<test::Position>(entity));
CHECK_EQ(pos.x, 10.0f);
CHECK_EQ(pos.y, 20.0f);
}
TEST_CASE("component_get") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
registry.emplace<test::Position>(entity, 5.0f, 15.0f);
auto& pos = registry.get<test::Position>(entity);
CHECK_EQ(pos.x, 5.0f);
CHECK_EQ(pos.y, 15.0f);
pos.x = 100.0f;
CHECK_EQ(registry.get<test::Position>(entity).x, 100.0f);
}
TEST_CASE("component_remove") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
registry.emplace<test::Position>(entity, 1.0f, 2.0f);
CHECK(registry.has<test::Position>(entity));
registry.remove<test::Position>(entity);
CHECK(!registry.has<test::Position>(entity));
}
TEST_CASE("component_try_get") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
CHECK(registry.tryGet<test::Position>(entity) == nullptr);
registry.emplace<test::Position>(entity, 1.0f, 2.0f);
auto* pos = registry.tryGet<test::Position>(entity);
CHECK(pos != nullptr);
CHECK_EQ(pos->x, 1.0f);
}
TEST_CASE("multiple_components") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
registry.emplace<test::Position>(entity, 1.0f, 2.0f);
registry.emplace<test::Velocity>(entity, 3.0f, 4.0f);
registry.emplace<test::Health>(entity, 100);
CHECK(registry.has<test::Position>(entity));
CHECK(registry.has<test::Velocity>(entity));
CHECK(registry.has<test::Health>(entity));
CHECK_EQ(registry.get<test::Position>(entity).x, 1.0f);
CHECK_EQ(registry.get<test::Velocity>(entity).dx, 3.0f);
CHECK_EQ(registry.get<test::Health>(entity).value, 100);
}
TEST_CASE("view_single_component") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
esengine::Entity e2 = registry.create();
esengine::Entity e3 = registry.create();
registry.emplace<test::Position>(e1, 1.0f, 1.0f);
registry.emplace<test::Position>(e2, 2.0f, 2.0f);
auto view = registry.view<test::Position>();
int count = 0;
for (auto entity : view) {
(void)entity;
count++;
}
CHECK_EQ(count, 2);
}
TEST_CASE("view_multiple_components") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
esengine::Entity e2 = registry.create();
esengine::Entity e3 = registry.create();
registry.emplace<test::Position>(e1, 1.0f, 1.0f);
registry.emplace<test::Velocity>(e1, 1.0f, 1.0f);
registry.emplace<test::Position>(e2, 2.0f, 2.0f);
registry.emplace<test::Velocity>(e3, 3.0f, 3.0f);
auto view = registry.view<test::Position, test::Velocity>();
int count = 0;
for (auto entity : view) {
(void)entity;
count++;
}
CHECK_EQ(count, 1);
}
TEST_CASE("view_each") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
esengine::Entity e2 = registry.create();
registry.emplace<test::Position>(e1, 10.0f, 20.0f);
registry.emplace<test::Velocity>(e1, 1.0f, 2.0f);
registry.emplace<test::Position>(e2, 30.0f, 40.0f);
registry.emplace<test::Velocity>(e2, 3.0f, 4.0f);
float totalX = 0.0f;
auto view = registry.view<test::Position, test::Velocity>();
view.each([&totalX](esengine::Entity entity, test::Position& pos, test::Velocity& vel) {
(void)entity;
pos.x += vel.dx;
totalX += pos.x;
});
CHECK_EQ(registry.get<test::Position>(e1).x, 11.0f);
CHECK_EQ(registry.get<test::Position>(e2).x, 33.0f);
CHECK_EQ(totalX, 44.0f);
}
TEST_CASE("eachLive visits every entity and allows in-place mutation") {
esengine::ecs::Registry registry;
esengine::Entity e1 = registry.create();
esengine::Entity e2 = registry.create();
esengine::Entity e3 = registry.create();
registry.emplace<test::Position>(e1, 1.0f, 0.0f);
registry.emplace<test::Position>(e2, 2.0f, 0.0f);
registry.emplace<test::Position>(e3, 3.0f, 0.0f);
int count = 0;
float sum = 0.0f;
registry.eachLive<test::Position>([&](esengine::Entity, test::Position& p) {
count++;
sum += p.x;
p.x += 10.0f; // read + in-place write is fine (not a structural change)
});
CHECK_EQ(count, 3);
CHECK_EQ(sum, 6.0f);
CHECK_EQ(registry.get<test::Position>(e1).x, 11.0f);
CHECK_EQ(registry.get<test::Position>(e3).x, 13.0f);
}
TEST_CASE("has_all_any") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
registry.emplace<test::Position>(entity, 0.0f, 0.0f);
registry.emplace<test::Velocity>(entity, 0.0f, 0.0f);
CHECK((registry.hasAll<test::Position, test::Velocity>(entity)));
CHECK(!(registry.hasAll<test::Position, test::Health>(entity)));
CHECK((registry.hasAny<test::Position, test::Health>(entity)));
CHECK(!(registry.hasAny<test::Health>(entity)));
}
TEST_CASE("clear_registry") {
esengine::ecs::Registry registry;
for (int i = 0; i < 10; ++i) {
esengine::Entity e = registry.create();
registry.emplace<test::Position>(e, static_cast<float>(i), 0.0f);
}
CHECK_EQ(registry.entityCount(), 10u);
registry.clear();
CHECK_EQ(registry.entityCount(), 0u);
esengine::Entity e = registry.create();
CHECK(registry.valid(e));
}
TEST_CASE("sparse_set_basic") {
esengine::ecs::SparseSet<test::Position> set;
esengine::Entity e1 = esengine::Entity::make(0, 1);
esengine::Entity e2 = esengine::Entity::make(5, 1);
esengine::Entity e3 = esengine::Entity::make(100, 1);
set.emplace(e1, 1.0f, 1.0f);
set.emplace(e2, 2.0f, 2.0f);
set.emplace(e3, 3.0f, 3.0f);
CHECK(set.contains(e1));
CHECK(set.contains(e2));
CHECK(set.contains(e3));
CHECK(!set.contains(esengine::Entity::make(50, 1)));
CHECK_EQ(set.get(e1).x, 1.0f);
CHECK_EQ(set.get(e2).x, 2.0f);
CHECK_EQ(set.get(e3).x, 3.0f);
CHECK_EQ(set.size(), 3u);
}
TEST_CASE("sparse_set_remove") {
esengine::ecs::SparseSet<test::Position> set;
esengine::Entity e1 = esengine::Entity::make(0, 1);
esengine::Entity e2 = esengine::Entity::make(1, 1);
esengine::Entity e3 = esengine::Entity::make(2, 1);
set.emplace(e1, 1.0f, 1.0f);
set.emplace(e2, 2.0f, 2.0f);
set.emplace(e3, 3.0f, 3.0f);
set.remove(e2);
CHECK(set.contains(e1));
CHECK(!set.contains(e2));
CHECK(set.contains(e3));
CHECK_EQ(set.get(e1).x, 1.0f);
CHECK_EQ(set.get(e3).x, 3.0f);
CHECK_EQ(set.size(), 2u);
}
TEST_CASE("local_transform_default") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
auto& local = registry.emplace<esengine::ecs::Transform>(entity);
CHECK_EQ(local.position.x, 0.0f);
CHECK_EQ(local.position.y, 0.0f);
CHECK_EQ(local.position.z, 0.0f);
CHECK_EQ(local.rotation.w, 1.0f);
CHECK_EQ(local.scale.x, 1.0f);
}
TEST_CASE("local_transform_with_position") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
auto& local = registry.emplace<esengine::ecs::Transform>(
entity, glm::vec3(10.0f, 20.0f, 30.0f));
CHECK_EQ(local.position.x, 10.0f);
CHECK_EQ(local.position.y, 20.0f);
CHECK_EQ(local.position.z, 30.0f);
}
TEST_CASE("local_transform_with_rotation") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
glm::quat rotation = glm::angleAxis(glm::radians(90.0f), glm::vec3(0, 1, 0));
auto& local = registry.emplace<esengine::ecs::Transform>(
entity, glm::vec3(0.0f), rotation);
CHECK(esengine::math::approxEqual(local.rotation.y, rotation.y, 0.001f));
}
TEST_CASE("hierarchy_parent_child") {
esengine::ecs::Registry registry;
esengine::Entity parent = registry.create();
esengine::Entity child = registry.create();
registry.emplace<esengine::ecs::Transform>(parent, glm::vec3(10.0f, 0.0f, 0.0f));
registry.emplace<esengine::ecs::Transform>(child, glm::vec3(5.0f, 0.0f, 0.0f));
esengine::ecs::setParent(registry, child, parent);
CHECK(registry.has<esengine::ecs::Parent>(child));
CHECK(registry.has<esengine::ecs::Children>(parent));
CHECK_EQ(registry.get<esengine::ecs::Parent>(child).entity, parent);
CHECK_EQ(registry.get<esengine::ecs::Children>(parent).entities.size(), 1u);
CHECK_EQ(registry.get<esengine::ecs::Children>(parent).entities[0], child);
}
TEST_CASE("hierarchy_depth") {
esengine::ecs::Registry registry;
esengine::Entity grandparent = registry.create();
esengine::Entity parent = registry.create();
esengine::Entity child = registry.create();
registry.emplace<esengine::ecs::Transform>(grandparent);
registry.emplace<esengine::ecs::Transform>(parent);
registry.emplace<esengine::ecs::Transform>(child);
esengine::ecs::setParent(registry, parent, grandparent);
esengine::ecs::setParent(registry, child, parent);
CHECK_EQ(registry.get<esengine::ecs::HierarchyDepth>(parent).depth, 1u);
CHECK_EQ(registry.get<esengine::ecs::HierarchyDepth>(child).depth, 2u);
}
TEST_CASE("hierarchy_get_root") {
esengine::ecs::Registry registry;
esengine::Entity root = registry.create();
esengine::Entity middle = registry.create();
esengine::Entity leaf = registry.create();
registry.emplace<esengine::ecs::Transform>(root);
registry.emplace<esengine::ecs::Transform>(middle);
registry.emplace<esengine::ecs::Transform>(leaf);
esengine::ecs::setParent(registry, middle, root);
esengine::ecs::setParent(registry, leaf, middle);
CHECK_EQ(esengine::ecs::getRoot(registry, leaf), root);
CHECK_EQ(esengine::ecs::getRoot(registry, middle), root);
CHECK_EQ(esengine::ecs::getRoot(registry, root), root);
}
TEST_CASE("hierarchy_is_descendant") {
esengine::ecs::Registry registry;
esengine::Entity root = registry.create();
esengine::Entity child = registry.create();
esengine::Entity grandchild = registry.create();
esengine::Entity unrelated = registry.create();
registry.emplace<esengine::ecs::Transform>(root);
registry.emplace<esengine::ecs::Transform>(child);
registry.emplace<esengine::ecs::Transform>(grandchild);
registry.emplace<esengine::ecs::Transform>(unrelated);
esengine::ecs::setParent(registry, child, root);
esengine::ecs::setParent(registry, grandchild, child);
CHECK(esengine::ecs::isDescendantOf(registry, child, root));
CHECK(esengine::ecs::isDescendantOf(registry, grandchild, root));
CHECK(esengine::ecs::isDescendantOf(registry, grandchild, child));
CHECK(!esengine::ecs::isDescendantOf(registry, root, child));
CHECK(!esengine::ecs::isDescendantOf(registry, unrelated, root));
}
TEST_CASE("sprite_with_texture_handle") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
esengine::resource::TextureHandle texHandle(42);
auto& sprite = registry.emplace<esengine::ecs::Sprite>(entity, texHandle);
CHECK(sprite.texture.isValid());
CHECK_EQ(sprite.texture.id(), 42u);
CHECK_EQ(sprite.color.r, 1.0f);
}
TEST_CASE("camera_default") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
auto& camera = registry.emplace<esengine::ecs::Camera>(entity);
CHECK_EQ(camera.projectionType, esengine::ecs::ProjectionType::Perspective);
CHECK_EQ(camera.fov, 60.0f);
CHECK_EQ(camera.nearPlane, 0.1f);
CHECK(!camera.isActive);
}
TEST_CASE("uuid_component") {
esengine::ecs::Registry registry;
esengine::Entity entity = registry.create();
auto& uuid = registry.emplace<esengine::ecs::UUID>(entity, 0x12345678ABCDEF00ULL);
CHECK_EQ(uuid.value, 0x12345678ABCDEF00ULL);
esengine::ecs::UUID other(0x12345678ABCDEF00ULL);
CHECK(uuid == other);
}
TEST_CASE("view_each tolerates mid-iteration emplace on the same pool") {
esengine::ecs::Registry registry;
for (int i = 0; i < 8; ++i) {
esengine::Entity e = registry.create();
registry.emplace<test::Position>(e, float(i), 0.0f);
}
int visited = 0;
auto view = registry.view<test::Position>();
view.each([&](esengine::Entity, test::Position&) {
++visited;
if (visited == 1) {
for (int j = 0; j < 32; ++j) {
esengine::Entity extra = registry.create();
registry.emplace<test::Position>(extra, 99.0f, 99.0f);
}
}
});
CHECK_EQ(visited, 8);
}
TEST_CASE("view_each tolerates mid-iteration remove of the current entity") {
esengine::ecs::Registry registry;
for (int i = 0; i < 5; ++i) {
esengine::Entity e = registry.create();
registry.emplace<test::Position>(e, float(i), 0.0f);
}
int visited = 0;
auto view = registry.view<test::Position>();
view.each([&](esengine::Entity e, test::Position&) {
++visited;
registry.remove<test::Position>(e);
});
CHECK_EQ(visited, 5);
CHECK_EQ(registry.view<test::Position>().size(), 0u);
}
TEST_CASE("onDestroy callback can safely disconnect itself mid-publish") {
esengine::ecs::Registry registry;
esengine::Entity e = registry.create();
bool other_fired = false;
esengine::u32 self_fires = 0;
esengine::Connection self;
esengine::Connection other = registry.onDestroy([&](esengine::Entity) { other_fired = true; });
self = registry.onDestroy([&](esengine::Entity) {
++self_fires;
self.disconnect();
});
registry.destroy(e);
CHECK(other_fired);
CHECK_EQ(self_fires, 1u);
esengine::Entity e2 = registry.create();
other_fired = false;
registry.destroy(e2);
CHECK(other_fired);
CHECK_EQ(self_fires, 1u);
}
TEST_CASE("setParent is idempotent on duplicate reparent") {
esengine::ecs::Registry registry;
esengine::Entity parent = registry.create();
esengine::Entity child = registry.create();
esengine::ecs::setParent(registry, child, parent);
esengine::ecs::setParent(registry, child, parent);
const auto& children = registry.get<esengine::ecs::Children>(parent).entities;
CHECK_EQ(children.size(), 1u);
CHECK_EQ(children[0], child);
}
// Storage order is iteration order is painter order: applyEntityOrder is how an
// already-populated registry is told the scene's authored order (see
// Registry::applyEntityOrder).
TEST_CASE("applyEntityOrder permutes every pool to the given order") {
esengine::ecs::Registry registry;
esengine::Entity a = registry.create();
esengine::Entity b = registry.create();
esengine::Entity c = registry.create();
for (auto e : {a, b, c}) {
registry.emplace<test::Position>(e, static_cast<float>(e.index()), 0.0f);
registry.emplace<test::Health>(e, static_cast<int>(e.index()));
}
std::vector<esengine::Entity> order{c, a, b};
registry.applyEntityOrder(order.data(), order.size());
std::vector<esengine::Entity> seen;
registry.each<test::Position>([&](esengine::Entity e, test::Position&) { seen.push_back(e); });
CHECK_EQ(seen, order);
// Every pool follows the same order, and the values travel with their entity.
seen.clear();
registry.each<test::Health>([&](esengine::Entity e, test::Health&) { seen.push_back(e); });
CHECK_EQ(seen, order);
CHECK_EQ(registry.get<test::Position>(c).x, static_cast<float>(c.index()));
CHECK_EQ(registry.get<test::Health>(a).value, static_cast<int>(a.index()));
}
TEST_CASE("applyEntityOrder leaves unlisted entities after the listed ones, in order") {
esengine::ecs::Registry registry;
esengine::Entity a = registry.create();
esengine::Entity b = registry.create();
esengine::Entity c = registry.create();
esengine::Entity d = registry.create();
for (auto e : {a, b, c, d}) registry.emplace<test::Position>(e, 0.0f, 0.0f);
std::vector<esengine::Entity> order{d, b};
registry.applyEntityOrder(order.data(), order.size());
std::vector<esengine::Entity> seen;
registry.each<test::Position>([&](esengine::Entity e, test::Position&) { seen.push_back(e); });
CHECK_EQ(seen, std::vector<esengine::Entity>{d, b, a, c});
}
TEST_CASE("applyEntityOrder keeps lookups intact across a partial pool") {
esengine::ecs::Registry registry;
esengine::Entity a = registry.create();
esengine::Entity b = registry.create();
esengine::Entity c = registry.create();
registry.emplace<test::Position>(a, 1.0f, 0.0f);
registry.emplace<test::Position>(c, 3.0f, 0.0f);
std::vector<esengine::Entity> order{c, b, a};
registry.applyEntityOrder(order.data(), order.size());
CHECK(registry.has<test::Position>(a));
CHECK(!registry.has<test::Position>(b));
CHECK_EQ(registry.get<test::Position>(a).x, 1.0f);
CHECK_EQ(registry.get<test::Position>(c).x, 3.0f);
std::vector<esengine::Entity> seen;
registry.each<test::Position>([&](esengine::Entity e, test::Position&) { seen.push_back(e); });
CHECK_EQ(seen, std::vector<esengine::Entity>{c, a});
}
// UI draws in child-list order while world sprites draw in storage order, so one
// authored order has to reach both (see applySceneEntityOrder).
TEST_CASE("applySceneEntityOrder reorders child lists as well as storage") {
esengine::ecs::Registry registry;
esengine::Entity parent = registry.create();
esengine::Entity a = registry.create();
esengine::Entity b = registry.create();
esengine::Entity c = registry.create();
for (auto child : {a, b, c}) esengine::ecs::setParent(registry, child, parent);
CHECK_EQ(registry.get<esengine::ecs::Children>(parent).entities,
std::vector<esengine::Entity>{a, b, c});
std::vector<esengine::Entity> order{parent, c, a, b};
esengine::ecs::applySceneEntityOrder(registry, order.data(), order.size());
CHECK_EQ(registry.get<esengine::ecs::Children>(parent).entities,
std::vector<esengine::Entity>{c, a, b});
}
TEST_CASE("applySceneEntityOrder keeps unlisted children after the listed ones") {
esengine::ecs::Registry registry;
esengine::Entity parent = registry.create();
esengine::Entity a = registry.create();
esengine::Entity b = registry.create();
esengine::Entity c = registry.create();
for (auto child : {a, b, c}) esengine::ecs::setParent(registry, child, parent);
std::vector<esengine::Entity> order{c};
esengine::ecs::applySceneEntityOrder(registry, order.data(), order.size());
CHECK_EQ(registry.get<esengine::ecs::Children>(parent).entities,
std::vector<esengine::Entity>{c, a, b});
}
// ─── Slot retirement ─────────────────────────────────────────────────────────
// The generation field is 10 bits, so recycling a slot past its last one mints an
// id it already issued. Retired instead — and 1023 reuses is not far away.
TEST_CASE("a slot is never handed back with an id it already issued") {
esengine::ecs::Registry registry;
std::unordered_set<esengine::u32> seen;
// Far past one slot's generation supply, so a wrapping registry must collide.
for (int i = 0; i < 5000; ++i) {
esengine::Entity e = registry.create();
REQUIRE(e != esengine::INVALID_ENTITY);
CHECK(seen.insert(e.raw).second);
registry.destroy(e);
}
}
TEST_CASE("retirement spends an index only when a generation runs out") {
esengine::ecs::Registry registry;
CHECK_EQ(registry.retiredSlots(), 0u);
// One slot, churned to exhaustion: generations 1..GEN_MASK, then retired.
const esengine::u32 supply = esengine::Entity::GEN_MASK;
for (esengine::u32 i = 0; i < supply; ++i) {
registry.destroy(registry.create());
}
CHECK_EQ(registry.retiredSlots(), 1u);
// The next entity cannot be that slot.
esengine::Entity fresh = registry.create();
CHECK_EQ(fresh.index(), 1u);
CHECK_EQ(fresh.generation(), 1u);
}
TEST_CASE("ordinary reuse still recycles the same slot") {
esengine::ecs::Registry registry;
esengine::Entity a = registry.create();
registry.destroy(a);
esengine::Entity b = registry.create();
CHECK_EQ(b.index(), a.index()); // same slot
CHECK_NE(b.raw, a.raw); // different handle
CHECK_EQ(registry.retiredSlots(), 0u);
}
TEST_CASE("a retired slot's old handle stays invalid forever") {
esengine::ecs::Registry registry;
esengine::Entity first = registry.create();
const esengine::Entity stale = first;
registry.destroy(first);
for (esengine::u32 i = 1; i < esengine::Entity::GEN_MASK; ++i) {
registry.destroy(registry.create());
}
// The slot is spent. Nothing after this may make `stale` valid again.
for (int i = 0; i < 64; ++i) {
esengine::Entity e = registry.create();
CHECK_NE(e.raw, stale.raw);
}
CHECK_FALSE(registry.valid(stale));
}
TEST_CASE("clear returns the retirement count to zero") {
esengine::ecs::Registry registry;
for (esengine::u32 i = 0; i < esengine::Entity::GEN_MASK; ++i) {
registry.destroy(registry.create());
}
REQUIRE(registry.retiredSlots() == 1u);
registry.clear();
CHECK_EQ(registry.retiredSlots(), 0u);
esengine::Entity e = registry.create();
CHECK_EQ(e.index(), 0u);
}