11 files changed, 266 insertions, 152 deletions

@@ -0,0 +1,12 @@
+#ifndef ALGORITHMS_H_1DDC517E
+#define ALGORITHMS_H_1DDC517E
+
+template< typename ContainerT, typename PredicateT >
+void erase_if( ContainerT& items, const PredicateT& predicate ) {
+  for( auto it = items.begin(); it != items.end(); ) {
+    if( predicate(*it) ) it = items.erase(it);
+    else ++it;
+  }
+};
+
+#endif /* end of include guard: ALGORITHMS_H_1DDC517E */
@@ -0,0 +1,27 @@
+#include "sprite_renderable.h"
+
+SpriteRenderableComponent::SpriteRenderableComponent(const char* filename, int frame_width, int frame_height, int frames_across)
+  : texture(filename), frame_width(frame_width), frame_height(frame_height), frames_across(frames_across)
+{
+  
+}
+
+int SpriteRenderableComponent::getFrame() const
+{
+  return frame;
+}
+
+void SpriteRenderableComponent::setFrame(int frame)
+{
+  this->frame = frame;
+}
+
+const Texture& SpriteRenderableComponent::getTexture() const
+{
+  return texture;
+}
+
+Rectangle SpriteRenderableComponent::getFrameRect() const
+{
+  return {frame_width * (frame % frames_across), frame_height * (frame / frames_across), frame_width, frame_height};
+}
@@ -0,0 +1,25 @@
+#ifndef SPRITE_RENDERABLE_H_D3AACBBF
+#define SPRITE_RENDERABLE_H_D3AACBBF
+
+#include "component.h"
+#include "renderer.h"
+
+class SpriteRenderableComponent : public Component {
+  public:
+    SpriteRenderableComponent(const char* filename, int frame_width, int frame_height, int frames_across);
+    
+    int getFrame() const;
+    void setFrame(int frame);
+    
+    const Texture& getTexture() const;
+    Rectangle getFrameRect() const;
+    
+  private:
+    Texture texture;
+    int frame_width;
+    int frame_height;
+    int frames_across;
+    int frame = 0;
+};
+
+#endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */
@@ -0,0 +1,47 @@
+#include "transformable.h"
+
+TransformableComponent::TransformableComponent(double x, double y, int w, int h)
+  : x(x), y(y), w(w), h(h)
+{
+  
+}
+
+double TransformableComponent::getX() const
+{
+  return x;
+}
+
+double TransformableComponent::getY() const
+{
+  return y;
+}
+
+int TransformableComponent::getW() const
+{
+  return w;
+}
+
+int TransformableComponent::getH() const
+{
+  return h;
+}
+
+void TransformableComponent::setX(double v)
+{
+  x = v;
+}
+
+void TransformableComponent::setY(double v)
+{
+  y = v;
+}
+
+void TransformableComponent::setW(int v)
+{
+  w = v;
+}
+
+void TransformableComponent::setH(int v)
+{
+  h = v;
+}
@@ -0,0 +1,27 @@
+#ifndef LOCATABLE_H_39E526CA
+#define LOCATABLE_H_39E526CA
+
+#include "component.h"
+
+class TransformableComponent : public Component {
+  public:
+    TransformableComponent(double x, double y, int w, int h);
+    
+    double getX() const;
+    double getY() const;
+    int getW() const;
+    int getH() const;
+    
+    void setX(double v);
+    void setY(double v);
+    void setW(int v);
+    void setH(int v);
+    
+  private:
+    double x;
+    double y;
+    int w;
+    int h;
+};
+
+#endif /* end of include guard: LOCATABLE_H_39E526CA */
@@ -0,0 +1,38 @@
+#ifndef ENTITY_MANAGER_CPP_42D78C22
+#define ENTITY_MANAGER_CPP_42D78C22
+
+#include "entity_manager.h"
+
+template <>
+std::set<int> EntityManager::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;
+}
+
+#endif /* end of include guard: ENTITY_MANAGER_CPP_42D78C22 */
@@ -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 */
@@ -4,22 +4,39 @@
 #include "renderer.h"
 #include "muxer.h"
 #include "entity_manager.h"
+#include "components/sprite_renderable.h"
+#include "components/transformable.h"
+#include "systems/rendering.h"
 
 int main()
 {
   srand(time(NULL));
   
   GLFWwindow* window = initRenderer();
+  glfwSwapInterval(1);
+  
   initMuxer();
   
   // Put this in a block so game goes out of scope before we destroy the renderer
   {
     EntityManager manager;
     
-    int eRef = manager.emplaceEntity();
-    int eRef2 = manager.emplaceEntity();
-    manager.setParent(eRef, eRef2);
-    printf("%d\n", manager.getParent(eRef));
+    int player = manager.emplaceEntity();
+    manager.emplaceComponent<SpriteRenderableComponent>(player, "res/Starla.png", 10, 12, 6);
+    manager.emplaceComponent<TransformableComponent>(player, 203, 44, 10, 12);
+    
+    std::list<std::unique_ptr<System>> loop;
+    loop.push_back(std::unique_ptr<System>(new RenderingSystem()));
+    
+    while (!glfwWindowShouldClose(window))
+    {
+      for (auto& sys : loop)
+      {
+        sys->tick(manager, 1.0);
+      }
+      
+      glfwPollEvents();
+    }
   }
   
   destroyMuxer();
@@ -0,0 +1,11 @@
+#ifndef SYSTEM_H_B61A8CEA
+#define SYSTEM_H_B61A8CEA
+
+class EntityManager;
+
+class System {
+  public:
+    virtual void tick(EntityManager& manager, float dt) = 0;
+};
+
+#endif /* end of include guard: SYSTEM_H_B61A8CEA */
@@ -0,0 +1,21 @@
+#include "rendering.h"
+#include "entity_manager.h"
+#include "components/sprite_renderable.h"
+#include "components/transformable.h"
+
+void RenderingSystem::tick(EntityManager& manager, float dt)
+{
+  texture.fill(texture.entirety(), 0, 0, 0);
+  
+  std::set<int> spriteEntities = manager.getEntitiesWithComponents<SpriteRenderableComponent, TransformableComponent>();
+  for (int entity : spriteEntities)
+  {
+    auto& sprite = manager.getComponent<SpriteRenderableComponent>(entity);
+    auto& transform = manager.getComponent<TransformableComponent>(entity);
+    Rectangle dstrect {(int) transform.getX(), (int) transform.getY(), transform.getW(), transform.getH()};
+    
+    texture.blit(sprite.getTexture(), sprite.getFrameRect(), dstrect);
+  }
+  
+  texture.renderScreen();
+}
@@ -0,0 +1,16 @@
+#ifndef RENDERING_H_76ABC02A
+#define RENDERING_H_76ABC02A
+
+#include "system.h"
+#include "renderer.h"
+#include "consts.h"
+
+class RenderingSystem : public System {
+  public:
+    void tick(EntityManager& manager, float dt);
+    
+  private:
+    Texture texture {GAME_WIDTH, GAME_HEIGHT};
+};
+
+#endif /* end of include guard: RENDERING_H_76ABC02A */