Engine-Pong/Game/Physics2D/Primitives/Triangle.cs

using System;

using Syntriax.Engine.Core;

namespace Syntriax.Engine.Physics2D.Primitives;

public record Triangle(Vector2D A, Vector2D B, Vector2D C)
{
    public float Area => MathF.Abs((
            A.X * (B.Y - C.Y) +
            B.X * (C.Y - A.Y) +
            C.X * (A.Y - B.Y)
            ) * .5f);

    public Circle CircumCircle
    {
        get
        {
            Vector2D midAB = (A + B) / 2;
            Vector2D midBC = (B + C) / 2;

            float slopeAB = (B.Y - A.Y) / (B.X - A.X);
            float slopeBC = (C.Y - B.Y) / (C.X - B.X);

            Vector2D center;
            if (MathF.Abs(slopeAB - slopeBC) > float.Epsilon)
            {
                float x = (slopeAB * slopeBC * (A.Y - C.Y) + slopeBC * (A.X + B.X) - slopeAB * (B.X + C.X)) / (2 * (slopeBC - slopeAB));
                float y = -(x - (A.X + B.X) / 2) / slopeAB + (A.Y + B.Y) / 2;
                center = new Vector2D(x, y);
            }
            else
                center = (midAB + midBC) * .5f;

            return new(center, Vector2D.Distance(center, A));
        }
    }

    public bool Overlaps(Vector2D point)
    {
        float originalTriangleArea = Area;

        float pointTriangleArea1 = new Triangle(point, B, C).Area;
        float pointTriangleArea2 = new Triangle(A, point, C).Area;
        float pointTriangleArea3 = new Triangle(A, B, point).Area;

        float pointTriangleAreasSum = pointTriangleArea1 + pointTriangleArea2 + pointTriangleArea3;

        return originalTriangleArea.ApproximatelyEquals(pointTriangleAreasSum, float.Epsilon * 3f);
    }

    public bool ApproximatelyEquals(Triangle other)
        => A.ApproximatelyEquals(other.A) && B.ApproximatelyEquals(other.B) && C.ApproximatelyEquals(other.C);
}