7 files changed, 213 insertions, 63 deletions

@@ -21,6 +21,7 @@ public:
   vec2s destPos;
   double movementTween = 0.0;
   double speed = 0.0; // Tiles per second
+  Direction moveDir = Direction::none;
 
   // Player
   bool controllable = false;
@@ -32,6 +33,8 @@ public:
   // Temp
   int colorVal = 25;
 
+  bool scheduled = false;
+
 };
 
 #endif /* end of include guard: ENTITY_H_0D6CB29A */
@@ -0,0 +1,59 @@
+#ifndef GRID_CACHE_H_67BBE74D
+#define GRID_CACHE_H_67BBE74D
+
+#include <unordered_map>
+#include <unordered_set>
+#include "level.h"
+
+template <typename T>
+class GridCache {
+public:
+
+  explicit GridCache(const Level& level) : width_(level.getSize().w())
+  {
+  }
+
+  void set(T value, vec2s pos)
+  {
+    if (reverse_.count(value))
+    {
+      size_t oldPosIndex = reverse_.at(value);
+      lookup_[oldPosIndex].erase(value);
+    }
+
+    size_t newPosIndex = getIndex(pos);
+    lookup_[newPosIndex].insert(value);
+    reverse_[value] = newPosIndex;
+  }
+
+  void remove(T value)
+  {
+    if (reverse_.count(value))
+    {
+      size_t index = reverse_.at(value);
+      lookup_[index].erase(value);
+      reverse_.erase(value);
+    }
+  }
+
+  const std::unordered_set<T>& at(vec2s pos) const
+  {
+    size_t index = getIndex(pos);
+
+    return lookup_[index];
+  }
+
+private:
+
+  inline size_t getIndex(const vec2s& pos) const
+  {
+    return pos.x() + pos.y() * width_;
+  }
+
+  size_t width_;
+
+  mutable std::unordered_map<size_t, std::unordered_set<T>> lookup_;
+  std::unordered_map<T, size_t> reverse_;
+};
+
+#endif /* end of include guard: GRID_CACHE_H_67BBE74D */
@@ -1,6 +1,8 @@
 #ifndef LEVEL_H_678CFCCF
 #define LEVEL_H_678CFCCF
 
+#include <vector>
+#include "vector.h"
 #include "consts.h"
 #include "tileset.h"
 
@@ -13,33 +13,6 @@ int main(int, char**)
   Level level;
   Simulation sim(level);
 
-  Simulation::id_type player = sim.emplaceEntity();
-  Entity& entity = sim.getEntity(player);
-  entity.size = TILE_SIZE;
-  entity.speed = 3.0;
-  entity.controllable = true;
-  entity.colliderType = ColliderType::player;
-  entity.colorVal = 180;
-  sim.setGridPos(player, vec2s { 1, 5 } );
-
-  Simulation::id_type crateId = sim.emplaceEntity();
-  Entity& crate = sim.getEntity(crateId);
-  crate.size = TILE_SIZE;
-  crate.speed = 4.0;
-  crate.colliderType = ColliderType::crate;
-  crate.canBePushedBy.insert(ColliderType::player);
-  crate.canBePushedBy.insert(ColliderType::crate);
-  sim.setGridPos(crateId, vec2s { 4, 5 } );
-
-  Simulation::id_type crateId2 = sim.emplaceEntity();
-  Entity& crate2 = sim.getEntity(crateId2);
-  crate2.size = TILE_SIZE;
-  crate2.speed = 4.0;
-  crate2.colliderType = ColliderType::crate;
-  crate2.canBePushedBy.insert(ColliderType::player);
-  crate2.canBePushedBy.insert(ColliderType::crate);
-  sim.setGridPos(crateId2, vec2s { 6, 7 } );
-
   bool quit = false;
 
   SDL_Event e;
