Added collidable object cache

4 files changed, 96 insertions, 18 deletions

@@ -27,6 +27,7 @@ void loop(Renderer& renderer) {
 
   int lucasSprite = game.emplaceSprite();
   game.getSystem<TransformSystem>().initSprite(lucasSprite, {32, 32});
+  game.getSystem<TransformSystem>().setUpCollision(lucasSprite, {-8, -8}, {12, 8});
   game.getSystem<AnimationSystem>().initSprite(lucasSprite, "../res/sprites/lucas_anim.txt", renderer);
   game.getSprite(lucasSprite).controllable = true;
   game.getSystem<CharacterSystem>().initSprite(lucasSprite);
@@ -33,6 +33,9 @@ public:
 
   // Transform
   vec2i loc { 0, 0 };
+  bool collidable = false;
+  vec2i collisionOffset;
+  vec2i collisionSize;
 
   // Animation
   bool isAnimated = false;
@@ -8,8 +8,21 @@ void TransformSystem::initSprite(int spriteId, vec2i loc) {
   spritesByY_.emplace(loc.y(), spriteId);
 }
 
+void TransformSystem::setUpCollision(int spriteId, vec2i offset, vec2i size) {
+  Sprite& sprite = game_.getSprite(spriteId);
+  sprite.collidable = true;
+  sprite.collisionOffset = offset;
+  sprite.collisionSize = size;
+
+  addCollidable(spriteId);
+}
+
 void TransformSystem::moveSprite(int spriteId, vec2i newLoc) {
   Sprite& sprite = game_.getSprite(spriteId);
+  if (sprite.collidable) {
+    removeCollidable(spriteId);
+  }
+
   bool changedY = (sprite.loc.y() != newLoc.y());
   if (changedY) {
     spritesByY_.erase(std::make_tuple(sprite.loc.y(), spriteId));
@@ -18,6 +31,9 @@ void TransformSystem::moveSprite(int spriteId, vec2i newLoc) {
   if (changedY) {
     spritesByY_.emplace(newLoc.y(), spriteId);
   }
+  if (sprite.collidable) {
+    addCollidable(spriteId);
+  }
 }
 
 CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Direction dir) {
@@ -28,17 +44,20 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
   const Map& map = game_.getMap();
   bool blocked = false;
 
-  const vec2i UL_COL_BOX = { 8, 8 };
-  const vec2i DR_COL_BOX = { 4, 0 };
-  vec2i oldColPosUL = (sprite.loc - UL_COL_BOX) / map.getTileSize();
-  vec2i newColPosUL = (newLoc - UL_COL_BOX) / map.getTileSize();
-  vec2i oldColPosDR = (sprite.loc + DR_COL_BOX) / map.getTileSize();
-  vec2i newColPosDR = (newLoc + DR_COL_BOX) / map.getTileSize();
+  vec2i oldColUL = sprite.loc + sprite.collisionOffset;
+  vec2i oldColDR = oldColUL + sprite.collisionSize;
+  vec2i newColUL = newLoc + sprite.collisionOffset;
+  vec2i newColDR = newColUL + sprite.collisionSize;
+
+  vec2i oldTileUL = oldColUL / map.getTileSize();
+  vec2i newTileUL = newColUL / map.getTileSize();
+  vec2i oldTileDR = oldColDR / map.getTileSize();
+  vec2i newTileDR = newColDR / map.getTileSize();
 
   if (dirHasDir(sprite.dir, Direction::right) &&
-      newColPosDR.x() > oldColPosDR.x()) {
-    for (int y = newColPosUL.y(); y <= newColPosDR.y(); y++) {
-      if (map.isBlocked(newColPosDR.x(), y)) {
+      newTileDR.x() > oldTileDR.x()) {
+    for (int y = newTileUL.y(); y <= newTileDR.y(); y++) {
+      if (map.isBlocked(newTileDR.x(), y)) {
         result.horiz.blocked = true;
         result.horiz.dir = Direction::right;
 
@@ -48,9 +67,9 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
   }
 
   if (dirHasDir(sprite.dir, Direction::left) &&
-      newColPosUL.x() < oldColPosUL.x()) {
-    for (int y = newColPosUL.y(); y <= newColPosDR.y(); y++) {
-      if (map.isBlocked(newColPosUL.x(), y)) {
+      newTileUL.x() < oldTileUL.x()) {
+    for (int y = newTileUL.y(); y <= newTileDR.y(); y++) {
+      if (map.isBlocked(newTileUL.x(), y)) {
         result.horiz.blocked = true;
         result.horiz.dir = Direction::left;
 
@@ -60,9 +79,9 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
   }
 
   if (dirHasDir(sprite.dir, Direction::down) &&
-      newColPosDR.y() > oldColPosDR.y()) {
-    for (int x = newColPosUL.x(); x <= newColPosDR.x(); x++) {
-      if (map.isBlocked(x, newColPosDR.y())) {
+      newTileDR.y() > oldTileDR.y()) {
+    for (int x = newTileUL.x(); x <= newTileDR.x(); x++) {
+      if (map.isBlocked(x, newTileDR.y())) {
         result.vert.blocked = true;
         result.vert.dir = Direction::down;
 
@@ -72,9 +91,9 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
   }
 
   if (dirHasDir(sprite.dir, Direction::up) &&
-      newColPosUL.y() < oldColPosUL.y()) {
-    for (int x = newColPosUL.x(); x <= newColPosDR.x(); x++) {
-      if (map.isBlocked(x, newColPosUL.y())) {
+      newTileUL.y() < oldTileUL.y()) {
+    for (int x = newTileUL.x(); x <= newTileDR.x(); x++) {
+      if (map.isBlocked(x, newTileUL.y())) {
         result.vert.blocked = true;
         result.vert.dir = Direction::up;
 
@@ -85,3 +104,27 @@ CollisionResult TransformSystem::checkCollision(int spriteId, vec2i newLoc, Dire
 
   return result;
 }
+
+void TransformSystem::addCollidable(int spriteId) {
+  Sprite& sprite = game_.getSprite(spriteId);
+
+  vec2i colUL = sprite.loc + sprite.collisionOffset;
+  vec2i colDR = colUL + sprite.collisionSize;
+
+  leftCollidables_.emplace(std::piecewise_construct, std::tie(colDR.x(), spriteId), std::tie(colUL.y(), colDR.y()));
+  rightCollidables_.emplace(std::piecewise_construct, std::tie(colUL.x(), spriteId), std::tie(colUL.y(), colDR.y()));
+  upCollidables_.emplace(std::piecewise_construct, std::tie(colDR.y(), spriteId), std::tie(colUL.x(), colDR.x()));
+  downCollidables_.emplace(std::piecewise_construct, std::tie(colUL.y(), spriteId), std::tie(colUL.x(), colDR.x()));
+}
+
+void TransformSystem::removeCollidable(int spriteId) {
+  Sprite& sprite = game_.getSprite(spriteId);
+
+  vec2i colUL = sprite.loc + sprite.collisionOffset;
+  vec2i colDR = colUL + sprite.collisionSize;
+
+  leftCollidables_.erase({ colDR.x(), spriteId });
+  rightCollidables_.erase({ colUL.x(), spriteId });
+  upCollidables_.erase({ colDR.y(), spriteId });
+  downCollidables_.erase({ colUL.y(), spriteId });
+}
@@ -3,6 +3,7 @@
 
 #include <range/v3/all.hpp>
 #include <set>
+#include <map>
 #include <tuple>
 #include "direction.h"
 #include "system.h"
@@ -29,6 +30,8 @@ public:
 
   void initSprite(int spriteId, vec2i loc);
 
+  void setUpCollision(int spriteId, vec2i offset, vec2i size);
+
   void moveSprite(int spriteId, vec2i newLoc);
 
   auto getSpritesByY() const {
@@ -43,6 +46,34 @@ private:
 
   Game& game_;
   std::set<std::tuple<int, int>> spritesByY_;
+
+  struct Collidable {
+    int lower;
+    int upper;
+
+    Collidable(int lower, int upper) : lower(lower), upper(upper) {}
+  };
+
+  using asc_collidables_type =
+    std::map<
+      std::tuple<int, int>,
+      const Collidable,
+      std::less<std::tuple<int, int>>>;
+
+  using desc_collidables_type =
+    std::map<
+      std::tuple<int, int>,
+      const Collidable,
+      std::greater<std::tuple<int, int>>>;
+
+  desc_collidables_type leftCollidables_;
+  asc_collidables_type rightCollidables_;
+  desc_collidables_type upCollidables_;
+  asc_collidables_type downCollidables_;
+
+  void addCollidable(int spriteId);
+
+  void removeCollidable(int spriteId);
 };
 
 #endif /* end of include guard: TRANSFORM_SYSTEM_H_BA2633BC */