проблема может быть в том, что вы исправляете и X и Y столкновение на основе той же позиции:

1. игрок находится в определенном положении. Давайте проверим столкновение.
2. нижний правый угол игрока перекрывает верхний левый угол объекта.
3. X положение исправлено: игрок перемещается влево.
4. нижний правый угол игрока перекрывает верхний левый угол объекта.
5. Y позиция исправлено: игрок перемещается вверх.
6. конечный результат: игрок перемещается вверх и влево.

вам, вероятно, нужно "получить" позицию игрока снова, между проверками.

МОЙ РАБОЧИЙ КОД

Итак, с некоторой помощью и руководством от удивительного @meowgoesthedog я, наконец, попал на правильный путь и нашел то, что искал. Проблема (как отметил @meowgoesthedog) заключалась в том, что мой код действительно работал только с квадратами. Решение состояло в том, чтобы проверить пересечение сталкивающихся тел и решить на основе кратчайшего пересечения. Примечание: это, вероятно, не будет оптимальным решением, если вам нужна точная физика с малым и быстро движущиеся объекты. код для нахождения глубины пересечения основан на следующем: https://github.com/kg/PlatformerStarterKit/blob/0e2fafb8dbc845279fe4116c37b6f2cdd3e636d6/RectangleExtensions.cs который связан с этим проектом: https://msdn.microsoft.com/en-us/library/dd254916(v=xnagamestudio.31).aspx.

вот мой рабочий код:

мой цикл физики не был сильно изменен, за исключением некоторых лучших имен для некоторых функций.

updatePhysics: function(step) {
  // Loop through entities and update positions based on velocities
  for (var entityID in Vroom.entityList) {
    var entity = Vroom.entityList[entityID];
    if (entity.physicsEnabled) {
      switch (entity.entityType) {
        case VroomEntity.KINEMATIC:
          entity.pos.x += entity.vel.x * step;
          entity.pos.y += entity.vel.y * step;
          break;

        case VroomEntity.DYNAMIC:
          // Dynamic stuff
          break;
      }
    }
  }
  // Loop through entities and detect collisions. Resolve collisions as they are detected.
  for (var entityID in Vroom.entityList) {
    var entity = Vroom.entityList[entityID];
    if (entity.physicsEnabled && entity.entityType !== VroomEntity.STATIC) {
      for (var targetID in Vroom.entityList) {
        if (targetID !== entityID) {
          var target = Vroom.entityList[targetID];
          if (target.physicsEnabled) {
            // Check if current entity and target is colliding
            if (Vroom.collideEntity(entity, target)) {
              switch (entity.collisionType) {
                case VroomEntity.DISPLACE:
                  Vroom.resolveDisplace(entity, target);
                  break;
              }
            }
          }
        }
      }
    }
  }
},

обнаружение столкновений также остается прежним.

collideEntity: function(entity, target) {
  if (entity.getBottom() < target.getTop() || entity.getTop() > target.getBottom() ||  entity.getRight() < target.getLeft() ||  entity.getLeft() > target.getRight()) {
    return false;
  }

  return true;
},

вот код, который в принципе решает проблему. Комментарии в коде должны объяснить, что это очень хорошо.

getIntersectionDepth: function(entity, target) {
  // Calculate current and minimum-non-intersecting distances between centers.
  var distanceX = entity.getMidX() - target.getMidX();
  var distanceY = entity.getMidY() - target.getMidY();
  var minDistanceX = entity.halfDim.width + target.halfDim.width;
  var minDistanceY = entity.halfDim.height + target.halfDim.height;

  // If we are not intersecting at all, return 0.
  if (Math.abs(distanceX) >= minDistanceX || Math.abs(distanceY) >= minDistanceY) {
    return {
      x: 0,
      y: 0,
    };
  }

  // Calculate and return intersection depths.
  var depthX = distanceX > 0 ? minDistanceX - distanceX : -minDistanceX - distanceX;
  var depthY = distanceY > 0 ? minDistanceY - distanceY : -minDistanceY - distanceY;

  return {
    x: depthX,
    y: depthY,
  };
},

вот обновленная функция разрешения. Теперь он принимает глубину пересечения для учета при определении оси столкновения, а затем использует знак глубины пересечения для сталкивающейся оси при определении направления на разрешить.

resolveDisplace: function(entity, target) {
  var intersection = Vroom.getIntersectionDepth(entity, target);
  if (intersection.x !== 0 && intersection.y !== 0) {
    if (Math.abs(intersection.x) < Math.abs(intersection.y)) {
      // Collision on the X axis
      if (Math.sign(intersection.x) < 0) {
        // Collision on entity right
        entity.pos.x = target.getLeft() - entity.dim.width;
      } else {
        // Collision on entity left
        entity.pos.x = target.getRight();
      }

      entity.vel.x = 0;
    } else if (Math.abs(intersection.x) > Math.abs(intersection.y)) {
      // Collision on the Y axis
      if (Math.sign(intersection.y) < 0) {
        // Collision on entity bottom
        entity.pos.y = target.getTop() - entity.dim.height;
      } else {
        // Collision on entity top
        entity.pos.y = target.getBottom();
      }

      entity.vel.y = 0;
    }
  }
},

спасибо всем за помощь!