component_manager.hpp

#pragma once
 
#include <memory>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
#include "compact_list.hpp"
#include "sparse_list.hpp"
 
template <typename T, typename... Types>
class ComponentIterator;
class Editor;
class Entity {
 public:
  friend ComponentManager;
  friend ComponentIterator;
 private:
  explicit Entity(const unsigned i) : id_(i) {}
  explicit operator unsigned() { return id_; }
  unsigned id_ = 0;
};
 
struct RenderTreeCmp;
 
class ComponentManager {
 public:
  //friend Editor;
  ComponentManager();
  ~ComponentManager() = default;
  ComponentManager(const ComponentManager&) = delete;
  ComponentManager& operator=(const ComponentManager&) = delete;
  ComponentManager& operator= (ComponentManager&&) = default;
 
  template <typename... T>
  Entity addEntity(Entity* parent, const std::string& editor_name,
                   const T&... args) {
    Entity e = addEntityEmpty(parent, editor_name);
    // Loops through the template arguments executing the lambda.
    ([&] { setComponent(e, args); }(), ...);
    return e;
  }
 
  void deleteEntity(Entity& entity);
 
  template <typename T>
  void addComponentClass(ComponentListType t = ComponentListType::kCompact) {
    if (t == ComponentListType::kSparse) {
      component_lists_.emplace(typeid(T).hash_code(),
                               std::make_unique<ComponentListSparse<T>>());
    } else {
      component_lists_.emplace(typeid(T).hash_code(),
                               std::make_unique<ComponentListCompact<T>>());
    }
  }
 
  template <typename T>
  void setComponent(const Entity& entity, const T& component) {
    auto comp_base = component_lists_.find(typeid(T).hash_code());
    if (comp_base->second.get()->type_ == ComponentListType::kSparse) {
      ComponentListSparse<T>* component_vector =
          static_cast<ComponentListSparse<T>*>(comp_base->second.get());
      component_vector->components_[entity.id_ - 1].emplace(component);
 
    } else {
      ComponentListCompact<T>* component_vector =
          static_cast<ComponentListCompact<T>*>(comp_base->second.get());
      component_vector->setComponent(entity.id_, component);
    }
  }
 
  template <typename T>
  T* getComponent(Entity entity) const{
    auto comp_base = component_lists_.find(typeid(T).hash_code());
    if (comp_base->second.get()->type_ == ComponentListType::kSparse) {
      ComponentListSparse<T>* component_vector =
          static_cast<ComponentListSparse<T>*>(comp_base->second.get());
      return &component_vector->components_[entity.id_ - 1].value();
 
    } else {
      ComponentListCompact<T>* component_vector =
          static_cast<ComponentListCompact<T>*>(comp_base->second.get());
      return component_vector->getComp(static_cast<unsigned>(entity));
    }
  }
 
  template <typename T>
  T* getComponent(unsigned entity) const{
    auto comp_base = component_lists_.find(typeid(T).hash_code());
    if (comp_base->second.get()->type_ == ComponentListType::kSparse) {
      ComponentListSparse<T>* component_vector =
          static_cast<ComponentListSparse<T>*>(comp_base->second.get());
      if(component_vector->components_[entity - 1].has_value()) {
        return &component_vector->components_[entity - 1].value();
      }
      return nullptr;
 
    } else {
      ComponentListCompact<T>* component_vector =
          static_cast<ComponentListCompact<T>*>(comp_base->second.get());
      return component_vector->getComp(entity);
    }
  }
 
  template <typename T>
  ComponentListCompact<T>& getComponentList() const{
    auto comp_base = component_lists_.find(typeid(T).hash_code());
    ComponentListCompact<T>* component_vector =
        static_cast<ComponentListCompact<T>*>(comp_base->second.get());
    return *component_vector;
  }
 
  template <typename T>
  ComponentListSparse<T>& getSparseList() const{
    auto comp_base = component_lists_.find(typeid(T).hash_code());
    ComponentListSparse<T>* component_vector =
        static_cast<ComponentListSparse<T>*>(comp_base->second.get());
    return *component_vector;
  }
 
 private:
  Entity addEntityEmpty(Entity* parent, const std::string& editor_name);
 
  void innerDelete(unsigned i);
  
  RenderTreeCmp* getRender(unsigned ent) const;
 
  // map containint all component lists
  std::unordered_map<std::size_t, std::unique_ptr<ComponentListBase>>
      component_lists_;
 
  // marks the positions where entities have been freed so that they can be
  // filled with new components to avoid blanks in the compoent vectors
  std::vector<unsigned> freed_entities_;
 
  // biggest entity id or position in the array
  unsigned current_entity_;
};