53 files changed, 933 insertions, 1930 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,7 @@
+#ifndef COMPONENT_H_F0CE4573
+#define COMPONENT_H_F0CE4573
+
+class Component {
+};
+
+#endif /* end of include guard: COMPONENT_H_F0CE4573 */
@@ -1,142 +0,0 @@
-#include "ai.h"
-#include <cstdlib>
-#include "entity.h"
-
-void AIActionContainer::addAction(std::shared_ptr<AIAction> action)
-{
-  actions.push_back(action);
-}
-
-void AIActionContainer::start(Game& game, Entity& entity)
-{
-  currentAction = begin(actions);
-  
-  if (currentAction != end(actions))
-  {
-    (*currentAction)->start(game, entity);
-  }
-}
-
-void AIActionContainer::perform(Game& game, Entity& entity, double dt)
-{
-  if (!isDone())
-  {
-    (*currentAction)->perform(game, entity, dt);
-  
-    if ((*currentAction)->isDone())
-    {
-      currentAction++;
-      
-      if (!isDone())
-      {
-        (*currentAction)->start(game, entity);
-      }
-    }
-  }
-}
-
-bool AIActionContainer::isDone() const
-{
-  return currentAction == end(actions);
-}
-
-AI::AI(int chance)
-{
-  this->chance = chance;
-}
-
-int AI::getChance() const
-{
-  return chance;
-}
-
-AI& AIComponent::emplaceAI(int chance)
-{
-  maxChance += chance;
-  ais.emplace_back(chance);
-  
-  return ais.back();
-}
-
-void AIComponent::tick(Game& game, Entity& entity, double dt)
-{
-  if (currentAI == nullptr)
-  {
-    int toChoose = rand() % maxChance;
-    for (auto& ai : ais)
-    {
-      if (toChoose < ai.getChance())
-      {
-        currentAI = &ai;
-        break;
-      } else {
-        toChoose -= ai.getChance();
-      }
-    }
-    
-    if (currentAI != nullptr)
-    {
-      currentAI->start(game, entity);
-    }
-  }
-  
-  if (currentAI != nullptr)
-  {
-    currentAI->perform(game, entity, dt);
-  
-    if (currentAI->isDone())
-    {
-      currentAI = nullptr;
-    }
-  }
-}
-
-MoveAIAction::MoveAIAction(Direction dir, int len, int speed)
-{
-  this->dir = dir;
-  this->len = len;
-  this->speed = speed;
-}
-
-void MoveAIAction::start(Game& game, Entity& entity)
-{
-  remaining = len;
-}
-
-void MoveAIAction::perform(Game&, Entity& entity, double dt)
-{
-  double dist = dt * speed;
-  remaining -= dist;
-  
-  switch (dir)
-  {
-    case Direction::Left:
-    {
-      entity.position.first -= dist;
-      break;
-    }
-    
-    case Direction::Right:
-    {
-      entity.position.first += dist;
-      break;
-    }
-    
-    case Direction::Up:
-    {
-      entity.position.second -= dist;
-      break;
-    }
-    
-    case Direction::Down:
-    {
-      entity.position.second += dist;
-      break;
-    }
-  }
-}
-
-bool MoveAIAction::isDone() const
-{
-  return remaining <= 0.0;
-}
@@ -1,73 +0,0 @@
-#ifndef AI_H
-#define AI_H
-
-#include <list>
-#include <map>
-#include <string>
-#include <memory>
-
-#include "entity.h"
-
-class AIAction {
-  public:
-    virtual void start(Game& game, Entity& entity) = 0;
-    virtual void perform(Game& game, Entity& entity, double dt) = 0;
-    virtual bool isDone() const = 0;
-};
-
-class AIActionContainer {
-  public:
-    void addAction(std::shared_ptr<AIAction> action);
-    virtual void start(Game& game, Entity& entity);
-    virtual void perform(Game& game, Entity& entity, double dt);
-    virtual bool isDone() const;
-  
-  private:
-    std::list<std::shared_ptr<AIAction>> actions;
-    std::list<std::shared_ptr<AIAction>>::iterator currentAction {end(actions)};
-};
-
-class AI : public AIActionContainer {
-  public:
-    AI(int chance);
-    
-    int getChance() const;
-    
-  private:
-    int chance;
-};
-
-class AIComponent : public Component {
-  public:
-    AI& emplaceAI(int chance);
-    void tick(Game& game, Entity& entity, double dt);
-
-  private:
-    int maxChance = 0;
-    std::list<AI> ais;
-    AI* currentAI = nullptr;
-};
-
-class MoveAIAction : public AIAction {
-  public:
-    enum class Direction {
-      Left,
-      Right,
-      Up,
-      Down
-    };
-    
-    MoveAIAction(Direction dir, int len, int speed);
-    
-    void start(Game& game, Entity& entity);
-    void perform(Game& game, Entity& entity, double dt);
-    bool isDone() const;
-    
-  private:
-    Direction dir;
-    int len;
-    int speed;
-    double remaining;
-};
-
-#endif /* end of include guard: AI_H */
@@ -0,0 +1,27 @@
+#include "animatable.h"
+
+AnimatableComponent::AnimatableComponent(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 AnimatableComponent::getFrame() const
+{
+  return frame;
+}
+
+void AnimatableComponent::setFrame(int frame)
+{
+  this->frame = frame;
+}
+
+const Texture& AnimatableComponent::getTexture() const
+{
+  return texture;
+}
+
+Rectangle AnimatableComponent::getFrameRect() const
+{
+  return {frame_width * (frame % frames_across), frame_height * (frame / frames_across), frame_width, frame_height};
+}
@@ -0,0 +1,31 @@
+#ifndef SPRITE_RENDERABLE_H_D3AACBBF
+#define SPRITE_RENDERABLE_H_D3AACBBF
+
+#include "component.h"
+#include "renderer.h"
+#include "direction.h"
+
+class AnimatableComponent : public Component {
+  public:
+    AnimatableComponent(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;
+    
+    void setDirection(Direction dir) {};
+    void setWalking(bool w) {};
+    void setJumping(bool w) {};
+    void setCrouching(bool w) {};
+    
+  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,71 @@
+#include "controllable.h"
+
+int ControllableComponent::getLeftKey() const
+{
+  return leftKey;
+}
+
+void ControllableComponent::setLeftKey(int k)
+{
+  leftKey = k;
+}
+
+int ControllableComponent::getRightKey() const
+{
+  return rightKey;
+}
+
+void ControllableComponent::setRightKey(int k)
+{
+  rightKey = k;
+}
+
+int ControllableComponent::getJumpKey() const
+{
+  return jumpKey;
+}
+
+void ControllableComponent::setJumpKey(int k)
+{
+  jumpKey = k;
+}
+
+int ControllableComponent::getDropKey() const
+{
+  return dropKey;
+}
+
+void ControllableComponent::setDropKey(int k)
+{
+  dropKey = k;
+}
+
+bool ControllableComponent::isFrozen() const
+{
+  return frozen;
+}
+
+void ControllableComponent::setFrozen(bool f)
+{
+  frozen = f;
+}
+
+bool ControllableComponent::isHoldingLeft() const
+{
+  return holdingLeft;
+}
+
+void ControllableComponent::setHoldingLeft(bool f)
+{
+  holdingLeft = f;
+}
+
+bool ControllableComponent::isHoldingRight() const
+{
+  return holdingRight;
+}
+
+void ControllableComponent::setHoldingRight(bool f)
+{
+  holdingRight = f;
+}
@@ -0,0 +1,36 @@
+#ifndef CONTROLLABLE_H_4E0B85B4
+#define CONTROLLABLE_H_4E0B85B4
+
+#include "component.h"
+#include "renderer.h"
+
+class ControllableComponent : public Component {
+  public:
+    int getLeftKey() const;
+    void setLeftKey(int k);
+    int getRightKey() const;
+    void setRightKey(int k);
+    int getJumpKey() const;
+    void setJumpKey(int k);
+    int getDropKey() const;
+    void setDropKey(int k);
+    
+    bool isFrozen() const;
+    void setFrozen(bool f);
+    bool isHoldingLeft() const;
+    void setHoldingLeft(bool f);
+    bool isHoldingRight() const;
+    void setHoldingRight(bool f);
+    
+  private:
+    int leftKey = GLFW_KEY_LEFT;
+    int rightKey = GLFW_KEY_RIGHT;
+    int jumpKey = GLFW_KEY_UP;
+    int dropKey = GLFW_KEY_DOWN;
+    
+    bool frozen = false;
+    bool holdingLeft = false;
+    bool holdingRight = false;
+};
+
+#endif /* end of include guard: CONTROLLABLE_H_4E0B85B4 */
@@ -0,0 +1,11 @@
+#include "droppable.h"
+
+void DroppableComponent::setDroppable(bool can)
+{
+  droppable = can;
+}
+
+bool DroppableComponent::isDroppable() const
+{
+  return droppable;
+}
@@ -0,0 +1,15 @@
+#ifndef DROPPABLE_H_5DB254EF
+#define DROPPABLE_H_5DB254EF
+
+#include "component.h"
+
+class DroppableComponent : public Component {
+  public:
+    void setDroppable(bool can);
+    bool isDroppable() const;
+    
+  private:
+    bool droppable = false;
+};
+
+#endif /* end of include guard: DROPPABLE_H_5DB254EF */
@@ -1,241 +0,0 @@
-#include "map_collision.h"
-#include "map.h"
-#include "game.h"
-#include "consts.h"
-
-MapCollisionComponent::MapCollisionComponent(const Map& map) : map(map)
-{
-  addCollision(-6, 0, MAP_HEIGHT*TILE_HEIGHT, Direction::left, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Left).type));
-  addCollision(GAME_WIDTH+6, 0, MAP_HEIGHT*TILE_HEIGHT, Direction::right, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Right).type));
-  addCollision(-6, 0, GAME_WIDTH, Direction::up, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Up).type));
-  addCollision(MAP_HEIGHT*TILE_HEIGHT+6, 0, GAME_WIDTH, Direction::down, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Down).type));
-  
-  for (int i=0; i<MAP_WIDTH*MAP_HEIGHT; i++)
-  {
-    int x = i % MAP_WIDTH;
-    int y = i / MAP_WIDTH;
-    int tile = map.getMapdata()[i];
-    
-    if ((tile > 0) && (tile < 28) && (!((tile >= 5) && (tile <= 7))))
-    {
-      addCollision(x*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, Direction::right, Collision::Type::wall);
-      addCollision((x+1)*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, Direction::left, Collision::Type::wall);
-      addCollision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::down, Collision::Type::wall);
-      addCollision((y+1)*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::up, Collision::Type::wall);
-    } else if ((tile >= 5) && (tile <= 7))
-    {
-      addCollision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::down, Collision::Type::platform);
-    } else if (tile == 42)
-    {
-      addCollision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::down, Collision::Type::danger);
-    }
-  }
-}
-
-void MapCollisionComponent::addCollision(double axis, double lower, double
-   upper, Direction dir, Collision::Type type)
-{
-  std::list<Collision>::iterator it;
-  
-  switch (dir)
-  {
-    case Direction::up:
-      it = up_collisions.begin();
-      for (; it!=up_collisions.end(); it++)
-      {
-        if (it->axis < axis) break;
-      }
-    
-      up_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case Direction::down:
-      it = down_collisions.begin();
-      for (; it!=down_collisions.end(); it++)
-      {
-        if (it->axis > axis) break;
-      }
-    
-      down_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case Direction::left:
-      it = left_collisions.begin();
-      for (; it!=left_collisions.end(); it++)
-      {
-        if (it->axis < axis) break;
-      }
-  
-      left_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case Direction::right:
-      it = right_collisions.begin();
-      for (; it!=right_collisions.end(); it++)
-      {
-        if (it->axis > axis) break;
-      }
-  
-      right_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-  }
-}
-
-void MapCollisionComponent::detectCollision(Game& game, Entity&, Entity& collider, std::pair<double, double> old_position)
-{
-  if (collider.position.first < old_position.first)
-  {
-    for (auto collision : left_collisions)
-    {
-      if (collision.axis > old_position.first) continue;
-      if (collision.axis < collider.position.first) break;
-  
-      if ((old_position.second+collider.size.second > collision.lower) && (old_position.second < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::left, old_position);
-    
-        break;
-      }
-    }
-  } else if (collider.position.first > old_position.first)
-  {
-    for (auto collision : right_collisions)
-    {
-      if (collision.axis < old_position.first+collider.size.first) continue;
-      if (collision.axis > collider.position.first+collider.size.first) break;
-  
-      if ((old_position.second+collider.size.second > collision.lower) && (old_position.second < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::right, old_position);
-    
-        break;
-      }
-    }
-  }
-  
-  if (collider.position.second < old_position.second)
-  {
-    for (auto collision : up_collisions)
-    {
-      if (collision.axis > old_position.second) continue;
-      if (collision.axis < collider.position.second) break;
-  
-      if ((collider.position.first+collider.size.first > collision.lower) && (collider.position.first < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::up, old_position);
-    
-        break;
-      }
-    }
-  } else if (collider.position.second > old_position.second)
-  {
-    for (auto collision : down_collisions)
-    {
-      if (collision.axis < old_position.second+collider.size.second) continue;
-      if (collision.axis > collider.position.second+collider.size.second) break;
-
-      if ((collider.position.first+collider.size.first > collision.lower) && (collider.position.first < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::down, old_position);
-        
-        break;
-      }
-    }
-  }
-}
-
-void MapCollisionComponent::processCollision(Game& game, Entity& collider, Collision collision, Direction dir, std::pair<double, double> old_position)
-{
-  if (collision.type == Collision::Type::wall)
-  {
-    if (dir == Direction::left)
-    {
-      collider.position.first = collision.axis;
-      
-      Message msg(Message::Type::setHorizontalVelocity);
-      msg.velocity = 0.0;
-      collider.send(game, msg);
-    } else if (dir == Direction::right)
-    {
-      collider.position.first = collision.axis - collider.size.first;
-
-      Message msg(Message::Type::setHorizontalVelocity);
-      msg.velocity = 0.0;
-      collider.send(game, msg);
-    } else if (dir == Direction::up)
-    {
-      collider.position.second = collision.axis;
-
-      Message msg(Message::Type::setVerticalVelocity);
-      msg.velocity = 0.0;
-      collider.send(game, msg);
-    } else if (dir == Direction::down)
-    {
-      collider.position.second = collision.axis - collider.size.second;
-      collider.send(game, Message::Type::hitTheGround);
-    }
-  } else if (collision.type == Collision::Type::wrap)
-  {
-    if (dir == Direction::left)
-    {
-      collider.position.first = GAME_WIDTH-collider.size.first/2;
-    } else if (dir == Direction::right)
-    {
-      collider.position.first = -collider.size.first/2;
-    } else if (dir == Direction::up)
-    {
-      collider.position.second = GAME_HEIGHT-collider.size.second/2-1;
-    } else if (dir == Direction::down)
-    {
-      collider.position.second = -collider.size.second/2;
-    }
-  } else if (collision.type == Collision::Type::teleport)
-  {
-    if (dir == Direction::left)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Left).map), std::make_pair(GAME_WIDTH-collider.size.first/2, old_position.second));
-    } else if (dir == Direction::right)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Right).map), std::make_pair(-collider.size.first/2, old_position.second));
-    } else if (dir == Direction::up)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Up).map), std::make_pair(old_position.first, MAP_HEIGHT*TILE_HEIGHT-collider.size.second/2));
-    } else if (dir == Direction::down)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Down).map), std::make_pair(old_position.first, -collider.size.second/2));
-    }
-  } else if (collision.type == Collision::Type::reverse)
-  {
-    // TODO reverse
-    if (dir == Direction::right)
-    {
-      collider.position.first = collision.axis - collider.size.first;
-      collider.send(game, Message::Type::walkLeft);
-    }
-  } else if (collision.type == Collision::Type::platform)
-  {
-    Message msg(Message::Type::drop);
-    msg.dropAxis = collision.axis;
-
-    collider.send(game, msg);
-  } else if (collision.type == Collision::Type::danger)
-  {
-    game.playerDie();
-  }
-}
-
-MapCollisionComponent::Collision::Type MapCollisionComponent::collisionFromMoveType(Map::MoveType type)
-{
-  switch (type)
-  {
-    case Map::MoveType::Wall: return Collision::Type::wall;
-    case Map::MoveType::Wrap: return Collision::Type::wrap;
-    case Map::MoveType::Warp: return Collision::Type::teleport;
-    case Map::MoveType::ReverseWarp: return Collision::Type::reverse;
-  }
-}
@@ -1,47 +0,0 @@
-#ifndef MAP_COLLISION_H
-#define MAP_COLLISION_H
-
-#include "entity.h"
-#include "map.h"
-#include <list>
-
-class Game;
-
-class MapCollisionComponent : public Component {
-  public:
-    MapCollisionComponent(const Map& map);
-    void detectCollision(Game& game, Entity& entity, Entity& collider, std::pair<double, double> old_position);
-    
-  private:
-    enum class Direction {
-      up, left, down, right
-    };
-
-    struct Collision {
-      enum class Type {
-        wall,
-        wrap,
-        teleport,
-        reverse,
-        platform,
-        danger
-      };
-      
-      double axis;
-      double lower;
-      double upper;
-      Type type;
-    };
-    
-    void addCollision(double axis, double lower, double upper, Direction dir, Collision::Type type);
-    void processCollision(Game& game, Entity& collider, Collision collision, Direction dir, std::pair<double, double> old_position);
-    Collision::Type collisionFromMoveType(Map::MoveType type);
-    
-    std::list<Collision> left_collisions;
-    std::list<Collision> right_collisions;
-    std::list<Collision> up_collisions;
-    std::list<Collision> down_collisions;
-    const Map& map;
-};
-
-#endif
@@ -1,40 +0,0 @@
-#include "map_render.h"
-#include "map.h"
-#include "game.h"
-#include "consts.h"
-
-MapRenderComponent::MapRenderComponent(const Map& map) : screen(GAME_WIDTH, GAME_HEIGHT)
-{
-  screen.fill(screen.entirety(), 0, 0, 0);
-  
-  Texture tiles("res/tiles.png");
-  
-  for (int i=0; i<MAP_WIDTH*MAP_HEIGHT; i++)
-  {
-    int tile = map.getMapdata()[i];
-    int x = i % MAP_WIDTH;
-    int y = i / MAP_WIDTH;
-    Rectangle dst {x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
-    Rectangle src {tile%8*TILE_WIDTH, tile/8*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
-
-    if (tile > 0)
-    {
-      screen.blit(tiles, src, dst);
-    }
-  }
-  
-  Texture font("res/font.bmp");
-  std::string map_name = map.getTitle();
-  int start_x = (40/2) - (map_name.length()/2);
-  for (size_t i=0; i<map_name.length(); i++)
-  {
-    Rectangle srcRect {map_name[i] % 16 * 8, map_name[i] / 16 * 8, 8, 8};
-    Rectangle dstRect {(start_x + (int)i)*8, 24*8, 8, 8};
-    screen.blit(font, srcRect, dstRect);
-  }
-}
-
-void MapRenderComponent::render(Game&, Entity&, Texture& buffer)
-{
-  buffer.blit(screen, screen.entirety(), buffer.entirety());
-}
@@ -1,19 +0,0 @@
-#ifndef MAP_RENDER_H
-#define MAP_RENDER_H
-
-#include "entity.h"
-#include "renderer.h"
-
-class Map;
-class Game;
-
-class MapRenderComponent : public Component {
-  public:
-    MapRenderComponent(const Map& map);
-    void render(Game& game, Entity& entity, Texture& buffer);
-    
-  private:
-    Texture screen;
-};
-
-#endif
@@ -1,66 +0,0 @@
-#include "physics_body.h"
-#include "game.h"
-#include "consts.h"
-
-void PhysicsBodyComponent::receive(Game&, Entity&, const Message& msg)
-{
-  if (msg.type == Message::Type::walkLeft)
-  {
-    velocity.first = -90;
-  } else if (msg.type == Message::Type::walkRight)
-  {
-    velocity.first = 90;
-  } else if (msg.type == Message::Type::stopWalking)
-  {
-    velocity.first = 0.0;
-  } else if (msg.type == Message::Type::setHorizontalVelocity)
-  {
-    velocity.first = msg.velocity;
-  } else if (msg.type == Message::Type::setVerticalVelocity)
-  {
-    velocity.second = msg.velocity;
-  }
-}
-
-void PhysicsBodyComponent::tick(Game&, Entity& entity, double dt)
-{
-  // Accelerate
-  velocity.first += accel.first * dt;
-  velocity.second += accel.second * dt;
-  
-  // Terminal velocity
-#define TERMINAL_VELOCITY_X (2 * TILE_WIDTH * FRAMES_PER_SECOND)
-#define TERMINAL_VELOCITY_Y (2 * TILE_HEIGHT * FRAMES_PER_SECOND)
-  if (velocity.first < -TERMINAL_VELOCITY_X) velocity.first = -TERMINAL_VELOCITY_X;
-  if (velocity.first > TERMINAL_VELOCITY_X) velocity.first = TERMINAL_VELOCITY_X;
-  if (velocity.second < -TERMINAL_VELOCITY_Y) velocity.second = -TERMINAL_VELOCITY_Y;
-  if (velocity.second > TERMINAL_VELOCITY_Y) velocity.second = TERMINAL_VELOCITY_Y;
-  
-  // Do the movement
-  entity.position.first += velocity.first * dt;
-  entity.position.second += velocity.second * dt;
-}
-
-void PhysicsBodyComponent::detectCollision(Game& game, Entity& entity, Entity& collider, std::pair<double, double> old_position)
-{
-  // If already colliding, do nothing!
-  if ((old_position.first + collider.size.first > entity.position.first)
-    && (old_position.first < entity.position.first + entity.size.first)
-    && (old_position.second + collider.size.second > entity.position.second)
-    && (old_position.second < entity.position.second + entity.size.second))
-  {
-    return;
-  }
-  
-  // If newly colliding, SHOCK AND HORROR!
-  if ((collider.position.first + collider.size.first > entity.position.first)
-    && (collider.position.first < entity.position.first + entity.size.first)
-    && (collider.position.second + collider.size.second > entity.position.second)
-    && (collider.position.second < entity.position.second + entity.size.second))
-  {
-    Message msg(Message::Type::collision);
-    msg.collisionEntity = &collider;
-    
-    entity.send(game, msg);
-  }
-}
@@ -1,20 +0,0 @@
-#ifndef PHYSICS_BODY_H
-#define PHYSICS_BODY_H
-
-#include "entity.h"
-#include <utility>
-
-class Game;
-
-class PhysicsBodyComponent : public Component {
-  public:
-    void receive(Game& game, Entity& entity, const Message& msg);
-    void tick(Game& game, Entity& entity, double dt);
-    void detectCollision(Game& game, Entity& entity, Entity& collider, std::pair<double, double> old_position);
-    
-  protected:    
-    std::pair<double, double> velocity;
-    std::pair<double, double> accel;
-};
-
-#endif
@@ -1,118 +0,0 @@
-#include "player_physics.h"
-#include "muxer.h"
-#include "game.h"
-#include "consts.h"
-
-#define JUMP_VELOCITY(h, l) (-2 * (h) / (l))
-#define JUMP_GRAVITY(h, l) (2 * ((h) / (l)) / (l))
-
-PlayerPhysicsComponent::PlayerPhysicsComponent()
-{
-  jump_velocity = JUMP_VELOCITY(TILE_HEIGHT*4.5, 0.3);
-  jump_gravity = JUMP_GRAVITY(TILE_HEIGHT*4.5, 0.3);
-  jump_gravity_short = JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233);
-  
-  accel.second = jump_gravity_short;
-}
-
-void PlayerPhysicsComponent::receive(Game&, Entity& entity, const Message& msg)
-{
-  if (msg.type == Message::Type::walkLeft)
-  {
-    velocity.first = -90;
-    direction = -1;
-  } else if (msg.type == Message::Type::walkRight)
-  {
-    velocity.first = 90;
-    direction = 1;
-  } else if (msg.type == Message::Type::stopWalking)
-  {
-    velocity.first = 0.0;
-    direction = 0;
-  } else if (msg.type == Message::Type::setHorizontalVelocity)
-  {
-    velocity.first = msg.velocity;
-  } else if (msg.type == Message::Type::setVerticalVelocity)
-  {
-    velocity.second = msg.velocity;
-  } else if (msg.type == Message::Type::hitTheGround)
-  {
-    if (isFalling)
-    {
-      playSound("res/Randomize27.wav", 0.05);
-      isFalling = false;
-    }
-    
-    velocity.second = 0.0;
-  } else if (msg.type == Message::Type::jump)
-  {
-    playSound("res/Randomize87.wav", 0.25);
-    
-    velocity.second = jump_velocity;
-    accel.second = jump_gravity;
-  } else if (msg.type == Message::Type::stopJump)
-  {
-    accel.second = jump_gravity_short;
-  } else if (msg.type == Message::Type::canDrop)
-  {
-    canDrop = true;
-  } else if (msg.type == Message::Type::cantDrop)
-  {
-    canDrop = false;
-  } else if (msg.type == Message::Type::drop)
-  {
-    if (canDrop)
-    {
-      canDrop = false;
-    } else {
-      entity.position.second = msg.dropAxis - entity.size.second;
-      velocity.second = 0;
-    }
-  } else if (msg.type == Message::Type::die)
-  {
-    frozen = true;
-  } else if (msg.type == Message::Type::stopDying)
-  {
-    frozen = false;
-  }
-}
-
-void PlayerPhysicsComponent::tick(Game& game, Entity& entity, double dt)
-{
-  // If frozen, do nothing
-  if (frozen)
-  {
-    return;
-  }
-  
-  // Continue walking even if blocked earlier
-  if (velocity.first == 0)
-  {
-    if (direction < 0)
-    {
-      velocity.first = -90;
-    } else if (direction > 0)
-    {
-      velocity.first = 90;
-    }
-  }
-  
-  // Increase gravity at the height of jump
-  if ((accel.second == jump_gravity) && (velocity.second >= 0))
-  {
-    accel.second = jump_gravity_short;
-  }
-  
-  // Do the movement
-  std::pair<double, double> old_position = entity.position;
-  PhysicsBodyComponent::tick(game, entity, dt);
-    
-  // Check for collisions
-  game.detectCollision(entity, old_position);
-  
-  // Are we moving due to gravity?
-  if (velocity.second != 0.0)
-  {
-    isFalling = true;
-  }
-}
@@ -1,25 +0,0 @@
-#ifndef PLAYER_PHYSICS_H
-#define PLAYER_PHYSICS_H
-
-#include "entity.h"
-#include "physics_body.h"
-
-class Game;
-
-class PlayerPhysicsComponent : public PhysicsBodyComponent {
-  public:
-    PlayerPhysicsComponent();
-    void tick(Game& game, Entity& entity, double dt);
-    void receive(Game& game, Entity& entity, const Message& msg);
-    
-  private:
-    double jump_velocity;
-    double jump_gravity;
-    double jump_gravity_short;
-    int direction = 0;
-    bool canDrop = false;
-    bool frozen = false;
-    bool isFalling = false;
-};
-
-#endif
@@ -1,60 +0,0 @@
-#include "player_sprite.h"
-
-PlayerSpriteComponent::PlayerSpriteComponent() : sprite("res/Starla.png")
-{
-  
-}
-
-void PlayerSpriteComponent::render(Game&, Entity& entity, Texture& buffer)
-{
-  animFrame++;
-  
-  int frame = 0;
-  if (isMoving)
-  {
-    frame += 2;
-    
-    if (animFrame % 20 < 10)
-    {
-      frame += 2;
-    }
-  }
-  
-  if (facingLeft)
-  {
-    frame++;
-  }
-  
-  double alpha = 1.0;
-  if (dying && (animFrame % 4 < 2))
-  {
-    alpha = 0.0;
-  }
-  
-  Rectangle src_rect {frame*10, 0, 10, 12};
-  Rectangle dst_rect {(int) entity.position.first, (int) entity.position.second, entity.size.first, entity.size.second};
-  buffer.blit(sprite, src_rect, dst_rect, alpha);
-}
-
-void PlayerSpriteComponent::receive(Game&, Entity&, const Message& msg)
-{
-  if (msg.type == Message::Type::walkLeft)
-  {
-    facingLeft = true;
-    isMoving = true;
-  } else if (msg.type == Message::Type::walkRight)
-  {
-    facingLeft = false;
-    isMoving = true;
-  } else if (msg.type == Message::Type::stopWalking)
-  {
-    isMoving = false;
-  } else if (msg.type == Message::Type::die)
-  {
-    dying = true;
-    isMoving = false;
-  } else if (msg.type == Message::Type::stopDying)
-  {
-    dying = false;
-  }
-}
@@ -1,23 +0,0 @@
-#ifndef PLAYER_SPRITE_H
-#define PLAYER_SPRITE_H
-
-#include "entity.h"
-#include "renderer.h"
-
-class Game;
-
-class PlayerSpriteComponent : public Component {
-  public:
-    PlayerSpriteComponent();
-    void render(Game& game, Entity& entity, Texture& buffer);
-    void receive(Game& game, Entity& entity, const Message& msg);
-    
-  private:
-    Texture sprite;
-    int animFrame = 0;
-    bool facingLeft = false;
-    bool isMoving = false;
-    bool dying = false;
-};
-
-#endif
@@ -0,0 +1,41 @@
+#include "ponderable.h"
+
+double PonderableComponent::getVelocityX() const
+{
+  return velocityX;
+}
+
+void PonderableComponent::setVelocityX(double v)
+{
+  velocityX = v;
+}
+
+double PonderableComponent::getVelocityY() const
+{
+  return velocityY;
+}
+
+void PonderableComponent::setVelocityY(double v)
+{
+  velocityY = v;
+}
+
+double PonderableComponent::getAccelX() const
+{
+  return accelX;
+}
+
+void PonderableComponent::setAccelX(double v)
+{
+  accelX = v;
+}
+
+double PonderableComponent::getAccelY() const
+{
+  return accelY;
+}
+
+void PonderableComponent::setAccelY(double v)
+{
+  accelY = v;
+}
@@ -0,0 +1,24 @@
+#ifndef TANGIBLE_H_746DB3EE
+#define TANGIBLE_H_746DB3EE
+
+#include "component.h"
+
+class PonderableComponent : public Component {
+  public:
+    double getVelocityX() const;
+    void setVelocityX(double v);
+    double getVelocityY() const;
+    void setVelocityY(double v);
+    double getAccelX() const;
+    void setAccelX(double v);
+    double getAccelY() const;
+    void setAccelY(double v);
+    
+  private:
+    double velocityX = 0.0;
+    double velocityY = 0.0;
+    double accelX = 0.0;
+    double accelY = 0.0;
+};
+
+#endif /* end of include guard: TANGIBLE_H_746DB3EE */
@@ -1,14 +0,0 @@
-#include "simple_collider.h"
-
-SimpleColliderComponent::SimpleColliderComponent(std::function<void (Game& game, Entity& collider)> callback) : callback(callback)
-{
-  
-}
-
-void SimpleColliderComponent::receive(Game& game, Entity&, const Message& msg)
-{
-  if (msg.type == Message::Type::collision)
-  {
-    callback(game, *msg.collisionEntity);
-  }
-}
@@ -1,18 +0,0 @@
-#ifndef SIMPLE_COLLIDER_H
-#define SIMPLE_COLLIDER_H
-
-#include "entity.h"
-#include <functional>
-
-class Game;
-
-class SimpleColliderComponent : public Component {
-  public:
-    SimpleColliderComponent(std::function<void (Game& game, Entity& collider)> callback);
-    void receive(Game& game, Entity& entity, const Message& msg);
-    
-  private:
-    std::function<void (Game& game, Entity& collider)> callback;
-};
-
-#endif
@@ -1,11 +0,0 @@
-#include "static_image.h"
-
-StaticImageComponent::StaticImageComponent(const char* filename) : sprite(Texture(filename))
-{
-  
-}
-
-void StaticImageComponent::render(Game&, Entity& entity, Texture& buffer)
-{
-  buffer.blit(sprite, sprite.entirety(), {(int) entity.position.first, (int) entity.position.second, entity.size.first, entity.size.second});
-}
@@ -1,18 +0,0 @@
-#ifndef STATIC_IMAGE_H
-#define STATIC_IMAGE_H
-
-#include "entity.h"
-#include "renderer.h"
-
-class Game;
-
-class StaticImageComponent : public Component {
-  public:
-    StaticImageComponent(const char* filename);
-    void render(Game& game, Entity& entity, Texture& buffer);
-    
-  private:
-    Texture sprite;
-};
-
-#endif
@@ -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 */
@@ -1,100 +0,0 @@
-#include "user_movement.h"
-#include "renderer.h"
-
-void UserMovementComponent::input(Game& game, Entity& entity, int key, int action)
-{
-  if (action == GLFW_PRESS)
-  {
-    if (key == GLFW_KEY_LEFT)
-    {
-      holdingLeft = true;
-      
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::walkLeft);
-      }
-    } else if (key == GLFW_KEY_RIGHT)
-    {
-      holdingRight = true;
-      
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::walkRight);
-      }
-    } else if (key == GLFW_KEY_UP)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::jump);
-      }
-    } else if (key == GLFW_KEY_DOWN)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::canDrop);
-      }
-    }
-  } else if (action == GLFW_RELEASE)
-  {
-    if (key == GLFW_KEY_LEFT)
-    {
-      holdingLeft = false;
-      
-      if (!frozen)
-      {
-        if (holdingRight)
-        {
-          entity.send(game, Message::Type::walkRight);
-        } else {
-          entity.send(game, Message::Type::stopWalking);
-        }
-      }
-    } else if (key == GLFW_KEY_RIGHT)
-    {
-      holdingRight = false;
-      
-      if (!frozen)
-      {
-        if (holdingLeft)
-        {
-          entity.send(game, Message::Type::walkLeft);
-        } else {
-          entity.send(game, Message::Type::stopWalking);
-        }
-      }
-    } else if (key == GLFW_KEY_DOWN)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::cantDrop);
-      }
-    } else if (key == GLFW_KEY_UP)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::stopJump);
-      }
-    }
-  }
-}
-
-void UserMovementComponent::receive(Game& game, Entity& entity, const Message& msg)
-{
-  if (msg.type == Message::Type::die)
-  {
-    frozen = true;
-    
-    entity.send(game, Message::Type::stopWalking);
-  } else if (msg.type == Message::Type::stopDying)
-  {
-    frozen = false;
-    
-    if (holdingLeft)
-    {
-      entity.send(game, Message::Type::walkLeft);
-    } else if (holdingRight)
-    {
-      entity.send(game, Message::Type::walkRight);
-    }
-  }
-}
@@ -1,19 +0,0 @@
-#ifndef USER_MOVEMENT_H
-#define USER_MOVEMENT_H
-
-#include "entity.h"
-
-class Game;
-
-class UserMovementComponent : public Component {
-  public:
-    void input(Game& game, Entity& entity, int key, int action);
-    void receive(Game&, Entity&, const Message& msg);
-      
-  private:
-    bool holdingLeft = false;
-    bool holdingRight = false;
-    bool frozen = false;
-};
-
-#endif
@@ -11,4 +11,7 @@ const int MAP_HEIGHT = GAME_HEIGHT/TILE_HEIGHT - 1;
 const int FRAMES_PER_SECOND = 60;
 const double SECONDS_PER_FRAME = 1.0 / FRAMES_PER_SECOND;
 
