[Domain] issue 16,17

Author: 95x8x9

CMakeLists.txt

@@ -94,6 +94,11 @@ add_library(safecrowd_domain STATIC
     src/domain/ImportValidationService.h
     src/domain/ImportValidationService.cpp
     src/domain/ImportContracts.h
+    src/domain/AgentComponents.h
+    src/domain/CompressionSystem.cpp
+    src/domain/Metrics.h
+    src/domain/Snapshot.cpp
+    src/domain/Snapshot.h
 )
 
 target_include_directories(safecrowd_domain

src/domain/AgentComponents.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "domain/Geometry2D.h"
+
+namespace safecrowd::domain {
+
+    // 에이전트의 위치를 나타내는 컴포넌트
+    struct Position {
+        Point2D value;
+    };
+
+    // 에이전트의 고유 특성을 나타내는 컴포넌트
+    struct Agent {
+        float radius = 0.25f;
+        float maxSpeed = 1.5f;
+    };
+
+    struct Velocity {
+        Point2D value;
+    };
+
+} // namespace safecrowd::domain

src/domain/CompressionSystem.cpp

@@ -0,0 +1,99 @@
+#include "domain/CompressionSystem.h"
+#include "domain/FacilityLayout2D.h"
+#include "domain/AgentComponents.h" 
+#include "domain/metrics.h"
+#include <algorithm>
+#include <cmath>
+
+namespace safecrowd::domain {
+
+    static float distanceBetween(const Point2D& p1, const Point2D& p2) {
+        float dx = static_cast<float>(p1.x - p2.x);
+        float dy = static_cast<float>(p1.y - p2.y);
+        return std::sqrt(dx * dx + dy * dy);
+    }
+
+    static float distancePointToSegment(const Point2D& p, const Point2D& a, const Point2D& b) {
+        float l2 = static_cast<float>(std::pow(b.x - a.x, 2) + std::pow(b.y - a.y, 2));
+        if (l2 == 0.0f) return distanceBetween(p, a);
+
+        float t = std::clamp(static_cast<float>(((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / l2), 0.0f, 1.0f);
+        Point2D projection = { a.x + t * (b.x - a.x), a.y + t * (b.y - a.y) };
+        return distanceBetween(p, projection);
+    }
+
+    void CompressionSystem::update(engine::ComponentRegistry& registry, float dt) {
+        // 필요한 스토리지들을 로드
+        auto& posStorage = registry.storageFor<Position>();
+        auto& agentStorage = registry.storageFor<Agent>();
+        auto& compStorage = registry.storageFor<CompressionData>();
+
+        // Barrier2D 스토리지가 있는지 확인
+        if (!registry.isRegistered<Barrier2D>()) return;
+        auto& barrierStorage = registry.storageFor<Barrier2D>();
+
+        // Position을 가진 모든 엔티티를 순회
+        for (const auto& entity : posStorage.getEntities()) {
+            // Agent와 CompressionData 컴포넌트가 모두 있는지 확인
+            if (!agentStorage.contains(entity) || !compStorage.contains(entity)) continue;
+
+            const auto& pos = posStorage.get(entity);
+            const auto& agent = agentStorage.get(entity);
+            auto& compression = compStorage.get(entity);
+
+            float currentForce = 0.0f;
+
+            // [군중 간 압박]
+            for (const auto& otherEntity : posStorage.getEntities()) {
+                if (entity.index == otherEntity.index && entity.generation == otherEntity.generation) continue;
+                if (!agentStorage.contains(otherEntity)) continue;
+
+                const auto& otherPos = posStorage.get(otherEntity);
+                const auto& otherAgent = agentStorage.get(otherEntity);
+
+                float dist = distanceBetween(pos.value, otherPos.value);
+                float combinedRadius = agent.radius + otherAgent.radius;
+
+                if (dist < combinedRadius) {
+                    currentForce += (combinedRadius - dist);
+                }
+            }
+
+            // [벽/장애물 압박]
+            for (const auto& barrierEntity : barrierStorage.getEntities()) {
+                const auto& barrier = barrierStorage.get(barrierEntity);
+                const auto& vertices = barrier.geometry.vertices;
+                if (vertices.size() < 2) continue;
+
+                for (size_t i = 0; i < vertices.size() - 1; ++i) {
+                    float distToWall = distancePointToSegment(pos.value, vertices[i], vertices[i + 1]);
+                    if (distToWall < agent.radius) {
+                        currentForce += (agent.radius - distToWall);
+                    }
+                }
+                if (barrier.geometry.closed) {
+                    float distToWall = distancePointToSegment(pos.value, vertices.back(), vertices.front());
+                    if (distToWall < agent.radius) {
+                        currentForce += (agent.radius - distToWall);
+                    }
+                }
+            }
+
+            compression.force = currentForce;
+
+            // [고위험 상태 업데이트]
+            const float FORCE_THRESHOLD = 0.5f;
+            if (compression.force > FORCE_THRESHOLD) {
+                compression.exposure += dt;
+            }
+            else {
+                compression.exposure = std::max(0.0f, compression.exposure - dt * 0.5f);
+            }
+
+            const float EXPOSURE_THRESHOLD = 2.0f;
+            compression.isCritical = (compression.force > FORCE_THRESHOLD) &&
+                (compression.exposure > EXPOSURE_THRESHOLD);
+        }
+    }
+
+} // namespace safecrowd::domain

src/domain/CompressionSystem.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "engine/ComponentRegistry.h" 
+
+namespace safecrowd::domain {
+
+    // 시스템 클래스 선언
+    class CompressionSystem {
+    public:
+        // 업데이트 함수 선언
+        void update(engine::ComponentRegistry& registry, float dt);
+    };
+
+} // namespace safecrowd::domain

src/domain/Metrics.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace safecrowd::domain {
+    // 특정 에이전트가 받는 물리적/시간적 압박 상태를 담음
+    struct CompressionData {
+        // CompressionForce: 주변 객체와의 접촉으로 인해 발생하는 즉각적인 하중
+        float force = 0.0f;
+
+        // CompressionExposure: 위험 임계값 이상의 압박이 지속된 누적 시간 (단위: sec)
+        float exposure = 0.0f;
+
+        // CompressionCriticalState: 하중과 지속시간을 종합한 고위험 판정 플래그
+        bool isCritical = false;
+    };
+
+} // namespace safecrowd::domain

src/domain/Snapshot.cpp

@@ -0,0 +1,40 @@
+#include "domain/snapshot.h"
+#include "domain/AgentComponents.h"
+#include "domain/metrics.h"
+#include "engine/ComponentRegistry.h"
+
+namespace safecrowd::domain {
+
+    // 인자 타입을 safecrowd::engine::ComponentRegistry로 명확히 지정 (E0276 해결)
+    SimulationSnapshot buildSnapshot(const safecrowd::engine::ComponentRegistry& registry, uint64_t frame, float time) {
+        SimulationSnapshot snapshot;
+        snapshot.frameIndex = frame;
+        snapshot.simulationTime = time;
+
+        // 우리 엔진의 저장소(Storage)에서 데이터를 로드
+        auto& posStorage = registry.storageFor<Position>();
+        auto& compStorage = registry.storageFor<CompressionData>();
+
+        snapshot.agentCount = static_cast<uint32_t>(posStorage.size());
+        snapshot.agents.reserve(snapshot.agentCount);
+
+        // Position을 가진 모든 엔티티를 순회하며 스냅샷 생성
+        for (const auto& entity : posStorage.getEntities()) {
+            // 해당 엔티티에 압박 지표 데이터도 있는지 확인
+            if (!compStorage.contains(entity)) continue;
+
+            const auto& pos = posStorage.get(entity);
+            const auto& metrics = compStorage.get(entity);
+
+            // AgentSnapshot 구조체에 맞춰 데이터 삽입
+            snapshot.agents.push_back({
+                static_cast<uint32_t>(entity.index), // id
+                pos.value,                            // position (Point2D)
+                metrics                               // metrics (CompressionData)
+                });
+        }
+
+        return snapshot;
+    }
+
+} // namespace safecrowd::domain

src/domain/Snapshot.h

@@ -0,0 +1,29 @@
+#pragma once
+#include <vector>
+#include <cstdint>
+#include "domain/Geometry2D.h"
+#include "domain/metrics.h"
+
+namespace safecrowd::engine {
+    class ComponentRegistry;
+}
+
+namespace safecrowd::domain {
+
+    struct AgentSnapshot {
+        uint32_t id;
+        Point2D position;
+        CompressionData metrics;
+    };
+
+    struct SimulationSnapshot {
+        uint64_t frameIndex = 0;
+        float simulationTime = 0.0f;
+        uint32_t agentCount = 0;
+        std::vector<AgentSnapshot> agents;
+    };
+
+    // 네임스페이스를 safecrowd::engine으로 명시
+    SimulationSnapshot buildSnapshot(const safecrowd::engine::ComponentRegistry& registry, uint64_t frame, float time);
+
+} // namespace safecrowd::domain

src/engine/PackedComponentStorage.h

@@ -61,6 +61,10 @@ class PackedComponentStorage final : public IComponentStorage {
         return components_.size();
     }
 
+    [[nodiscard]] const std::vector<Entity>& getEntities() const noexcept {
+        return entities_;
+    }
+
 private:
     struct EntityHash {
         [[nodiscard]] std::size_t operator()(const Entity& entity) const noexcept {