CollisionResolver.cs

using System.Drawing;
 
namespace Gondwana.Physics.Collisions;

internal sealed class CollisionResolver
{
    private readonly List<ColliderInstance> _queryResults = new();
    private readonly ColliderRegistry _world;

    internal event Action<ICollider, ICollider, Rectangle>? TriggerOverlap;

    internal event Action<ICollider, ICollider, Rectangle>? SolidOverlap;

    internal CollisionResolver(ColliderRegistry world)
    {
        _world = world ?? throw new ArgumentNullException(nameof(world));
    }

    internal void Resolve()
    {
        foreach (var mover in _world.DynamicColliders)
        {
            if (mover.Owner is not ICollisionMovableEntity movableOwner)
                continue; // Dynamic list should only contain movable owners
 
            ResolveForMover(mover, movableOwner);
        }
    }
 
    private void ResolveForMover(ICollider mover, ICollisionMovableEntity movableOwner)
    {
        Rectangle rect = mover.Owner.CollisionArea;
 
        var aabb = Aabb.FromRectangle(rect);
 
        _world.QueryInstances(
            aabb,
            mover.CollisionGroup,
            mover.CollidesWith,
            _queryResults,
            ignore: mover);
 
        int totalDx = 0;
        int totalDy = 0;
        bool hitX = false;
        bool hitY = false;
 
        foreach (var instance in _queryResults)
        {
            var otherCollider = instance.Collider;
            var otherRect = instance.BoundsWorldPx.ToRectangle();
 
            if (!rect.IntersectsWith(otherRect))
                continue;
 
            Rectangle overlap = Rectangle.Intersect(rect, otherRect);
 
            if (overlap.IsEmpty)
                continue;
 
            if (mover.ResponseType == CollisionResponseType.Trigger ||
                otherCollider.ResponseType == CollisionResponseType.Trigger)
            {
                TriggerOverlap?.Invoke(mover, otherCollider, overlap);
                continue;
            }
 
            SolidOverlap?.Invoke(mover, otherCollider, overlap);
 
            float centerX = rect.Left + rect.Width * 0.5f;
            float centerY = rect.Top + rect.Height * 0.5f;
            float otherCenterX = otherRect.Left + otherRect.Width * 0.5f;
            float otherCenterY = otherRect.Top + otherRect.Height * 0.5f;
 
            int dx = 0;
            int dy = 0;
 
            if (overlap.Width < overlap.Height)
            {
                dx = centerX < otherCenterX
                    ? -overlap.Width
                    : overlap.Width;
 
                hitX = true;
            }
            else
            {
                dy = centerY < otherCenterY
                    ? -overlap.Height
                    : overlap.Height;
 
                hitY = true;
            }
 
            rect.Offset(dx, dy);
 
            totalDx += dx;
            totalDy += dy;
        }
 
        if (totalDx != 0 || totalDy != 0)
        {
            movableOwner.TranslateWorldPx(totalDx, totalDy);
        }
 
        if (hitX || hitY)
        {
            movableOwner.CancelVelocityComponent(hitX, hitY);
        }
    }
}