Started implementing schedule

Scheduled entities move downward every beat, although they have a speed that is twice the bpm, so essentially they move every other beat?

Broke the simulation loop such that different parts run independently -- made it horizontal rather than vertical.

Encapsulated the grid cache so that more than one position field could be cached. This is used to make sure that an entity can't move into a space that something else is already moving into.

Fixed issue where an entity could move perpendicularly into the space an entity was moving out of.

1 files changed, 59 insertions, 0 deletions

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