Added map object collision

Collision checking in PonderingSystem was rewritten to work as follows: horizontal movement is step first, then vertical. In each step, the closest environmental boundary to the body is found on the axis of movement in the space traversed by the body. Then, if any map objects fall in the region between the body's old position and the environmental boundary (or body new position if no boundary was found), process collision with those bodies in increasing distance order, stopping if a collision stops movement short of where the next collision would take place. After this, process collision with all of the environmental boundaries at the axis distance found earlier, as long as movement hasn't stopped short.

This is not the most optimal implementation, and there is a lot of code repetition, but it is a start and it works.

All map objects currently function as walls.

This fixes the bug where you could, with pixel-perfect precision, jump into the corner of a wall tile.

The top of the hitbox for the spike tile was lowered by one pixel. This fixes a problem where if the player is halfway on a floor tile and halfway over a spike tile, the floor tile would not stop the spike tile from being processed, and the player would die.

1 files changed, 0 insertions, 97 deletions

@@ -1,97 +0,0 @@
-#include "collision.h"
-
-bool Collision::operator<(const Collision& other) const
-{
-  // Most important is the type of collision
-  if (type_ != other.type_)
-  {
-    return (static_cast<int>(type_) > static_cast<int>(other.type_));
-  }
-
-  // Next, categorize the collisions arbitrarily based on direction
-  if (dir_ != other.dir_)
-  {
-    return (static_cast<int>(dir_) < static_cast<int>(other.dir_));
-  }
-
-  // We want to process closer collisions first
-  if (axis_ != other.axis_)
-  {
-    switch (dir_)
-    {
-      case Direction::left:
-      case Direction::up:
-      {
-        return (axis_ < other.axis_);
-      }
-
-      case Direction::right:
-      case Direction::down:
-      {
-        return (axis_ > other.axis_);
-      }
-    }
-  }
-
-  // Order the remaining attributes arbitrarily
-  return std::tie(collider_, lower_, upper_) <
-    std::tie(other.collider_, other.lower_, other.upper_);
-}
-
-bool Collision::isColliding(
-  double x,
-  double y,
-  int w,
-  int h) const
-{
-  int right = x + w;
-  int bottom = y + h;
-
-  switch (dir_)
-  {
-    case Direction::left:
-    case Direction::right:
-    {
-      if (!((bottom > lower_) && (y < upper_)))
-      {
-        return false;
-      }
-
-      break;
-    }
-
-    case Direction::up:
-    case Direction::down:
-    {
-      if (!((right > lower_) && (x < upper_)))
-      {
-        return false;
-      }
-
-      break;
-    }
-  }
-
-  switch (dir_)
-  {
-    case Direction::left:
-    {
-      return (axis_ >= x);
-    }
-
-    case Direction::right:
-    {
-      return (axis_ <= right);
-    }
-
-    case Direction::up:
-    {
-      return (axis_ >= y);
-    }
-
-    case Direction::down:
-    {
-      return (axis_ <= bottom);
-    }
-  }
-}