6 files changed, 271 insertions, 0 deletions

@@ -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 */