Added .gitignore, and implemented stable stacking

.gitignore

@@ -0,0 +1,16 @@
+# Build results
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio user files
+.vs/
+*.user
+*.userosscache
+*.suo
+*.userprefs
+
+# OS generated files
+.DS_Store
+Thumbs.db

PhysicsEngine/Core/Program.cs

@@ -0,0 +1,234 @@
+using System.Numerics;
+using Raylib_cs;
+
+namespace PhysicsEngine
+{
+    class Program
+    {
+        private static Font robotoFont;
+        private static WorldModel world;
+
+        static void Main(string[] args)
+        {
+            Raylib.SetConfigFlags(ConfigFlags.FullscreenMode | ConfigFlags.VSyncHint);
+            Raylib.InitWindow(0, 0, "Physics Engine");
+
+            robotoFont = Raylib.LoadFont("Roboto-Regular.ttf");
+            Raylib.SetTextureFilter(robotoFont.Texture, TextureFilter.Bilinear);
+
+            Camera camera = new Camera();
+            world = new WorldModel();
+
+            Scenario();
+
+            const float physicsTimeStep = 1.0f / 60.0f;
+            float accumulator = 0.0f;
+
+            // main loop
+            while (!Raylib.WindowShouldClose())
+            {
+                float frameTime = Raylib.GetFrameTime();
+                if (frameTime > 0.25f)
+                {
+                    frameTime = 0.25f;
+                }
+
+                // update Camera
+                camera.Update(frameTime);
+
+                // update physics accumulator
+                accumulator += frameTime;
+                while (accumulator >= physicsTimeStep)
+                {
+                    UpdatePhysics(physicsTimeStep);
+                    accumulator -= physicsTimeStep;
+                }
+
+                // render loop
+                Raylib.BeginDrawing();
+                Raylib.ClearBackground(MuiDarkColor.BackgroundDefault.ToColor());
+
+                camera.DrawGrid();
+
+                // draw bodies
+                Raylib.BeginMode2D(camera.RaylibCamera);
+                RenderScene();
+                Raylib.EndMode2D();
+
+                camera.DrawHUD();
+                DrawText("Physics Engine", 20, 20, 30, MuiDarkColor.TextPrimary.ToColor());
+
+                Raylib.EndDrawing();
+            }
+
+            Raylib.UnloadFont(robotoFont);
+            Raylib.CloseWindow();
+        }
+
+        public static void DrawText(string text, int posX, int posY, float fontSize, Color color)
+        {
+            Raylib.DrawTextEx(robotoFont, text, new Vector2(posX, posY), fontSize, 1.0f, color);
+        }
+
+        private static void UpdatePhysics(float dt)
+        {
+            world.Step(dt);
+        }
+
+        private static void RenderScene()
+        {
+            foreach (var body in world.Bodies)
+            {
+                body.Draw();
+            }
+        }
+
+        private static void Scenario()
+        {
+            float worldWidth = 12.8f;
+            float worldHeight = 7.2f;
+            float wallThickness = 1.0f;
+
+            // 1. Static World Borders
+            Box floor = new Box(new Vector2(worldWidth * 0.5f, worldHeight + (wallThickness * 0.5f)), new Vector2(worldWidth + wallThickness * 2, wallThickness), 0f);
+            floor.BaseColor = new Color(60, 60, 60);
+            floor.Friction = 0.9f;
+            world.AddBody(floor);
+
+            Box ceiling = new Box(new Vector2(worldWidth * 0.5f, -wallThickness * 0.5f), new Vector2(worldWidth + wallThickness * 2, wallThickness), 0f);
+            ceiling.BaseColor = new Color(60, 60, 60);
+            world.AddBody(ceiling);
+
+            Box leftWall = new Box(new Vector2(-wallThickness * 0.5f, worldHeight * 0.5f), new Vector2(wallThickness, worldHeight + wallThickness * 2), 0f);
+            leftWall.BaseColor = new Color(60, 60, 60);
+            world.AddBody(leftWall);
+
+            Box rightWall = new Box(new Vector2(worldWidth + wallThickness * 0.5f, worldHeight * 0.5f), new Vector2(wallThickness, worldHeight + wallThickness * 2), 0f);
+            rightWall.BaseColor = new Color(60, 60, 60);
+            world.AddBody(rightWall);
+
+
+            // =========================================================================
+            // TEST 1: Ultra-Tall Thin Skyscraper (X = 2.0)
+            // 18-box high column testing vertical constraint propagation and slop
+            // =========================================================================
+            float singleStackX = 2.0f;
+            float colBoxWidth = 0.5f;
+            float colBoxHeight = 0.35f;
+            int towerHeight = 18;
+
+            for (int i = 0; i < towerHeight; i++)
+            {
+                float y = worldHeight - (colBoxHeight * 0.5f) - (i * colBoxHeight);
+                Box box = new Box(new Vector2(singleStackX, y), new Vector2(colBoxWidth, colBoxHeight), 10f);
+
+                // Color gradient using integer calculations
+                int r = Math.Clamp(30 + i * 11, 0, 255);
+                int g = Math.Clamp(140 - i * 6, 0, 255);
+                int b = Math.Clamp(255 - i * 5, 0, 255);
+                box.BaseColor = new Color(r, g, b);
+
+                box.Friction = 0.85f;
+                box.Restitution = 0.0f;
+                world.AddBody(box);
+            }
+
+
+            // =========================================================================
+            // TEST 2: 10-Tier Staggered Pyramid (Centered at X = 6.2)
+            // 55 boxes in multi-contact arrangement testing shear and load distribution
+            // =========================================================================
+            int pyramidTiers = 10;
+            float pBoxWidth = 0.45f;
+            float pBoxHeight = 0.30f;
+            float pyramidCenterX = 6.2f;
+
+            for (int row = 0; row < pyramidTiers; row++)
+            {
+                int boxesInRow = pyramidTiers - row;
+                float rowY = worldHeight - (pBoxHeight * 0.5f) - (row * pBoxHeight);
+                float startX = pyramidCenterX - ((boxesInRow - 1) * pBoxWidth * 0.5f);
+
+                for (int col = 0; col < boxesInRow; col++)
+                {
+                    float x = startX + (col * pBoxWidth);
+                    Box pBox = new Box(new Vector2(x, rowY), new Vector2(pBoxWidth - 0.01f, pBoxHeight - 0.01f), 15f);
+
+                    // Heatmap color gradient (Integer args)
+                    int r = Math.Min(255, 180 + row * 8);
+                    int g = Math.Min(255, row * 26);
+                    int b = 30;
+                    pBox.BaseColor = new Color(r, g, b);
+
+                    pBox.Friction = 0.9f;
+                    pBox.Restitution = 0.0f;
+                    world.AddBody(pBox);
+                }
+            }
+
+
+            // =========================================================================
+            // TEST 3: Interlocked Double Tower Structure (X = 10.0 and X = 11.0)
+            // Parallel columns tied together by heavy cross-planks every 4 tiers
+            // =========================================================================
+            float towerAX = 10.0f;
+            float towerBX = 11.0f;
+            float tBoxWidth = 0.45f;
+            float tBoxHeight = 0.32f;
+            int towerRows = 16;
+
+            for (int row = 0; row < towerRows; row++)
+            {
+                float y = worldHeight - (tBoxHeight * 0.5f) - (row * tBoxHeight);
+
+                int r = 50;
+                int g = Math.Min(255, 100 + row * 8);
+                int b = Math.Min(255, 180 + row * 4);
+
+                // Column A Box
+                Box boxA = new Box(new Vector2(towerAX, y), new Vector2(tBoxWidth, tBoxHeight), 12f);
+                boxA.BaseColor = new Color(r, g, b);
+                boxA.Friction = 0.8f;
+                boxA.Restitution = 0.0f;
+                world.AddBody(boxA);
+
+                // Column B Box
+                Box boxB = new Box(new Vector2(towerBX, y), new Vector2(tBoxWidth, tBoxHeight), 12f);
+                boxB.BaseColor = new Color(r, g, b);
+                boxB.Friction = 0.8f;
+                boxB.Restitution = 0.0f;
+                world.AddBody(boxB);
+
+                // Cross-plank binder every 4th level
+                if (row % 4 == 3)
+                {
+                    float plankY = y - (tBoxHeight * 0.5f) - 0.08f;
+                    Box plank = new Box(new Vector2((towerAX + towerBX) * 0.5f, plankY), new Vector2(1.6f, 0.16f), 30f);
+                    plank.BaseColor = new Color(220, 160, 40);
+                    plank.Friction = 0.95f;
+                    plank.Restitution = 0.0f;
+                    world.AddBody(plank);
+                }
+            }
+
+
+            // =========================================================================
+            // TEST 4: High-Mass Top Stressers
+            // =========================================================================
+            
+            // Heavy weight on top of thin skyscraper
+            float capY = worldHeight - (towerHeight * colBoxHeight) - 0.4f;
+            Box heavyCap = new Box(new Vector2(singleStackX, capY), new Vector2(0.8f, 0.8f), 150f);
+            heavyCap.BaseColor = new Color(240, 40, 40);
+            heavyCap.Friction = 0.9f;
+            world.AddBody(heavyCap);
+
+            // Heavy sphere dropping onto the peak of the pyramid
+            Circle impactBall = new Circle(new Vector2(pyramidCenterX, 0.5f), 0.45f, 250f);
+            impactBall.BaseColor = new Color(255, 80, 0);
+            impactBall.Friction = 0.7f;
+            impactBall.Restitution = 0.05f;
+            world.AddBody(impactBall);
+        }
+    }
+}

PhysicsEngine/Graphics/Camera.cs

@@ -12,7 +12,7 @@ namespace PhysicsEngine
         private const float MoveLerpSpeed = 20.0f;
         private const float ZoomFactor = 0.1f;
         private const float MinZoom = 0.2f;
-        private const float MaxZoom = 500000000000000000000000000000000000.0f;
+        private const float MaxZoom = 50.0f;
 
         public Camera2D RaylibCamera { get; private set; }
         public Vector2 Position => RaylibCamera.Target / PixelsPerMeter;
@@ -82,6 +82,8 @@ namespace PhysicsEngine
                 targetPosition = Vector2.Zero;
                 targetZoom = 1.0f;
                 isDragging = false;
+                cam.Target = Vector2.Zero;
+                cam.Zoom = 1.0f;
             }
 
             // zooming
@@ -114,7 +116,6 @@ namespace PhysicsEngine
             {
                 cam.Target.X += (targetPosition.X - cam.Target.X) * MoveLerpSpeed * frameTime;
                 cam.Target.Y += (targetPosition.Y - cam.Target.Y) * MoveLerpSpeed * frameTime;
-                targetPosition = cam.Target;
             }
 
             RaylibCamera = cam;
@@ -180,8 +181,8 @@ namespace PhysicsEngine
         public void DrawHUD()
         {
             float screenH = Raylib.GetScreenHeight();
-            string hudText = $"X: {Position.X:F1}m  Y: {Position.Y:F1}m  Zoom: {Zoom:F2}x";
-            Raylib.DrawText(hudText, 20, (int)screenH - 40, 20, MuiDarkColor.TextPrimary.ToColor());
+            string hudText = $"X: {Position.X:F2}m  Y: {Position.Y:F2}m  Zoom: {Zoom:F2}x";
+            Program.DrawText(hudText, 20, (int)screenH - 40, 20, MuiDarkColor.TextPrimary.ToColor());
         }
     }
 }

