Entity.h

Go to the documentation of this file.

#pragma once
#include <Engine/Core/Tick.h>
#include <vector>
#include <memory>
#include <algorithm>
#include <plog/Log.h>
#include <entt/entt.hpp>
#include "uuid/uuid.h"
#include "Engine/Component/LogicComponent.h"
 
namespace EngineCore{
    class Entity : public ITickable, protected std::enable_shared_from_this<Entity> {
    public:
        Entity();
        virtual ~Entity();

        void enableTick(bool enable);

        void tick(double deltaTime) override;

        template<typename T, typename... Args>
        T* addComponent(Args&&... args) {
            static_assert(std::is_base_of_v<LogicComponent, T>, "T must derive from LogicComponent");
 
            if constexpr (T::IsUnique) {
                T* existing = getComponent<T>();
                if (existing) {
                    PLOGW << "Attempted to add unique component " << typeid(T).name() << " which already exists on entity.";
                    return existing;
                }
            }
 
            auto component = std::make_shared<T>(std::forward<Args>(args)...);
            component->setOwningEntity(this);
            components.push_back(component);
 
            // If the entity is already initialized (e.g. gameplay started), we might want to call beginPlay immediately?
            // For now, we assume standard flow where components are added before play or beginPlay handles late init if needed.
            // But typical pattern is to call beginPlay() if the actor has already begun play.
            // We will leave that responsibility to the caller or Actor subclass for now to keep Entity simple.
            // Note: Actor implementation will need to ensure new components get initialized.
 
            return component.get();
        }

        template<typename T>
        T* getComponent() const {
            static_assert(std::is_base_of_v<LogicComponent, T>, "T must derive from LogicComponent");
            for (const auto& component : components) {
                if (auto typed = dynamic_cast<T*>(component.get())) {
                    return typed;
                }
            }
            return nullptr;
        }

        template<typename T>
        std::vector<T*> getComponents() const {
            static_assert(std::is_base_of_v<LogicComponent, T>, "T must derive from LogicComponent");
            std::vector<T*> result;
            for (const auto& component : components) {
                if (auto typed = dynamic_cast<T*>(component.get())) {
                    result.push_back(typed);
                }
            }
            return result;
        }

        void removeComponent(LogicComponent* component) {
            auto it = std::ranges::find_if(components, [component](const auto& ptr) {
                return ptr.get() == component;
            });
 
            if (it != components.end()) {
                (*it)->endPlay(); // Ensure cleanup
                components.erase(it);
            }
        }

        template<typename T>
        bool removeFirstComponent() {
            static_assert(std::is_base_of_v<LogicComponent, T>, "T must derive from LogicComponent");
            auto it = std::ranges::find_if(components, [](const auto& ptr) {
                return dynamic_cast<T*>(ptr.get()) != nullptr;
            });
 
            if (it != components.end()) {
                (*it)->endPlay();
                components.erase(it);
                return true;
            }
            return false;
        }

        template<typename T>
        bool hasComponent() const {
            return getComponent<T>() != nullptr;
        }

        [[nodiscard]] bool canTick() const;

        [[nodiscard]] bool canEverTick() const;
    protected:
        uuids::uuid getUUID() const { return uuid; }

        std::string getUuidString() const;

        std::vector<std::shared_ptr<LogicComponent>> components;
 
        entt::entity data = entt::null;
    protected:
        bool allowTicking = false;
    private:
        uuids::uuid uuid;
    };
 
}