ecs.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <iostream>
#include <memory>
#include <queue>
#include <set>
 
#include "entity.hpp"
#include "log.hpp"
#include "registry.hpp"
#include "view.hpp"
 
namespace Easys {
 
template <typename... AllComponentTypes>
class ECS {
   public:
    ECS()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        for (Entity entity = 0; entity < MAX_ENTITIES; entity++)
        {
            availableEntityIds_.push(entity);
        }
    }
 
    ECS(const std::set<Entity>& oldEntities)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        // I decided against an addEntity(Entity) method to discourage
        // tampering with entities too much. I think this really should be the ECS's
        // responsibility.
        for (Entity entity = 0; entity < MAX_ENTITIES; entity++)
        {
            if (oldEntities.contains(entity))
            {
                entities_.insert(entity);
            } else
            {
                availableEntityIds_.push(entity);
            }
        }
    }
 
    inline Entity addEntity()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        if (getEntityCount() < MAX_ENTITIES)
        {
            Entity e = availableEntityIds_.front();
            availableEntityIds_.pop();
            entities_.insert(e);
 
            EASYS_LOG_INFO(EASYS_E_STR(e));
            return e;
        }
        EASYS_LOG_ERROR("addEntity(): MAX_ENTITIES reached.");
        // throwing an exception here seems kind of drastic, but on the other hand
        // maybe not
        throw std::runtime_error("MAX NUMBER OF ENTITIES REACHED!");
    }
 
    inline void removeEntity(const Entity e)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        // Remove all components associated with the entity
        registry_.removeComponents(e);
        // Remove entity from the set of active entities_
        entities_.erase(e);
        // Make the entity ID available again
        availableEntityIds_.push(e);
 
        EASYS_LOG_INFO(EASYS_E_STR(e));
    }
 
    inline bool hasEntity(const Entity e) const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return entities_.contains(e);
    }
 
    //inline std::set<Entity> getEntities() const
    //{
    //  EASYS_LOG_ENTRY_EXIT;
 
    //  return entities_;
    //}
 
    inline View getEntities() const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        std::vector<Entity> vec;
        vec.reserve(entities_.size());
        vec.assign(entities_.begin(), entities_.end());
 
        return View(std::move(vec));
    }
 
    //template <typename... Ts>
    //inline std::vector<Entity> getEntities() const
    //{
    //  EASYS_LOG_ENTRY_EXIT;
 
    //  // return View(registry_.template getEntities<Ts...>());
    //  return registry_.template getEntities<Ts...>();
    //}
 
    template <typename... Ts>
    inline View getEntities() const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return View(std::move(registry_.template getEntities<Ts...>()));
    }
 
    inline size_t getEntityCount() const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return entities_.size();
    }
 
    template <typename T>
    inline void addComponent(const Entity e, T component)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        //  TODO: maybe we should check, if the entity already has a component of type T, mainly so emitted event types
        // are consistent.
        registry_.addComponent(e, std::move(component));
 
        EASYS_LOG_INFO(EASYS_EC_STR(e));
    }
 
    template <typename T, typename Func>
    inline void modifyComponent(const Entity e, Func&& fn)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        // we need the component for event dispatch, so we handle it manually.
        T& c = getComponent<T>(e);
        fn(c);
        // registry_.template modifyComponent<T>(e, fn);
 
        EASYS_LOG_INFO(EASYS_EC_STR(e));
    }
 
    template <typename T>
    inline void modifyComponent(const Entity e, T c)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        // we need the component for event dispatch, so we handle it manually.
        getComponent<T>(e) = c;
        // registry_.template modifyComponent<T>(e, c);
 
        EASYS_LOG_INFO(EASYS_EC_STR(e));
    }
 
    template <typename T>
    inline void removeComponent(const Entity e)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        registry_.template removeComponent<T>(e);
 
        EASYS_LOG_INFO(EASYS_EC_STR(e));
    }
 
    template <typename... Ts>
    inline void removeComponents(const Entity e)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        (removeComponent<Ts>(e), ...);
    }
 
    inline void removeComponents(const Entity e)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        removeComponents<AllComponentTypes...>(e);
        // (removeComponent<AllComponentTypes>(e), ...);
    }
 
    template <typename T>
    inline T& getComponent(const Entity e)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return registry_.template getComponent<T>(e);
    }
 
    template <typename T>
    inline const T& getComponent(const Entity e) const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return registry_.template getComponent<T>(e);
    }
 
    template <typename T>
    inline T& getComponentOr(const Entity e, T& c)
    {
        EASYS_LOG_ENTRY_EXIT;
 
        if (hasComponent<T>(e))
        {
            return registry_.template getComponent<T>(e);
        }
        return c;
    }
 
    template <typename T>
    inline const T& getComponentOr(const Entity e, const T& c) const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        if (hasComponent<T>(e))
        {
            return registry_.template getComponent<T>(e);
        }
        return c;
    }
 
    template <typename T>
    inline bool hasComponent(const Entity e) const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return registry_.template hasComponent<T>(e);
    }
 
    template <typename... Ts>
    inline size_t getComponentCount() const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return registry_.template size<Ts...>();
    }
 
    inline size_t getComponentCount() const
    {
        EASYS_LOG_ENTRY_EXIT;
 
        return getComponentCount<AllComponentTypes...>();
        // return registry_.size();
    }
 
    template <typename T>
    inline void clearComponent()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        registry_.template clear<T>();
 
        EASYS_LOG_INFO(std::format("Clearing all components of type {}", typeid(T).name()));
    }
 
    template <typename... Ts>
    inline void clearComponents()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        // registry_.template clear<Ts...>();
        (clearComponent<Ts>(), ...);
    }
 
    inline void clearComponents()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        (clearComponent<AllComponentTypes>(), ...);
        // registry_.clear();
    }
 
    inline void clear()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        clearComponents();
        clearEntities();
    }
 
   private:
    std::queue<Entity> availableEntityIds_;
    std::set<Entity> entities_;
    Registry<AllComponentTypes...> registry_;
 
    void clearEntities()
    {
        EASYS_LOG_ENTRY_EXIT;
 
        entities_.clear();
 
        std::queue<Entity> empty;
        std::swap(availableEntityIds_, empty);
 
        for (Entity entity = 0; entity < MAX_ENTITIES; entity++)
        {
            availableEntityIds_.push(entity);
        }
 
        EASYS_LOG_INFO("Cleared all entities");
    }
};
 
}  // namespace Easys