PhysicsEngine/Physics/Bodies/Body.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Numerics;
+using Raylib_cs;
+
+namespace PhysicsEngine
+{
+    public class Body
+    {
+        public Vector2 Position;
+        public Vector2 Velocity;
+        public Vector2 ForceAccumulator;
+        public Color BaseColor = Color.Blue;
+        public float Rotation;
+        public float AngularVelocity;
+        public float TorqueAccumulator;
+        public float Mass;
+        public float InverseMass => Mass > 0.0f ? 1.0f / Mass : 0.0f;
+        public float MomentOfInertia;
+        public float InverseInertia => MomentOfInertia > 0.0f ? 1.0f / MomentOfInertia : 0.0f;
+        public float Restitution = 0.5f;
+        public float Friction = 0.2f;
+        public float DragCoefficient = 0.0f; // Drag per m^2 (ignored if 0.0)
+        public bool IsStatic => Mass == 0.0f;
+
+        public void ApplyForce(Vector2 force)
+        {
+            if (IsStatic) return;
+            ForceAccumulator += force;
+        }
+
+        public void ApplyTorque(float torque)
+        {
+            if (IsStatic) return;
+            TorqueAccumulator += torque;
+        }
+
+        public void ApplyImpulse(Vector2 impulse)
+        {
+            if (IsStatic) return;
+            Velocity += impulse * InverseMass;
+        }
+
+        public void ApplyImpulseAtOffset(Vector2 impulse, Vector2 localOffset)
+        {
+            if (IsStatic) return;
+
+            Velocity += impulse * InverseMass;
+
+            float cos = MathF.Cos(Rotation);
+            float sin = MathF.Sin(Rotation);
+            Vector2 worldOffset = new Vector2(
+                localOffset.X * cos - localOffset.Y * sin,
+                localOffset.X * sin + localOffset.Y * cos
+            );
+
+            float torque = worldOffset.X * impulse.Y - worldOffset.Y * impulse.X;
+            AngularVelocity += torque * InverseInertia;
+        }
+
+        public void ApplyImpulseAtWorldPosition(Vector2 impulse, Vector2 worldPosition)
+        {
+            if (IsStatic) return;
+
+            Velocity += impulse * InverseMass;
+
+            Vector2 worldOffset = worldPosition - Position;
+
+            float torque = worldOffset.X * impulse.Y - worldOffset.Y * impulse.X;
+            AngularVelocity += torque * InverseInertia;
+        }
+
+        public void ApplyForceAtWorldPosition(Vector2 force, Vector2 worldPosition)
+        {
+            if (IsStatic) return;
+
+            ForceAccumulator += force;
+            Vector2 worldOffset = worldPosition - Position;
+            float torque = worldOffset.X * force.Y - worldOffset.Y * force.X;
+            TorqueAccumulator += torque;
+        }
+
+        public Vector2 GetWorldPointFromLocal(Vector2 localPoint)
+        {
+            float cos = MathF.Cos(Rotation);
+            float sin = MathF.Sin(Rotation);
+            Vector2 rotated = new Vector2(
+                localPoint.X * cos - localPoint.Y * sin,
+                localPoint.X * sin + localPoint.Y * cos
+            );
+            return Position + rotated;
+        }
+
+        public Vector2 GetLocalPointFromWorld(Vector2 worldPoint)
+        {
+            Vector2 delta = worldPoint - Position;
+            float cos = MathF.Cos(-Rotation);
+            float sin = MathF.Sin(-Rotation);
+            return new Vector2(
+                delta.X * cos - delta.Y * sin,
+                delta.X * sin + delta.Y * cos
+            );
+        }
+
+        public void ClearForces()
+        {
+            ForceAccumulator = Vector2.Zero;
+            TorqueAccumulator = 0.0f;
+        }
+
+        public virtual void Draw(float pixelsPerMeter = 100.0f) {}
+        public virtual void ApplyAerodynamicDrag(float dt) {}
+    }
+}

PhysicsEngine/Physics/Bodies/Box.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Numerics;
+using Raylib_cs;
+
+namespace PhysicsEngine
+{
+    public class Box : Body
+    {
+        public Vector2 Size;
+
+        public Box(Vector2 position, Vector2 size, float mass)
+        {
+            Position = position;
+            Size = size;
+            Mass = mass;
+            MomentOfInertia = (1.0f / 12.0f) * mass * (size.X * size.X + size.Y * size.Y);
+        }
+
+        public override void Draw(float pixelsPerMeter = 100.0f)
+        {
+            DrawHelper.DrawRotatedBox(Position, Size, Rotation, BaseColor, pixelsPerMeter);
+        }
+
+        private Vector2 RotatePoint(Vector2 point, float radians)
+        {
+            float cos = MathF.Cos(radians);
+            float sin = MathF.Sin(radians);
+            return new Vector2(
+                point.X * cos - point.Y * sin,
+                point.X * sin + point.Y * cos
+            );
+        }
+
+        public override void ApplyAerodynamicDrag(float dt)
+        {
+            if (DragCoefficient <= 0.0f) return;
+
+            const float airDensity = 1.225f;
+            float speed = Velocity.Length();
+            if (speed < 0.01f) return;
+
+            Vector2 windDir = -Velocity / speed;
+
+            float cos = MathF.Cos(Rotation);
+            float sin = MathF.Sin(Rotation);
+
+            Vector2 worldAxisY = new Vector2(-sin, cos); // Major axis vector
+            Vector2 worldAxisX = new Vector2(cos, sin);  // Minor axis vector
+
+            Vector2 windPerp = new Vector2(-windDir.Y, windDir.X);
+            float projX = MathF.Abs(Vector2.Dot(worldAxisX, windPerp));
+            float projY = MathF.Abs(Vector2.Dot(worldAxisY, windPerp));
+            float effectiveWidth = Size.X * projX + Size.Y * projY;
+
+            float dragMagnitude = 0.5f * airDensity * speed * speed * DragCoefficient * effectiveWidth;
+            Vector2 dragForce = windDir * dragMagnitude;
+            ApplyForce(dragForce);
+
+            float cross = worldAxisY.X * windDir.Y - worldAxisY.Y * windDir.X;
+            float restoringTorque = cross * 0.5f * airDensity * speed * speed * DragCoefficient * Size.X * Size.Y;
+            ApplyTorque(restoringTorque);
+
+            float angularSpeed = MathF.Abs(AngularVelocity);
+            if (angularSpeed > 0.0001f)
+            {
+                float angularDragTorque = -MathF.Sign(AngularVelocity) * 0.5f * airDensity * angularSpeed * angularSpeed * DragCoefficient * (Size.X + Size.Y);
+                ApplyTorque(angularDragTorque);
+            }
+        }
+    }
+}

PhysicsEngine/Physics/Bodies/Circle.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Numerics;
+using Raylib_cs;
+
+namespace PhysicsEngine
+{
+    public class Circle : Body
+    {
+        public float Radius;
+
+        public Circle(Vector2 position, float radius, float mass)
+        {
+            Position = position;
+            Radius = radius;
+            Mass = mass;
+            
+            if (mass > 0.0f)
+            {
+                MomentOfInertia = 0.5f * mass * radius * radius;
+            }
+        }
+
+        public override void Draw(float pixelsPerMeter = 100.0f)
+        {
+            DrawHelper.DrawCircleBody(Position, Radius, Rotation, BaseColor, pixelsPerMeter);
+        }
+
+        public override void ApplyAerodynamicDrag(float dt)
+        {
+            if (DragCoefficient <= 0.0f) return;
+
+            const float airDensity = 1.225f;
+            float area = Radius * 2.0f;
+            float speed = Velocity.Length();
+
+            if (speed > 0.0001f)
+            {
+                Vector2 dragDir = -Vector2.Normalize(Velocity);
+                float dragMagnitude = 0.5f * airDensity * speed * speed * DragCoefficient * area;
+                ApplyForce(dragDir * dragMagnitude);
+            }
+        }
+    }
+}

PhysicsEngine/Physics/CollisionEngine.cs