+#define JUMP_VELOCITY(h, l) (-2 * (h) / (l))
+#define JUMP_GRAVITY(h, l) (2 * ((h) / (l)) / (l))
+
 #endif
@@ -0,0 +1,11 @@
+#ifndef DIRECTION_H_9C49EAFD
+#define DIRECTION_H_9C49EAFD
+
+enum class Direction {
+  Left,
+  Right,
+  Up,
+  Down
+};
+
+#endif /* end of include guard: DIRECTION_H_9C49EAFD */
@@ -1,46 +0,0 @@
-#include "entity.h"
-
-void Entity::addComponent(std::shared_ptr<Component> c)
-{
-  components.push_back(c);
-}
-
-void Entity::send(Game& game, const Message& msg)
-{
-  for (auto component : components)
-  {
-    component->receive(game, *this, msg);
-  }
-}
-
-void Entity::tick(Game& game, double dt)
-{
-  for (auto component : components)
-  {
-    component->tick(game, *this, dt);
-  }
-}
-
-void Entity::input(Game& game, int key, int action)
-{
-  for (auto component : components)
-  {
-    component->input(game, *this, key, action);
-  }
-}
-
-void Entity::render(Game& game, Texture& buffer)
-{
-  for (auto component : components)
-  {
-    component->render(game, *this, buffer);
-  }
-}
-
-void Entity::detectCollision(Game& game, Entity& collider, std::pair<double, double> old_position)
-{
-  for (auto component : components)
-  {
-    component->detectCollision(game, *this, collider, old_position);
-  }
-}
@@ -1,64 +0,0 @@
-#ifndef ENTITY_H
-#define ENTITY_H
-
-#include <list>
-#include "renderer.h"
-
-class Game;
-class Map;
-class Entity;
-class Component;
-
-class Message {
-  public:
-    enum class Type {
-      walkLeft,
-      walkRight,
-      stopWalking,
-      setHorizontalVelocity,
-      setVerticalVelocity,
-      collision,
-      jump,
-      stopJump,
-      drop,
-      canDrop,
-      cantDrop,
-      die,
-      stopDying,
-      hitTheGround
-    };
-    
-    Message(Type type) : type(type) {}
-    
-    Type type;
-    Entity* collisionEntity;
-    int dropAxis;
-    double velocity;
-};
-
-class Entity {
-  public:
-    void addComponent(std::shared_ptr<Component> c);
-    void send(Game& game, const Message& msg);
-    void tick(Game& game, double dt);
-    void input(Game& game, int key, int action);
-    void render(Game& game, Texture& buffer);
-    void detectCollision(Game& game, Entity& collider, std::pair<double, double> old_position);
-    
-    std::pair<double, double> position;
-    std::pair<int, int> size;
-    
-  private:
-    std::list<std::shared_ptr<Component>> components;
-};
-
-class Component {
-  public:
-    virtual void receive(Game&, Entity&, const Message&) {}
-    virtual void render(Game&, Entity&, Texture&) {}
-    virtual void tick(Game&, Entity&, double) {}
-    virtual void input(Game&, Entity&, int, int) {}
-    virtual void detectCollision(Game&, Entity&, Entity&, std::pair<double, double>) {}
-};
-
-#endif
@@ -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 */
@@ -0,0 +1,152 @@
+#ifndef ENTITY_MANAGER_H_C5832F11
+#define ENTITY_MANAGER_H_C5832F11
+
+#include <map>
+#include <typeindex>
+#include <set>
+#include <cassert>
+#include "component.h"
+#include "algorithms.h"
+
+class EntityManager {
+  private:
+    struct EntityData {
+      std::map<std::type_index, std::unique_ptr<Component>> components;
+    };
+  
+    std::map<int, EntityData> entities;
+    std::map<std::set<std::type_index>, std::set<int>> cachedComponents;
+  
+    int nextEntityID = 0;
+    
+    template <class T, class... R>
+    std::set<int> getEntitiesWithComponentsHelper(std::set<std::type_index>& componentTypes)
+    {
+      componentTypes.insert(typeid(T));
+      
+      return getEntitiesWithComponents<R...>(componentTypes);
+    }
+    
+    template <class... R>
+    std::set<int> getEntitiesWithComponents(std::set<std::type_index>& componentTypes)
+    {
+      return getEntitiesWithComponentsHelper<R...>(componentTypes);
+    }
+    
+  public:
+    EntityManager() = default;
+    EntityManager(const EntityManager& copy) = delete;
+    
+    int emplaceEntity()
+    {
+      // Find a suitable entity ID
+      while ((entities.count(nextEntityID) == 1) && (nextEntityID >= 0))
+      {
+        nextEntityID++;
+      }
+        
+      if (nextEntityID < 0)
+      {
+        nextEntityID = 0;
+        
+        while ((entities.count(nextEntityID) == 1) && (nextEntityID >= 0))
+        {
+          nextEntityID++;
+        }
+        
+        assert(nextEntityID >= 0);
+      }
+      
+      // Initialize the data
+      int id = nextEntityID++;
+      entities[id];
+      
+      return id;
+    }
+    
+    void deleteEntity(int entity)
+    {
+      assert(entities.count(entity) == 1);
+      
+      // Uncache components
+      for (auto& cache : cachedComponents)
+      {
+        cache.second.erase(entity);
+      }
+      
+      // Destroy the data
+      entities.erase(entity);
+    }
+    
+    template <class T, class... Args>
+    T& emplaceComponent(int entity, Args&&... args)
+    {
+      assert(entities.count(entity) == 1);
+      
+      EntityData& data = entities[entity];
+      std::type_index componentType = typeid(T);
+      
+      assert(data.components.count(componentType) == 0);
+      
+      // Initialize the component
+      std::unique_ptr<T> ptr = std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+      T& component = *ptr;
+      data.components[componentType] = std::move(ptr);
+      
+      // Invalidate related caches
+      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)
+    {
+      assert(entities.count(entity) == 1);
+      
+      EntityData& data = entities[entity];
+      std::type_index componentType = typeid(T);
+      
+      assert(data.components.count(componentType) == 1);
+      
+      // Destroy the component
+      data.components.erase(componentType);
+      
+      // Uncache the component
+      for (auto& cache : cachedComponents)
+      {
+        if (cache.first.count(componentType) == 1)
+        {
+          cache.second.erase(entity);
+        }
+      }
+    }
+    
+    template <class T>
+    T& getComponent(int entity)
+    {
+      assert(entities.count(entity) == 1);
+      
+      EntityData& data = entities[entity];
+      std::type_index componentType = typeid(T);
+      
+      assert(data.components.count(componentType) == 1);
+      
+      return *((T*)data.components[componentType].get());
+    }
+    
+    template <class... R>
+    std::set<int> getEntitiesWithComponents()
+    {
+      std::set<std::type_index> 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 */
@@ -1,182 +0,0 @@
-#include "entityfactory.h"
-#include <libxml/parser.h>
-#include "muxer.h"
-#include <cstdio>
-#include <map>
-#include <list>
-#include "components/static_image.h"
-#include "components/simple_collider.h"
-#include "components/physics_body.h"
-#include "components/ai.h"
-#include "game.h"
-
-void parseEntityAIData(AI& ai, xmlNodePtr node, const std::map<std::string, int>& items)
-{
-  xmlChar* key;
-  
-  for (xmlNodePtr aiNode = node->xmlChildrenNode; aiNode != NULL; aiNode = aiNode->next)
-  {
-    if (!xmlStrcmp(aiNode->name, (xmlChar*) "move"))
-    {
-      MoveAIAction::Direction dir;
-      int len;
-      int speed;
-      
-      key = xmlGetProp(aiNode, (xmlChar*) "direction");
-      if (key == 0) exit(2);
-      if (!xmlStrcmp(key, (xmlChar*) "left"))
-      {
-        dir = MoveAIAction::Direction::Left;
-      } else if (!xmlStrcmp(key, (xmlChar*) "right"))
-      {
-        dir = MoveAIAction::Direction::Right;
-      } else if (!xmlStrcmp(key, (xmlChar*) "up"))
-      {
-        dir = MoveAIAction::Direction::Up;
-      } else if (!xmlStrcmp(key, (xmlChar*) "down"))
-      {
-        dir = MoveAIAction::Direction::Down;
-      } else {
-        exit(2);
-      }
-      xmlFree(key);
-      
-      key = xmlGetProp(aiNode, (xmlChar*) "length");
-      if (key != 0)
-      {
-        len = atoi((char*) key);
-      } else {
-        key = xmlGetProp(aiNode, (xmlChar*) "length-var");
-        if (key == 0) exit(2);
-        std::string varName = (char*) key;
-        len = items.at(varName);
-      }
-      xmlFree(key);
-      
-      key = xmlGetProp(aiNode, (xmlChar*) "speed");
-      if (key != 0)
-      {
-        speed = atoi((char*) key);
-      } else {
-        key = xmlGetProp(aiNode, (xmlChar*) "speed-var");
-        if (key == 0) exit(2);
-        std::string varName = (char*) key;
-        speed = items.at(varName);
-      }
-      xmlFree(key);
-      
-      ai.addAction(std::make_shared<MoveAIAction>(dir, len, speed));
-    } else if (!xmlStrcmp(aiNode->name, (xmlChar*) "switch"))
-    {
-      key = xmlGetProp(aiNode, (xmlChar*) "item");
-      if (key == 0) exit(2);
-      std::string switchItem = (char*) key;
-      xmlFree(key);
-      
-      for (xmlNodePtr switchNode = aiNode->xmlChildrenNode; switchNode != NULL; switchNode = switchNode->next)
-      {
-        if (!xmlStrcmp(switchNode->name, (xmlChar*) "case"))
-        {
-          key = xmlGetProp(switchNode, (xmlChar*) "value");
-          if (key == 0) exit(2);
-          int caseValue = atoi((char*) key);
-          xmlFree(key);
-          
-          if (items.at(switchItem) == caseValue)
-          {
-            parseEntityAIData(ai, switchNode, items);
-          }
-        }
-      }
-    }
-  }
-}
-
-std::shared_ptr<Entity> EntityFactory::createNamedEntity(const std::string name, const std::map<std::string, int>& items)
-{
-  xmlDocPtr doc = xmlParseFile("res/entities.xml");
-  if (doc == nullptr)
-  {
-    fprintf(stderr, "Error reading entities\n");
-    exit(-1);
-  }
-
-  xmlNodePtr top = xmlDocGetRootElement(doc);
-  if (top == nullptr)
-  {
-    fprintf(stderr, "Empty entities file\n");
-    exit(-1);
-  }
-
-  if (xmlStrcmp(top->name, (const xmlChar*) "entities"))
-  {
-    fprintf(stderr, "Invalid entities definition\n");
-    exit(-1);
-  }
-  
-  auto entity = std::make_shared<Entity>();
-
-  xmlChar* key;
-  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
-  {
-    if (!xmlStrcmp(node->name, (xmlChar*) "entity"))
-    {
-      key = xmlGetProp(node, (xmlChar*) "id");
-      if (key == 0) exit(-1);
-      std::string entityID = (char*) key;
-      xmlFree(key);
-      
-      if (entityID == name)
-      {
-        key = xmlGetProp(node, (xmlChar*) "sprite");
-        if (key == 0) exit(-1);
-        auto spriteComponent = std::make_shared<StaticImageComponent>((char*) key);
-        entity->addComponent(spriteComponent);
-        xmlFree(key);
-        
-        auto physicsComponent = std::make_shared<PhysicsBodyComponent>();
-        entity->addComponent(physicsComponent);
-      
-        key = xmlGetProp(node, (xmlChar*) "width");
-        if (key == 0) exit(-1);
-        entity->size.first = atoi((char*) key);
-        xmlFree(key);
-      
-        key = xmlGetProp(node, (xmlChar*) "height");
-        if (key == 0) exit(-1);
-        entity->size.second = atoi((char*) key);
-        xmlFree(key);
-        
-        bool addAI = false;
-        auto aiComponent = std::make_shared<AIComponent>();
-        
-        for (xmlNodePtr entityNode = node->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)
-        {
-          if (!xmlStrcmp(entityNode->name, (xmlChar*) "ai"))
-          {
-            addAI = true;
-            
-            xmlChar* chanceKey = xmlGetProp(entityNode, (xmlChar*) "chance");
-            if (chanceKey == 0) exit(2);
-            int chance = atoi((char*) chanceKey);
-            xmlFree(chanceKey);
-            
-            AI& ai = aiComponent->emplaceAI(chance);
-            parseEntityAIData(ai, entityNode, items);
-          }
-        }
-        
-        if (addAI)
-        {
-          entity->addComponent(aiComponent);
-        }
-        
-        break;
-      }
-    }
-  }
-
-  xmlFreeDoc(doc);
-  
-  return entity;
-}
@@ -1,15 +0,0 @@
-#ifndef ENTITYFACTORY_H
-#define ENTITYFACTORY_H
-
-#include <string>
-#include <map>
-
-class Entity;
-class Map;
-
-class EntityFactory {
-  public:
-    static std::shared_ptr<Entity> createNamedEntity(const std::string name, const std::map<std::string, int>& items);
-};
-
-#endif
@@ -1,60 +1,47 @@
 #include "game.h"
-#include <cstdlib>
-#include "renderer.h"
-#include "muxer.h"
-#include "map.h"
-#include "components/user_movement.h"
-#include "components/player_physics.h"
-#include "components/player_sprite.h"
-#include "components/map_render.h"
-#include "components/map_collision.h"
-#include "consts.h"
-
-Game::Game(const char* mapfile) : world(mapfile)
-{ 
-  // Set up entities
-  player = std::make_shared<Entity>();
-  player->position = world.getStartingPosition();
-  player->size = std::make_pair(10.0,12.0);
-  
-  auto player_input = std::make_shared<UserMovementComponent>();
-  player->addComponent(player_input);
-  
-  auto player_physics = std::make_shared<PlayerPhysicsComponent>();
-  player->addComponent(player_physics);
-  
-  auto player_anim = std::make_shared<PlayerSpriteComponent>();
-  player->addComponent(player_anim);
-  
-  const Map& startingMap = world.getStartingMap();
-  save = {&startingMap, player->position};
-  
-  loadMap(startingMap, player->position);
-}
+#include "components/animatable.h"
+#include "components/transformable.h"
+#include "components/controllable.h"
+#include "components/droppable.h"
+#include "components/ponderable.h"
+#include "systems/rendering.h"
+#include "systems/controlling.h"
+#include "systems/pondering.h"
 
 void key_callback(GLFWwindow* window, int key, int, int action, int)
 {
-  Game* game = (Game*) glfwGetWindowUserPointer(window);
+  Game& game = *((Game*) glfwGetWindowUserPointer(window));
   
-  if ((key == GLFW_KEY_ESCAPE) && (action == GLFW_PRESS))
+  if ((action == GLFW_PRESS) && (key == GLFW_KEY_ESCAPE))
   {
-    game->shouldQuit = true;
+    game.shouldQuit = true;
+    
+    return;
   }
   
-  for (auto entity : game->entities)
-  {
-    entity->input(*game, key, action);
-  }
+  game.systemManager.getSystem<ControllingSystem>().input(key, action);
 }
 
-void Game::execute(GLFWwindow* window)
+Game::Game(GLFWwindow* window) : window(window)
 {
+  systemManager.emplaceSystem<ControllingSystem>(*this);
+  systemManager.emplaceSystem<RenderingSystem>(*this);
+  systemManager.emplaceSystem<PonderingSystem>(*this);
+  
+  int player = entityManager.emplaceEntity();
+  entityManager.emplaceComponent<AnimatableComponent>(player, "res/Starla.png", 10, 12, 6);
+  entityManager.emplaceComponent<TransformableComponent>(player, 203, 44, 10, 12);
+  entityManager.emplaceComponent<DroppableComponent>(player);
+  entityManager.emplaceComponent<PonderableComponent>(player);
+  entityManager.emplaceComponent<ControllableComponent>(player);
+  
   glfwSwapInterval(1);
   glfwSetWindowUserPointer(window, this);
   glfwSetKeyCallback(window, key_callback);
-  
-  Texture buffer(GAME_WIDTH, GAME_HEIGHT);
+}
 
+void Game::execute()
+{
   double lastTime = glfwGetTime();
   const double dt = 0.01;
   double accumulator = 0.0;
@@ -65,114 +52,24 @@ void Game::execute(GLFWwindow* window)
     double frameTime = currentTime - lastTime;
     lastTime = currentTime;
     
-    // Should we load a new world?
-    if (newWorld)
-    {
-      newWorld = false;
-      entities.clear();
-      entities = std::move(nextEntities);
-      
-      player->position = nextPosition;
-    }
-    
-    // Handle input
     glfwPollEvents();
     
-    // Tick!
     accumulator += frameTime;
     while (accumulator >= dt)
     {
-      for (auto entity : entities)
-      {
-        entity->tick(*this, dt);
-      }
+      systemManager.getSystem<ControllingSystem>().tick(dt);
+      systemManager.getSystem<PonderingSystem>().tick(dt);
       
       accumulator -= dt;
     }
     
-    // Do any scheduled tasks
-    for (auto& task : scheduled)
-    {
-      task.first -= frameTime;
-      
-      if (task.first <= 0)
-      {
-        task.second();
-      }
-    }
-    
-    scheduled.remove_if([] (std::pair<double, std::function<void ()>> value) { return value.first <= 0; });
-  
-    // Do rendering
-    buffer.fill(buffer.entirety(), 0, 0, 0);
-    for (auto entity : entities)
-    {
-      entity->render(*this, buffer);
-    }
-
-    buffer.renderScreen();
-  }
-}
-
-void Game::loadMap(const Map& map, std::pair<double, double> position)
-{
-  auto mapEn = std::make_shared<Entity>();
-  
-  auto map_render = std::make_shared<MapRenderComponent>(map);
-  mapEn->addComponent(map_render);
-  
-  auto map_collision = std::make_shared<MapCollisionComponent>(map);
-  mapEn->addComponent(map_collision);
-  
-  // Map in the back, player on top, rest of entities in between
-  nextEntities.clear();
-  nextEntities.push_back(mapEn);
-  map.createEntities(nextEntities);
-  nextEntities.push_back(player);
-  
-  newWorld = true;
-  
-  currentMap = &map;
-  nextPosition = position;
-}
-
-void Game::detectCollision(Entity& collider, std::pair<double, double> old_position)
-{
-  for (auto entity : entities)
-  {
-    entity->detectCollision(*this, collider, old_position);
+    systemManager.getSystem<RenderingSystem>().tick(frameTime);
   }
 }
 
-void Game::saveGame()
+EntityManager& Game::getEntityManager()
 {
-  save = {currentMap, player->position};
+  return entityManager;
 }
 
-void Game::schedule(double time, std::function<void ()> callback)
-{
-  scheduled.emplace_front(time, std::move(callback));
-}
 
-void Game::playerDie()
-{
-  player->send(*this, Message::Type::die);
-  
-  playSound("res/Hit_Hurt5.wav", 0.25);
-  
-  schedule(0.75, [&] () {
-    if (*currentMap != *save.map)
-    {
-      loadMap(*save.map, save.position);
-    } else {
-      player->position = save.position;
-    }
-    
-    player->send(*this, Message::Type::stopDying);
-  });
-}
-
-const World& Game::getWorld() const
-{
-  return world;
-}
@@ -1,45 +1,24 @@
-#ifndef GAME_H
-#define GAME_H
+#ifndef GAME_H_1014DDC9
+#define GAME_H_1014DDC9
 
-#include <memory>
-#include <functional>
-#include <list>
-#include <map>
-#include "map.h"
-#include "world.h"
-
-class Entity;
-struct GLFWwindow;
-
-struct Savefile {
-  const Map* map;
-  std::pair<double, double> position;
-};
+#include "renderer.h"
+#include "entity_manager.h"
+#include "system_manager.h"
 
 class Game {
   public:
-    Game(const char* maps);
-    void execute(GLFWwindow* window);
-    void loadMap(const Map& map, std::pair<double, double> position);
-    void detectCollision(Entity& collider, std::pair<double, double> old_position);
-    void saveGame();
-    void schedule(double time, std::function<void ()> callback);
-    void playerDie();
-    const World& getWorld() const;
+    Game(GLFWwindow* window);
+    
+    void execute();
+    EntityManager& getEntityManager();
     
-  private:
     friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
-
-    std::list<std::shared_ptr<Entity>> entities;
-    std::list<std::shared_ptr<Entity>> nextEntities;
-    std::pair<double, double> nextPosition;
-    bool newWorld;
-    std::shared_ptr<Entity> player;
-    const Map* currentMap;
-    Savefile save;
-    std::list<std::pair<double, std::function<void ()>>> scheduled;
+    
+  private:
+    EntityManager entityManager;
+    SystemManager systemManager;
+    GLFWwindow* const window;
     bool shouldQuit = false;
-    World world;
 };
 
-#endif
+#endif /* end of include guard: GAME_H_1014DDC9 */
@@ -1,21 +1,23 @@
 #include <ctime>
 #include <list>
-#include "renderer.h"
 #include <cstdlib>
-#include "game.h"
+#include "renderer.h"
 #include "muxer.h"
+#include "game.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
   {
-    Game game {"res/maps.xml"};
-    game.execute(window);
+    Game game {window};
+    game.execute();
   }
   
   destroyMuxer();
@@ -1,151 +0,0 @@
-#include "map.h"
-#include <cstdlib>
-#include <cstring>
-#include <map>
-#include "entityfactory.h"
-#include "entity.h"
-#include "game.h"
-#include "consts.h"
-
-Map::Map(int id)
-{
-  this->id = id;
-  mapdata = (int*) calloc(1, sizeof(int));
-}
-
-Map::Map(const Map& map)
-{
-  mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));
-  memcpy(mapdata, map.mapdata, MAP_WIDTH*MAP_HEIGHT*sizeof(int));
-  
-  id = map.id;
-  title = map.title;
-  adjacents = map.adjacents;
-  entities = map.entities;
-}
-
-Map::Map(Map&& map) : Map()
-{
-  swap(*this, map);
-}
-
-Map::~Map()
-{
-  free(mapdata);
-}
-
-Map& Map::operator= (Map map)
-{
-  swap(*this, map);
-  
-  return *this;
-}
-
-void swap(Map& first, Map& second)
-{
-  std::swap(first.mapdata, second.mapdata);
-  std::swap(first.title, second.title);
-  std::swap(first.adjacents, second.adjacents);
-  std::swap(first.id, second.id);
-  std::swap(first.entities, second.entities);
-}
-
-int Map::getID() const
-{
-  return id;
-}
-
-const int* Map::getMapdata() const
-{
-  return mapdata;
-}
-
-std::string Map::getTitle() const
-{
-  return title;
-}
-
-void Map::createEntities(std::list<std::shared_ptr<Entity>>& entities) const
-{
-  for (auto data : this->entities)
-  {
-    auto entity = EntityFactory::createNamedEntity(data.name, data.items);
-    entity->position = data.position;
-    
-    entities.push_back(entity);
-  }
-}
-
-bool Map::operator==(const Map& other) const
-{
-  return id == other.id;
-}
-
-bool Map::operator!=(const Map& other) const
-{
-  return id != other.id;
-}
-
-Map::MoveType Map::moveTypeForShort(std::string str)
-{
-  if (str == "wrap") return MoveType::Wrap;
-  if (str == "warp") return MoveType::Warp;
-  if (str == "reverseWarp") return MoveType::ReverseWarp;
-  
-  return MoveType::Wall;
-}
-
-Map::MoveDir Map::moveDirForShort(std::string str)
-{
-  if (str == "right") return MoveDir::Right;
-  if (str == "up") return MoveDir::Up;
-  if (str == "down") return MoveDir::Down;
-  
-  return MoveDir::Left;
-}
-
-static const Map::Adjacent defaultAdjacent {};
-const Map::Adjacent& Map::getAdjacent(MoveDir dir) const
-{
-  if (adjacents.count(dir) > 0)
-  {
-    return adjacents.at(dir);
-  } else {
-    return defaultAdjacent;
-  }
-}
-
-bool Map::moveTypeTakesMap(MoveType type)
-{
-  switch (type)
-  {
-    case MoveType::Wall: return false;
-    case MoveType::Wrap: return false;
-    case MoveType::Warp: return true;
-    case MoveType::ReverseWarp: return true;
-  }
-}
-
-void Map::setMapdata(int* mapdata)
-{
-  free(this->mapdata);
-  this->mapdata = mapdata;
-}
-
-void Map::setTitle(std::string title)
-{
-  this->title = title;
-}
-
-void Map::setAdjacent(MoveDir dir, MoveType type, int map)
-{
-  Adjacent& cur = adjacents[dir];
-  cur.type = type;
-  if (map != -1) cur.map = map;
-}
-
-void Map::addEntity(EntityData& data)
-{
-  entities.push_back(data);
-}
-
@@ -1,70 +0,0 @@
-#ifndef MAP_H
-#define MAP_H
-
-#include <string>
-#include <list>
-#include <map>
-
-class Entity;
-
-class Map {
-  public:
-    Map(int id);
-    Map() : Map(-1) {}
-    Map(const Map& map);
-    Map(Map&& map);
-    ~Map();
-    Map& operator= (Map other);
-    friend void swap(Map& first, Map& second);
-    
-    enum class MoveType {
-      Wall,
-      Wrap,
-      Warp,
-      ReverseWarp
-    };
-    
-    enum class MoveDir {
-      Left,
-      Right,
-      Up,
-      Down
-    };
-    
-    struct EntityData {
-      std::string name;
-      std::pair<int, int> position;
-      std::map<std::string, int> items;
-    };
-    
-    struct Adjacent {
-      MoveType type = MoveType::Wall;
-      int map = -1;
-    };
-    
-    static MoveType moveTypeForShort(std::string str);
-    static MoveDir moveDirForShort(std::string str);
-    static bool moveTypeTakesMap(MoveType type);
-    
-    int getID() const;
-    const int* getMapdata() const;
-    std::string getTitle() const;
-    const Adjacent& getAdjacent(MoveDir dir) const;
-    
-    void createEntities(std::list<std::shared_ptr<Entity>>& entities) const;
-    bool operator==(const Map& other) const;
-    bool operator!=(const Map& other) const;
-    
-    void setMapdata(int* mapdata);
-    void setTitle(std::string title);
-    void setAdjacent(MoveDir dir, MoveType type, int map);
-    void addEntity(EntityData& data);
-  private:
-    int* mapdata;
-    std::string title;
-    int id;
-    std::list<EntityData> entities;
-    std::map<MoveDir, Adjacent> adjacents;
-};
-
-#endif
@@ -0,0 +1,17 @@
+#ifndef SYSTEM_H_B61A8CEA
+#define SYSTEM_H_B61A8CEA
+
+class Game;
+
+class System {
+  public:
+    System(Game& game)
+      : game(game) {}
+    
+    virtual void tick(double dt) = 0;
+    
+  protected:
+    Game& game;
+};
+
+#endif /* end of include guard: SYSTEM_H_B61A8CEA */
@@ -0,0 +1,37 @@
+#ifndef SYSTEM_MANAGER_H_544E6056
+#define SYSTEM_MANAGER_H_544E6056
+
+#include <list>
+#include <memory>
+#include <map>
+#include <typeindex>
+#include "system.h"
+
+class SystemManager {
+  private:
+    std::list<std::unique_ptr<System>> loop;
+    std::map<std::type_index, System*> systems;
+
+  public:
+    template <class T, class... Args>
+    void emplaceSystem(Game& game, Args&&... args)
+    {
+      std::unique_ptr<T> ptr = std::unique_ptr<T>(new T(game, std::forward<Args>(args)...));
+      std::type_index systemType = typeid(T);
+      
+      systems[systemType] = ptr.get();
+      loop.push_back(std::move(ptr));
+    }
+    
+    template <class T>
+    T& getSystem()
+    {
+      std::type_index systemType = typeid(T);
+      
+      assert(systems.count(systemType) == 1);
+      
+      return *((T*)systems[systemType]);
+    }
+};
+
+#endif /* end of include guard: SYSTEM_MANAGER_H_544E6056 */
@@ -0,0 +1,168 @@
+#include "controlling.h"
+#include "game.h"
+#include "components/controllable.h"
+#include "components/ponderable.h"
+#include "components/animatable.h"
+#include "components/droppable.h"
+#include "direction.h"
+#include "muxer.h"
+#include "consts.h"
+
+void ControllingSystem::tick(double dt)
+{
+  while (!actions.empty())
+  {
+    int key = actions.front().first;
+    int action = actions.front().second;
+    
+    auto entities = game.getEntityManager().getEntitiesWithComponents<ControllableComponent, PonderableComponent, AnimatableComponent, DroppableComponent>();
+    for (auto entity : entities)
+    {
+      auto& controllable = game.getEntityManager().getComponent<ControllableComponent>(entity);
+      
+      if (action == GLFW_PRESS)
+      {
+        if (key == controllable.getLeftKey())
+        {
+          controllable.setHoldingLeft(true);
+
+          if (!controllable.isFrozen())
+          {
+            walkLeft(entity);
+          }
+        } else if (key == controllable.getRightKey())
+        {
+          controllable.setHoldingRight(true);
+      
+          if (!controllable.isFrozen())
+          {
+            walkRight(entity);
+          }
+        } else if (key == controllable.getJumpKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            jump(entity);
+          }
+        } else if (key == controllable.getDropKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            drop(entity, true);
+          }
+        }
+      } else if (action == GLFW_RELEASE)
+      {
+        if (key == controllable.getLeftKey())
+        {
+          controllable.setHoldingLeft(false);
+      
+          if (!controllable.isFrozen())
+          {
+            if (controllable.isHoldingRight())
+            {
+              walkRight(entity);
+            } else {
+              stopWalking(entity);
+            }
+          }
+        } else if (key == controllable.getRightKey())
+        {
+          controllable.setHoldingRight(false);
+      
+          if (!controllable.isFrozen())
+          {
+            if (controllable.isHoldingRight())
+            {
+              walkLeft(entity);
+            } else {
+              stopWalking(entity);
+            }
+          }
+        } else if (key == controllable.getDropKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            drop(entity, false);
+          }
+        } else if (key == controllable.getJumpKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            stopJumping(entity);
+          }
+        }
+      }
+    }
+    
+    actions.pop();
+  }
+}
+
+void ControllingSystem::input(int key, int action)
+{
+  actions.push(std::make_pair(key, action));
+}
+
+void ControllingSystem::walkLeft(int entity)
+{
+  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+  
+  ponderable.setVelocityX(-90);
+  
+  animatable.setDirection(Direction::Left);
+  animatable.setWalking(true);
+}
+
+void ControllingSystem::walkRight(int entity)
+{
+  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+  
+  ponderable.setVelocityX(90);
+
+  animatable.setDirection(Direction::Right);
+  animatable.setWalking(true);
+}
+
+void ControllingSystem::stopWalking(int entity)
+{
+  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+  
+  ponderable.setVelocityX(0);
+  
+  animatable.setWalking(false);
+}
+
+void ControllingSystem::jump(int entity)
+{
+  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+  
+  playSound("res/Randomize87.wav", 0.25);
+
+  ponderable.setVelocityY(JUMP_VELOCITY(TILE_HEIGHT*4.5, 0.3));
+  ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*4.5, 0.3));
+  
+  animatable.setJumping(true);
+}
+
+void ControllingSystem::stopJumping(int entity)
+{
+  auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+  
+  ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233));
+  animatable.setJumping(false);
+}
+
+void ControllingSystem::drop(int entity, bool start)
+{
+  auto& animatable = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+  auto& droppable = game.getEntityManager().getComponent<DroppableComponent>(entity);
+  
+  droppable.setDroppable(start);
+  animatable.setCrouching(start);
+}
@@ -0,0 +1,26 @@
+#ifndef CONTROLLING_H_80B1BB8D
+#define CONTROLLING_H_80B1BB8D
+
+#include "system.h"
+#include <queue>
+
+class ControllingSystem : public System {
+  public:
+    ControllingSystem(Game& game)
+      : System(game) {}
+    
+    void tick(double dt);
+    void input(int key, int action);
+    
+  private:
+    void walkLeft(int entity);
+    void walkRight(int entity);
+    void stopWalking(int entity);
+    void jump(int entity);
+    void stopJumping(int entity);
+    void drop(int entity, bool start);
+    
+    std::queue<std::pair<int,int>> actions;
+};
+
+#endif /* end of include guard: CONTROLLING_H_80B1BB8D */
@@ -0,0 +1,23 @@
+#include "pondering.h"
+#include "game.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+
+void PonderingSystem::tick(double dt)
+{
+  auto entities = game.getEntityManager().getEntitiesWithComponents<PonderableComponent, TransformableComponent>();
+  
+  for (auto entity : entities)
+  {
+    auto& transformable = game.getEntityManager().getComponent<TransformableComponent>(entity);
+    auto& ponderable = game.getEntityManager().getComponent<PonderableComponent>(entity);
+    
+    // Accelerate
+    ponderable.setVelocityX(ponderable.getVelocityX() + ponderable.getAccelX() * dt);
+    ponderable.setVelocityY(ponderable.getVelocityY() + ponderable.getAccelY() * dt);
+    
+    // Move
+    transformable.setX(transformable.getX() + ponderable.getVelocityX() * dt);
+    transformable.setY(transformable.getY() + ponderable.getVelocityY() * dt);
+  }
+}
@@ -0,0 +1,14 @@
+#ifndef PONDERING_H_F2530E0E
+#define PONDERING_H_F2530E0E
+
+#include "system.h"
+
+class PonderingSystem : public System {
+  public:
+    PonderingSystem(Game& game)
+      : System(game) {}
+    
+    void tick(double dt);
+};
+
+#endif /* end of include guard: PONDERING_H_F2530E0E */
@@ -0,0 +1,21 @@
+#include "rendering.h"
+#include "game.h"
+#include "components/animatable.h"
+#include "components/transformable.h"
+
+void RenderingSystem::tick(double dt)
+{
+  texture.fill(texture.entirety(), 0, 0, 0);
+  
+  std::set<int> spriteEntities = game.getEntityManager().getEntitiesWithComponents<AnimatableComponent, TransformableComponent>();
+  for (int entity : spriteEntities)
+  {
+    auto& sprite = game.getEntityManager().getComponent<AnimatableComponent>(entity);
+    auto& transform = game.getEntityManager().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,19 @@
+#ifndef RENDERING_H_76ABC02A
+#define RENDERING_H_76ABC02A
+
+#include "system.h"
+#include "renderer.h"
+#include "consts.h"
+
+class RenderingSystem : public System {
+  public:
+    RenderingSystem(Game& game)
+      : System(game) {}
+    
+    void tick(double dt);
+    
+  private:
+    Texture texture {GAME_WIDTH, GAME_HEIGHT};
+};
+
+#endif /* end of include guard: RENDERING_H_76ABC02A */
@@ -1,150 +0,0 @@
-#include "world.h"
-#include <libxml/parser.h>
-#include "consts.h"
-
-World::World(const char* filename)
-{
-  xmlDocPtr doc = xmlParseFile(filename);
-  if (doc == nullptr)
-  {
-    exit(2);
-  }
-  
-  xmlNodePtr top = xmlDocGetRootElement(doc);
-  if (top == nullptr)
-  {
-    exit(2);
-  }
-  
-  if (xmlStrcmp(top->name, (const xmlChar*) "world"))
-  {
-    exit(2);
-  }
-  
-  xmlChar* startxKey = xmlGetProp(top, (xmlChar*) "startx");
-  if (startxKey == 0) exit(2);
-  startX = atoi((char*) startxKey);
-  xmlFree(startxKey);
-  
-  xmlChar* startyKey = xmlGetProp(top, (xmlChar*) "starty");
-  if (startyKey == 0) exit(2);
-  startY = atoi((char*) startyKey);
-  xmlFree(startyKey);
-  
-  xmlChar* startmapKey = xmlGetProp(top, (xmlChar*) "startmap");
-  if (startxKey == 0) exit(2);
-  startMap = atoi((char*) startmapKey);
-  xmlFree(startmapKey);
-  
-  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
-  {
-    if (!xmlStrcmp(node->name, (const xmlChar*) "map"))
-    {
-      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");
-      if (idKey == 0) exit(2);
-      int theId = atoi((char*) idKey);
-      xmlFree(idKey);
-      
-      maps.emplace(theId, theId);
-      Map& map = maps[theId];
-      
-      xmlChar* titleKey = xmlGetProp(node, (xmlChar*) "title");
-      if (titleKey == 0) exit(2);
-      map.setTitle((char*) titleKey);
-      xmlFree(titleKey);
-      
-      for (xmlNodePtr mapNode = node->xmlChildrenNode; mapNode != NULL; mapNode = mapNode->next)
-      {
-        if (!xmlStrcmp(mapNode->name, (const xmlChar*) "environment"))
-        {
-          xmlChar* key = xmlNodeGetContent(mapNode);
-          int* mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));
-          mapdata[0] = atoi(strtok((char*) key, ",\n"));
-          for (int i=1; i<(MAP_WIDTH*MAP_HEIGHT); i++)
-          {
-            mapdata[i] = atoi(strtok(NULL, ",\n"));
-          }
-          map.setMapdata(mapdata);
-          xmlFree(key);
-        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "entity"))
-        {
-          Map::EntityData data;
-          
-          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");
-          if (typeKey == 0) exit(2);
-          data.name = (char*) typeKey;
-          xmlFree(typeKey);
-          
-          xmlChar* xKey = xmlGetProp(mapNode, (const xmlChar*) "x");
-          if (xKey == 0) exit(2);
-          data.position.first = atoi((char*) xKey);
-          xmlFree(xKey);
-          
-          xmlChar* yKey = xmlGetProp(mapNode, (const xmlChar*) "y");
-          if (yKey == 0) exit(2);
-          data.position.second = atoi((char*) yKey);
-          xmlFree(yKey);
-          
-          for (xmlNodePtr entityNode = mapNode->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)
-          {
-            if (!xmlStrcmp(entityNode->name, (xmlChar*) "item"))
-            {
-              xmlChar* itemIdKey = xmlGetProp(entityNode, (const xmlChar*) "id");
-              if (itemIdKey == 0) exit(2);
-              std::string itemId = (char*) itemIdKey;
-              xmlFree(itemIdKey);
-              
-              xmlChar* itemIdVal = xmlNodeGetContent(entityNode);
-              if (itemIdVal == 0) exit(2);
-              data.items[itemId] = atoi((char*) itemIdVal);
-              xmlFree(itemIdVal);
-            }
-          }
-          
-          map.addEntity(data);
-        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "adjacent"))
-        {
-          Map::MoveDir direction;
-          Map::MoveType moveType;
-          int mapId = 0;
-          
-          xmlChar* dirKey = xmlGetProp(mapNode, (const xmlChar*) "dir");
-          if (dirKey == 0) exit(2);
-          direction = Map::moveDirForShort((char*) dirKey);
-          xmlFree(dirKey);
-          
-          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");
-          if (typeKey == 0) exit(2);
-          moveType = Map::moveTypeForShort((char*) typeKey);
-          xmlFree(typeKey);
-          
-          xmlChar* mapIdKey = xmlGetProp(mapNode, (const xmlChar*) "map");
-          if (mapIdKey != 0)
-          {
-            mapId = atoi((char*) mapIdKey);
-          }
-          xmlFree(mapIdKey);
-          
-          map.setAdjacent(direction, moveType, mapId);
-        }
-      }
-    }
-  }
-  
-  xmlFreeDoc(doc);
-}
-
-const Map& World::getMap(int id) const
-{
-  return maps.at(id);
-}
-
-const Map& World::getStartingMap() const
-{
-  return maps.at(startMap);
-}
-
-std::pair<int, int> World::getStartingPosition() const
-{
-  return std::make_pair(startX, startY);
-}
@@ -1,21 +0,0 @@
-#ifndef WORLD_H
-#define WORLD_H
-
-#include <map>
-#include "map.h"
-
-class World {
-  public:
-    World(const char* filename);
-    const Map& getMap(int id) const;
-    const Map& getStartingMap() const;
-    std::pair<int, int> getStartingPosition() const;
-    
-  private:
-    std::map<int, Map> maps;
-    int startMap;
-    int startX;
-    int startY;
-};
-
-#endif /* end of include guard: WORLD_H */