[Engine] WorldQuery facade 및 EntityRegistry::eachAlive 구현 (#69)

- WorldQuery: view<T...>(), contains<T>(), get<T>() read-only facade 추가
- EntityRegistry: eachAlive() 템플릿 순회 메서드 추가
- WorldQueryTests: view 필터링, 미등록 타입, 파괴된 entity, contains, get 검증 5개 테스트 추가
- CMakeLists.txt: WorldQuery.h, WorldQueryTests.cpp 등록

Closes #9

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: learncold <learncold8154@gmail.com>

Author: 3 people

CMakeLists.txt

@@ -49,6 +49,7 @@ add_library(ecs_engine STATIC
     src/engine/EngineStepContext.h
     src/engine/EngineSystem.h
     src/engine/FrameClock.h
+    src/engine/WorldQuery.h
     src/engine/EntityRegistry.cpp
     src/engine/EngineRuntime.cpp
     src/engine/FrameClock.cpp
@@ -103,6 +104,7 @@ if (BUILD_TESTING)
         tests/EcsCoreTests.cpp
         tests/ImportContractsTests.cpp
         tests/DxfImportServiceTests.cpp
+        tests/WorldQueryTests.cpp
     )
 
     target_include_directories(safecrowd_tests

src/engine/EntityRegistry.h

@@ -22,6 +22,16 @@ class EntityRegistry {
     void setSignature(Entity entity, Signature signature);
     [[nodiscard]] Signature signatureOf(Entity entity) const;
 
+    template <typename Fn>
+    void eachAlive(Fn&& fn) const {
+        for (std::size_t i = 0; i < entries_.size(); ++i) {
+            const Entry& entry = entries_[i];
+            if (entry.alive) {
+                fn(Entity{static_cast<EntityIndex>(i), entry.generation}, entry.signature);
+            }
+        }
+    }
+
 private:
     struct Entry {
         EntityGeneration generation{0};

src/engine/WorldQuery.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <vector>
+
+#include "engine/EcsCore.h"
+
+namespace safecrowd::engine {
+
+class WorldQuery {
+public:
+    explicit WorldQuery(EcsCore& core) : core_(core) {}
+
+    template <typename... Ts>
+    [[nodiscard]] std::vector<Entity> view() const {
+        Signature required{};
+        bool allRegistered = true;
+        ([&] {
+            const auto id = core_.componentRegistry().tryTypeOf<Ts>();
+            if (!id.has_value()) {
+                allRegistered = false;
+            } else {
+                required.set(id.value());
+            }
+        }(), ...);
+
+        if (!allRegistered) return {};
+
+        std::vector<Entity> result;
+        core_.entityRegistry().eachAlive([&](Entity entity, const Signature& sig) {
+            if ((sig & required) == required) {
+                result.push_back(entity);
+            }
+        });
+        return result;
+    }
+
+    template <typename T>
+    [[nodiscard]] bool contains(Entity entity) const {
+        return core_.hasComponent<T>(entity);
+    }
+
+    template <typename T>
+    [[nodiscard]] T& get(Entity entity) {
+        return core_.getComponent<T>(entity);
+    }
+
+    template <typename T>
+    [[nodiscard]] const T& get(Entity entity) const {
+        return core_.getComponent<T>(entity);
+    }
+
+private:
+    EcsCore& core_;
+};
+
+}  // namespace safecrowd::engine

tests/WorldQueryTests.cpp

@@ -0,0 +1,84 @@
+#include "TestSupport.h"
+
+#include "engine/WorldQuery.h"
+
+namespace {
+
+struct Position {
+    float x{0.0f};
+    float y{0.0f};
+};
+
+struct Velocity {
+    float vx{0.0f};
+    float vy{0.0f};
+};
+
+}  // namespace
+
+SC_TEST(WorldQuery_ViewFiltersEntitiesBySignature) {
+    safecrowd::engine::EcsCore core;
+    safecrowd::engine::WorldQuery query{core};
+
+    const auto e1 = core.createEntity();
+    const auto e2 = core.createEntity();
+    const auto e3 = core.createEntity();
+
+    core.addComponent(e1, Position{});
+    core.addComponent(e1, Velocity{});
+    core.addComponent(e2, Position{});
+    core.addComponent(e3, Velocity{});
+
+    const auto result = query.view<Position, Velocity>();
+    SC_EXPECT_EQ(result.size(), std::size_t{1});
+    SC_EXPECT_TRUE(result[0] == e1);
+}
+
+SC_TEST(WorldQuery_ViewReturnsEmptyIfTypeNotRegistered) {
+    safecrowd::engine::EcsCore core;
+    safecrowd::engine::WorldQuery query{core};
+
+    static_cast<void>(core.createEntity());
+
+    const auto result = query.view<Position>();
+    SC_EXPECT_TRUE(result.empty());
+}
+
+SC_TEST(WorldQuery_ViewExcludesDestroyedEntities) {
+    safecrowd::engine::EcsCore core;
+    safecrowd::engine::WorldQuery query{core};
+
+    const auto e1 = core.createEntity();
+    core.addComponent(e1, Position{});
+    core.destroyEntity(e1);
+
+    const auto e2 = core.createEntity();
+    core.addComponent(e2, Position{});
+
+    const auto result = query.view<Position>();
+    SC_EXPECT_EQ(result.size(), std::size_t{1});
+    SC_EXPECT_TRUE(result[0] == e2);
+}
+
+SC_TEST(WorldQuery_ContainsReflectsComponentPresence) {
+    safecrowd::engine::EcsCore core;
+    safecrowd::engine::WorldQuery query{core};
+
+    const auto e = core.createEntity();
+    core.addComponent(e, Position{});
+
+    SC_EXPECT_TRUE(query.contains<Position>(e));
+    SC_EXPECT_TRUE(!query.contains<Velocity>(e));
+}
+
+SC_TEST(WorldQuery_GetReturnsComponentRef) {
+    safecrowd::engine::EcsCore core;
+    safecrowd::engine::WorldQuery query{core};
+
+    const auto e = core.createEntity();
+    core.addComponent(e, Position{3.0f, 4.0f});
+
+    const auto& pos = query.get<Position>(e);
+    SC_EXPECT_NEAR(pos.x, 3.0f, 1e-6);
+    SC_EXPECT_NEAR(pos.y, 4.0f, 1e-6);
+}