@@ -0,0 +1,542 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace PhysicsEngine
+{
+    public static class CollisionEngine
+    {
+        private const float Slop = 0.005f;
+        private const float PositionCorrectionPercent = 0.2f;
+        private const float MaxCorrection = 0.2f;
+        private const int VelocityIterations = 8;
+        private const int PositionIterations = 3;
+
+        private class Contact
+        {
+            public Vector2 Point;
+            public Vector2 Normal;          // from BodyA to BodyB
+            public Vector2 Tangent;         // perpendicular to Normal
+            public float Penetration;
+            public float AccumulatedNormalImpulse;
+            public float AccumulatedTangentImpulse;
+            public Body BodyA;
+            public Body BodyB;
+            public Vector2 RA;
+            public Vector2 RB;
+            public Vector2 LocalA;
+            public Vector2 LocalB;
+            public float NormalMass;
+            public float TangentMass;
+            public float Friction;
+            public float Restitution;
+            public float RestitutionBias;
+            public float VelocityBias;
+
+            public ContactKey Key;
+        }
+
+        private struct ContactKey : IEquatable<ContactKey>
+        {
+            public Body BodyA;
+            public Body BodyB;
+            public int Index;
+
+            public ContactKey(Body a, Body b, int index)
+            {
+                BodyA = a;
+                BodyB = b;
+                Index = index;
+            }
+
+            public bool Equals(ContactKey other)
+            {
+                return Equals(BodyA, other.BodyA) && Equals(BodyB, other.BodyB) && Index == other.Index;
+            }
+
+            public override int GetHashCode()
+            {
+                return HashCode.Combine(BodyA, BodyB, Index);
+            }
+        }
+
+        private static Dictionary<ContactKey, (float Normal, float Tangent)> WarmStartCache = new Dictionary<ContactKey, (float, float)>();
+
+        public static void ResolveCollisions(List<Body> bodies, float dt)
+        {
+            if (dt <= 0) return;
+
+            List<Contact> contacts = new List<Contact>();
+
+            // broadphase & barrowphase collision detection
+            for (int i = 0; i < bodies.Count; i++)
+            {
+                for (int j = i + 1; j < bodies.Count; j++)
+                {
+                    Body b1 = bodies[i];
+                    Body b2 = bodies[j];
+                    if (b1.IsStatic && b2.IsStatic) continue;
+
+                    if (b1 is Circle && b2 is Circle)
+                        ResolveCircleCircle((Circle)b1, (Circle)b2, contacts);
+                    else if (b1 is Box && b2 is Circle)
+                        ResolveBoxCircle((Box)b1, (Circle)b2, contacts, false);
+                    else if (b1 is Circle && b2 is Box)
+                        ResolveBoxCircle((Box)b2, (Circle)b1, contacts, true);
+                    else if (b1 is Box && b2 is Box)
+                        ResolveBoxBox((Box)b1, (Box)b2, contacts);
+                }
+            }
+
+            Dictionary<ContactKey, (float Normal, float Tangent)> newCache = new Dictionary<ContactKey, (float, float)>();
+
+            // pre-step / initialization
+            foreach (var contact in contacts)
+            {
+                contact.RA = contact.Point - contact.BodyA.Position;
+                contact.RB = contact.Point - contact.BodyB.Position;
+
+                float cosA = (float)Math.Cos(-contact.BodyA.Rotation);
+                float sinA = (float)Math.Sin(-contact.BodyA.Rotation);
+                contact.LocalA = new Vector2(contact.RA.X * cosA - contact.RA.Y * sinA, contact.RA.X * sinA + contact.RA.Y * cosA);
+
+                float cosB = (float)Math.Cos(-contact.BodyB.Rotation);
+                float sinB = (float)Math.Sin(-contact.BodyB.Rotation);
+                contact.LocalB = new Vector2(contact.RB.X * cosB - contact.RB.Y * sinB, contact.RB.X * sinB + contact.RB.Y * cosB);
+
+                float invMassA = contact.BodyA.InverseMass;
+                float invMassB = contact.BodyB.InverseMass;
+                float invIA = contact.BodyA.InverseInertia;
+                float invIB = contact.BodyB.InverseInertia;
+
+                float rnA = Cross(contact.RA, contact.Normal);
+                float rnB = Cross(contact.RB, contact.Normal);
+                float denom = invMassA + invMassB + rnA * rnA * invIA + rnB * rnB * invIB;
+                contact.NormalMass = denom > 0 ? 1.0f / denom : 0;
+
+                contact.Tangent = new Vector2(-contact.Normal.Y, contact.Normal.X);
+                float rtA = Cross(contact.RA, contact.Tangent);
+                float rtB = Cross(contact.RB, contact.Tangent);
+                denom = invMassA + invMassB + rtA * rtA * invIA + rtB * rtB * invIB;
+                contact.TangentMass = denom > 0 ? 1.0f / denom : 0;
+
+                contact.Friction = (float)Math.Sqrt(contact.BodyA.Friction * contact.BodyB.Friction);
+                contact.Restitution = Math.Max(contact.BodyA.Restitution, contact.BodyB.Restitution);
+
+                float rvNormal = Vector2.Dot(GetRelativeVelocity(contact), contact.Normal);
+                contact.RestitutionBias = rvNormal < -0.5f ? -contact.Restitution * rvNormal : 0;
+
+                float penetrationError = Math.Max(contact.Penetration - Slop, 0.0f);
+                contact.VelocityBias = (PositionCorrectionPercent / dt) * penetrationError;
+
+                if (WarmStartCache.TryGetValue(contact.Key, out var impulse))
+                {
+                    contact.AccumulatedNormalImpulse = impulse.Normal;
+                    contact.AccumulatedTangentImpulse = impulse.Tangent;
+
+                    Vector2 totalImpulse = contact.Normal * contact.AccumulatedNormalImpulse + contact.Tangent * contact.AccumulatedTangentImpulse;
+                    ApplyImpulse(contact, totalImpulse);
+                }
+                else
+                {
+                    contact.AccumulatedNormalImpulse = 0;
+                    contact.AccumulatedTangentImpulse = 0;
+                }
+            }
+
+            // velocity Impulse Solver
+            for (int iter = 0; iter < VelocityIterations; iter++)
+            {
+                foreach (var contact in contacts)
+                {
+                    // normal impulse
+                    Vector2 rv = GetRelativeVelocity(contact);
+                    float vn = Vector2.Dot(rv, contact.Normal);
+
+                    float targetVn = contact.RestitutionBias + contact.VelocityBias;
+                    float lambda = -contact.NormalMass * (vn - targetVn);
+
+                    float newImpulse = Math.Max(contact.AccumulatedNormalImpulse + lambda, 0.0f);
+                    lambda = newImpulse - contact.AccumulatedNormalImpulse;
+                    contact.AccumulatedNormalImpulse = newImpulse;
+
+                    ApplyImpulse(contact, contact.Normal * lambda);
+
+                    // tangent impulse
+                    rv = GetRelativeVelocity(contact);
+                    float vt = Vector2.Dot(rv, contact.Tangent);
+                    float lambdaT = -contact.TangentMass * vt;
+
+                    float maxFriction = contact.Friction * contact.AccumulatedNormalImpulse;
+                    float oldImpulseT = contact.AccumulatedTangentImpulse;
+                    contact.AccumulatedTangentImpulse = Math.Clamp(oldImpulseT + lambdaT, -maxFriction, maxFriction);
+                    lambdaT = contact.AccumulatedTangentImpulse - oldImpulseT;
+
+                    ApplyImpulse(contact, contact.Tangent * lambdaT);
+                }
+            }
+
+            foreach (var contact in contacts)
+            {
+                newCache[contact.Key] = (contact.AccumulatedNormalImpulse, contact.AccumulatedTangentImpulse);
+            }
+            WarmStartCache = newCache;
+
+            for (int iter = 0; iter < PositionIterations; iter++)
+            {
+                foreach (var contact in contacts)
+                {
+                    float cosA = (float)Math.Cos(contact.BodyA.Rotation);
+                    float sinA = (float)Math.Sin(contact.BodyA.Rotation);
+                    Vector2 rA = new Vector2(contact.LocalA.X * cosA - contact.LocalA.Y * sinA, contact.LocalA.X * sinA + contact.LocalA.Y * cosA);
+
+                    float cosB = (float)Math.Cos(contact.BodyB.Rotation);
+                    float sinB = (float)Math.Sin(contact.BodyB.Rotation);
+                    Vector2 rB = new Vector2(contact.LocalB.X * cosB - contact.LocalB.Y * sinB, contact.LocalB.X * sinB + contact.LocalB.Y * cosB);
+
+                    Vector2 pA = contact.BodyA.Position + rA;
+                    Vector2 pB = contact.BodyB.Position + rB;
+
+                    float currentPenetration = contact.Penetration - Vector2.Dot(pB - pA, contact.Normal);
+                    float penetrationError = Math.Max(currentPenetration - Slop, 0.0f);
+                    if (penetrationError <= 0) continue;
+
+                    float correctionAmount = Math.Min(penetrationError * PositionCorrectionPercent, MaxCorrection);
+
+                    float rnA = Cross(rA, contact.Normal);
+                    float rnB = Cross(rB, contact.Normal);
+                    float denom = contact.BodyA.InverseMass + contact.BodyB.InverseMass + rnA * rnA * contact.BodyA.InverseInertia + rnB * rnB * contact.BodyB.InverseInertia;
+                    float normalMass = denom > 0 ? 1.0f / denom : 0;
+
+                    Vector2 pImpulse = contact.Normal * (correctionAmount * normalMass);
+
+                    if (!contact.BodyA.IsStatic)
+                    {
+                        contact.BodyA.Position -= pImpulse * contact.BodyA.InverseMass;
+                        contact.BodyA.Rotation -= Cross(rA, pImpulse) * contact.BodyA.InverseInertia;
+                    }
+                    if (!contact.BodyB.IsStatic)
+                    {
+                        contact.BodyB.Position += pImpulse * contact.BodyB.InverseMass;
+                        contact.BodyB.Rotation += Cross(rB, pImpulse) * contact.BodyB.InverseInertia;
+                    }
+                }
+            }
+        }
+
+        private static void ResolveCircleCircle(Circle c1, Circle c2, List<Contact> contacts)
+        {
+            Vector2 d = c2.Position - c1.Position;
+            float distSq = d.LengthSquared();
+            float radiusSum = c1.Radius + c2.Radius;
+            if (distSq >= radiusSum * radiusSum || distSq < 1e-12f) return;
+
+            float dist = (float)Math.Sqrt(distSq);
+            Vector2 normal = d / dist;
+            float penetration = radiusSum - dist;
+            Vector2 contactPoint = c1.Position + normal * (c1.Radius - penetration * 0.5f);
+
+            contacts.Add(new Contact
+            {
+                Point = contactPoint,
+                Normal = normal,
+                Penetration = penetration,
+                BodyA = c1,
+                BodyB = c2,
+                Key = new ContactKey(c1, c2, 0)
+            });
+        }
+
+        private static void ResolveBoxCircle(Box box, Circle circle, List<Contact> contacts, bool swapped)
+        {
+            Vector2 localCircleCenter = circle.Position - box.Position;
+            float cos = (float)Math.Cos(box.Rotation);
+            float sin = (float)Math.Sin(box.Rotation);
+            Vector2 local = new Vector2(
+                localCircleCenter.X * cos + localCircleCenter.Y * sin,
+                -localCircleCenter.X * sin + localCircleCenter.Y * cos);
+
+            float hx = box.Size.X * 0.5f;
+            float hy = box.Size.Y * 0.5f;
+            Vector2 closestLocal = new Vector2(Math.Clamp(local.X, -hx, hx), Math.Clamp(local.Y, -hy, hy));
+
+            Vector2 normalWorld;
+            Vector2 contactPointWorld;
+            float penetration;
+
+            bool inside = (closestLocal == local);
+            if (inside)
+            {
+                float distLeft = local.X + hx;
+                float distRight = hx - local.X;
+                float distBottom = local.Y + hy;
+                float distTop = hy - local.Y;
+                float minDist = Math.Min(Math.Min(distLeft, distRight), Math.Min(distBottom, distTop));
+
+                Vector2 normalLocal;
+                if (minDist == distLeft) normalLocal = new Vector2(-1, 0);
+                else if (minDist == distRight) normalLocal = new Vector2(1, 0);
+                else if (minDist == distBottom) normalLocal = new Vector2(0, -1);
+                else normalLocal = new Vector2(0, 1);
+
+                normalWorld = new Vector2(normalLocal.X * cos - normalLocal.Y * sin,
+                                          normalLocal.X * sin + normalLocal.Y * cos);
+                penetration = circle.Radius + minDist;
+
+                Vector2 faceLocal = local;
+                if (normalLocal.X != 0) faceLocal.X = normalLocal.X > 0 ? hx : -hx;
+                else faceLocal.Y = normalLocal.Y > 0 ? hy : -hy;
+                contactPointWorld = box.Position + new Vector2(faceLocal.X * cos - faceLocal.Y * sin,
+                                                               faceLocal.X * sin + faceLocal.Y * cos);
+            }
+            else
+            {
+                Vector2 closestWorld = box.Position + new Vector2(closestLocal.X * cos - closestLocal.Y * sin,
+                                                                  closestLocal.X * sin + closestLocal.Y * cos);
+                Vector2 delta = circle.Position - closestWorld;
+                float distSq = delta.LengthSquared();
+                float radiusSq = circle.Radius * circle.Radius;
+                if (distSq >= radiusSq) return;
+
+                float dist = (float)Math.Sqrt(distSq);
+                normalWorld = dist > 1e-6f ? delta / dist : new Vector2(1, 0);
+                penetration = circle.Radius - dist;
+                contactPointWorld = closestWorld;
+            }
+
+            Contact contact = new Contact
+            {
+                Point = contactPointWorld,
+                Normal = normalWorld,
+                Penetration = penetration,
+                BodyA = box,
+                BodyB = circle,
+                Key = new ContactKey(box, circle, 0)
+            };
+
+            if (swapped)
+            {
+                contact.BodyA = circle;
+                contact.BodyB = box;
+                contact.Normal = -contact.Normal;
+                contact.Key = new ContactKey(circle, box, 0);
+            }
+
+            contacts.Add(contact);
+        }
+
+        private static void ResolveBoxBox(Box b1, Box b2, List<Contact> contacts)
+        {
+            float h1x = b1.Size.X * 0.5f;
+            float h1y = b1.Size.Y * 0.5f;
+            float h2x = b2.Size.X * 0.5f;
+            float h2y = b2.Size.Y * 0.5f;
+
+            float cos1 = (float)Math.Cos(b1.Rotation);
+            float sin1 = (float)Math.Sin(b1.Rotation);
+            float cos2 = (float)Math.Cos(b2.Rotation);
+            float sin2 = (float)Math.Sin(b2.Rotation);
+
+            Vector2 axisX1 = new Vector2(cos1, sin1);
+            Vector2 axisY1 = new Vector2(-sin1, cos1);
+            Vector2 axisX2 = new Vector2(cos2, sin2);
+            Vector2 axisY2 = new Vector2(-sin2, cos2);
+
+            Vector2 d = b2.Position - b1.Position;
+            float minOverlap = float.MaxValue;
+            Vector2 bestAxis = Vector2.Zero;
+            bool axisFromB1 = false;
+
+            TestAxis(axisX1, b1, b2, h1x, h1y, h2x, h2y, axisX1, axisY1, axisX2, axisY2, d, ref minOverlap, ref bestAxis, true, ref axisFromB1);
+            if (minOverlap <= 0) return;
+            TestAxis(axisY1, b1, b2, h1x, h1y, h2x, h2y, axisX1, axisY1, axisX2, axisY2, d, ref minOverlap, ref bestAxis, true, ref axisFromB1);
+            if (minOverlap <= 0) return;
+            TestAxis(axisX2, b1, b2, h1x, h1y, h2x, h2y, axisX1, axisY1, axisX2, axisY2, d, ref minOverlap, ref bestAxis, false, ref axisFromB1);
+            if (minOverlap <= 0) return;
+            TestAxis(axisY2, b1, b2, h1x, h1y, h2x, h2y, axisX1, axisY1, axisX2, axisY2, d, ref minOverlap, ref bestAxis, false, ref axisFromB1);
+            if (minOverlap <= 0 || minOverlap == float.MaxValue) return;
+
+            Vector2 normal = Vector2.Dot(d, bestAxis) > 0 ? bestAxis : -bestAxis;
+
+            Box refBox, incBox;
+            Vector2 refNormal, incNormal;
+            if (axisFromB1)
+            {
+                refBox = b1;
+                incBox = b2;
+                refNormal = normal;
+                incNormal = -normal;
+            }
+            else
+            {
+                refBox = b2;
+                incBox = b1;
+                refNormal = -normal;
+                incNormal = normal;
+            }
+
+            Vector2[] refFace = GetFaceVertices(refBox, refNormal);
+            Vector2[] incFace = GetFaceVertices(incBox, incNormal);
+
+            Vector2 refV1 = refFace[0];
+            Vector2 refV2 = refFace[1];
+            Vector2 edgeDir = refV2 - refV1;
+            if (edgeDir.LengthSquared() < 1e-8f) return;
+            edgeDir = Vector2.Normalize(edgeDir);
+
+            int contactsBefore = contacts.Count;
+
+            List<Vector2> clipped = new List<Vector2> { incFace[0], incFace[1] };
+            clipped = ClipSegmentAgainstPlane(clipped, edgeDir, Vector2.Dot(edgeDir, refV1));
+            clipped = ClipSegmentAgainstPlane(clipped, -edgeDir, -Vector2.Dot(edgeDir, refV2));
+
+            int localIndex = 0;
+            foreach (var p in clipped)
+            {
+                float pen = -Vector2.Dot(p - refV1, refNormal);
+                if (pen > 0)
+                {
+                    contacts.Add(new Contact
+                    {
+                        Point = p,
+                        Normal = normal,
+                        Penetration = pen,
+                        BodyA = b1,
+                        BodyB = b2,
+                        Key = new ContactKey(b1, b2, localIndex++)
+                    });
+                }
+            }
+
+            if (contacts.Count == contactsBefore)
+            {
+                Vector2 contactPoint = (incFace[0] + incFace[1]) * 0.5f;
+                contacts.Add(new Contact
+                {
+                    Point = contactPoint,
+                    Normal = normal,
+                    Penetration = Math.Max(minOverlap, 1e-4f),
+                    BodyA = b1,
+                    BodyB = b2,
+                    Key = new ContactKey(b1, b2, 0)
+                });
+            }
+        }
+
+        private static void TestAxis(Vector2 axis, Box b1, Box b2,
+            float h1x, float h1y, float h2x, float h2y,
+            Vector2 axisX1, Vector2 axisY1, Vector2 axisX2, Vector2 axisY2,
+            Vector2 d, ref float minOverlap, ref Vector2 bestAxis, bool fromB1, ref bool axisFromB1)
+        {
+            float r1 = h1x * Math.Abs(Vector2.Dot(axisX1, axis)) + h1y * Math.Abs(Vector2.Dot(axisY1, axis));
+            float r2 = h2x * Math.Abs(Vector2.Dot(axisX2, axis)) + h2y * Math.Abs(Vector2.Dot(axisY2, axis));
+            float distance = Math.Abs(Vector2.Dot(d, axis));
+            float overlap = r1 + r2 - distance;
+
+            if (overlap <= 0)
+            {
+                minOverlap = overlap;
+                return;
+            }
+
+            if (overlap < minOverlap)
+            {
+                minOverlap = overlap;
+                bestAxis = axis;
+                axisFromB1 = fromB1;
+            }
+        }
+
+        private static Vector2[] GetBoxVertices(Box box)
+        {
+            float hx = box.Size.X * 0.5f;
+            float hy = box.Size.Y * 0.5f;
+            float cos = (float)Math.Cos(box.Rotation);
+            float sin = (float)Math.Sin(box.Rotation);
+            Vector2 axisX = new Vector2(cos, sin);
+            Vector2 axisY = new Vector2(-sin, cos);
+
+            return new Vector2[]
+            {
+                box.Position - axisX * hx - axisY * hy,
+                box.Position + axisX * hx - axisY * hy,
+                box.Position + axisX * hx + axisY * hy,
+                box.Position - axisX * hx + axisY * hy
+            };
+        }
+
+        private static Vector2[] GetFaceVertices(Box box, Vector2 faceNormalWorld)
+        {
+            Vector2[] vertices = GetBoxVertices(box);
+            float maxDot = -float.MaxValue;
+            int bestIndex = 0;
+
+            for (int i = 0; i < 4; i++)
+            {
+                Vector2 v1 = vertices[i];
+                Vector2 v2 = vertices[(i + 1) % 4];
+                Vector2 edge = v2 - v1;
+                Vector2 outwardNormal = Vector2.Normalize(new Vector2(edge.Y, -edge.X));
+                float dot = Vector2.Dot(outwardNormal, faceNormalWorld);
+                if (dot > maxDot)
+                {
+                    maxDot = dot;
+                    bestIndex = i;
+                }
+            }
+            return new Vector2[] { vertices[bestIndex], vertices[(bestIndex + 1) % 4] };
+        }
+
+        private static List<Vector2> ClipSegmentAgainstPlane(List<Vector2> segment, Vector2 normal, float offset)
+        {
+            List<Vector2> result = new List<Vector2>();
+            if (segment.Count < 2) return result;
+
+            Vector2 v0 = segment[0];
+            Vector2 v1 = segment[1];
+
+            float d0 = Vector2.Dot(v0, normal) - offset;
+            float d1 = Vector2.Dot(v1, normal) - offset;
+
+            if (d0 >= 0) result.Add(v0);
+
+            if (d0 * d1 < 0)
+            {
+                float t = d0 / (d0 - d1);
+                Vector2 intersection = v0 + t * (v1 - v0);
+                result.Add(intersection);
+            }
+
+            if (d1 >= 0) result.Add(v1);
+
+            return result;
+        }
+
+        private static Vector2 GetRelativeVelocity(Contact contact)
+        {
+            Body a = contact.BodyA;
+            Body b = contact.BodyB;
+            Vector2 va = a.Velocity + Cross(a.AngularVelocity, contact.RA);
+            Vector2 vb = b.Velocity + Cross(b.AngularVelocity, contact.RB);
+            return vb - va;
+        }
+
+        private static void ApplyImpulse(Contact contact, Vector2 impulse)
+        {
+            if (!contact.BodyA.IsStatic)
+                contact.BodyA.ApplyImpulseAtWorldPosition(-impulse, contact.Point);
+            if (!contact.BodyB.IsStatic)
+                contact.BodyB.ApplyImpulseAtWorldPosition(impulse, contact.Point);
+        }
+
+        private static float Cross(Vector2 a, Vector2 b)
+        {
+            return a.X * b.Y - a.Y * b.X;
+        }
+
+        private static Vector2 Cross(float s, Vector2 a)
+        {
+            return new Vector2(-s * a.Y, s * a.X);
+        }
+    }
+}

