Now displaying player character

1 files changed, 21 insertions, 148 deletions

@@ -6,70 +6,31 @@
 #include <set>
 #include <cassert>
 #include "component.h"
+#include "algorithms.h"
 
 class EntityManager {
   private:
     struct EntityData {
-      int parent = -1;
       std::map<std::type_index, std::unique_ptr<Component>> components;
     };
   
     std::map<int, EntityData> entities;
-    std::map<int, std::set<int>> cachedChildren;
     std::map<std::set<std::type_index>, std::set<int>> cachedComponents;
   
     int nextEntityID = 0;
     
-    bool ensureNoParentCycles(int entity, int parent)
+    template <class T, class... R>
+    std::set<int> getEntitiesWithComponentsHelper(std::set<std::type_index>& componentTypes)
     {
-      EntityData& data = entities[parent];
-      if (data.parent == entity)
-      {
-        return false;
-      } else if (data.parent == -1)
-      {
-        return true;
-      }
+      componentTypes.insert(typeid(T));
       
-      return ensureNoParentCycles(entity, data.parent);
+      return getEntitiesWithComponents<R...>(componentTypes);
     }
     
+    template <class... R>
     std::set<int> getEntitiesWithComponents(std::set<std::type_index>& componentTypes)
     {
-      if (cachedComponents.count(componentTypes) == 1)
-      {
-        return cachedComponents[componentTypes];
-      }
-      
-      std::set<int>& cache = cachedComponents[componentTypes];
-      for (auto& entity : entities)
-      {
-        EntityData& data = entity.second;
-        bool cacheEntity = true;
-        
-        for (auto& componentType : componentTypes)
-        {
-          if (data.components.count(componentType) == 0)
-          {
-            cacheEntity = false;
-            break;
-          }
-        }
-        
-        if (cacheEntity)
-        {
-          cache.insert(entity.first);
-        }
-      }
-      
-      return cache;
-    }
-    
-    template <class T, class... R> std::set<int> getEntitiesWithComponents(std::set<std::type_index>& componentTypes)
-    {
-      componentTypes.insert(typeid(T));
-      
-      return getEntitiesWithComponents<R...>(componentTypes);
+      return getEntitiesWithComponentsHelper<R...>(componentTypes);
     }
     
   public:
@@ -107,26 +68,6 @@ class EntityManager {
     {
       assert(entities.count(entity) == 1);
       
-      EntityData& data = entities[entity];
-      
-      // Destroy the children
-      std::set<int> children = getChildren(entity);
-      for (int child : children)
-      {
-        EntityData& childData = entities[child];
-        childData.parent = -1;
-        
-        deleteEntity(child);
-      }
-      
-      // Uncache children
-      cachedChildren.erase(entity);
-      
-      if ((data.parent != -1) && (cachedChildren.count(data.parent) == 1))
-      {
-        cachedChildren[data.parent].erase(entity);
-      }
-      
       // Uncache components
       for (auto& cache : cachedComponents)
       {
@@ -137,81 +78,8 @@ class EntityManager {
       entities.erase(entity);
     }
     
-    std::set<int> getChildren(int parent)
-    {
-      assert(entities.count(parent) == 1);
-      
-      if (cachedChildren.count(parent) == 1)
-      {
-        return cachedChildren[parent];
-      }
-      
-      std::set<int>& cache = cachedChildren[parent];
-      for (auto& entity : entities)
-      {
-        EntityData& data = entity.second;
-        if (data.parent == parent)
-        {
-          cache.insert(entity.first);
-        }
-      }
-      
-      return cache;
-    }
-    
-    void setParent(int entity, int parent)
-    {
-      assert(entities.count(entity) == 1);
-      assert(entities.count(parent) == 1);
-      assert(ensureNoParentCycles(entity, parent));
-      
-      EntityData& data = entities[entity];
-      
-      // Remove from old parent
-      if (data.parent != -1)
-      {
-        if (cachedChildren.count(data.parent) == 1)
-        {
-          cachedChildren[data.parent].erase(entity);
-        }
-      }
-      
-      data.parent = parent;
-      
-      // Cache new parent
-      if (cachedChildren.count(parent) == 1)
-      {
-        cachedChildren[parent].insert(entity);
-      }
-    }
-    
-    void setNoParent(int entity)
-    {
-      assert(entities.count(entity) == 1);
-      
-      EntityData& data = entities[entity];
-      
-      // Remove from old parent
-      if (data.parent != -1)
-      {
-        if (cachedChildren.count(data.parent) == 1)
-        {
-          cachedChildren[data.parent].erase(entity);
-        }
-      }
-      
-      data.parent = -1;
-    }
-    
-    int getParent(int entity)
-    {
-      assert(entities.count(entity) == 1);
-      
-      EntityData& data = entities[entity];
-      return data.parent;
-    }
-    
-    template <class T, class... Args> T& emplaceComponent(int entity, Args&&... args)
+    template <class T, class... Args>
+    T& emplaceComponent(int entity, Args&&... args)
     {
       assert(entities.count(entity) == 1);
       
@@ -226,14 +94,15 @@ class EntityManager {
       data.components[componentType] = std::move(ptr);
       
       // Invalidate related caches
-      std::remove_if(begin(cachedComponents), end(cachedComponents), [&] (std::pair<std::set<std::type_index>, int>& cache) {
+      erase_if(cachedComponents, [&componentType] (std::pair<const std::set<std::type_index>, std::set<int>>& cache) {
         return cache.first.count(componentType) == 1;
       });
       
       return component;
     }
     
-    template <class T> void removeComponent(int entity)
+    template <class T>
+    void removeComponent(int entity)
     {
       assert(entities.count(entity) == 1);
       
@@ -255,7 +124,8 @@ class EntityManager {
       }
     }
     
-    template <class T> T& getComponent(int entity)
+    template <class T>
+    T& getComponent(int entity)
     {
       assert(entities.count(entity) == 1);
       
@@ -264,16 +134,19 @@ class EntityManager {
       
       assert(data.components.count(componentType) == 1);
       
-      return *(data.components[componentType]);
+      return *((T*)data.components[componentType].get());
     }
     
-    template <class T, class... R> std::set<int> getEntitiesWithComponents()
+    template <class... R>
+    std::set<int> getEntitiesWithComponents()
     {
       std::set<std::type_index> componentTypes;
-      componentTypes.insert(typeid(T));
       
-      return getEntitiesWithComponents<R...>(componentTypes);
+      return getEntitiesWithComponentsHelper<R...>(componentTypes);
     }
 };
 
+template <>
+std::set<int> EntityManager::getEntitiesWithComponents<>(std::set<std::type_index>& componentTypes);
+
 #endif /* end of include guard: ENTITY_MANAGER_H_C5832F11 */