EntityContainer.h

#pragma once
 
#include "Engine/Entity/Entity.h"
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <plog/Log.h>
 
namespace Engine::Entities
{
    class EntityContainer
    {
    public:
        virtual ~EntityContainer();

        template <class T, typename... Args>
        requires std::is_base_of_v<Entity, T> && std::is_constructible_v<T, Args...>
        T * spawnEntity( Args &&... args )
        {
            auto entity = std::make_unique<T>( std::forward<Args>( args )... );
            return adoptEntity( std::move( entity ) );
        }

        template <class T>
        requires std::is_base_of_v<Entity, T>
        T * adoptEntity( std::unique_ptr<T> entity )
        {
            if ( entity == nullptr )
            {
                PLOGW << "Attempted to adopt a null entity.";
                return nullptr;
            }
 
            if ( entity->owningContainer_ != nullptr )
            {
                PLOGW << "Attempted to adopt an entity that already has an owning container.";
                return nullptr;
            }
 
            T * rawEntity = entity.get();
            rawEntity->owningContainer_ = this;
            entities_.push_back( std::move( entity ) );
            ++revision_;
 
            onEntitySpawned( *rawEntity );
            rawEntity->engineBeginPlay();
 
            return rawEntity;
        }

        void destroyEntity( Entity * entity );

        void destroyEntityImmediate( Entity * entity );

        void flushPendingEntityDestruction();

        void cleanupEntities();

        void reserve( std::size_t capacity );

        [[nodiscard]] std::vector<Entity *> getEntities() const;

        [[nodiscard]] std::uint64_t getRevision() const { return revision_; }

        template<typename Func>
        void forEachEntity(Func&& func) const
        {
            for (const auto& entity : entities_)
            {
                if (entity != nullptr)
                {
                    func(entity.get());
                }
            }
        }
 
    protected:
        virtual void onEntitySpawned( Entity & entity );

        virtual void onEntityDestroyed( Entity & entity );
 
    private:
        std::vector<std::unique_ptr<Entity>> entities_;
        std::vector<Entity *>                pendingDestroyEntities_;
        std::uint64_t                        revision_ = 0;
    };
}  // namespace Engine::Entities