refactor: Renamed BehaviourCacher to BehaviourCollector

Engine.Physics2D/PhysicsEngine2DCollector.cs

@@ -0,0 +1,150 @@
+using System;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Abstract;
+using Syntriax.Engine.Physics2D.Abstract;
+
+namespace Syntriax.Engine.Physics2D;
+
+public class PhysicsEngine2DCollector : IPhysicsEngine2D, IAssignableGameManager
+{
+    public Action<IAssignable>? OnUnassigned { get; set; } = null;
+    public Action<IAssignableGameManager>? OnGameManagerAssigned { get; set; } = null;
+
+
+    private int _iterationPerStep = 1;
+
+    protected readonly ICollisionDetector2D collisionDetector = null!;
+    protected readonly ICollisionResolver2D collisionResolver = null!;
+
+    protected BehaviourCollector<IRigidBody2D> rigidBodyCollector = new();
+    protected BehaviourCollector<ICollider2D> colliderCollector = new();
+
+
+    public int IterationPerStep { get => _iterationPerStep; set => _iterationPerStep = value < 1 ? 1 : value; }
+    public IGameManager GameManager { get; private set; } = null!;
+
+    public void Step(float deltaTime)
+    {
+        float intervalDeltaTime = deltaTime / IterationPerStep;
+
+        for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
+        {
+            // Can Parallel
+            foreach (var rigidBody in rigidBodyCollector)
+                StepRigidBody(rigidBody, intervalDeltaTime);
+
+            // Can Parallel
+            foreach (var collider in colliderCollector)
+                collider.Recalculate();
+
+            // Can Parallel
+            for (int x = 0; x < colliderCollector.Behaviours.Count; x++)
+            {
+                ICollider2D? colliderX = colliderCollector.Behaviours[x];
+                if (!colliderX.IsActive)
+                    return;
+
+                for (int y = x + 1; y < colliderCollector.Behaviours.Count; y++)
+                {
+                    ICollider2D? colliderY = colliderCollector.Behaviours[y];
+
+                    if (!colliderY.IsActive)
+                        return;
+
+                    if (colliderX.RigidBody2D == colliderY.RigidBody2D)
+                        continue;
+
+                    bool bothCollidersAreTriggers = colliderX.IsTrigger && colliderX.IsTrigger == colliderY.IsTrigger;
+                    if (bothCollidersAreTriggers)
+                        continue;
+
+                    bool bothCollidersAreStatic = colliderX.RigidBody2D?.IsStatic ?? true && colliderX.RigidBody2D?.IsStatic == colliderY.RigidBody2D?.IsStatic;
+                    if (bothCollidersAreStatic)
+                        continue;
+
+                    if (collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
+                    {
+                        if (colliderX.IsTrigger)
+                        {
+                            colliderX.OnTriggered?.Invoke(colliderX, colliderY);
+                            continue;
+                        }
+                        else if (colliderY.IsTrigger)
+                        {
+                            colliderY.OnTriggered?.Invoke(colliderY, colliderY);
+                            continue;
+                        }
+
+                        colliderX.OnCollisionDetected?.Invoke(colliderX, information);
+                        colliderY.OnCollisionDetected?.Invoke(colliderY, information);
+
+                        collisionResolver?.Resolve(information);
+                    }
+                }
+            }
+        }
+    }
+
+    private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)
+    {
+        if (rigidBody.IsStatic || !rigidBody.IsActive)
+            return;
+
+        rigidBody.Transform.Position += rigidBody.Velocity * intervalDeltaTime;
+        rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
+    }
+
+    public bool Assign(IGameManager gameManager)
+    {
+        if (GameManager is not null)
+            return false;
+
+        colliderCollector.Assign(gameManager);
+        rigidBodyCollector.Assign(gameManager);
+
+        GameManager = gameManager;
+        OnGameManagerAssigned?.Invoke(this);
+
+        return true;
+    }
+
+    public bool Unassign()
+    {
+        if (GameManager is null)
+            return false;
+
+        colliderCollector.Unassign();
+        rigidBodyCollector.Unassign();
+
+        GameManager = null!;
+        OnUnassigned?.Invoke(this);
+        return true;
+    }
+
+    public PhysicsEngine2DCollector()
+    {
+        collisionDetector = new CollisionDetector2D();
+        collisionResolver = new CollisionResolver2D();
+    }
+
+    public PhysicsEngine2DCollector(IGameManager gameManager)
+    {
+        Assign(gameManager);
+        collisionDetector = new CollisionDetector2D();
+        collisionResolver = new CollisionResolver2D();
+    }
+
+    public PhysicsEngine2DCollector(IGameManager gameManager, ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
+    {
+        Assign(gameManager);
+        this.collisionDetector = collisionDetector;
+        this.collisionResolver = collisionResolver;
+    }
+
+    public PhysicsEngine2DCollector(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
+    {
+        this.collisionDetector = collisionDetector;
+        this.collisionResolver = collisionResolver;
+    }
+}