PhysicsEngine/Physics/Constraints/Constraint.cs

@@ -0,0 +1,24 @@
+using System.Numerics;
+
+namespace PhysicsEngine
+{
+    public abstract class Constraint
+    {
+        public Body BodyA;
+        public Body BodyB;
+        public Vector2 LocalAnchorA;
+        public Vector2 LocalAnchorB;
+
+        public Vector2 GetWorldAnchorA()
+        {
+            return BodyA.Position + LocalAnchorA;
+        }
+
+        public Vector2 GetWorldAnchorB()
+        {
+            return BodyB.Position + LocalAnchorB;
+        }
+
+        public abstract void Solve();
+    }
+}

PhysicsEngine/Physics/Forces/DragForce.cs

@@ -0,0 +1,10 @@
+namespace PhysicsEngine
+{
+    public static class DragForce
+    {
+        public static void Apply(Body body, float dt)
+        {
+            body.ApplyAerodynamicDrag(dt);
+        }
+    }
+}

PhysicsEngine/Physics/Forces/GlobalForce.cs

@@ -0,0 +1,4 @@
+namespace PhysicsEngine
+{
+    public delegate void GlobalForce(Body body, float dt);
+}

PhysicsEngine/Physics/Forces/GravityForce.cs

@@ -0,0 +1,12 @@
+using System.Numerics;
+
+namespace PhysicsEngine
+{
+    public static class GravityForce
+    {
+        public static void Apply(Body body, float dt)
+        {
+            body.ApplyForce(Vector2.UnitY * 9.81f * body.Mass);
+        }
+    }
+}

PhysicsEngine/Physics/Solver.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace PhysicsEngine
+{
+    public class Solver
+    {
+        private const int DefaultSubSteps = 8;
+
+        public void Step(float dt, List<Body> bodies, List<Constraint> constraints, List<GlobalForce> globalForces, int subSteps = DefaultSubSteps)
+        {
+            if (subSteps <= 0) subSteps = 1;
+
+            float subDt = dt / subSteps;
+
+            for (int step = 0; step < subSteps; step++)
+            {
+                // accumulate global forces
+                foreach (var body in bodies)
+                {
+                    if (body.IsStatic) continue;
+
+                    foreach (var forceGenerator in globalForces)
+                    {
+                        forceGenerator(body, subDt);
+                    }
+                }
+
+                // velocity & position updates
+                foreach (var body in bodies)
+                {
+                    if (body.IsStatic) continue;
+
+                    // linear motion
+                    Vector2 acceleration = body.ForceAccumulator * body.InverseMass;
+                    body.Velocity += acceleration * subDt;
+                    body.Position += body.Velocity * subDt;
+
+                    // angular motion
+                    float angularAcceleration = body.TorqueAccumulator * body.InverseInertia;
+                    body.AngularVelocity += angularAcceleration * subDt;
+                    body.Rotation += body.AngularVelocity * subDt;
+
+                    // clear
+                    body.ClearForces();
+                }
+
+                // collisions
+                CollisionEngine.ResolveCollisions(bodies, subDt);
+
+                // constraints
+                foreach (var constraint in constraints)
+                {
+                    constraint.Solve();
+                }
+            }
+        }
+    }
+}

PhysicsEngine/Physics/WorldModel.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+
+namespace PhysicsEngine
+{
+    public class WorldModel
+    {
+        public List<Body> Bodies { get; private set; } = new();
+        public List<Constraint> Constraints { get; private set; } = new();
+        public List<GlobalForce> GlobalForces = new();
+
+        private readonly Solver _solver = new();
+
+        public WorldModel()
+        {
+            GlobalForces.Add(GravityForce.Apply);
+            GlobalForces.Add(DragForce.Apply);
+        }
+
+        public void AddBody(Body body)
+        {
+            if (!Bodies.Contains(body))
+            {
+                Bodies.Add(body);
+            }
+        }
+
+        public void RemoveBody(Body body)
+        {
+            Bodies.Remove(body);
+        }
+
+        public void AddConstraint(Constraint constraint)
+        {
+            if (!Constraints.Contains(constraint))
+            {
+                Constraints.Add(constraint);
+            }
+        }
+
+        public void RemoveConstraint(Constraint constraint)
+        {
+            Constraints.Remove(constraint);
+        }
+
+        public void Step(float dt)
+        {
+            _solver.Step(dt, Bodies, Constraints, GlobalForces, 8);
+        }
+    }
+}

PhysicsEngine/PhysicsEngine.csproj

@@ -11,4 +11,10 @@
     <PackageReference Include="Raylib-cs" Version="8.0.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="Roboto-Regular.ttf">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
 </Project>

PhysicsEngine/Program.cs