@@ -0,0 +1,44 @@
+#ifndef SCHEDULE_H_EF7B9D12
+#define SCHEDULE_H_EF7B9D12
+
+class Schedule {
+public:
+
+  explicit Schedule(
+    size_t bpm) :
+      bpm_(bpm),
+      tick_(60.0 / static_cast<double>(bpm_))
+  {
+  }
+
+  size_t getBPM() const
+  {
+    return bpm_;
+  }
+
+  void accumulate(double dt)
+  {
+    accum_ += dt;
+  }
+
+  bool step()
+  {
+    if (accum_ > tick_)
+    {
+      accum_ -= tick_;
+
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+private:
+
+  size_t bpm_;
+  double tick_;
+  double accum_ = 0.0;
+
+};
+
+#endif /* end of include guard: SCHEDULE_H_EF7B9D12 */
@@ -3,15 +3,68 @@
 #include "consts.h"
 #include "level.h"
 
+Simulation::Simulation(
+  const Level& level) :
+    level_(level)
+{
+  id_type player = emplaceEntity();
+  Entity& entity = getEntity(player);
+  entity.size = TILE_SIZE;
+  entity.speed = 3.0;
+  entity.controllable = true;
+  entity.colliderType = ColliderType::player;
+  entity.colorVal = 180;
+  entity.gridPos = vec2s { 1, 5 };
+
+  id_type crateId = emplaceEntity();
+  Entity& crate = getEntity(crateId);
+  crate.size = TILE_SIZE;
+  crate.speed = static_cast<double>(schedule_.getBPM()) / 30.0;
+  crate.colliderType = ColliderType::crate;
+  crate.canBePushedBy.insert(ColliderType::player);
+  crate.canBePushedBy.insert(ColliderType::crate);
+  crate.canBePushedBy.insert(ColliderType::train);
+  crate.gridPos = vec2s { 4, 5 };
+
+  id_type crateId2 = emplaceEntity();
+  Entity& crate2 = getEntity(crateId2);
+  crate2.size = TILE_SIZE;
+  crate2.speed = static_cast<double>(schedule_.getBPM()) / 30.0;
+  crate2.colliderType = ColliderType::crate;
+  crate2.canBePushedBy.insert(ColliderType::player);
+  crate2.canBePushedBy.insert(ColliderType::crate);
+  crate2.canBePushedBy.insert(ColliderType::train);
+  crate2.gridPos = vec2s { 6, 7 };
+
+  id_type trainId = emplaceEntity();
+  Entity& train = getEntity(trainId);
+  train.size = TILE_SIZE;
+  train.speed = static_cast<double>(schedule_.getBPM()) / 30.0;
+  train.colliderType = ColliderType::train;
+  train.scheduled = true;
+  train.colorVal = 90;
+  train.gridPos = vec2s { 6, 1 };
+
+
+
+
+  for (id_type id : active_)
+  {
+    Entity& entity = entities_.at(id);
+
+    posCache_.set(id, entity.gridPos);
+  }
+}
+
 void Simulation::tick(
   double dt,
   const Uint8* keystate)
 {
+  // Control
   for (id_type id : active_)
   {
     Entity& entity = entities_.at(id);
 
-    // Control
     if (entity.controllable &&
         !entity.moving)
     {
@@ -38,7 +91,7 @@ void Simulation::tick(
 
         vec2s lookPos = posInDir(entity.gridPos, lookDir);
 
-        for (id_type blockId : getGridEntities(lookPos))
+        for (id_type blockId : posCache_.at(lookPos))
         {
           Entity& block = entities_.at(blockId);
 
@@ -79,16 +132,40 @@ void Simulation::tick(
         }
       }
     }
+  }
+
+  // Schedule
+  schedule_.accumulate(dt);
+
+  if (schedule_.step())
+  {
+    for (id_type id : active_)
+    {
+      Entity& entity = entities_.at(id);
+
+      if (entity.scheduled && !entity.moving)
+      {
+        moveEntityOnGrid(id, Direction::down);
+      }
+    }
+  }
+
 
 
 
 
-    // Collision
 
 
+  // Collision
 
 
-    // Movement
+
+
+  // Movement
+  for (id_type id : active_)
+  {
+    Entity& entity = entities_.at(id);
+
     if (entity.moving)
     {
       entity.movementTween += entity.speed * dt;
@@ -96,7 +173,9 @@ void Simulation::tick(
       if (entity.movementTween >= 1.0)
       {
         entity.moving = false;
-        setGridPos(id, entity.destPos);
+        entity.gridPos = entity.destPos;
+        posCache_.set(id, entity.gridPos);
+        moveToCache_.remove(id);
       }
     }
 
@@ -141,29 +220,6 @@ void Simulation::deleteEntity(id_type id)
   active_.erase(id);
 }
 
-void Simulation::setGridPos(id_type id, vec2s pos)
-{
-  Entity& entity = entities_.at(id);
-
-  size_t oldPosIndex =
-    entity.gridPos.x() + entity.gridPos.y() * level_.getSize().w();
-  gridCache_[oldPosIndex].erase(id);
-
-  entity.gridPos = pos;
-
-  size_t newPosIndex =
-    entity.gridPos.x() + entity.gridPos.y() * level_.getSize().w();
-  gridCache_[newPosIndex].insert(id);
-}
-
-const std::unordered_set<Simulation::id_type>&
-  Simulation::getGridEntities(vec2s pos) const
-{
-  size_t posIndex = pos.x() + pos.y() * level_.getSize().w();
-
-  return gridCache_[posIndex];
-}
-
 bool Simulation::moveEntityOnGrid(
   id_type id,
   Direction moveDir,
@@ -225,7 +281,13 @@ bool Simulation::moveEntityOnGrid(
     return false;
   }
 
-  for (id_type blockId : getGridEntities(shouldMoveTo))
+  // Can't move into a space that something else is already moving into.
+  if (!moveToCache_.at(shouldMoveTo).empty())
+  {
+    return false;
+  }
+
+  for (id_type blockId : posCache_.at(shouldMoveTo))
   {
     Entity& block = entities_.at(blockId);
 
@@ -240,6 +302,11 @@ bool Simulation::moveEntityOnGrid(
       {
         return false;
       }
+    } else if (block.moveDir != moveDir)
+    {
+      // Can't move perpendicularly into a space that something else is moving
+      // out of.
+      return false;
     }
 
     double entityTimeLeft = 1.0 / entity.speed;
@@ -260,6 +327,9 @@ bool Simulation::moveEntityOnGrid(
     entity.moving = true;
     entity.destPos = shouldMoveTo;
     entity.movementTween = 0.0;
+    entity.moveDir = moveDir;
+
+    moveToCache_.set(id, entity.destPos);
   }
 
   return true;
@@ -3,11 +3,11 @@
 
 #include "entity.h"
 #include "renderer.h"
+#include "schedule.h"
+#include "grid_cache.h"
 #include <vector>
 #include <deque>
 #include <set>
-#include <unordered_map>
-#include <unordered_set>
 
 class Level;
 
@@ -17,7 +17,7 @@ public:
   using id_type = std::vector<Entity>::size_type;
 
   // Constructor
-  explicit Simulation(const Level& level) : level_(level) {}
+  explicit Simulation(const Level& level);
 
   void tick(
     double dt,
@@ -47,15 +47,12 @@ public:
     return level_;
   }
 
-  void setGridPos(id_type id, vec2s pos);
-
   static vec2s posInDir(vec2s orig, Direction dir);
 
 private:
 
 
 
-  const std::unordered_set<id_type>& getGridEntities(vec2s pos) const;
 
   bool moveEntityOnGrid(
     id_type id,
@@ -63,12 +60,14 @@ private:
     bool validate = false);
 
   const Level& level_;
+  Schedule schedule_ { 120 };
 
   std::vector<Entity> entities_;
   std::deque<id_type> available_;
   std::set<id_type> active_;
 
-  mutable std::unordered_map<size_t, std::unordered_set<id_type>> gridCache_;
+  mutable GridCache<id_type> posCache_ { level_ };
+  mutable GridCache<id_type> moveToCache_ { level_ };
 };
 
 #endif /* end of include guard: SIMULATION_H_7BF6EEA4 */