From 9fcd5358ff1349a840a5f266c1bebdef4a124d34 Mon Sep 17 00:00:00 2001
From: Jacob Wirth <xthexder@users.noreply.github.com>
Date: Sun, 11 Sep 2022 21:26:33 -0400
Subject: [PATCH] Fix integration tests

---
 src/game/game/SceneManager.cc      | 79 +++++++++++++++---------------
 src/game/game/SceneManager.hh      |  4 +-
 tests/CMakeLists.txt               |  1 +
 tests/integration/scene-manager.cc | 44 ++++++++---------
 tests/tests.cc                     | 10 ++--
 5 files changed, 69 insertions(+), 69 deletions(-)

diff --git a/src/game/game/SceneManager.cc b/src/game/game/SceneManager.cc
index 4d9249c7a..d68fa4479 100644
--- a/src/game/game/SceneManager.cc
+++ b/src/game/game/SceneManager.cc
@@ -20,13 +20,11 @@
 
 namespace sp {
     SceneManager &GetSceneManager() {
-        static SceneManager GSceneManager(ecs::World, ecs::StagingWorld);
+        static SceneManager GSceneManager;
         return GSceneManager;
     }
 
-    SceneManager::SceneManager(ecs::ECS &liveWorld, ecs::ECS &stagingWorld, bool skipPreload)
-        : RegisteredThread("SceneManager", 30.0), liveWorld(liveWorld), stagingWorld(stagingWorld),
-          skipPreload(skipPreload) {
+    SceneManager::SceneManager(bool skipPreload) : RegisteredThread("SceneManager", 30.0), skipPreload(skipPreload) {
         funcs.Register<std::string>("loadscene",
             "Load a scene and replace current scenes",
             [this](std::string sceneName) {
@@ -48,7 +46,7 @@ namespace sp {
             QueueActionAndBlock(SceneAction::ReloadBindings);
         });
         funcs.Register("respawn", "Respawn the player", [this]() {
-            auto liveLock = this->liveWorld.StartTransaction<ecs::Read<ecs::Name>,
+            auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name>,
                 ecs::Write<ecs::TransformSnapshot, ecs::TransformTree>>();
             RespawnPlayer(liveLock, player);
         });
@@ -73,8 +71,8 @@ namespace sp {
         }
         StopThread(true);
 
-        auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-        auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+        auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+        auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
         for (auto &list : scenes) {
             list.clear();
@@ -115,13 +113,14 @@ namespace sp {
                     }
 
                     {
-                        auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
+                        auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
                         item.applyCallback(stagingLock, scene);
                     }
                     {
                         Tracef("Applying system scene: %s", scene->name);
-                        auto stagingLock = stagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
-                        auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                        auto stagingLock =
+                            ecs::StagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
+                        auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
                         scene->ApplyScene(stagingLock, liveLock);
                     }
                 }
@@ -134,7 +133,7 @@ namespace sp {
                     if (scene) {
                         if (scene->type != SceneType::System) {
                             Debugf("Editing staging scene: %s", scene->name);
-                            auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
+                            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
                             item.applyCallback(stagingLock, scene);
                         } else {
                             Errorf("SceneManager::EditStagingScene: Cannot edit system scene: %s", scene->name);
@@ -157,8 +156,8 @@ namespace sp {
                 auto scene = stagedScenes.Load(item.sceneName);
                 if (scene) {
                     Debugf("Applying scene: %s", scene->name);
-                    auto stagingLock = stagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
-                    auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                    auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
+                    auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
                     scene->ApplyScene(stagingLock, liveLock);
                 } else {
                     Errorf("SceneManager::ApplyScene: scene %s not found", item.sceneName);
@@ -170,8 +169,8 @@ namespace sp {
                 // Unload all current scenes first
                 size_t expectedCount = scenes[SceneType::Async].size() + scenes[SceneType::World].size();
                 if (expectedCount > 0) {
-                    auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                    auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                    auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                    auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
                     scenes[SceneType::Async].clear();
                     scenes[SceneType::World].clear();
@@ -200,8 +199,8 @@ namespace sp {
                     reloadScenes.reserve(reloadCount);
 
                     if (reloadCount > 0) {
-                        auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                        auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                        auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                        auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
                         for (auto &scene : scenes[SceneType::World]) {
                             reloadScenes.emplace_back(scene->name, SceneType::World);
@@ -234,8 +233,8 @@ namespace sp {
                         sceneList.erase(std::remove(sceneList.begin(), sceneList.end(), loadedScene));
 
                         {
-                            auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                            auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                            auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
                             loadedScene->RemoveScene(stagingLock, liveLock);
                         }
 
@@ -262,8 +261,8 @@ namespace sp {
                     sceneList.erase(std::remove(sceneList.begin(), sceneList.end(), loadedScene));
 
                     {
-                        auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                        auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                        auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                        auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
                         loadedScene->RemoveScene(stagingLock, liveLock);
                     }
 
@@ -274,8 +273,8 @@ namespace sp {
             } else if (item.action == SceneAction::ReloadPlayer) {
                 ZoneScopedN("ReloadPlayer");
                 if (playerScene) {
-                    auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                    auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                    auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                    auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
                     playerScene->RemoveScene(stagingLock, liveLock);
                     playerScene.reset();
@@ -300,16 +299,16 @@ namespace sp {
             } else if (item.action == SceneAction::ReloadBindings) {
                 ZoneScopedN("ReloadBindings");
                 if (bindingsScene) {
-                    auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                    auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                    auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                    auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
                     bindingsScene->RemoveScene(stagingLock, liveLock);
                     bindingsScene.reset();
                 }
 
                 bindingsScene = LoadBindingsJson();
                 if (bindingsScene) {
-                    auto stagingLock = stagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
-                    auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                    auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
+                    auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
                     bindingsScene->ApplyScene(stagingLock, liveLock);
                 } else {
@@ -332,7 +331,7 @@ namespace sp {
         ZoneScoped;
         requiredSceneList.clear();
         {
-            auto lock = liveWorld.StartTransaction<ecs::ReadSignalsLock, ecs::Read<ecs::SceneConnection>>();
+            auto lock = ecs::World.StartTransaction<ecs::ReadSignalsLock, ecs::Read<ecs::SceneConnection>>();
 
             for (auto &ent : lock.EntitiesWith<ecs::SceneConnection>()) {
                 auto loadSignal = ecs::SignalBindings::GetSignal(lock, ent, "load_scene_connection");
@@ -363,8 +362,8 @@ namespace sp {
         stagedScenes.Tick(this->interval, [this](std::shared_ptr<Scene> &scene) {
             ZoneScopedN("RemoveExpiredScene");
             ZoneStr(scene->name);
-            auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-            auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+            auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
             scene->RemoveScene(stagingLock, liveLock);
             scene.reset();
         });
@@ -401,7 +400,7 @@ namespace sp {
     void SceneManager::PreloadSceneGraphics(ScenePreloadCallback callback) {
         std::shared_lock lock(preloadMutex);
         if (preloadScene) {
-            auto stagingLock = stagingWorld.StartTransaction<ecs::ReadAll>();
+            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::ReadAll>();
             if (callback(stagingLock, preloadScene)) {
                 graphicsPreload.test_and_set();
                 graphicsPreload.notify_all();
@@ -412,7 +411,7 @@ namespace sp {
     void SceneManager::PreloadScenePhysics(ScenePreloadCallback callback) {
         std::shared_lock lock(preloadMutex);
         if (preloadScene) {
-            auto stagingLock = stagingWorld.StartTransaction<ecs::ReadAll>();
+            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::ReadAll>();
             if (callback(stagingLock, preloadScene)) {
                 physicsPreload.test_and_set();
                 physicsPreload.notify_all();
@@ -443,8 +442,8 @@ namespace sp {
 
         {
             Tracef("Applying scene: %s", scene->name);
-            auto stagingLock = stagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
-            auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::ReadAll, ecs::Write<ecs::SceneInfo>>();
+            auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
             scene->ApplyScene(stagingLock, liveLock);
 
@@ -518,7 +517,7 @@ namespace sp {
         }
 
         if (sceneObj.count("entities")) {
-            auto lock = stagingWorld.StartTransaction<ecs::AddRemove>();
+            auto lock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
 
             auto &entityList = sceneObj["entities"];
             std::vector<ecs::Entity> entities;
@@ -586,7 +585,7 @@ namespace sp {
         }
 
         {
-            auto lock = stagingWorld.StartTransaction<ecs::AddRemove>();
+            auto lock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
 
             for (auto &param : root.get<picojson::object>()) {
                 Tracef("Loading input for: %s", param.first);
@@ -615,9 +614,9 @@ namespace sp {
     }
 
     void SceneManager::TranslateSceneByConnection(const std::shared_ptr<Scene> &scene) {
-        auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo, ecs::Animation>,
+        auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo, ecs::Animation>,
             ecs::Write<ecs::TransformTree, ecs::Animation>>();
-        auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::TransformSnapshot>>();
+        auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::TransformSnapshot>>();
 
         ecs::Entity liveConnection, stagingConnection;
         for (auto &e : stagingLock.EntitiesWith<ecs::SceneConnection>()) {
@@ -714,8 +713,8 @@ namespace sp {
         to_lower(filterName);
 
         {
-            auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-            auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+            auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
 
             if (filterName.empty() || filterName == "player") {
                 Logf("Player scene entities:");
diff --git a/src/game/game/SceneManager.hh b/src/game/game/SceneManager.hh
index ec76924db..ad520fe01 100644
--- a/src/game/game/SceneManager.hh
+++ b/src/game/game/SceneManager.hh
@@ -40,7 +40,7 @@ namespace sp {
 
     class SceneManager : public RegisteredThread {
     public:
-        SceneManager(ecs::ECS &liveWorld, ecs::ECS &stagingWorld, bool skipPreload = false);
+        SceneManager(bool skipPreload = false);
         ~SceneManager();
 
         using PreApplySceneCallback = std::function<void(ecs::Lock<ecs::AddRemove>, std::shared_ptr<Scene>)>;
@@ -95,8 +95,6 @@ namespace sp {
                 : action(action), editCallback(editCallback) {}
         };
 
-        ecs::ECS &liveWorld;
-        ecs::ECS &stagingWorld;
         ecs::Entity player;
 
         LockFreeMutex actionMutex, preloadMutex;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 66f0ed1e4..a8963d66d 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -32,6 +32,7 @@ target_link_libraries(sp-integration-tests
     ${PROJECT_CORE_LIB}
     ${PROJECT_GAME_TEST_LIB}
     ${PROJECT_PHYSICS_PHYSX_LIB}
+    ${PROJECT_SCRIPTS_LIB}
 )
 target_include_directories(sp-integration-tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
diff --git a/tests/integration/scene-manager.cc b/tests/integration/scene-manager.cc
index 02bee7df8..6631e60cd 100644
--- a/tests/integration/scene-manager.cc
+++ b/tests/integration/scene-manager.cc
@@ -8,9 +8,7 @@
 namespace SceneManagerTests {
     using namespace testing;
 
-    ecs::ECS liveWorld;
-    ecs::ECS stagingWorld;
-    sp::SceneManager Scenes(liveWorld, stagingWorld, true);
+    sp::SceneManager Scenes(true);
 
     void AssertEntityScene(ecs::Lock<ecs::Read<ecs::Name, ecs::SceneInfo>> stagingLock,
         ecs::Lock<ecs::Read<ecs::Name, ecs::SceneInfo>> liveLock,
@@ -72,8 +70,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::ApplySystemScene, "system", systemSceneCallback);
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"system"});
             }
         }
@@ -82,8 +80,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::ReloadPlayer);
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"player", "system"});
             }
         }
@@ -91,8 +89,8 @@ namespace SceneManagerTests {
             Timer t("Unload player scene (primary player entity)");
             std::shared_ptr<sp::Scene> playerScene;
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-                auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
                 auto player = ecs::EntityWith<ecs::Name>(liveLock, ecs::Name("player", "player"));
                 Assert(player.Has<ecs::Name, ecs::SceneInfo>(liveLock), "Expected player entity to be valid");
@@ -107,8 +105,8 @@ namespace SceneManagerTests {
             }
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"system"});
             }
         }
@@ -117,8 +115,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::ReloadPlayer);
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"player", "system"});
             }
         }
@@ -126,8 +124,8 @@ namespace SceneManagerTests {
             Timer t("Reset ECS");
             Scenes.QueueActionAndBlock(sp::SceneAction::RemoveScene, "system");
 
-            auto stagingLock = stagingWorld.StartTransaction<ecs::AddRemove>();
-            auto liveLock = liveWorld.StartTransaction<ecs::AddRemove>();
+            auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+            auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
 
             for (auto &e : stagingLock.Entities()) {
                 e.Destroy(stagingLock);
@@ -141,8 +139,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::ReloadPlayer);
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"player"});
             }
         }
@@ -151,8 +149,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::ApplySystemScene, "system", systemSceneCallback);
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"player", "system"});
             }
         }
@@ -161,8 +159,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::RemoveScene, "system");
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"player"});
             }
         }
@@ -171,8 +169,8 @@ namespace SceneManagerTests {
             Scenes.QueueActionAndBlock(sp::SceneAction::ApplySystemScene, "system", systemSceneCallback);
 
             {
-                auto stagingLock = stagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
-                auto liveLock = liveWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
+                auto liveLock = ecs::World.StartTransaction<ecs::Read<ecs::Name, ecs::SceneInfo>>();
                 AssertEntityScene(stagingLock, liveLock, "player", "player", {"player", "system"});
             }
         }
diff --git a/tests/tests.cc b/tests/tests.cc
index 2b76276ea..9b0b117d6 100644
--- a/tests/tests.cc
+++ b/tests/tests.cc
@@ -23,9 +23,13 @@ int main(int argc, char **argv) {
             test();
             {
                 // Reset the ECS between tests
-                auto lock = ecs::World.StartTransaction<ecs::AddRemove>();
-                for (auto &ent : lock.Entities()) {
-                    ent.Destroy(lock);
+                auto stagingLock = ecs::StagingWorld.StartTransaction<ecs::AddRemove>();
+                auto liveLock = ecs::World.StartTransaction<ecs::AddRemove>();
+                for (auto &ent : stagingLock.Entities()) {
+                    ent.Destroy(stagingLock);
+                }
+                for (auto &ent : liveLock.Entities()) {
+                    ent.Destroy(liveLock);
                 }
             }
         }