圆形角色擦过墙角：扩张 AABB 为什么会提前挡住移动

namespace SweepLab;

public readonly record struct V(double X, double Y)
{
    public static V operator +(V a, V b) => new(a.X + b.X, a.Y + b.Y);
    public static V operator -(V a, V b) => new(a.X - b.X, a.Y - b.Y);
    public static V operator *(V a, double k) => new(a.X * k, a.Y * k);
    public double Length2 => X * X + Y * Y;
}
public readonly record struct Box(double MinX, double MinY, double MaxX, double MaxY);

public static class CircleSweep
{
    public static double Distance2(V p, Box b)
    {
        double dx = Math.Max(Math.Max(b.MinX - p.X, 0), p.X - b.MaxX);
        double dy = Math.Max(Math.Max(b.MinY - p.Y, 0), p.Y - b.MaxY);
        return dx * dx + dy * dy;
    }

    public static double? Hit(V p, V d, double r, Box b)
    {
        if (Distance2(p, b) <= r * r) return 0;
        if (d.Length2 == 0) return null;
        double best = double.PositiveInfinity;
        void Accept(double t) { if (t >= 0 && t <= 1) best = Math.Min(best, t); }
        if (d.X != 0)
        {
            foreach (double x in new[] { b.MinX - r, b.MaxX + r })
            {
                double t = (x - p.X) / d.X, y = p.Y + d.Y * t;
                if (y >= b.MinY && y <= b.MaxY) Accept(t);
            }
        }
        if (d.Y != 0)
        {
            foreach (double y in new[] { b.MinY - r, b.MaxY + r })
            {
                double t = (y - p.Y) / d.Y, x = p.X + d.X * t;
                if (x >= b.MinX && x <= b.MaxX) Accept(t);
            }
        }
        foreach (double x in new[] { b.MinX, b.MaxX })
        foreach (double y in new[] { b.MinY, b.MaxY })
        {
            var c = new V(x, y);
            foreach (double t in CircleRoots(p - c, d, r))
            {
                var q = p + d * t;
                bool outerX = x == b.MinX ? q.X <= x : q.X >= x;
                bool outerY = y == b.MinY ? q.Y <= y : q.Y >= y;
                if (outerX && outerY) Accept(t);
            }
        }
        return double.IsFinite(best) ? best : null;
    }

    private static IEnumerable<double> CircleRoots(V m, V d, double r)
    {
        double a = d.Length2, h = m.X * d.X + m.Y * d.Y;
        double c = m.Length2 - r * r, disc = h * h - a * c;
        if (disc < 0) yield break;
        double root = Math.Sqrt(disc);
        double q = -h - Math.CopySign(root, h);
        if (q == 0) { yield return -h / a; yield break; }
        yield return q / a;
        yield return c / q;
    }

    public static double? ExpandedBox(V p, V d, double r, Box b)
    {
        double enter = 0, exit = 1;
        bool Axis(double v, double dv, double lo, double hi)
        {
            if (dv == 0) return v >= lo && v <= hi;
            double t0 = (lo - v) / dv, t1 = (hi - v) / dv;
            enter = Math.Max(enter, Math.Min(t0, t1));
            exit = Math.Min(exit, Math.Max(t0, t1));
            return enter <= exit;
        }
        return Axis(p.X, d.X, b.MinX-r, b.MaxX+r) &&
            Axis(p.Y, d.Y, b.MinY-r, b.MaxY+r) ? enter : null;
    }
}

var box = new Box(0, 0, 2, 2);
var start = new V(-2, -.9);
Check(CircleSweep.Hit(start, new(1.2, 0), 1, box) is null,
    "short false positive rejected");
Check(Near(CircleSweep.Hit(start, new(3, 0), 1, box),
    (2-Math.Sqrt(.19))/3), "corner analytic");
Check(Near(CircleSweep.Hit(new(-2,-1), new(4,0), 1, box), .5),
    "tangent");

dotnet build SweepLab.csproj -c Release --no-restore --nologo
dotnet run --project SweepLab.csproj -c Release --no-build

Build succeeded. 0 warnings, 0 errors
passed=21 failed=0 skipped=0
paths=8281 samples=836381 hits=2529
falsePositives=372
elapsedMs=63.2687
short: broad=0.8333333333333334 exact=null
long:  broad=0.3333333333333333 exact=0.5213700352153111
contact=(-0.4358898943540668,-0.9)