Entity.h

Go to the documentation of this file.

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

        void enableTick(bool enable);
 
        void setTickPriority(int32_t priority);
        [[nodiscard]] int32_t getTickPriority() const { return tickPriority_; }

        void tick(double deltaTime) override;

        template<typename T, typename... Args>
        requires std::is_base_of_v<Components::Logic, T> && std::is_constructible_v<T, Args...>
        T* addComponent(Args&&... args) {
 
            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_unique<T>(std::forward<Args>(args)...);
            component->setOwningEntity(this);
            T* rawComponent = component.get();
            components_.push_back(std::move(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 rawComponent;
        }

        template<typename T>
        requires std::is_base_of_v<Components::Logic, T>
        T* getComponent() const {
            for (const auto& component : components_) {
                if (auto typed = dynamic_cast<T*>(component.get())) {
                    return typed;
                }
            }
            return nullptr;
        }

        template<typename T>
        requires std::is_base_of_v<Components::Logic, T>
        std::vector<T*> getComponents() const {
            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(Components::Logic* 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>
        requires std::is_base_of_v<Components::Logic, T>
        bool removeFirstComponent() {
            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>
        requires std::is_base_of_v<Components::Logic, T>
        bool hasComponent() const {
            return getComponent<T>() != nullptr;
        }

        [[nodiscard]] const std::vector<std::unique_ptr<Components::Logic>>& getAllComponents() const {
            return components_;
        }

        [[nodiscard]] bool canTick() const;

        [[nodiscard]] bool canEverTick() const;

        [[nodiscard]] entt::entity getEcsEntity() const { return data_; }
 
    protected:
        uuids::uuid getUUID() const { return uuid_; }

        std::string getUuidString() const;

        std::vector<std::unique_ptr<Components::Logic>> components_;
 
        entt::entity data_ = entt::null;
 
        bool allowTicking_ = false;
        int32_t tickPriority_ = 0;
    private:
        uuids::uuid uuid_;
    };
 
}