I'm using Unity to create a 2D platformer. For collision detection, I'm using raycasting to detect any possible collisions with specific collision layers, and adjusting the desired delta x & y values as appropriate.
Here is my collision detection class.
public class RaycastCollisionDetection : IEntityCollisionDetection {
private BoxCollider _collider;
private Rect _collisionRect;
private LayerMask _collisionMask;
private LayerMask _playerMask;
private GameObject _entityGo;
public bool OnGround { get; set; }
public bool SideCollision { get; set; }
public bool PlayerCollision { get; set; }
public void Init(GameObject entityGo) {
_collisionMask = LayerMask.NameToLayer("Collisions");
_playerMask = LayerMask.NameToLayer("Player");
_collider = entityGo.GetComponent<BoxCollider>();
_entityGo = entityGo;
}
public Vector3 Move(Vector3 moveAmount, GameObject entityGo, float skin) {
float deltaX = moveAmount.x;
float deltaY = moveAmount.y;
Vector3 entityPosition = entityGo.transform.position;
// Resolve any possible collisions below and above the entity.
deltaY = YAxisCollisions(deltaY, Mathf.Sign(deltaX), entityPosition, skin);
// Resolve any possible collisions left and right of the entity.
// Check if our deltaX value is 0 to avoid unnecessary collision detection.
if (deltaX != 0) {
deltaX = XAxisCollisions(deltaX, entityPosition);
}
Vector3 finalTransform = new Vector2(deltaX, deltaY);
return finalTransform;
}
private float XAxisCollisions(float deltaX, Vector3 entityPosition) {
SideCollision = false;
PlayerCollision = false;
// It's VERY important that the entity's collider doesn't change
// shape during the game. This will cause irregular raycast hits
// and most likely cause things to go through layers.
// Ensure sprites use a fixed collider size for all frames.
_collisionRect = GetNewCollisionRect();
// Increase this value if you want the rays to start and end
// outside of the entity's collider bounds.
float margin = 0.0f;
int numOfRays = 4;
Vector3 rayStartPoint = new Vector3(_collisionRect.center.x,
_collisionRect.yMin + margin, entityPosition.z);
Vector3 rayEndPoint = new Vector3(_collisionRect.center.x,
_collisionRect.yMax - margin, entityPosition.z);
float distance = (_collisionRect.width / 2) + Mathf.Abs(deltaX);
for (int i = 0; i < numOfRays; ++i) {
float lerpAmount = (float) i / ((float) numOfRays - 1);
Vector3 origin = Vector3.Lerp(rayStartPoint, rayEndPoint, lerpAmount);
Ray ray = new Ray(origin, new Vector2(Mathf.Sign(deltaX), 0));
//Debug.DrawRay(ray.origin, ray.direction, Color.white);
RaycastHit hit;
// Bit shift the layers to tell Unity to NOT ignore them.
if (Physics.Raycast(ray, out hit, distance, 1 << _collisionMask) ||
Physics.Raycast(ray, out hit, distance, 1 << _playerMask)) {
if (hit.transform.gameObject.layer == _playerMask) {
PlayerCollision = true;
}
//Debug.DrawRay(ray.origin, ray.direction, Color.yellow);
deltaX = 0;
SideCollision = true;
break;
}
}
return deltaX;
}
private float YAxisCollisions(float deltaY, float dirX, Vector3 entityPosition, float skin) {
OnGround = false;
// It's VERY important that the entity's collider doesn't change
// shape during the game. This will cause irregular raycast hits
// and most likely cause things to go through layers.
// Ensure sprites use a fixed collider size for all frames.
_collisionRect = GetNewCollisionRect();
// Increase this value if you want the rays to start and end
// outside of the entity's collider bounds.
float margin = 0.0f;
int numOfRays = 4;
Vector3 rayStartPoint = new Vector3(_collisionRect.xMin + margin,
_collisionRect.center.y, entityPosition.z);
Vector3 rayEndPoint = new Vector3(_collisionRect.xMax - margin,
_collisionRect.center.y, entityPosition.z);
float distance = (_collisionRect.height / 2) + Mathf.Abs(deltaY);
for (int i = 0; i < numOfRays; ++i) {
float lerpAmount = (float) i / ((float) numOfRays - 1);
// If we are facing left, start the rays on the left side,
// else start the ray rays on the right side.
// This will help ensure precise castings on the corners.
Vector3 origin = dirX == -1
? Vector3.Lerp(rayStartPoint, rayEndPoint, lerpAmount)
: Vector3.Lerp(rayEndPoint, rayStartPoint, lerpAmount);
Ray ray = new Ray(origin, new Vector2(0, Mathf.Sign(deltaY)));
//Debug.DrawRay(ray.origin, ray.direction, Color.white);
RaycastHit hit;
// Bit shift the layers to tell Unity to NOT ignore them.
if (Physics.Raycast(ray, out hit, distance, 1 << _collisionMask) ||
Physics.Raycast(ray, out hit, distance, 1 << _playerMask)) {
Debug.DrawRay(ray.origin, ray.direction, Color.yellow);
OnGround = true;
deltaY = 0;
break;
}
}
return deltaY;
}
private Rect GetNewCollisionRect() {
return new Rect(
_collider.bounds.min.x,
_collider.bounds.min.y,
_collider.bounds.size.x,
_collider.bounds.size.y);
}
}
This works very well except for the y-axis collisions in YAxisCollisions. The origin of my ray is the center of my sprite. The direction of the ray is the direction the player is moving (up or down). The distance of the ray is half the height of the collision rectangle + the desired movement speed along the y-axis. As a result, collision is detected slightly above the actual collision layer.
Here's a video clip showing the behavior. YouTube: Overtime Y-Axis Collision Detection Bug
As you can see, collision is detected as the player is moving downward. The sprite stops its y movement a bit earlier then I would like (which makes sense since the distance of the ray is the desired movement amount of the player, not it's actual current position).
What I would like is for the collision to be detected at a much closer distance between the sprite and collision layer, but everything I've tried introduces other bugs; mainly the player can easily fall through the collision layers under the right circumstances. I'm sort of at wit's end on how to get the y-axis collision detection more precise.
Before you ask, yes, this is all being called in FixedUpdate :)
