feat: add component registry and basic gameplay components (#19)

* feat: implement component registration system for game components

* feat: add game component classes for collider, enemy, health, and player

* refactor: use std::function for factory map

---------

Co-authored-by: AhmedAmrNabil <ahmedamr24680@gmail.com>

Author: AhmedSobhy01

CMakeLists.txt

@@ -136,12 +136,19 @@ 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/common
+        src/game
         src/states
 )
 

src/common/components/component-deserializer.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "../ecs/component-registry.hpp"
 #include "../ecs/entity.hpp"
 #include "camera.hpp"
 #include "free-camera-controller.hpp"
@@ -8,20 +9,24 @@
 
 namespace our {
 
+    inline void registerCommonComponents() {
+        static bool initialized = false;
+        if (initialized) return;
+
+        ComponentRegistry::registerType<CameraComponent>();
+        ComponentRegistry::registerType<FreeCameraControllerComponent>();
+        ComponentRegistry::registerType<MovementComponent>();
+        ComponentRegistry::registerType<MeshRendererComponent>();
+
+        initialized = true;
+    }
+
     // Given a json object, this function picks and creates a component in the given entity
     // based on the "type" specified in the json object which is later deserialized from the rest of the json object
     inline void deserializeComponent(const nlohmann::json& data, Entity* entity) {
+        registerCommonComponents();
         std::string type = data.value("type", "");
-        Component* component = nullptr;
-        if (type == CameraComponent::getID()) {
-            component = entity->addComponent<CameraComponent>();
-        } else if (type == FreeCameraControllerComponent::getID()) {
-            component = entity->addComponent<FreeCameraControllerComponent>();
-        } else if (type == MovementComponent::getID()) {
-            component = entity->addComponent<MovementComponent>();
-        } else if (type == MeshRendererComponent::getID()) {
-            component = entity->addComponent<MeshRendererComponent>();
-        }
+        Component* component = ComponentRegistry::create(type, entity);
         if (component) component->deserialize(data);
     }
 

src/common/ecs/component-registry.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <unordered_map>
+
+#include "entity.hpp"
+
+namespace our {
+
+    class ComponentRegistry {
+    private:
+        template <typename T>
+        static Component* createComponent(Entity* entity) {
+            return entity->addComponent<T>();
+        }
+
+        static inline std::unordered_map<std::string, std::function<Component*(Entity*)>> factories = {};
+
+    public:
+        template <typename T>
+        static void registerType() {
+            factories[T::getID()] = createComponent<T>;
+        }
+
+        static Component* create(const std::string& type, Entity* entity) {
+            auto it = factories.find(type);
+
+            if (it == factories.end()) return nullptr;
+
+            return it->second(entity);
+        }
+    };
+
+}  // namespace our

src/game/components/collider.cpp

@@ -0,0 +1,20 @@
+#include "collider.hpp"
+
+static gameplay::ColliderShape parseColliderShape(const std::string& value, gameplay::ColliderShape fallback) {
+    if (value == "Sphere") return gameplay::ColliderShape::Sphere;
+    if (value == "Capsule") return gameplay::ColliderShape::Capsule;
+    return fallback;
+}
+
+namespace gameplay {
+
+    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,25 @@
+#include "enemy.hpp"
+
+static gameplay::EnemyType parseEnemyType(const std::string& type, gameplay::EnemyType fallback) {
+    if (type == "Brute") return gameplay::EnemyType::Brute;
+    if (type == "Charger") return gameplay::EnemyType::Charger;
+    if (type == "Flyer") return gameplay::EnemyType::Flyer;
+    return fallback;
+}
+
+namespace gameplay {
+
+    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