feat: IPhysicsEngine2D.StepIndividual method for individual object simulation

Engine.Physics2D/Abstract/IPhysicsEngine2D.cs

@@ -26,6 +26,13 @@ public interface IPhysicsEngine2D
     /// <param name="deltaTime">The time step.</param>
     void Step(float deltaTime);
 
+    /// <summary>
+    /// Advances the physics simulation by the specified time on a single <see cref="IRigidBody2D"/>.
+    /// </summary>
+    /// <param name="rigidBody">The <see cref="IRigidBody2D"/> to be progressed individually.</param>
+    /// <param name="deltaTime">The time step.</param>
+    void StepIndividual(IRigidBody2D rigidBody, float deltaTime);
+
     delegate void PhysicsIterationEventHandler(IPhysicsEngine2D sender, float iterationDeltaTime);
     delegate void PhysicsStepEventHandler(IPhysicsEngine2D sender, float stepDeltaTime);
 }

Engine.Physics2D/PhysicsEngine2D.cs

@@ -58,28 +58,93 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
                     if (!colliderY.IsActive)
                         continue;
 
-                    if (colliderX.RigidBody2D == colliderY.RigidBody2D)
+                    ResolveColliders(colliderX, colliderY);
+                }
+            }
+
+            OnPhysicsIteration?.InvokeSafe(this, intervalDeltaTime);
+        }
+
+        foreach (IPostPhysicsUpdate physicsPostUpdate in physicsPostUpdateCollector)
+            physicsPostUpdate.PostPhysicsUpdate(deltaTime);
+
+        OnPhysicsStep?.InvokeSafe(this, deltaTime);
+    }
+
+    public void StepIndividual(IRigidBody2D rigidBody, float deltaTime)
+    {
+        float intervalDeltaTime = deltaTime / IterationPerStep;
+
+        System.Collections.Generic.List<ICollider2D> childColliders = [];
+        System.Collections.Generic.List<IPrePhysicsUpdate> physicsPreUpdates = [];
+        System.Collections.Generic.List<IPhysicsUpdate> physicsUpdates = [];
+        System.Collections.Generic.List<IPostPhysicsUpdate> physicsPostUpdates = [];
+
+        rigidBody.BehaviourController.GetBehavioursInChildren(childColliders);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsPreUpdates);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsUpdates);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsPostUpdates);
+
+        foreach (IPrePhysicsUpdate physicsPreUpdate in physicsPreUpdates)
+            physicsPreUpdate.PrePhysicsUpdate(deltaTime);
+
+        foreach (IPhysicsUpdate physicsUpdate in physicsUpdates)
+            physicsUpdate.PhysicsUpdate(deltaTime);
+
+        for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
+        {
+            StepRigidBody(rigidBody, intervalDeltaTime);
+
+            foreach (ICollider2D collider in childColliders)
+                collider.Recalculate();
+
+            for (int x = 0; x < childColliders.Count; x++)
+            {
+                ICollider2D? colliderX = childColliders[x];
+                if (!colliderX.IsActive)
                     continue;
 
+                for (int y = 0; y < colliderCollector.Behaviours.Count; y++)
+                {
+                    ICollider2D? colliderY = colliderCollector.Behaviours[y];
+
+                    if (!colliderY.IsActive)
+                        continue;
+
+                    ResolveColliders(colliderX, colliderY);
+                }
+            }
+        }
+
+        foreach (IPostPhysicsUpdate physicsPostUpdate in physicsPostUpdates)
+            physicsPostUpdate.PostPhysicsUpdate(deltaTime);
+    }
+
+    private void ResolveColliders(ICollider2D colliderX, ICollider2D colliderY)
+    {
+        if (colliderX.RigidBody2D == colliderY.RigidBody2D)
+            return;
+
         bool bothCollidersAreTriggers = colliderX.IsTrigger && colliderX.IsTrigger == colliderY.IsTrigger;
         if (bothCollidersAreTriggers)
-                        continue;
+            return;
 
         bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
         if (bothCollidersAreStatic)
-                        continue;
+            return;
+
+        if (!collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
+            return;
 
-                    if (collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
-                    {
         if (colliderX.IsTrigger)
         {
             colliderX.Trigger(colliderY);
-                            continue;
+            return;
         }
         else if (colliderY.IsTrigger)
         {
             colliderY.Trigger(colliderX);
-                            continue;
+            return;
         }
 
         if (information.Detector == colliderX)
@@ -95,17 +160,6 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
 
         collisionResolver?.Resolve(information);
     }
-                }
-            }
-
-            OnPhysicsIteration?.InvokeSafe(this, intervalDeltaTime);
-        }
-
-        foreach (IPostPhysicsUpdate physicsPostUpdate in physicsPostUpdateCollector)
-            physicsPostUpdate.PostPhysicsUpdate(deltaTime);
-
-        OnPhysicsStep?.InvokeSafe(this, deltaTime);
-    }
 
     private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)
     {

Engine.Physics2D/PhysicsEngine2DStandalone.cs

@@ -60,34 +60,93 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
                     continue;
 
                 for (int y = x + 1; y < colliders.Count; y++)
+                {
+                    ICollider2D? colliderY = colliders[y];
+                    if (!colliderY.IsActive)
+                        return;
+
+                    ResolveColliders(colliderX, colliderY);
+                }
+            }
+            OnPhysicsIteration?.InvokeSafe(this, intervalDeltaTime);
+        }
+        OnPhysicsStep?.InvokeSafe(this, deltaTime);
+    }
+
+    public void StepIndividual(IRigidBody2D rigidBody, float deltaTime)
+    {
+        float intervalDeltaTime = deltaTime / IterationPerStep;
+
+        List<ICollider2D> childColliders = [];
+        List<IPrePhysicsUpdate> physicsPreUpdates = [];
+        List<IPhysicsUpdate> physicsUpdates = [];
+        List<IPostPhysicsUpdate> physicsPostUpdates = [];
+
+        rigidBody.BehaviourController.GetBehavioursInChildren(childColliders);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsPreUpdates);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsUpdates);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsPostUpdates);
+
+        foreach (IPrePhysicsUpdate physicsPreUpdate in physicsPreUpdates)
+            physicsPreUpdate.PrePhysicsUpdate(deltaTime);
+
+        foreach (IPhysicsUpdate physicsUpdate in physicsUpdates)
+            physicsUpdate.PhysicsUpdate(deltaTime);
+
+        for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
+        {
+            StepRigidBody(rigidBody, intervalDeltaTime);
+
+            foreach (ICollider2D collider in childColliders)
+                collider.Recalculate();
+
+            for (int x = 0; x < childColliders.Count; x++)
+            {
+                ICollider2D? colliderX = childColliders[x];
+                if (!colliderX.IsActive)
+                    continue;
+
+                for (int y = 0; y < colliders.Count; y++)
                 {
                     ICollider2D? colliderY = colliders[y];
 
                     if (!colliderY.IsActive)
                         continue;
 
+                    ResolveColliders(colliderX, colliderY);
+                }
+            }
+        }
+
+        foreach (IPostPhysicsUpdate physicsPostUpdate in physicsPostUpdates)
+            physicsPostUpdate.PostPhysicsUpdate(deltaTime);
+    }
+
+    private void ResolveColliders(ICollider2D colliderX, ICollider2D colliderY)
+    {
         if (colliderX.RigidBody2D == colliderY.RigidBody2D)
-                        continue;
+            return;
 
         bool bothCollidersAreTriggers = colliderX.IsTrigger && colliderX.IsTrigger == colliderY.IsTrigger;
         if (bothCollidersAreTriggers)
-                        continue;
+            return;
 
         bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
         if (bothCollidersAreStatic)
-                        continue;
+            return;
+
+        if (!collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
+            return;
 
-                    if (collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
-                    {
         if (colliderX.IsTrigger)
         {
             colliderX.Trigger(colliderY);
-                            continue;
+            return;
         }
         else if (colliderY.IsTrigger)
         {
             colliderY.Trigger(colliderX);
-                            continue;
+            return;
         }
 
         if (information.Detector == colliderX)
@@ -103,12 +162,6 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
 
         collisionResolver?.Resolve(information);
     }
-                }
-            }
-            OnPhysicsIteration?.InvokeSafe(this, intervalDeltaTime);
-        }
-        OnPhysicsStep?.InvokeSafe(this, deltaTime);
-    }
 
     private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)
     {