ECS.hpp

#ifndef ECS_H
#define ECS_H
 
#include <algorithm>
#include <stdexcept>
#include <unordered_map>
#include "Types.hpp"
#include "Base.hpp"
#include "ComponentArray.hpp"
#include "SystemBase.hpp"
#include <execinfo.h>
 
namespace Engine {
  class ComponentBase{};
 
  // initializes all components to defaults or whatever
  class ECS {
    private:
      // typedefs
      typedef std::unordered_map<ComponentTypeID, IComponentDataArray*> CompIdArrayMap;
      typedef std::unordered_map<EntityID, Archetype> EntityArchMap;
      typedef std::unordered_map<SystemID, Ref<SystemBase>> SystemMap;
 
      EntityID m_entityIdCounter;
      SystemID m_systemIdCounter;
      CompIdArrayMap m_componentMap;
      EntityArchMap m_entityArch;
      SystemMap m_systems;
 
    public:
      ECS() : m_systemIdCounter(0), m_entityIdCounter(1) { }
 
      ~ECS() {
        m_componentMap.clear();
        m_entityArch.clear();
      }
 
      EntityID CreateEntityID() {
        // TODO: Check if we have too many entites
        EntityID id = GetNewID(); 
        m_entityArch[id] = Archetype().reset();
        return id;
      }
 
      template<class C>
      void RemoveComponent(const EntityID& id)
      {
        ComponentTypeID compId = GetTypeID<C>();
        if (!IsComponentRegistered<C>()){
          Log::printStackTrace();
          throw std::runtime_error("Component Not Registered!");
          return;
        }
 
        ComponentDataArray<C>* arr = getComponentArray<C>();
        m_entityArch[id].set(compId, 0);
        arr->Remove(id);
      }
 
      Archetype GetArchetype(EntityID id) {
        return m_entityArch[id];
      }
 
      template<class C>
      Ref<C> GetComponent(const EntityID& id) {
        ComponentTypeID compId = GetTypeID<C>();
        if (!IsComponentRegistered<C>()){
          Log::printStackTrace();
          throw std::runtime_error("Component Not Registered!");
          return nullptr;
        }
 
        ComponentDataArray<C>* arr = getComponentArray<C>();
        return arr->GetComp(id);
      }
 
      void RemoveEntity(const EntityID& id)
      {
        m_entityArch.erase(id);
        for (auto itr : m_componentMap) {
          itr.second->EntityDestroyed(id);
        }
      }
 
      template<class C, typename... Args>
      Ref<C> AddComponent(EntityID id, Ref<C> args) {
        ComponentTypeID compId = GetTypeID<C>();
        if (!IsComponentRegistered<C>()){
          Log::printStackTrace();
          throw std::runtime_error("Component Not Registered!");
        }
 
        // update the entity's archetype
        m_entityArch[id].set(compId, true);
        ComponentDataArray<C>* arr = getComponentArray<C>();
        return arr->Insert(id, args);
      }
 
      template<class C, typename... Args>
      Ref<C> AddComponent(EntityID id, Args&&... args) {
        ComponentTypeID compId = GetTypeID<C>();
        if (!IsComponentRegistered<C>()){
          Log::printStackTrace();
          throw std::runtime_error("Component Not Registered!");
        }
 
        // update the entity's archetype
        m_entityArch[id].set(compId, true);
        ComponentDataArray<C>* arr = getComponentArray<C>();
        return arr->Insert(id, C(std::forward<Args>(args)...));
      }
 
      SystemID RegisterSystem(Ref<SystemBase>& s) {
        // get the archetype of this system
        s->m_id = m_systemIdCounter++;
        m_systems[s->m_id] = s;
        return s->m_id;
      }
 
      void RunSystem(SystemID sid) {
        Ref<SystemBase> sys = m_systems[sid];
        // get the relevent entities and run on them
        for (auto& e : GetEntitiesWith(sys->m_arch)) {
          sys->Run(e);
        }
      }
 
      void RunSystemArch(Archetype a) {
        for (auto& itr : m_systems) {
          if (itr.second->m_arch == a) {
            RunSystem(itr.first);
          }
        }
      }
 
      template<class... Cs>
      Archetype GetArchetype() {
        Archetype arch;
 
        for(auto b : std::vector<bool>{{IsComponentRegistered<Cs>()...}}) {
          if (!b)
            Log::Err("ECS", "Oh no compnent not registered");
        }
 
        std::vector<ComponentTypeID> ids = {{GetTypeID<Cs>()...}};
        for (auto& i : ids) {
          arch.set(i, 1);
        }
 
        return arch;
      }
 
      template<class... Cs>
      std::vector<EntityID> GetEntitiesWith() {
        Archetype a = GetArchetype<Cs...>();
        std::vector<EntityID> ret;
        for (auto& itr : m_entityArch) {
          auto bits = itr.second;
          // check if the other one at least has the same bits set
          if ((itr.second & a) == a) {
            ret.push_back(itr.first);
          }
        }
        return ret;
      }
 
      std::vector<EntityID> GetEntitiesWith(Archetype a) {
        std::vector<EntityID> ret;
        for (auto& itr : m_entityArch) {
          auto bits = itr.second;
          // check if the other one at least has the same bits set
          if ((itr.second & a) == a) {
            ret.push_back(itr.first);
          }
        }
        return ret;
      }
 
      template<class C>
      void RegisterComponent() {
        ComponentTypeID typeId = GetTypeID<C>();
 
        // already registered
        if (m_componentMap.find(typeId) != m_componentMap.end())
          return;
 
        m_componentMap.emplace(typeId, new ComponentDataArray<C>);
      }
 
      template<class C>
      bool IsComponentRegistered() {
        ComponentTypeID typeId = GetTypeID<C>();
        return m_componentMap.find(typeId) != m_componentMap.end();
      }
 
 
    private:
      template<class C>
      ComponentDataArray<C>* getComponentArray() {
        const ComponentTypeID compId = GetTypeID<C>();
        if (!IsComponentRegistered<C>()){
          throw std::runtime_error("Component Not Registered!");
          return nullptr;
        }
 
        return (ComponentDataArray<C>*) m_componentMap[compId];
      }
 
      EntityID GetNewID() {
        return m_entityIdCounter++;
      }
 
      template<class C>
      ComponentTypeID GetTypeID() {
        return TypeIdGenerator<ComponentBase>::GetTypeID<C>();
      }
 
  };
 
  // Enitialize entity counter to 1 so that we can
  // reserve 0 for null
}
#endif