Added sound when you hit the ground

Also split up components.cpp into files for each class, fixed a bug concerning falling off the screen when you change maps, and converted collision data into doubles.

16 files changed, 805 insertions, 0 deletions

@@ -0,0 +1,211 @@
+#include "map_collision.h"
+#include "map.h"
+#include "game.h"
+
+MapCollisionComponent::MapCollisionComponent(const Map& map) : map(map)
+{
+  addCollision(-6, 0, GAME_WIDTH, Direction::left, (map.getLeftMap() == nullptr) ? Collision::Type::wrap : Collision::Type::teleport);
+  addCollision(GAME_WIDTH+6, 0, GAME_WIDTH, Direction::right, (map.getRightMap() == nullptr) ? Collision::Type::reverse : Collision::Type::teleport);
+  
+  for (int i=0; i<MAP_WIDTH*(MAP_HEIGHT-1); 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;
+      collider.send(game, Message::Type::stopMovingHorizontally);
+    } else if (dir == Direction::right)
+    {
+      collider.position.first = collision.axis - collider.size.first;
+      collider.send(game, Message::Type::stopMovingHorizontally);
+    } else if (dir == Direction::up)
+    {
+      collider.position.second = collision.axis;
+      collider.send(game, Message::Type::stopMovingVertically);
+    } 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(*map.getLeftMap(), std::make_pair(GAME_WIDTH-collider.size.first/2, old_position.second));
+    } else if (dir == Direction::right)
+    {
+      game.loadMap(*map.getRightMap(), std::make_pair(-collider.size.first/2, old_position.second));
+    }
+  } else if (collision.type == Collision::Type::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();
+  }
+}
@@ -0,0 +1,46 @@
+#ifndef MAP_COLLISION_H
+#define MAP_COLLISION_H
+
+#include "entity.h"
+#include <list>
+
+class Map;
+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);
+    
+    std::list<Collision> left_collisions;
+    std::list<Collision> right_collisions;
+    std::list<Collision> up_collisions;
+    std::list<Collision> down_collisions;
+    const Map& map;
+};
+
+#endif
@@ -0,0 +1,39 @@
+#include "map_render.h"
+#include "map.h"
+#include "game.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-1); 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");
+  const char* map_name = map.getTitle();
+  int start_x = (40/2) - (strlen(map_name)/2);
+  for (size_t i=0; i<strlen(map_name); 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());
+}
@@ -0,0 +1,19 @@
+#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
@@ -0,0 +1,65 @@
+#include "physics_body.h"
+#include "game.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::stopMovingHorizontally)
+  {
+    velocity.first = 0.0;
+  } else if (msg.type == Message::Type::stopMovingVertically)
+  {
+    velocity.second = 0.0;
+  }
+}
+
+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);
+  }
+}
@@ -0,0 +1,20 @@
+#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
@@ -0,0 +1,117 @@
+#include "player_physics.h"
+#include "muxer.h"
+#include "game.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::stopMovingHorizontally)
+  {
+    velocity.first = 0.0;
+  } else if (msg.type == Message::Type::stopMovingVertically)
+  {
+    velocity.second = 0.0;
+  } 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;
+  }
+}
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,60 @@
+#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;
+  }
+}
@@ -0,0 +1,23 @@
+#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,14 @@
+#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);
+  }
+}
@@ -0,0 +1,18 @@
+#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
@@ -0,0 +1,11 @@
+#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});
+}
@@ -0,0 +1,18 @@
+#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,100 @@
+#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);
+    }
+  }
+}
@@ -0,0 +1,19 @@
+#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