@@ -1,68 +0,0 @@
-using Raylib_cs;
-
-namespace PhysicsEngine
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            Raylib.SetConfigFlags(ConfigFlags.FullscreenMode | ConfigFlags.VSyncHint);
-            Raylib.InitWindow(0, 0, "Physics Engine");
-
-            Camera camera = new Camera();
-
-            const float physicsTimeStep = 1.0f / 60.0f;
-            float accumulator = 0.0f;
-
-            // Main loop
-            while (!Raylib.WindowShouldClose())
-            {
-                float frameTime = Raylib.GetFrameTime();
-                if (frameTime > 0.25f)
-                {
-                    frameTime = 0.25f;
-                }
-
-                // Update Camera
-                camera.Update(frameTime);
-
-                // Update Physics accumulator
-                accumulator += frameTime;
-                while (accumulator >= physicsTimeStep)
-                {
-                    UpdatePhysics(physicsTimeStep);
-                    accumulator -= physicsTimeStep;
-                }
-
-                // Render loop
-                Raylib.BeginDrawing();
-                Raylib.ClearBackground(MuiDarkColor.BackgroundDefault.ToColor());
-
-                // Draw background screen-space elements (Grid)
-                camera.DrawGrid();
-
-                // Draw world-space elements inside 2D mode
-                Raylib.BeginMode2D(camera.RaylibCamera);
-                Raylib.EndMode2D();
-
-                // Draw UI / HUD elements
-                RenderScene();
-                camera.DrawHUD();
-
-                Raylib.EndDrawing();
-            }
-
-            Raylib.CloseWindow();
-        }
-
-        private static void UpdatePhysics(float dt)
-        {
-            // Physics simulation step
-        }
-
-        private static void RenderScene()
-        {
-            Raylib.DrawText("Physics Engine", 20, 20, 20, MuiDarkColor.TextPrimary.ToColor());
-        }
-    }
-}

PhysicsEngine/UI/DrawHelper.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Numerics;
+using Raylib_cs;
+
+namespace PhysicsEngine
+{
+    public static class DrawHelper
+    {
+        public static Color GetDarkerColor(Color color, float factor = 0.5f)
+        {
+            return new Color(
+                (byte)(color.R * factor),
+                (byte)(color.G * factor),
+                (byte)(color.B * factor),
+                color.A
+            );
+        }
+
+        public static void DrawRotatedBox(Vector2 position, Vector2 size, float rotationRadians, Color fillColor, float pixelsPerMeter = 100.0f, float outlineThickness = 3.0f)
+        {
+            Vector2 sizePixels = size * pixelsPerMeter;
+            Vector2 positionPixels = position * pixelsPerMeter;
+            float rotationDegrees = rotationRadians * (180.0f / MathF.PI);
+
+            Color outlineColor = GetDarkerColor(fillColor);
+
+            Vector2 outerSizePixels = sizePixels;
+            Vector2 outerOrigin = outerSizePixels * 0.5f;
+            Rectangle outerRec = new Rectangle(positionPixels.X, positionPixels.Y, outerSizePixels.X, outerSizePixels.Y);
+            Raylib.DrawRectanglePro(outerRec, outerOrigin, rotationDegrees, outlineColor);
+
+            Vector2 innerSizePixels = new Vector2(
+                MathF.Max(0, sizePixels.X - outlineThickness),
+                MathF.Max(0, sizePixels.Y - outlineThickness)
+            );
+            Vector2 innerOrigin = innerSizePixels * 0.5f;
+            Rectangle innerRec = new Rectangle(positionPixels.X, positionPixels.Y, innerSizePixels.X, innerSizePixels.Y);
+            Raylib.DrawRectanglePro(innerRec, innerOrigin, rotationDegrees, fillColor);
+        }
+
+        public static void DrawCircleBody(Vector2 position, float radius, float rotationRadians, Color fillColor, float pixelsPerMeter = 100.0f, float outlineThickness = 3.0f)
+        {
+            Vector2 positionPixels = position * pixelsPerMeter;
+            float radiusPixels = radius * pixelsPerMeter;
+            Color outlineColor = GetDarkerColor(fillColor);
+
+            Raylib.DrawCircleV(positionPixels, radiusPixels, outlineColor);
+
+            float innerRadius = MathF.Max(0, radiusPixels - outlineThickness);
+            Raylib.DrawCircleV(positionPixels, innerRadius, fillColor);
+
+            float cos = MathF.Cos(rotationRadians);
+            float sin = MathF.Sin(rotationRadians);
+            Vector2 edge = positionPixels + new Vector2(cos, sin) * innerRadius;
+            Raylib.DrawLineEx(positionPixels, edge, 2.0f, outlineColor);
+        }
+    }
+}

PhysicsEngine/bin/Debug/net10.0/PhysicsEngine.deps.json

@@ -1,68 +0,0 @@
-{
-  "runtimeTarget": {
-    "name": ".NETCoreApp,Version=v10.0",
-    "signature": ""
-  },
-  "compilationOptions": {},
-  "targets": {
-    ".NETCoreApp,Version=v10.0": {
-      "PhysicsEngine/1.0.0": {
-        "dependencies": {
-          "Raylib-cs": "8.0.0"
-        },
-        "runtime": {
-          "PhysicsEngine.dll": {}
-        }
-      },
-      "Raylib-cs/8.0.0": {
-        "runtime": {
-          "lib/net10.0/Raylib-cs.dll": {
-            "assemblyVersion": "0.0.0.0",
-            "fileVersion": "0.0.0.0"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/linux-x64/native/libraylib.so": {
-            "rid": "linux-x64",
-            "assetType": "native",
-            "fileVersion": "0.0.0.0"
-          },
-          "runtimes/osx-arm64/native/libraylib.dylib": {
-            "rid": "osx-arm64",
-            "assetType": "native",
-            "fileVersion": "0.0.0.0"
-          },
-          "runtimes/osx-x64/native/libraylib.dylib": {
-            "rid": "osx-x64",
-            "assetType": "native",
-            "fileVersion": "0.0.0.0"
-          },
-          "runtimes/win-x64/native/raylib.dll": {
-            "rid": "win-x64",
-            "assetType": "native",
-            "fileVersion": "0.0.0.0"
-          },
-          "runtimes/win-x86/native/raylib.dll": {
-            "rid": "win-x86",
-            "assetType": "native",
-            "fileVersion": "0.0.0.0"
-          }
-        }
-      }
-    }
-  },
-  "libraries": {
-    "PhysicsEngine/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "Raylib-cs/8.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-m+fStTZjOGtkx05RNflERtKbmEUrIZ5/PFV5QXnlA02kAEwxxOC+XhNeCSZJhaGHu9d8m0eTMmefRhHueS3hkg==",
-      "path": "raylib-cs/8.0.0",
-      "hashPath": "raylib-cs.8.0.0.nupkg.sha512"
-    }
-  }
-}

PhysicsEngine/bin/Debug/net10.0/PhysicsEngine.runtimeconfig.json

@@ -1,12 +0,0 @@
-{
-  "runtimeOptions": {
-    "tfm": "net10.0",
-    "framework": {
-      "name": "Microsoft.NETCore.App",
-      "version": "10.0.0"
-    },
-    "configProperties": {
-      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
-    }
-  }
-}

PhysicsEngine/obj/Debug/net10.0/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs

