feat: add basic game components with registration logic

Author: AhmedSobhy01

CMakeLists.txt

@@ -136,12 +136,20 @@ add_executable(GAME_APPLICATION
     src/common/components/free-camera-controller.cpp
     src/common/components/movement.cpp
 
+    src/game/components/collider.cpp
+    src/game/components/enemy.cpp
+    src/game/components/health.cpp
+    src/game/components/player.cpp
+    src/game/game-registration.cpp
+
     src/common/systems/forward-renderer.cpp
 )
 
 target_include_directories(GAME_APPLICATION
     PRIVATE
+        src
         src/common
+        src/game
         src/states
 )
 

src/game/components/collider.cpp

@@ -0,0 +1,24 @@
+#include "collider.hpp"
+
+namespace gameplay {
+
+    namespace {
+
+        ColliderShape parseColliderShape(const std::string& value, ColliderShape fallback) {
+            if (value == "Sphere") return ColliderShape::Sphere;
+            if (value == "Capsule") return ColliderShape::Capsule;
+            return fallback;
+        }
+
+    }  // namespace
+
+    void ColliderComponent::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) return;
+        shape = parseColliderShape(data.value("shape", std::string("Sphere")), shape);
+        layer = data.value("layer", layer);
+        radius = data.value("radius", radius);
+        height = data.value("height", height);
+        isTrigger = data.value("isTrigger", isTrigger);
+    }
+
+}  // namespace gameplay

src/game/components/collider.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <ecs/component.hpp>
+
+namespace gameplay {
+
+    enum class ColliderShape { Sphere, Capsule };
+
+    class ColliderComponent : public our::Component {
+    public:
+        ColliderShape shape = ColliderShape::Sphere;
+        std::string layer = "default";
+        float radius = 0.5f;
+        float height = 1.0f;
+        bool isTrigger = false;
+
+        static std::string getID() {
+            return "Collider";
+        }
+
+        void deserialize(const nlohmann::json& data) override;
+    };
+
+}  // namespace gameplay

src/game/components/enemy.cpp

@@ -0,0 +1,29 @@
+#include "enemy.hpp"
+
+namespace gameplay {
+
+    namespace {
+
+        EnemyType parseEnemyType(const std::string& type, EnemyType fallback) {
+            if (type == "Brute") return EnemyType::Brute;
+            if (type == "Charger") return EnemyType::Charger;
+            if (type == "Flyer") return EnemyType::Flyer;
+            return fallback;
+        }
+
+    }  // namespace
+
+    void EnemyComponent::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) return;
+        type = parseEnemyType(data.value("enemyType", std::string("Brute")), type);
+        moveSpeed = data.value("moveSpeed", moveSpeed);
+        acceleration = data.value("acceleration", acceleration);
+        turnSpeed = data.value("turnSpeed", turnSpeed);
+        aggroRange = data.value("aggroRange", aggroRange);
+        attackRange = data.value("attackRange", attackRange);
+        separationRadius = data.value("separationRadius", separationRadius);
+        preferredDistance = data.value("preferredDistance", preferredDistance);
+        scoreValue = data.value("scoreValue", scoreValue);
+    }
+
+}  // namespace gameplay

src/game/components/enemy.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <ecs/component.hpp>
+
+namespace gameplay {
+
+    enum class EnemyType { Brute, Charger, Flyer };
+
+    class EnemyComponent : public our::Component {
+    public:
+        EnemyType type = EnemyType::Brute;
+        float moveSpeed = 2.0f;
+        float acceleration = 8.0f;
+        float turnSpeed = 6.0f;
+        float aggroRange = 15.0f;
+        float attackRange = 1.5f;
+        float separationRadius = 1.0f;
+        float preferredDistance = 4.0f;
+        int scoreValue = 100;
+
+        static std::string getID() {
+            return "Enemy";
+        }
+
+        void deserialize(const nlohmann::json& data) override;
+    };
+
+}  // namespace gameplay

src/game/components/health.cpp

@@ -0,0 +1,13 @@
+#include "health.hpp"
+
+namespace gameplay {
+
+    void HealthComponent::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) return;
+        maxHealth = data.value("maxHealth", maxHealth);
+        currentHealth = data.contains("currentHealth") ? data["currentHealth"].get<float>() : maxHealth;
+        invulnerabilityTimer = data.value("invulnerabilityTimer", invulnerabilityTimer);
+        isDead = data.value("isDead", isDead);
+    }
+
+}  // namespace gameplay

src/game/components/health.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <ecs/component.hpp>
+
+namespace gameplay {
+
+    class HealthComponent : public our::Component {
+    public:
+        float maxHealth = 100.0f;
+        float currentHealth = 100.0f;
+        float invulnerabilityTimer = 0.0f;
+        bool isDead = false;
+
+        static std::string getID() {
+            return "Health";
+        }
+
+        void deserialize(const nlohmann::json& data) override;
+    };
+
+}  // namespace gameplay

src/game/components/player.cpp

@@ -0,0 +1,11 @@
+#include "player.hpp"
+
+namespace gameplay {
+
+    void PlayerComponent::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) return;
+        radius = data.value("radius", radius);
+        height = data.value("height", height);
+    }
+
+}  // namespace gameplay

src/game/components/player.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <ecs/component.hpp>
+
+namespace gameplay {
+
+    class PlayerComponent : public our::Component {
+    public:
+        float radius = 0.5f;
+        float height = 1.8f;
+
+        static std::string getID() {
+            return "Player";
+        }
+
+        void deserialize(const nlohmann::json& data) override;
+    };
+
+}  // namespace gameplay

src/game/game-registration.cpp

@@ -0,0 +1,24 @@
+#include "game-registration.hpp"
+
+#include <ecs/component-registry.hpp>
+
+#include "components/collider.hpp"
+#include "components/enemy.hpp"
+#include "components/health.hpp"
+#include "components/player.hpp"
+
+namespace gameplay {
+
+    void registerGameComponents() {
+        static bool initialized = false;
+        if (initialized) return;
+
+        our::ComponentRegistry::registerType<ColliderComponent>();
+        our::ComponentRegistry::registerType<EnemyComponent>();
+        our::ComponentRegistry::registerType<HealthComponent>();
+        our::ComponentRegistry::registerType<PlayerComponent>();
+
+        initialized = true;
+    }
+
+}  // namespace gameplay