Entity update + components

include/object/entity.hpp

@@ -8,6 +8,8 @@
 #include <utility>
 #include <memory>
 #include <renderer/renderer.hpp>
+#include <vector>
+#include <object/components/component.hpp>
 
 namespace Game::Renderer {
     class Renderer;
@@ -44,14 +46,57 @@ namespace Game::Object {
             bool isActive() { return mIsActive; }
             int getZIndex() const { return mZIndex; }
 
+            // Component management
+            template<typename T, typename... Args>
+            T* addComponent(Args&&... args);
+            template<typename T>
+            T* getComponent();
+            template<typename T>
+            bool removeComponent();
+            void updateComponents(float deltaTime);
+
         protected:
             std::string mName;
             std::shared_ptr<Game::Renderer::Texture> mTex;
             Transform mTransform;
             bool mIsFlipped = false; // Whether the texture should be rendered flipped horizontally or not
-            bool mIsActive;
+            bool mIsActive = true;
+            bool mIsVisible = true;
             int mZIndex = 0; // For rendering order; higher zIndex renders on top of lower zIndex
             float mTiledScale = 1.f; // Only used if the texture is tiled, to determine how much to scale the texture when rendering (since the entire texture is rendered as a single tile, this is necessary to be able to have different sized tiles)
+            std::vector<std::unique_ptr<Object::Components::Component>> mComponents; // Components attached to this entity; TODO
         private:
     };
+
+    template<typename T, typename... Args>
+    T* Entity::addComponent(Args&&... args) {
+        static_assert(std::is_base_of_v<Object::Components::Component, T>, "T must derive from Component");
+        auto component = std::make_unique<T>(std::forward<Args>(args)...);
+        T* componentPtr = component.get();
+        mComponents.push_back(std::move(component));
+        return componentPtr;
+    }
+
+    template<typename T>
+    T* Entity::getComponent() {
+        static_assert(std::is_base_of_v<Object::Components::Component, T>, "T must derive from Component");
+        for (const auto& component : mComponents) {
+            if (auto casted = dynamic_cast<T*>(component.get())) {
+                return casted;
+            }
+        }
+        return nullptr;
+    }
+
+    template<typename T>
+    bool Entity::removeComponent() {
+        static_assert(std::is_base_of_v<Object::Components::Component, T>, "T must derive from Component");
+        for (auto it = mComponents.begin(); it != mComponents.end(); it++) {
+            if (dynamic_cast<T*>(it->get())) {
+                mComponents.erase(it);
+                return true;
+            }
+        }
+        return false;
+    }
 }