@@ -1,4 +0,0 @@
-// <autogenerated />
-using System;
-using System.Reflection;
-[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v10.0", FrameworkDisplayName = ".NET 10.0")]

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.AssemblyInfo.cs

@@ -1,22 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-using System;
-using System.Reflection;
-
-[assembly: System.Reflection.AssemblyCompanyAttribute("PhysicsEngine")]
-[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
-[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+5680beef02a5c7a4cdc1dc725326855b4af1faab")]
-[assembly: System.Reflection.AssemblyProductAttribute("PhysicsEngine")]
-[assembly: System.Reflection.AssemblyTitleAttribute("PhysicsEngine")]
-[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
-
-// Generated by the MSBuild WriteCodeFragment class.
-

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.AssemblyInfoInputs.cache

@@ -1 +0,0 @@
-65813feab20f3482f44a4d97f31d1282ff5b6ec731137cac82a3e7db08a5bb63

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.GeneratedMSBuildEditorConfig.editorconfig

@@ -1,17 +0,0 @@
-is_global = true
-build_property.TargetFramework = net10.0
-build_property.TargetFrameworkIdentifier = .NETCoreApp
-build_property.TargetFrameworkVersion = v10.0
-build_property.TargetPlatformMinVersion = 
-build_property.UsingMicrosoftNETSdkWeb = 
-build_property.ProjectTypeGuids = 
-build_property.InvariantGlobalization = 
-build_property.PlatformNeutralAssembly = 
-build_property.EnforceExtendedAnalyzerRules = 
-build_property._SupportedPlatformList = Linux,macOS,Windows
-build_property.RootNamespace = PhysicsEngine
-build_property.ProjectDir = C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\
-build_property.EnableComHosting = 
-build_property.EnableGeneratedComInterfaceComImportInterop = 
-build_property.EffectiveAnalysisLevelStyle = 10.0
-build_property.EnableCodeStyleSeverity = 

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.GlobalUsings.g.cs

@@ -1,8 +0,0 @@
-// <auto-generated/>
-global using System;
-global using System.Collections.Generic;
-global using System.IO;
-global using System.Linq;
-global using System.Net.Http;
-global using System.Threading;
-global using System.Threading.Tasks;

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.csproj.CoreCompileInputs.cache

@@ -1 +0,0 @@
-6b2f1f27b472d9ef51ad7745525496297fe0832151173bc3df4acdae2fd1d6fe

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.csproj.FileListAbsolute.txt

@@ -1,44 +0,0 @@
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.exe
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.deps.json
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.runtimeconfig.json
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.pdb
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.GeneratedMSBuildEditorConfig.editorconfig
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.AssemblyInfoInputs.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.AssemblyInfo.cs
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.csproj.CoreCompileInputs.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\refint\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.pdb
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.genruntimeconfig.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\ref\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\Raylib-cs.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\linux-x64\native\libraylib.so
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\osx-arm64\native\libraylib.dylib
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\osx-x64\native\libraylib.dylib
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\win-x64\native\raylib.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\win-x86\native\raylib.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.csproj.AssemblyReference.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsE.CA49F505.Up2Date
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.exe
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.deps.json
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.runtimeconfig.json
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\PhysicsEngine.pdb
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\Raylib-cs.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\linux-x64\native\libraylib.so
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\osx-arm64\native\libraylib.dylib
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\osx-x64\native\libraylib.dylib
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\win-x64\native\raylib.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\bin\Debug\net10.0\runtimes\win-x86\native\raylib.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.csproj.AssemblyReference.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.GeneratedMSBuildEditorConfig.editorconfig
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.AssemblyInfoInputs.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.AssemblyInfo.cs
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.csproj.CoreCompileInputs.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsE.CA49F505.Up2Date
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\refint\PhysicsEngine.dll
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.pdb
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\PhysicsEngine.genruntimeconfig.cache
-C:\Users\maxwes08\source\repos\Physics-Engine\PhysicsEngine\obj\Debug\net10.0\ref\PhysicsEngine.dll

PhysicsEngine/obj/Debug/net10.0/PhysicsEngine.genruntimeconfig.cache

@@ -1 +0,0 @@
-37ea7c12f0356941dc732812414abe750a46377a93f758cd17f2e72c58cb3a80

PhysicsEngine/obj/PhysicsEngine.csproj.nuget.dgspec.json

@@ -1,349 +0,0 @@
-{
-  "format": 1,
-  "restore": {
-    "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj": {}
-  },
-  "projects": {
-    "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj": {
-      "version": "1.0.0",
-      "restore": {
-        "projectUniqueName": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj",
-        "projectName": "PhysicsEngine",
-        "projectPath": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj",
-        "packagesPath": "C:\\Users\\maxwes08\\.nuget\\packages\\",
-        "outputPath": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\obj\\",
-        "projectStyle": "PackageReference",
-        "configFilePaths": [
-          "C:\\Users\\maxwes08\\AppData\\Roaming\\NuGet\\NuGet.Config",
-          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
-        ],
-        "originalTargetFrameworks": [
-          "net10.0"
-        ],
-        "sources": {
-          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
-          "https://api.nuget.org/v3/index.json": {}
-        },
-        "frameworks": {
-          "net10.0": {
-            "targetAlias": "net10.0",
-            "projectReferences": {}
-          }
-        },
-        "warningProperties": {
-          "warnAsError": [
-            "NU1605"
-          ]
-        },
-        "restoreAuditProperties": {
-          "enableAudit": "true",
-          "auditLevel": "low",
-          "auditMode": "all"
-        },
-        "SdkAnalysisLevel": "10.0.200"
-      },
-      "frameworks": {
-        "net10.0": {
-          "targetAlias": "net10.0",
-          "dependencies": {
-            "Raylib-cs": {
-              "target": "Package",
-              "version": "[8.0.0, )"
-            }
-          },
-          "imports": [
-            "net461",
-            "net462",
-            "net47",
-            "net471",
-            "net472",
-            "net48",
-            "net481"
-          ],
-          "assetTargetFallback": true,
-          "warn": true,
-          "frameworkReferences": {
-            "Microsoft.NETCore.App": {
-              "privateAssets": "all"
-            }
-          },
-          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\10.0.204/PortableRuntimeIdentifierGraph.json",
-          "packagesToPrune": {
-            "Microsoft.CSharp": "(,4.7.32767]",
-            "Microsoft.VisualBasic": "(,10.4.32767]",
-            "Microsoft.Win32.Primitives": "(,4.3.32767]",
-            "Microsoft.Win32.Registry": "(,5.0.32767]",
-            "runtime.any.System.Collections": "(,4.3.32767]",
-            "runtime.any.System.Diagnostics.Tools": "(,4.3.32767]",
-            "runtime.any.System.Diagnostics.Tracing": "(,4.3.32767]",
-            "runtime.any.System.Globalization": "(,4.3.32767]",
-            "runtime.any.System.Globalization.Calendars": "(,4.3.32767]",
-            "runtime.any.System.IO": "(,4.3.32767]",
-            "runtime.any.System.Reflection": "(,4.3.32767]",
-            "runtime.any.System.Reflection.Extensions": "(,4.3.32767]",
-            "runtime.any.System.Reflection.Primitives": "(,4.3.32767]",
-            "runtime.any.System.Resources.ResourceManager": "(,4.3.32767]",
-            "runtime.any.System.Runtime": "(,4.3.32767]",
-            "runtime.any.System.Runtime.Handles": "(,4.3.32767]",
-            "runtime.any.System.Runtime.InteropServices": "(,4.3.32767]",
-            "runtime.any.System.Text.Encoding": "(,4.3.32767]",
-            "runtime.any.System.Text.Encoding.Extensions": "(,4.3.32767]",
-            "runtime.any.System.Threading.Tasks": "(,4.3.32767]",
-            "runtime.any.System.Threading.Timer": "(,4.3.32767]",
-            "runtime.aot.System.Collections": "(,4.3.32767]",
-            "runtime.aot.System.Diagnostics.Tools": "(,4.3.32767]",
-            "runtime.aot.System.Diagnostics.Tracing": "(,4.3.32767]",
-            "runtime.aot.System.Globalization": "(,4.3.32767]",
-            "runtime.aot.System.Globalization.Calendars": "(,4.3.32767]",
-            "runtime.aot.System.IO": "(,4.3.32767]",
-            "runtime.aot.System.Reflection": "(,4.3.32767]",
-            "runtime.aot.System.Reflection.Extensions": "(,4.3.32767]",
-            "runtime.aot.System.Reflection.Primitives": "(,4.3.32767]",
-            "runtime.aot.System.Resources.ResourceManager": "(,4.3.32767]",
-            "runtime.aot.System.Runtime": "(,4.3.32767]",
-            "runtime.aot.System.Runtime.Handles": "(,4.3.32767]",
-            "runtime.aot.System.Runtime.InteropServices": "(,4.3.32767]",
-            "runtime.aot.System.Text.Encoding": "(,4.3.32767]",
-            "runtime.aot.System.Text.Encoding.Extensions": "(,4.3.32767]",
-            "runtime.aot.System.Threading.Tasks": "(,4.3.32767]",
-            "runtime.aot.System.Threading.Timer": "(,4.3.32767]",
-            "runtime.debian.8-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.debian.8-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.debian.8-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.debian.8-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.debian.8-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.debian.9-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.debian.9-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.debian.9-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.debian.9-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.fedora.23-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.fedora.23-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.fedora.23-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.fedora.24-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.fedora.24-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.fedora.24-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.fedora.27-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.fedora.27-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.fedora.27-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.fedora.27-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.fedora.28-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.fedora.28-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.fedora.28-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.fedora.28-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.opensuse.13.2-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.opensuse.42.1-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.opensuse.42.3-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.opensuse.42.3-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.opensuse.42.3-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.opensuse.42.3-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "(,4.3.32767]",
-            "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.rhel.7-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.rhel.7-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.rhel.7-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.ubuntu.14.04-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.ubuntu.16.04-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.ubuntu.16.10-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-            "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-            "runtime.ubuntu.18.04-x64.runtime.native.System": "(,4.3.32767]",
-            "runtime.ubuntu.18.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-            "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-            "runtime.unix.Microsoft.Win32.Primitives": "(,4.3.32767]",
-            "runtime.unix.System.Console": "(,4.3.32767]",
-            "runtime.unix.System.Diagnostics.Debug": "(,4.3.32767]",
-            "runtime.unix.System.IO.FileSystem": "(,4.3.32767]",
-            "runtime.unix.System.Net.Primitives": "(,4.3.32767]",
-            "runtime.unix.System.Net.Sockets": "(,4.3.32767]",
-            "runtime.unix.System.Private.Uri": "(,4.3.32767]",
-            "runtime.unix.System.Runtime.Extensions": "(,4.3.32767]",
-            "runtime.win.Microsoft.Win32.Primitives": "(,4.3.32767]",
-            "runtime.win.System.Console": "(,4.3.32767]",
-            "runtime.win.System.Diagnostics.Debug": "(,4.3.32767]",
-            "runtime.win.System.IO.FileSystem": "(,4.3.32767]",
-            "runtime.win.System.Net.Primitives": "(,4.3.32767]",
-            "runtime.win.System.Net.Sockets": "(,4.3.32767]",
-            "runtime.win.System.Runtime.Extensions": "(,4.3.32767]",
-            "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
-            "runtime.win10-arm64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
-            "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
-            "runtime.win7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.win7-x86.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "runtime.win7.System.Private.Uri": "(,4.3.32767]",
-            "runtime.win8-arm.runtime.native.System.IO.Compression": "(,4.3.32767]",
-            "System.AppContext": "(,4.3.32767]",
-            "System.Buffers": "(,5.0.32767]",
-            "System.Collections": "(,4.3.32767]",
-            "System.Collections.Concurrent": "(,4.3.32767]",
-            "System.Collections.Immutable": "(,10.0.32767]",
-            "System.Collections.NonGeneric": "(,4.3.32767]",
-            "System.Collections.Specialized": "(,4.3.32767]",
-            "System.ComponentModel": "(,4.3.32767]",
-            "System.ComponentModel.Annotations": "(,4.3.32767]",
-            "System.ComponentModel.EventBasedAsync": "(,4.3.32767]",
-            "System.ComponentModel.Primitives": "(,4.3.32767]",
-            "System.ComponentModel.TypeConverter": "(,4.3.32767]",
-            "System.Console": "(,4.3.32767]",
-            "System.Data.Common": "(,4.3.32767]",
-            "System.Data.DataSetExtensions": "(,4.4.32767]",
-            "System.Diagnostics.Contracts": "(,4.3.32767]",
-            "System.Diagnostics.Debug": "(,4.3.32767]",
-            "System.Diagnostics.DiagnosticSource": "(,10.0.32767]",
-            "System.Diagnostics.FileVersionInfo": "(,4.3.32767]",
-            "System.Diagnostics.Process": "(,4.3.32767]",
-            "System.Diagnostics.StackTrace": "(,4.3.32767]",
-            "System.Diagnostics.TextWriterTraceListener": "(,4.3.32767]",
-            "System.Diagnostics.Tools": "(,4.3.32767]",
-            "System.Diagnostics.TraceSource": "(,4.3.32767]",
-            "System.Diagnostics.Tracing": "(,4.3.32767]",
-            "System.Drawing.Primitives": "(,4.3.32767]",
-            "System.Dynamic.Runtime": "(,4.3.32767]",
-            "System.Formats.Asn1": "(,10.0.32767]",
-            "System.Formats.Tar": "(,10.0.32767]",
-            "System.Globalization": "(,4.3.32767]",
-            "System.Globalization.Calendars": "(,4.3.32767]",
-            "System.Globalization.Extensions": "(,4.3.32767]",
-            "System.IO": "(,4.3.32767]",
-            "System.IO.Compression": "(,4.3.32767]",
-            "System.IO.Compression.ZipFile": "(,4.3.32767]",
-            "System.IO.FileSystem": "(,4.3.32767]",
-            "System.IO.FileSystem.AccessControl": "(,4.4.32767]",
-            "System.IO.FileSystem.DriveInfo": "(,4.3.32767]",
-            "System.IO.FileSystem.Primitives": "(,4.3.32767]",
-            "System.IO.FileSystem.Watcher": "(,4.3.32767]",
-            "System.IO.IsolatedStorage": "(,4.3.32767]",
-            "System.IO.MemoryMappedFiles": "(,4.3.32767]",
-            "System.IO.Pipelines": "(,10.0.32767]",
-            "System.IO.Pipes": "(,4.3.32767]",
-            "System.IO.Pipes.AccessControl": "(,5.0.32767]",
-            "System.IO.UnmanagedMemoryStream": "(,4.3.32767]",
-            "System.Linq": "(,4.3.32767]",
-            "System.Linq.AsyncEnumerable": "(,10.0.32767]",
-            "System.Linq.Expressions": "(,4.3.32767]",
-            "System.Linq.Parallel": "(,4.3.32767]",
-            "System.Linq.Queryable": "(,4.3.32767]",
-            "System.Memory": "(,5.0.32767]",
-            "System.Net.Http": "(,4.3.32767]",
-            "System.Net.Http.Json": "(,10.0.32767]",
-            "System.Net.NameResolution": "(,4.3.32767]",
-            "System.Net.NetworkInformation": "(,4.3.32767]",
-            "System.Net.Ping": "(,4.3.32767]",
-            "System.Net.Primitives": "(,4.3.32767]",
-            "System.Net.Requests": "(,4.3.32767]",
-            "System.Net.Security": "(,4.3.32767]",
-            "System.Net.ServerSentEvents": "(,10.0.32767]",
-            "System.Net.Sockets": "(,4.3.32767]",
-            "System.Net.WebHeaderCollection": "(,4.3.32767]",
-            "System.Net.WebSockets": "(,4.3.32767]",
-            "System.Net.WebSockets.Client": "(,4.3.32767]",
-            "System.Numerics.Vectors": "(,5.0.32767]",
-            "System.ObjectModel": "(,4.3.32767]",
-            "System.Private.DataContractSerialization": "(,4.3.32767]",
-            "System.Private.Uri": "(,4.3.32767]",
-            "System.Reflection": "(,4.3.32767]",
-            "System.Reflection.DispatchProxy": "(,6.0.32767]",
-            "System.Reflection.Emit": "(,4.7.32767]",
-            "System.Reflection.Emit.ILGeneration": "(,4.7.32767]",
-            "System.Reflection.Emit.Lightweight": "(,4.7.32767]",
-            "System.Reflection.Extensions": "(,4.3.32767]",
-            "System.Reflection.Metadata": "(,10.0.32767]",
-            "System.Reflection.Primitives": "(,4.3.32767]",
-            "System.Reflection.TypeExtensions": "(,4.3.32767]",
-            "System.Resources.Reader": "(,4.3.32767]",
-            "System.Resources.ResourceManager": "(,4.3.32767]",
-            "System.Resources.Writer": "(,4.3.32767]",
-            "System.Runtime": "(,4.3.32767]",
-            "System.Runtime.CompilerServices.Unsafe": "(,7.0.32767]",
-            "System.Runtime.CompilerServices.VisualC": "(,4.3.32767]",
-            "System.Runtime.Extensions": "(,4.3.32767]",
-            "System.Runtime.Handles": "(,4.3.32767]",
-            "System.Runtime.InteropServices": "(,4.3.32767]",
-            "System.Runtime.InteropServices.RuntimeInformation": "(,4.3.32767]",
-            "System.Runtime.Loader": "(,4.3.32767]",
-            "System.Runtime.Numerics": "(,4.3.32767]",
-            "System.Runtime.Serialization.Formatters": "(,4.3.32767]",
-            "System.Runtime.Serialization.Json": "(,4.3.32767]",
-            "System.Runtime.Serialization.Primitives": "(,4.3.32767]",
-            "System.Runtime.Serialization.Xml": "(,4.3.32767]",
-            "System.Security.AccessControl": "(,6.0.32767]",
-            "System.Security.Claims": "(,4.3.32767]",
-            "System.Security.Cryptography.Algorithms": "(,4.3.32767]",
-            "System.Security.Cryptography.Cng": "(,5.0.32767]",
-            "System.Security.Cryptography.Csp": "(,4.3.32767]",
-            "System.Security.Cryptography.Encoding": "(,4.3.32767]",
-            "System.Security.Cryptography.OpenSsl": "(,5.0.32767]",
-            "System.Security.Cryptography.Primitives": "(,4.3.32767]",
-            "System.Security.Cryptography.X509Certificates": "(,4.3.32767]",
-            "System.Security.Principal": "(,4.3.32767]",
-            "System.Security.Principal.Windows": "(,5.0.32767]",
-            "System.Security.SecureString": "(,4.3.32767]",
-            "System.Text.Encoding": "(,4.3.32767]",
-            "System.Text.Encoding.CodePages": "(,10.0.32767]",
-            "System.Text.Encoding.Extensions": "(,4.3.32767]",
-            "System.Text.Encodings.Web": "(,10.0.32767]",
-            "System.Text.Json": "(,10.0.32767]",
-            "System.Text.RegularExpressions": "(,4.3.32767]",
-            "System.Threading": "(,4.3.32767]",
-            "System.Threading.AccessControl": "(,10.0.32767]",
-            "System.Threading.Channels": "(,10.0.32767]",
-            "System.Threading.Overlapped": "(,4.3.32767]",
-            "System.Threading.Tasks": "(,4.3.32767]",
-            "System.Threading.Tasks.Dataflow": "(,10.0.32767]",
-            "System.Threading.Tasks.Extensions": "(,5.0.32767]",
-            "System.Threading.Tasks.Parallel": "(,4.3.32767]",
-            "System.Threading.Thread": "(,4.3.32767]",
-            "System.Threading.ThreadPool": "(,4.3.32767]",
-            "System.Threading.Timer": "(,4.3.32767]",
-            "System.ValueTuple": "(,4.5.32767]",
-            "System.Xml.ReaderWriter": "(,4.3.32767]",
-            "System.Xml.XDocument": "(,4.3.32767]",
-            "System.Xml.XmlDocument": "(,4.3.32767]",
-            "System.Xml.XmlSerializer": "(,4.3.32767]",
-            "System.Xml.XPath": "(,4.3.32767]",
-            "System.Xml.XPath.XDocument": "(,5.0.32767]"
-          }
-        }
-      }
-    }
-  }
-}

PhysicsEngine/obj/PhysicsEngine.csproj.nuget.g.props

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
-    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
-    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
-    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
-    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\maxwes08\.nuget\packages\</NuGetPackageFolders>
-    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
-    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">7.0.0</NuGetToolVersion>
-  </PropertyGroup>
-  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <SourceRoot Include="C:\Users\maxwes08\.nuget\packages\" />
-  </ItemGroup>
-</Project>

PhysicsEngine/obj/PhysicsEngine.csproj.nuget.g.targets

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" />

PhysicsEngine/obj/project.assets.json

@@ -1,415 +0,0 @@
-{
-  "version": 3,
-  "targets": {
-    "net10.0": {
-      "Raylib-cs/8.0.0": {
-        "type": "package",
-        "compile": {
-          "lib/net10.0/Raylib-cs.dll": {
-            "related": ".xml"
-          }
-        },
-        "runtime": {
-          "lib/net10.0/Raylib-cs.dll": {
-            "related": ".xml"
-          }
-        },
-        "runtimeTargets": {
-          "runtimes/linux-x64/native/libraylib.so": {
-            "assetType": "native",
-            "rid": "linux-x64"
-          },
-          "runtimes/osx-arm64/native/libraylib.dylib": {
-            "assetType": "native",
-            "rid": "osx-arm64"
-          },
-          "runtimes/osx-x64/native/libraylib.dylib": {
-            "assetType": "native",
-            "rid": "osx-x64"
-          },
-          "runtimes/win-x64/native/raylib.dll": {
-            "assetType": "native",
-            "rid": "win-x64"
-          },
-          "runtimes/win-x86/native/raylib.dll": {
-            "assetType": "native",
-            "rid": "win-x86"
-          }
-        }
-      }
-    }
-  },
-  "libraries": {
-    "Raylib-cs/8.0.0": {
-      "sha512": "m+fStTZjOGtkx05RNflERtKbmEUrIZ5/PFV5QXnlA02kAEwxxOC+XhNeCSZJhaGHu9d8m0eTMmefRhHueS3hkg==",
-      "type": "package",
-      "path": "raylib-cs/8.0.0",
-      "files": [
-        ".nupkg.metadata",
-        ".signature.p7s",
-        "README.md",
-        "lib/net10.0/Raylib-cs.dll",
-        "lib/net10.0/Raylib-cs.xml",
-        "lib/net8.0/Raylib-cs.dll",
-        "lib/net8.0/Raylib-cs.xml",
-        "raylib-cs.8.0.0.nupkg.sha512",
-        "raylib-cs.nuspec",
-        "raylib-cs_64x64.png",
-        "runtimes/linux-x64/native/libraylib.so",
-        "runtimes/osx-arm64/native/libraylib.dylib",
-        "runtimes/osx-x64/native/libraylib.dylib",
-        "runtimes/win-x64/native/raylib.dll",
-        "runtimes/win-x86/native/raylib.dll"
-      ]
-    }
-  },
-  "projectFileDependencyGroups": {
-    "net10.0": [
-      "Raylib-cs >= 8.0.0"
-    ]
-  },
-  "packageFolders": {
-    "C:\\Users\\maxwes08\\.nuget\\packages\\": {}
-  },
-  "project": {
-    "version": "1.0.0",
-    "restore": {
-      "projectUniqueName": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj",
-      "projectName": "PhysicsEngine",
-      "projectPath": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj",
-      "packagesPath": "C:\\Users\\maxwes08\\.nuget\\packages\\",
-      "outputPath": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\obj\\",
-      "projectStyle": "PackageReference",
-      "configFilePaths": [
-        "C:\\Users\\maxwes08\\AppData\\Roaming\\NuGet\\NuGet.Config",
-        "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
-      ],
-      "originalTargetFrameworks": [
-        "net10.0"
-      ],
-      "sources": {
-        "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
-        "https://api.nuget.org/v3/index.json": {}
-      },
-      "frameworks": {
-        "net10.0": {
-          "targetAlias": "net10.0",
-          "projectReferences": {}
-        }
-      },
-      "warningProperties": {
-        "warnAsError": [
-          "NU1605"
-        ]
-      },
-      "restoreAuditProperties": {
-        "enableAudit": "true",
-        "auditLevel": "low",
-        "auditMode": "all"
-      },
-      "SdkAnalysisLevel": "10.0.200"
-    },
-    "frameworks": {
-      "net10.0": {
-        "targetAlias": "net10.0",
-        "dependencies": {
-          "Raylib-cs": {
-            "target": "Package",
-            "version": "[8.0.0, )"
-          }
-        },
-        "imports": [
-          "net461",
-          "net462",
-          "net47",
-          "net471",
-          "net472",
-          "net48",
-          "net481"
-        ],
-        "assetTargetFallback": true,
-        "warn": true,
-        "frameworkReferences": {
-          "Microsoft.NETCore.App": {
-            "privateAssets": "all"
-          }
-        },
-        "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\10.0.204/PortableRuntimeIdentifierGraph.json",
-        "packagesToPrune": {
-          "Microsoft.CSharp": "(,4.7.32767]",
-          "Microsoft.VisualBasic": "(,10.4.32767]",
-          "Microsoft.Win32.Primitives": "(,4.3.32767]",
-          "Microsoft.Win32.Registry": "(,5.0.32767]",
-          "runtime.any.System.Collections": "(,4.3.32767]",
-          "runtime.any.System.Diagnostics.Tools": "(,4.3.32767]",
-          "runtime.any.System.Diagnostics.Tracing": "(,4.3.32767]",
-          "runtime.any.System.Globalization": "(,4.3.32767]",
-          "runtime.any.System.Globalization.Calendars": "(,4.3.32767]",
-          "runtime.any.System.IO": "(,4.3.32767]",
-          "runtime.any.System.Reflection": "(,4.3.32767]",
-          "runtime.any.System.Reflection.Extensions": "(,4.3.32767]",
-          "runtime.any.System.Reflection.Primitives": "(,4.3.32767]",
-          "runtime.any.System.Resources.ResourceManager": "(,4.3.32767]",
-          "runtime.any.System.Runtime": "(,4.3.32767]",
-          "runtime.any.System.Runtime.Handles": "(,4.3.32767]",
-          "runtime.any.System.Runtime.InteropServices": "(,4.3.32767]",
-          "runtime.any.System.Text.Encoding": "(,4.3.32767]",
-          "runtime.any.System.Text.Encoding.Extensions": "(,4.3.32767]",
-          "runtime.any.System.Threading.Tasks": "(,4.3.32767]",
-          "runtime.any.System.Threading.Timer": "(,4.3.32767]",
-          "runtime.aot.System.Collections": "(,4.3.32767]",
-          "runtime.aot.System.Diagnostics.Tools": "(,4.3.32767]",
-          "runtime.aot.System.Diagnostics.Tracing": "(,4.3.32767]",
-          "runtime.aot.System.Globalization": "(,4.3.32767]",
-          "runtime.aot.System.Globalization.Calendars": "(,4.3.32767]",
-          "runtime.aot.System.IO": "(,4.3.32767]",
-          "runtime.aot.System.Reflection": "(,4.3.32767]",
-          "runtime.aot.System.Reflection.Extensions": "(,4.3.32767]",
-          "runtime.aot.System.Reflection.Primitives": "(,4.3.32767]",
-          "runtime.aot.System.Resources.ResourceManager": "(,4.3.32767]",
-          "runtime.aot.System.Runtime": "(,4.3.32767]",
-          "runtime.aot.System.Runtime.Handles": "(,4.3.32767]",
-          "runtime.aot.System.Runtime.InteropServices": "(,4.3.32767]",
-          "runtime.aot.System.Text.Encoding": "(,4.3.32767]",
-          "runtime.aot.System.Text.Encoding.Extensions": "(,4.3.32767]",
-          "runtime.aot.System.Threading.Tasks": "(,4.3.32767]",
-          "runtime.aot.System.Threading.Timer": "(,4.3.32767]",
-          "runtime.debian.8-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.debian.8-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.debian.8-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.debian.8-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.debian.8-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.debian.9-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.debian.9-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.debian.9-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.debian.9-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.fedora.23-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.fedora.23-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.fedora.23-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.fedora.24-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.fedora.24-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.fedora.24-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.fedora.27-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.fedora.27-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.fedora.27-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.fedora.27-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.fedora.28-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.fedora.28-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.fedora.28-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.fedora.28-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.opensuse.13.2-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.opensuse.42.1-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.opensuse.42.3-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.opensuse.42.3-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.opensuse.42.3-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.opensuse.42.3-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "(,4.3.32767]",
-          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.rhel.7-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.rhel.7-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.rhel.7-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.ubuntu.14.04-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.ubuntu.16.04-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.ubuntu.16.10-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
-          "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
-          "runtime.ubuntu.18.04-x64.runtime.native.System": "(,4.3.32767]",
-          "runtime.ubuntu.18.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
-          "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
-          "runtime.unix.Microsoft.Win32.Primitives": "(,4.3.32767]",
-          "runtime.unix.System.Console": "(,4.3.32767]",
-          "runtime.unix.System.Diagnostics.Debug": "(,4.3.32767]",
-          "runtime.unix.System.IO.FileSystem": "(,4.3.32767]",
-          "runtime.unix.System.Net.Primitives": "(,4.3.32767]",
-          "runtime.unix.System.Net.Sockets": "(,4.3.32767]",
-          "runtime.unix.System.Private.Uri": "(,4.3.32767]",
-          "runtime.unix.System.Runtime.Extensions": "(,4.3.32767]",
-          "runtime.win.Microsoft.Win32.Primitives": "(,4.3.32767]",
-          "runtime.win.System.Console": "(,4.3.32767]",
-          "runtime.win.System.Diagnostics.Debug": "(,4.3.32767]",
-          "runtime.win.System.IO.FileSystem": "(,4.3.32767]",
-          "runtime.win.System.Net.Primitives": "(,4.3.32767]",
-          "runtime.win.System.Net.Sockets": "(,4.3.32767]",
-          "runtime.win.System.Runtime.Extensions": "(,4.3.32767]",
-          "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
-          "runtime.win10-arm64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
-          "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
-          "runtime.win7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.win7-x86.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "runtime.win7.System.Private.Uri": "(,4.3.32767]",
-          "runtime.win8-arm.runtime.native.System.IO.Compression": "(,4.3.32767]",
-          "System.AppContext": "(,4.3.32767]",
-          "System.Buffers": "(,5.0.32767]",
-          "System.Collections": "(,4.3.32767]",
-          "System.Collections.Concurrent": "(,4.3.32767]",
-          "System.Collections.Immutable": "(,10.0.32767]",
-          "System.Collections.NonGeneric": "(,4.3.32767]",
-          "System.Collections.Specialized": "(,4.3.32767]",
-          "System.ComponentModel": "(,4.3.32767]",
-          "System.ComponentModel.Annotations": "(,4.3.32767]",
-          "System.ComponentModel.EventBasedAsync": "(,4.3.32767]",
-          "System.ComponentModel.Primitives": "(,4.3.32767]",
-          "System.ComponentModel.TypeConverter": "(,4.3.32767]",
-          "System.Console": "(,4.3.32767]",
-          "System.Data.Common": "(,4.3.32767]",
-          "System.Data.DataSetExtensions": "(,4.4.32767]",
-          "System.Diagnostics.Contracts": "(,4.3.32767]",
-          "System.Diagnostics.Debug": "(,4.3.32767]",
-          "System.Diagnostics.DiagnosticSource": "(,10.0.32767]",
-          "System.Diagnostics.FileVersionInfo": "(,4.3.32767]",
-          "System.Diagnostics.Process": "(,4.3.32767]",
-          "System.Diagnostics.StackTrace": "(,4.3.32767]",
-          "System.Diagnostics.TextWriterTraceListener": "(,4.3.32767]",
-          "System.Diagnostics.Tools": "(,4.3.32767]",
-          "System.Diagnostics.TraceSource": "(,4.3.32767]",
-          "System.Diagnostics.Tracing": "(,4.3.32767]",
-          "System.Drawing.Primitives": "(,4.3.32767]",
-          "System.Dynamic.Runtime": "(,4.3.32767]",
-          "System.Formats.Asn1": "(,10.0.32767]",
-          "System.Formats.Tar": "(,10.0.32767]",
-          "System.Globalization": "(,4.3.32767]",
-          "System.Globalization.Calendars": "(,4.3.32767]",
-          "System.Globalization.Extensions": "(,4.3.32767]",
-          "System.IO": "(,4.3.32767]",
-          "System.IO.Compression": "(,4.3.32767]",
-          "System.IO.Compression.ZipFile": "(,4.3.32767]",
-          "System.IO.FileSystem": "(,4.3.32767]",
-          "System.IO.FileSystem.AccessControl": "(,4.4.32767]",
-          "System.IO.FileSystem.DriveInfo": "(,4.3.32767]",
-          "System.IO.FileSystem.Primitives": "(,4.3.32767]",
-          "System.IO.FileSystem.Watcher": "(,4.3.32767]",
-          "System.IO.IsolatedStorage": "(,4.3.32767]",
-          "System.IO.MemoryMappedFiles": "(,4.3.32767]",
-          "System.IO.Pipelines": "(,10.0.32767]",
-          "System.IO.Pipes": "(,4.3.32767]",
-          "System.IO.Pipes.AccessControl": "(,5.0.32767]",
-          "System.IO.UnmanagedMemoryStream": "(,4.3.32767]",
-          "System.Linq": "(,4.3.32767]",
-          "System.Linq.AsyncEnumerable": "(,10.0.32767]",
-          "System.Linq.Expressions": "(,4.3.32767]",
-          "System.Linq.Parallel": "(,4.3.32767]",
-          "System.Linq.Queryable": "(,4.3.32767]",
-          "System.Memory": "(,5.0.32767]",
-          "System.Net.Http": "(,4.3.32767]",
-          "System.Net.Http.Json": "(,10.0.32767]",
-          "System.Net.NameResolution": "(,4.3.32767]",
-          "System.Net.NetworkInformation": "(,4.3.32767]",
-          "System.Net.Ping": "(,4.3.32767]",
-          "System.Net.Primitives": "(,4.3.32767]",
-          "System.Net.Requests": "(,4.3.32767]",
-          "System.Net.Security": "(,4.3.32767]",
-          "System.Net.ServerSentEvents": "(,10.0.32767]",
-          "System.Net.Sockets": "(,4.3.32767]",
-          "System.Net.WebHeaderCollection": "(,4.3.32767]",
-          "System.Net.WebSockets": "(,4.3.32767]",
-          "System.Net.WebSockets.Client": "(,4.3.32767]",
-          "System.Numerics.Vectors": "(,5.0.32767]",
-          "System.ObjectModel": "(,4.3.32767]",
-          "System.Private.DataContractSerialization": "(,4.3.32767]",
-          "System.Private.Uri": "(,4.3.32767]",
-          "System.Reflection": "(,4.3.32767]",
-          "System.Reflection.DispatchProxy": "(,6.0.32767]",
-          "System.Reflection.Emit": "(,4.7.32767]",
-          "System.Reflection.Emit.ILGeneration": "(,4.7.32767]",
-          "System.Reflection.Emit.Lightweight": "(,4.7.32767]",
-          "System.Reflection.Extensions": "(,4.3.32767]",
-          "System.Reflection.Metadata": "(,10.0.32767]",
-          "System.Reflection.Primitives": "(,4.3.32767]",
-          "System.Reflection.TypeExtensions": "(,4.3.32767]",
-          "System.Resources.Reader": "(,4.3.32767]",
-          "System.Resources.ResourceManager": "(,4.3.32767]",
-          "System.Resources.Writer": "(,4.3.32767]",
-          "System.Runtime": "(,4.3.32767]",
-          "System.Runtime.CompilerServices.Unsafe": "(,7.0.32767]",
-          "System.Runtime.CompilerServices.VisualC": "(,4.3.32767]",
-          "System.Runtime.Extensions": "(,4.3.32767]",
-          "System.Runtime.Handles": "(,4.3.32767]",
-          "System.Runtime.InteropServices": "(,4.3.32767]",
-          "System.Runtime.InteropServices.RuntimeInformation": "(,4.3.32767]",
-          "System.Runtime.Loader": "(,4.3.32767]",
-          "System.Runtime.Numerics": "(,4.3.32767]",
-          "System.Runtime.Serialization.Formatters": "(,4.3.32767]",
-          "System.Runtime.Serialization.Json": "(,4.3.32767]",
-          "System.Runtime.Serialization.Primitives": "(,4.3.32767]",
-          "System.Runtime.Serialization.Xml": "(,4.3.32767]",
-          "System.Security.AccessControl": "(,6.0.32767]",
-          "System.Security.Claims": "(,4.3.32767]",
-          "System.Security.Cryptography.Algorithms": "(,4.3.32767]",
-          "System.Security.Cryptography.Cng": "(,5.0.32767]",
-          "System.Security.Cryptography.Csp": "(,4.3.32767]",
-          "System.Security.Cryptography.Encoding": "(,4.3.32767]",
-          "System.Security.Cryptography.OpenSsl": "(,5.0.32767]",
-          "System.Security.Cryptography.Primitives": "(,4.3.32767]",
-          "System.Security.Cryptography.X509Certificates": "(,4.3.32767]",
-          "System.Security.Principal": "(,4.3.32767]",
-          "System.Security.Principal.Windows": "(,5.0.32767]",
-          "System.Security.SecureString": "(,4.3.32767]",
-          "System.Text.Encoding": "(,4.3.32767]",
-          "System.Text.Encoding.CodePages": "(,10.0.32767]",
-          "System.Text.Encoding.Extensions": "(,4.3.32767]",
-          "System.Text.Encodings.Web": "(,10.0.32767]",
-          "System.Text.Json": "(,10.0.32767]",
-          "System.Text.RegularExpressions": "(,4.3.32767]",
-          "System.Threading": "(,4.3.32767]",
-          "System.Threading.AccessControl": "(,10.0.32767]",
-          "System.Threading.Channels": "(,10.0.32767]",
-          "System.Threading.Overlapped": "(,4.3.32767]",
-          "System.Threading.Tasks": "(,4.3.32767]",
-          "System.Threading.Tasks.Dataflow": "(,10.0.32767]",
-          "System.Threading.Tasks.Extensions": "(,5.0.32767]",
-          "System.Threading.Tasks.Parallel": "(,4.3.32767]",
-          "System.Threading.Thread": "(,4.3.32767]",
-          "System.Threading.ThreadPool": "(,4.3.32767]",
-          "System.Threading.Timer": "(,4.3.32767]",
-          "System.ValueTuple": "(,4.5.32767]",
-          "System.Xml.ReaderWriter": "(,4.3.32767]",
-          "System.Xml.XDocument": "(,4.3.32767]",
-          "System.Xml.XmlDocument": "(,4.3.32767]",
-          "System.Xml.XmlSerializer": "(,4.3.32767]",
-          "System.Xml.XPath": "(,4.3.32767]",
-          "System.Xml.XPath.XDocument": "(,5.0.32767]"
-        }
-      }
-    }
-  }
-}

PhysicsEngine/obj/project.nuget.cache

@@ -1,10 +0,0 @@
-{
-  "version": 2,
-  "dgSpecHash": "OBnd1zSM6H8=",
-  "success": true,
-  "projectFilePath": "C:\\Users\\maxwes08\\source\\repos\\Physics-Engine\\PhysicsEngine\\PhysicsEngine.csproj",
-  "expectedPackageFiles": [
-    "C:\\Users\\maxwes08\\.nuget\\packages\\raylib-cs\\8.0.0\\raylib-cs.8.0.0.nupkg.sha512"
-  ],
-  "logs": []
-}