Entity update + components

include/object/components/component.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <utils.hpp>
+#include <string>
+
+namespace Game::Object {
+    class Entity;
+}
+
+namespace Game::Object::Components {
+    class Component {
+        public:
+            Component() = default;
+
+            // Declare copy and move; in case components declare some other things, we want to make sure those are properly copied/moved as well, so we'll just define these as virtual and implement them in the .cpp file
+            Component(const Component&);
+            Component& operator=(const Component&);
+            Component(Component&&) noexcept;
+            Component& operator=(Component&&) noexcept;
+
+            virtual ~Component() = 0;
+            virtual void start() = 0;
+            virtual void update(float deltaTime, Object::Entity* thisEntity) = 0;
+
+            // Getters and setters
+            void setName(const std::string& name);
+            std::string getName();
+            void setActive(bool active);
+            bool isActive();
+
+        protected:
+            // Uniqueness is NOT enforced; be careful when naming!
+            std::string mName;
+            bool mIsActive = true;
+    };
+}

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;
+    }
 }