Player now moves

23 files changed, 642 insertions, 61 deletions

@@ -50,9 +50,15 @@ add_executable(Aromatherapy
   src/renderer.cpp
   src/muxer.cpp
   src/entity_manager.cpp
-  src/components/sprite_renderable.cpp
+  src/game.cpp
   src/components/transformable.cpp
+  src/components/droppable.cpp
+  src/components/controllable.cpp
+  src/components/ponderable.cpp
+  src/components/animatable.cpp
   src/systems/rendering.cpp
+  src/systems/controlling.cpp
+  src/systems/pondering.cpp
 )
 target_link_libraries(Aromatherapy ${ALL_LIBS})
 install(TARGETS Aromatherapy RUNTIME DESTINATION ${BIN_DIR})
@@ -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};
+}
@@ -3,10 +3,11 @@
 
 #include "component.h"
 #include "renderer.h"
+#include "direction.h"
 
-class SpriteRenderableComponent : public Component {
+class AnimatableComponent : public Component {
   public:
-    SpriteRenderableComponent(const char* filename, int frame_width, int frame_height, int frames_across);
+    AnimatableComponent(const char* filename, int frame_width, int frame_height, int frames_across);
     
     int getFrame() const;
     void setFrame(int frame);
@@ -14,6 +15,11 @@ class SpriteRenderableComponent : public Component {
     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;
@@ -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 */
@@ -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,27 +0,0 @@
-#include "sprite_renderable.h"
-
-SpriteRenderableComponent::SpriteRenderableComponent(const char* filename, int frame_width, int frame_height, int frames_across)
-  : texture(filename), frame_width(frame_width), frame_height(frame_height), frames_across(frames_across)
-{
-  
-}
-
-int SpriteRenderableComponent::getFrame() const
-{
-  return frame;
-}
-
-void SpriteRenderableComponent::setFrame(int frame)
-{
-  this->frame = frame;
-}
-
-const Texture& SpriteRenderableComponent::getTexture() const
-{
-  return texture;
-}
-
-Rectangle SpriteRenderableComponent::getFrameRect() const
-{
-  return {frame_width * (frame % frames_across), frame_height * (frame / frames_across), frame_width, frame_height};
-}
@@ -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 */
@@ -0,0 +1,75 @@
+#include "game.h"
+#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));
+  
+  if ((action == GLFW_PRESS) && (key == GLFW_KEY_ESCAPE))
+  {
+    game.shouldQuit = true;
+    
+    return;
+  }
+  
+  game.systemManager.getSystem<ControllingSystem>().input(key, action);
+}
+
+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);
+}
+
+void Game::execute()
+{
+  double lastTime = glfwGetTime();
+  const double dt = 0.01;
+  double accumulator = 0.0;
+  
+  while (!(shouldQuit || glfwWindowShouldClose(window)))
+  {
+    double currentTime = glfwGetTime();
+    double frameTime = currentTime - lastTime;
+    lastTime = currentTime;
+    
+    glfwPollEvents();
+    
+    accumulator += frameTime;
+    while (accumulator >= dt)
+    {
+      systemManager.getSystem<ControllingSystem>().tick(dt);
+      systemManager.getSystem<PonderingSystem>().tick(dt);
+      
+      accumulator -= dt;
+    }
+    
+    systemManager.getSystem<RenderingSystem>().tick(frameTime);
+  }
+}
+
+EntityManager& Game::getEntityManager()
+{
+  return entityManager;
+}
+
+
@@ -0,0 +1,24 @@
+#ifndef GAME_H_1014DDC9
+#define GAME_H_1014DDC9
+
+#include "renderer.h"
+#include "entity_manager.h"
+#include "system_manager.h"
+
+class Game {
+  public:
+    Game(GLFWwindow* window);
+    
+    void execute();
+    EntityManager& getEntityManager();
+    
+    friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
+    
+  private:
+    EntityManager entityManager;
+    SystemManager systemManager;
+    GLFWwindow* const window;
+    bool shouldQuit = false;
+};
+
+#endif /* end of include guard: GAME_H_1014DDC9 */
@@ -3,10 +3,7 @@
 #include <cstdlib>
 #include "renderer.h"
 #include "muxer.h"
-#include "entity_manager.h"
-#include "components/sprite_renderable.h"
-#include "components/transformable.h"
-#include "systems/rendering.h"
+#include "game.h"
 
 int main()
 {
@@ -19,24 +16,8 @@ int main()
   
   // Put this in a block so game goes out of scope before we destroy the renderer
   {
-    EntityManager manager;
-    
-    int player = manager.emplaceEntity();
-    manager.emplaceComponent<SpriteRenderableComponent>(player, "res/Starla.png", 10, 12, 6);
-    manager.emplaceComponent<TransformableComponent>(player, 203, 44, 10, 12);
-    
-    std::list<std::unique_ptr<System>> loop;
-    loop.push_back(std::unique_ptr<System>(new RenderingSystem()));
-    
-    while (!glfwWindowShouldClose(window))
-    {
-      for (auto& sys : loop)
-      {
-        sys->tick(manager, 1.0);
-      }
-      
-      glfwPollEvents();
-    }
+    Game game {window};
+    game.execute();
   }
   
   destroyMuxer();
@@ -1,11 +1,17 @@
 #ifndef SYSTEM_H_B61A8CEA
 #define SYSTEM_H_B61A8CEA
 
-class EntityManager;
+class Game;
 
 class System {
   public:
-    virtual void tick(EntityManager& manager, float dt) = 0;
+    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 */
@@ -1,17 +1,17 @@
 #include "rendering.h"
-#include "entity_manager.h"
-#include "components/sprite_renderable.h"
+#include "game.h"
+#include "components/animatable.h"
 #include "components/transformable.h"
 
-void RenderingSystem::tick(EntityManager& manager, float dt)
+void RenderingSystem::tick(double dt)
 {
   texture.fill(texture.entirety(), 0, 0, 0);
   
-  std::set<int> spriteEntities = manager.getEntitiesWithComponents<SpriteRenderableComponent, TransformableComponent>();
+  std::set<int> spriteEntities = game.getEntityManager().getEntitiesWithComponents<AnimatableComponent, TransformableComponent>();
   for (int entity : spriteEntities)
   {
-    auto& sprite = manager.getComponent<SpriteRenderableComponent>(entity);
-    auto& transform = manager.getComponent<TransformableComponent>(entity);
+    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);
@@ -7,7 +7,10 @@
 
 class RenderingSystem : public System {
   public:
-    void tick(EntityManager& manager, float dt);
+    RenderingSystem(Game& game)
+      : System(game) {}
+    
+    void tick(double dt);
     
   private:
     Texture texture {GAME_WIDTH, GAME_HEIGHT};