chore: simplified type names on physics engine 2D

All delegate events are refactored to use the Event<TSender> and Event<TSender, TArgument> for performance issues regarding delegate events creating garbage, also this gives us better control on event invocation since C# Delegates did also create unnecessary garbage during Delegate.DynamicInvoke

Engine.Core/ActiveBehaviourCollector.cs

@@ -10,11 +10,11 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
     public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
     public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAdded = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemoved = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
-    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler cachedOnBehaviourStateChanged = null!;
+    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnBehaviourStateChanged = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler cachedOnUniverseObjectRegistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler cachedOnUniverseObjectUnregistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
     private readonly List<T> monitoringBehaviours = new(32);
     protected readonly List<T> activeBehaviours = new(32);
@@ -22,46 +22,47 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
 
     public IUniverse Universe { get; private set; } = null!;
 
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments arguments)
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectRegistered;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments arguments)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectUnregistered;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourRemoved(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
     protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
         monitoringBehaviours.Add(tBehaviour);
         monitoringActiveToBehaviour.Add(tBehaviour, tBehaviour);
-        tBehaviour.OnActiveChanged.AddListener(cachedOnBehaviourStateChanged);
+        tBehaviour.OnActiveChanged.AddListener(delegateOnBehaviourStateChanged);
         OnBehaviourStateChanged(tBehaviour, new(!tBehaviour.IsActive));
     }
 
-    private void OnBehaviourStateChanged(IActive sender, IActive.ActiveChangedArguments arguments)
+    protected virtual void AddBehaviour(T behaviour) => activeBehaviours.Add(behaviour);
+    private void OnBehaviourStateChanged(IActive sender, IActive.ActiveChangedArguments args)
     {
         T behaviour = monitoringActiveToBehaviour[sender];
         if (sender.IsActive)
         {
-            activeBehaviours.Add(behaviour);
+            AddBehaviour(behaviour);
             OnBehaviourAdd(behaviour);
             OnCollected?.Invoke(this, new(behaviour));
         }
@@ -73,15 +74,15 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
         if (!monitoringBehaviours.Remove(tBehaviour) || !monitoringActiveToBehaviour.Remove(tBehaviour))
             return;
 
-        tBehaviour.OnActiveChanged.RemoveListener(cachedOnBehaviourStateChanged);
+        tBehaviour.OnActiveChanged.RemoveListener(delegateOnBehaviourStateChanged);
         if (activeBehaviours.Remove(tBehaviour))
         {
             OnBehaviourRemove(tBehaviour);
@@ -97,8 +98,8 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
             OnUniverseObjectRegistered(universe, new(universeObject));
 
-        universe.OnUniverseObjectRegistered.AddListener(cachedOnUniverseObjectRegistered);
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered.AddListener(cachedOnUniverseObjectUnregistered);
+        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnUniverseAssigned?.Invoke(this);
@@ -114,8 +115,8 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
             OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        Universe.OnUniverseObjectRegistered.RemoveListener(cachedOnUniverseObjectRegistered);
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(cachedOnUniverseObjectUnregistered);
+        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);
@@ -127,10 +128,21 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
 
     public ActiveBehaviourCollector()
     {
-        cachedOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
-        cachedOnBehaviourStateChanged = OnBehaviourStateChanged;
+        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
-        cachedOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        cachedOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
+
+    public ActiveBehaviourCollector(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
     }
 }

Engine.Core/ActiveBehaviourCollectorSorted.cs

@@ -1,11 +1,14 @@
 using System;
+using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> where T : class, IBehaviour
 {
-    private Comparison<T>? _sortBy = null;
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
-    public Comparison<T>? SortBy
+
+    private IComparer<T>? _sortBy = null;
+    public IComparer<T>? SortBy
     {
         get => _sortBy;
         set
@@ -17,9 +20,48 @@ public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> whe
         }
     }
 
+    protected override void AddBehaviour(T behaviour)
+    {
+        if (SortBy is null)
+        {
+            activeBehaviours.Add(behaviour);
+            return;
+        }
+
+        int insertionIndex = activeBehaviours.BinarySearch(behaviour, SortBy);
+
+        if (insertionIndex < 0)
+            insertionIndex = ~insertionIndex;
+
+        activeBehaviours.Insert(insertionIndex, behaviour);
+    }
+
     protected override void OnBehaviourAdd(IBehaviour behaviour)
     {
-        if (SortBy is not null)
+        behaviour.OnPriorityChanged.AddListener(delegateOnPriorityChanged);
-            activeBehaviours.Sort(SortBy);
+    }
+
+    protected override void OnBehaviourRemove(IBehaviour behaviour)
+    {
+        behaviour.OnPriorityChanged.RemoveListener(delegateOnPriorityChanged);
+    }
+
+    private void OnPriorityChanged(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
+    {
+        T behaviour = (T)sender;
+        activeBehaviours.Remove(behaviour);
+        AddBehaviour(behaviour);
+    }
+
+    public ActiveBehaviourCollectorSorted()
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+    }
+
+    public ActiveBehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+
+        SortBy = Comparer<T>.Create(sortBy);
     }
 }

Engine.Core/Behaviour.cs

@@ -7,8 +7,8 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
     protected IUniverse Universe => BehaviourController.UniverseObject.Universe;
     protected IUniverseObject UniverseObject => BehaviourController.UniverseObject;
 
-    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler cachedEnteredUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler delegateEnteredUniverse = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler cachedExitedUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateExitedUniverse = null!;
 
     public Behaviour()
     {
@@ -16,8 +16,8 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
         OnFinalized.AddListener(OnFinalize);
         OnUnassigned.AddListener(OnUnassign);
 
-        cachedEnteredUniverse = EnteredUniverse;
+        delegateEnteredUniverse = EnteredUniverse;
-        cachedExitedUniverse = ExitedUniverse;
+        delegateExitedUniverse = ExitedUniverse;
     }
 
     protected virtual void OnUnassign() { }
@@ -26,8 +26,8 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
     protected virtual void OnInitialize() { }
     protected virtual void OnInitialize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(cachedEnteredUniverse);
+        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(delegateEnteredUniverse);
-        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(cachedExitedUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(delegateExitedUniverse);
 
         OnInitialize();
 
@@ -38,8 +38,8 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
     protected virtual void OnFinalize() { }
     protected virtual void OnFinalize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(cachedEnteredUniverse);
+        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(delegateEnteredUniverse);
-        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(cachedExitedUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(delegateExitedUniverse);
 
         OnFinalize();
 
@@ -139,8 +139,8 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
     }
 
     protected virtual void OnEnteredUniverse(IUniverse universe) { }
-    protected virtual void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments arguments) => OnEnteredUniverse(arguments.Universe);
+    protected virtual void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => OnEnteredUniverse(args.Universe);
 
     protected virtual void OnExitedUniverse(IUniverse universe) { }
-    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments) => OnExitedUniverse(arguments.Universe);
+    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args) => OnExitedUniverse(args.Universe);
 }

Engine.Core/Behaviour2D.cs

@@ -17,6 +17,6 @@ public abstract class Behaviour2D : Behaviour, IBehaviour2D
     }
 
     protected sealed override void OnUnassign(IAssignable assignable) => base.OnUnassign(assignable);
-    protected sealed override void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments arguments) => base.EnteredUniverse(sender, arguments);
+    protected sealed override void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => base.EnteredUniverse(sender, args);
-    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments) => base.ExitedUniverse(sender, arguments);
+    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args) => base.ExitedUniverse(sender, args);
 }

Engine.Core/BehaviourBase.cs

@@ -7,9 +7,9 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
     public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
 
-    private readonly Event<IHasUniverseObject>.EventHandler cachedOnUniverseObjectAssigned = null!;
+    private readonly Event<IHasUniverseObject>.EventHandler delegateOnUniverseObjectAssigned = null!;
-    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler cachedOnUniverseObjectActiveChanged = null!;
+    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnUniverseObjectActiveChanged = null!;
-    private readonly Event<IStateEnable, IStateEnable.EnabledChangedArguments>.EventHandler cachedOnStateEnabledChanged = null!;
+    private readonly Event<IStateEnable, IStateEnable.EnabledChangedArguments>.EventHandler delegateOnStateEnabledChanged = null!;
 
     private IBehaviourController _behaviourController = null!;
     public IBehaviourController BehaviourController => _behaviourController;
@@ -40,7 +40,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
         _behaviourController = behaviourController;
         OnAssign(behaviourController);
-        behaviourController.OnUniverseObjectAssigned.AddListener(cachedOnUniverseObjectAssigned);
+        behaviourController.OnUniverseObjectAssigned.AddListener(delegateOnUniverseObjectAssigned);
         if (behaviourController.UniverseObject is not null)
             OnUniverseObjectAssigned(behaviourController);
         OnBehaviourControllerAssigned?.Invoke(this);
@@ -49,7 +49,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
     private void OnUniverseObjectAssigned(IHasUniverseObject sender)
     {
-        sender.UniverseObject.OnActiveChanged.AddListener(cachedOnUniverseObjectActiveChanged);
+        sender.UniverseObject.OnActiveChanged.AddListener(delegateOnUniverseObjectActiveChanged);
         UpdateActive();
     }
 
@@ -57,14 +57,14 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     {
         base.OnAssign(stateEnable);
 
-        stateEnable.OnEnabledChanged.AddListener(cachedOnStateEnabledChanged);
+        stateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
     }
 
     protected override void UnassignInternal()
     {
-        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(cachedOnUniverseObjectActiveChanged);
+        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(delegateOnUniverseObjectActiveChanged);
-        StateEnable.OnEnabledChanged.RemoveListener(cachedOnStateEnabledChanged);
+        StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
-        BehaviourController.OnUniverseObjectAssigned.RemoveListener(cachedOnUniverseObjectAssigned);
+        BehaviourController.OnUniverseObjectAssigned.RemoveListener(delegateOnUniverseObjectAssigned);
         base.UnassignInternal();
         _behaviourController = null!;
     }
@@ -75,8 +75,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         Debug.Assert.AssertStateEnableAssigned(this);
     }
 
-    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments arguments) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
-    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments arguments) => UpdateActive();
+    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
 
     private void UpdateActive()
     {
@@ -89,8 +89,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
     protected BehaviourBase()
     {
-        cachedOnUniverseObjectAssigned = OnUniverseObjectAssigned;
+        delegateOnUniverseObjectAssigned = OnUniverseObjectAssigned;
-        cachedOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
+        delegateOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
-        cachedOnStateEnabledChanged = OnStateEnabledChanged;
+        delegateOnStateEnabledChanged = OnStateEnabledChanged;
     }
 }

Engine.Core/BehaviourCollector.cs

@@ -10,58 +10,59 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
     public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
     public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAdded = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemoved = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler cachedOnUniverseObjectRegistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler cachedOnUniverseObjectUnregistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
     protected readonly List<T> behaviours = new(32);
 
     public IUniverse Universe { get; private set; } = null!;
 
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments arguments)
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectRegistered;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments arguments)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectUnregistered;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourRemoved(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
+    protected virtual void AddBehaviour(T behaviour) => behaviours.Add(behaviour);
     protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
-        behaviours.Add(tBehaviour);
+        AddBehaviour(tBehaviour);
-        OnBehaviourAdd(arguments.BehaviourAdded);
+        OnBehaviourAdd(args.BehaviourAdded);
         OnCollected?.Invoke(this, new(tBehaviour));
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
         if (!behaviours.Remove(tBehaviour))
             return;
 
-        OnBehaviourRemove(arguments.BehaviourRemoved);
+        OnBehaviourRemove(args.BehaviourRemoved);
         OnRemoved?.Invoke(this, new(tBehaviour));
     }
 
@@ -74,8 +75,8 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
             OnUniverseObjectRegistered(universe, new(universeObject));
 
-        universe.OnUniverseObjectRegistered.AddListener(cachedOnUniverseObjectRegistered);
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered.AddListener(cachedOnUniverseObjectUnregistered);
+        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnAssign(universe);
@@ -92,8 +93,8 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
             OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        Universe.OnUniverseObjectRegistered.RemoveListener(cachedOnUniverseObjectRegistered);
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(cachedOnUniverseObjectUnregistered);
+        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);
@@ -105,9 +106,19 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
 
     public BehaviourCollector()
     {
-        cachedOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
-        cachedOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        cachedOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
+
+    public BehaviourCollector(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
     }
 }

Engine.Core/BehaviourCollectorSorted.cs

@@ -1,11 +1,14 @@
 using System;
+using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
 {
-    private Comparison<T>? _sortBy = null;
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
-    public Comparison<T>? SortBy
+
+    private IComparer<T>? _sortBy = null;
+    public IComparer<T>? SortBy
     {
         get => _sortBy;
         set
@@ -17,9 +20,48 @@ public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
         }
     }
 
+    protected override void AddBehaviour(T behaviour)
+    {
+        if (SortBy is null)
+        {
+            behaviours.Add(behaviour);
+            return;
+        }
+
+        int insertionIndex = behaviours.BinarySearch(behaviour, SortBy);
+
+        if (insertionIndex < 0)
+            insertionIndex = ~insertionIndex;
+
+        behaviours.Insert(insertionIndex, behaviour);
+    }
+
     protected override void OnBehaviourAdd(IBehaviour behaviour)
     {
-        if (SortBy is not null)
+        behaviour.OnPriorityChanged.AddListener(delegateOnPriorityChanged);
-            behaviours.Sort(SortBy);
+    }
+
+    protected override void OnBehaviourRemove(IBehaviour behaviour)
+    {
+        behaviour.OnPriorityChanged.RemoveListener(delegateOnPriorityChanged);
+    }
+
+    private void OnPriorityChanged(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
+    {
+        T behaviour = (T)sender;
+        behaviours.Remove(behaviour);
+        AddBehaviour(behaviour);
+    }
+
+    public BehaviourCollectorSorted()
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+    }
+
+    public BehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+
+        SortBy = Comparer<T>.Create(sortBy);
     }
 }

Engine.Core/BehaviourController.cs

@@ -27,6 +27,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
 
         if (IsInitialized)
             behaviour.Initialize();
+
         behaviour.OnPriorityChanged.AddListener(OnPriorityChange);
         OnBehaviourAdded?.Invoke(this, new(behaviour));
         return behaviour;
@@ -145,7 +146,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
             behaviours.Add(behaviour);
     }
 
-    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments arguments)
+    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
     {
         behaviours.Remove(sender);
         InsertBehaviourByPriority(sender);

Engine.Core/CoroutineManager.cs

@@ -28,7 +28,7 @@ public class CoroutineManager : UniverseObject
         universe.OnUpdate.RemoveListener(OnUpdate);
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = enumerators.Count - 1; i >= 0; i--)
         {

Engine.Core/Helpers/Event.cs

@@ -3,6 +3,27 @@ using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
+public class Event
+{
+    private readonly List<EventHandler> listeners = new(8);
+
+    public void AddListener(EventHandler listener) => listeners.Add(listener);
+    public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
+    public void Clear() => listeners.Clear();
+    public void Invoke()
+    {
+        for (int i = 0; i < listeners.Count; i++)
+            try { listeners[i].Invoke(); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}()";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+    }
+
+    public delegate void EventHandler();
+}
+
 public class Event<TSender>
 {
     private readonly List<EventHandler> listeners = new(8);
@@ -31,16 +52,16 @@ public class Event<TSender, TArguments>
     public void AddListener(EventHandler listener) => listeners.Add(listener);
     public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
     public void Clear() => listeners.Clear();
-    public void Invoke(TSender sender, TArguments arguments)
+    public void Invoke(TSender sender, TArguments args)
     {
         for (int i = 0; i < listeners.Count; i++)
-            try { listeners[i].Invoke(sender, arguments); }
+            try { listeners[i].Invoke(sender, args); }
             catch (Exception exception)
             {
-                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({string.Join(", ", sender, arguments)})";
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({string.Join(", ", sender, args)})";
                 Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
             }
     }
 
-    public delegate void EventHandler(TSender sender, TArguments arguments);
+    public delegate void EventHandler(TSender sender, TArguments args);
 }

Engine.Core/Primitives/Shape2D.cs

@@ -256,8 +256,6 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
 
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => Vertices.GetEnumerator();
-
-    public readonly record struct ShapeUpdatedArguments(Shape2D shape2D);
 }
 
 /// <summary>

Engine.Core/Systems/DrawManager.cs

@@ -1,9 +1,10 @@
+using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class DrawManager : UniverseObject
 {
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
+    private static Comparer<IBehaviour> SortByPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
 
     private readonly ActiveBehaviourCollectorSorted<IPreDraw> preDrawEntities = new() { SortBy = SortByPriority() };
     private readonly ActiveBehaviourCollectorSorted<IDraw> drawEntities = new() { SortBy = SortByPriority() };

Engine.Core/Systems/UpdateManager.cs

@@ -1,11 +1,10 @@
-
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class UpdateManager : UniverseObject
 {
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
+    private static Comparer<IBehaviour> SortByPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
 
     private readonly ActiveBehaviourCollectorSorted<IFirstFrameUpdate> firstFrameUpdates = new() { SortBy = SortByPriority() };
     private readonly ActiveBehaviourCollectorSorted<IPreUpdate> preUpdateEntities = new() { SortBy = SortByPriority() };
@@ -38,7 +37,7 @@ public class UpdateManager : UniverseObject
         universe.OnPostUpdate.RemoveListener(OnPostUpdate);
     }
 
-    private void OnPreUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnPreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = toCallFirstFrameUpdates.Count - 1; i >= 0; i--)
         {
@@ -50,21 +49,21 @@ public class UpdateManager : UniverseObject
             preUpdateEntities[i].PreUpdate();
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = updateEntities.Count - 1; i >= 0; i--)
             updateEntities[i].Update();
     }
 
-    private void OnPostUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnPostUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = postUpdateEntities.Count - 1; i >= 0; i--)
             postUpdateEntities[i].PostUpdate();
     }
 
-    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments arguments)
+    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments args)
     {
-        toCallFirstFrameUpdates.Add(arguments.BehaviourCollected);
+        toCallFirstFrameUpdates.Add(args.BehaviourCollected);
     }
 
     public UpdateManager()

Engine.Core/Transform2D.cs

@@ -118,17 +118,17 @@ public class Transform2D : Behaviour, ITransform2D
         }
     }
 
-    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments arguments)
+    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments args)
     {
         if (parentTransform is null)
             return;
 
         UpdatePosition();
 
-        OnPositionChanged?.Invoke(this, arguments);
+        OnPositionChanged?.Invoke(this, args);
     }
 
-    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments arguments)
+    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments args)
     {
         if (parentTransform is null)
             return;
@@ -138,11 +138,11 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateScale();
         UpdatePosition();
 
-        OnScaleChanged?.Invoke(this, arguments);
+        OnScaleChanged?.Invoke(this, args);
         OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
-    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments arguments)
+    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments args)
     {
         if (parentTransform is null)
             return;
@@ -152,7 +152,7 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateRotation();
         UpdatePosition();
 
-        OnRotationChanged?.Invoke(this, arguments);
+        OnRotationChanged?.Invoke(this, args);
         OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
@@ -252,16 +252,16 @@ public class Transform2D : Behaviour, ITransform2D
         OnRotationChanged?.Invoke(this, new(Rotation));
     }
 
-    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
+    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not ITransform2D)
+        if (args.BehaviourAdded is not ITransform2D)
             return;
 
         UpdateReferences(UniverseObject.Parent);
     }
 
-    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments arguments)
+    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
     {
-        UpdateReferences(arguments.CurrentParent);
+        UpdateReferences(args.CurrentParent);
     }
 }

Engine.Core/Universe.cs

@@ -17,16 +17,16 @@ public class Universe : BaseEntity, IUniverse
     public Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; } = new();
     public Event<IUniverse, IUniverse.TimeScaleChangedArguments> OnTimeScaleChanged { get; } = new();
 
-    private readonly Event<IInitializable>.EventHandler cachedOnUniverseObjectFinalize = null!;
+    private readonly Event<IInitializable>.EventHandler delegateOnUniverseObjectFinalize = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler cachedOnUniverseObjectExitedUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateOnUniverseObjectExitedUniverse = null!;
 
     private readonly List<IUniverseObject> _universeObjects = new(Constants.UNIVERSE_OBJECTS_SIZE_INITIAL);
     private float _timeScale = 1f;
 
     public Universe()
     {
-        cachedOnUniverseObjectFinalize = OnUniverseObjectFinalize;
+        delegateOnUniverseObjectFinalize = OnUniverseObjectFinalize;
-        cachedOnUniverseObjectExitedUniverse = OnUniverseObjectExitedUniverse;
+        delegateOnUniverseObjectExitedUniverse = OnUniverseObjectExitedUniverse;
     }
 
     public IReadOnlyList<IUniverseObject> UniverseObjects => _universeObjects;
@@ -53,8 +53,8 @@ public class Universe : BaseEntity, IUniverse
         if (_universeObjects.Contains(universeObject))
             throw new Exception($"{nameof(IUniverseObject)} named {universeObject.Name} is already registered to the {nameof(Universe)}.");
 
-        universeObject.OnFinalized.AddListener(cachedOnUniverseObjectFinalize);
+        universeObject.OnFinalized.AddListener(delegateOnUniverseObjectFinalize);
-        universeObject.OnExitedUniverse.AddListener(cachedOnUniverseObjectExitedUniverse);
+        universeObject.OnExitedUniverse.AddListener(delegateOnUniverseObjectExitedUniverse);
 
         if (!universeObject.Initialize())
             throw new Exception($"{universeObject.Name} can't be initialized");
@@ -88,8 +88,8 @@ public class Universe : BaseEntity, IUniverse
         if (!_universeObjects.Contains(universeObject))
             throw new Exception($"{nameof(IUniverseObject)} named {universeObject.Name} is not registered to the {nameof(Universe)}.");
 
-        universeObject.OnFinalized.RemoveListener(cachedOnUniverseObjectFinalize);
+        universeObject.OnFinalized.RemoveListener(delegateOnUniverseObjectFinalize);
-        universeObject.OnExitedUniverse.RemoveListener(cachedOnUniverseObjectExitedUniverse);
+        universeObject.OnExitedUniverse.RemoveListener(delegateOnUniverseObjectExitedUniverse);
 
         for (int i = universeObject.Children.Count - 1; i >= 0; i--)
             Remove(universeObject.Children[i]);
@@ -145,7 +145,7 @@ public class Universe : BaseEntity, IUniverse
             Remove(universeObject);
     }
 
-    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments)
+    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args)
     {
         if (sender is IUniverseObject universeObject)
             Remove(universeObject);

Engine.Core/UniverseObject.cs

@@ -135,8 +135,8 @@ public class UniverseObject : BaseEntity, IUniverseObject
         stateEnable.OnEnabledChanged.AddListener(OnStateEnabledChanged);
     }
 
-    private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments arguments) => UpdateActive();
+    private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
-    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments arguments) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
 
     private void UpdateActive()
     {

Engine.Physics2D/Collider2DBehaviourBase.cs

@@ -8,24 +8,24 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
     public Event<ICollider2D, CollisionDetectionInformation> OnCollisionResolved { get; } = new();
     public Event<ICollider2D, ICollider2D> OnTriggered { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAddedToController = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAddedToController = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemovedFromController = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemovedFromController = null!;
-    private readonly Event<ITransform2D, ITransform2D.PositionChangedArguments>.EventHandler cachedSetNeedsRecalculationFromPosition = null!;
+    private readonly Event<ITransform2D, ITransform2D.PositionChangedArguments>.EventHandler delegateSetNeedsRecalculationFromPosition = null!;
-    private readonly Event<ITransform2D, ITransform2D.RotationChangedArguments>.EventHandler cachedSetNeedsRecalculationFromRotation = null!;
+    private readonly Event<ITransform2D, ITransform2D.RotationChangedArguments>.EventHandler delegateSetNeedsRecalculationFromRotation = null!;
-    private readonly Event<ITransform2D, ITransform2D.ScaleChangedArguments>.EventHandler cachedSetNeedsRecalculationFromScale = null!;
+    private readonly Event<ITransform2D, ITransform2D.ScaleChangedArguments>.EventHandler delegateSetNeedsRecalculationFromScale = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ParentChangedArguments>.EventHandler cachedUpdateRigidBody2D = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ParentChangedArguments>.EventHandler delegateUpdateRigidBody2D = null!;
 
     protected bool NeedsRecalculation { get; set; } = true;
     protected IRigidBody2D? _rigidBody2D = null;
 
     protected Collider2DBehaviourBase()
     {
-        cachedOnBehaviourAddedToController = OnBehaviourAddedToController;
+        delegateOnBehaviourAddedToController = OnBehaviourAddedToController;
-        cachedOnBehaviourRemovedFromController = OnBehaviourRemovedFromController;
+        delegateOnBehaviourRemovedFromController = OnBehaviourRemovedFromController;
-        cachedSetNeedsRecalculationFromPosition = SetNeedsRecalculationFromPosition;
+        delegateSetNeedsRecalculationFromPosition = SetNeedsRecalculationFromPosition;
-        cachedSetNeedsRecalculationFromRotation = SetNeedsRecalculationFromRotation;
+        delegateSetNeedsRecalculationFromRotation = SetNeedsRecalculationFromRotation;
-        cachedSetNeedsRecalculationFromScale = SetNeedsRecalculationFromScale;
+        delegateSetNeedsRecalculationFromScale = SetNeedsRecalculationFromScale;
-        cachedUpdateRigidBody2D = UpdateRigidBody2D;
+        delegateUpdateRigidBody2D = UpdateRigidBody2D;
     }
 
     public IRigidBody2D? RigidBody2D => _rigidBody2D;
@@ -46,44 +46,44 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
     {
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
 
-        BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAddedToController);
+        BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAddedToController);
-        BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemovedFromController);
+        BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemovedFromController);
 
-        Transform.OnPositionChanged.AddListener(cachedSetNeedsRecalculationFromPosition);
+        Transform.OnPositionChanged.AddListener(delegateSetNeedsRecalculationFromPosition);
-        Transform.OnRotationChanged.AddListener(cachedSetNeedsRecalculationFromRotation);
+        Transform.OnRotationChanged.AddListener(delegateSetNeedsRecalculationFromRotation);
-        Transform.OnScaleChanged.AddListener(cachedSetNeedsRecalculationFromScale);
+        Transform.OnScaleChanged.AddListener(delegateSetNeedsRecalculationFromScale);
-        UniverseObject.OnParentChanged.AddListener(cachedUpdateRigidBody2D);
+        UniverseObject.OnParentChanged.AddListener(delegateUpdateRigidBody2D);
     }
 
-    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject.ParentChangedArguments arguments)
+    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
     {
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
     }
 
-    private void OnBehaviourAddedToController(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAddedToController(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is IRigidBody2D rigidBody)
+        if (args.BehaviourAdded is IRigidBody2D rigidBody)
             _rigidBody2D = rigidBody;
     }
 
-    private void OnBehaviourRemovedFromController(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemovedFromController(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is IRigidBody2D)
+        if (args.BehaviourRemoved is IRigidBody2D)
             _rigidBody2D = null;
     }
 
-    private void SetNeedsRecalculationFromPosition(ITransform2D sender, ITransform2D.PositionChangedArguments arguments) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromPosition(ITransform2D sender, ITransform2D.PositionChangedArguments args) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromScale(ITransform2D sender, ITransform2D.ScaleChangedArguments arguments) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromScale(ITransform2D sender, ITransform2D.ScaleChangedArguments args) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromRotation(ITransform2D sender, ITransform2D.RotationChangedArguments arguments) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromRotation(ITransform2D sender, ITransform2D.RotationChangedArguments args) => NeedsRecalculation = true;
 
     protected override void OnFinalize()
     {
-        BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAddedToController);
+        BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAddedToController);
-        BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemovedFromController);
+        BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemovedFromController);
-        Transform.OnScaleChanged.RemoveListener(cachedSetNeedsRecalculationFromScale);
+        Transform.OnScaleChanged.RemoveListener(delegateSetNeedsRecalculationFromScale);
 
-        Transform.OnPositionChanged.RemoveListener(cachedSetNeedsRecalculationFromPosition);
+        Transform.OnPositionChanged.RemoveListener(delegateSetNeedsRecalculationFromPosition);
-        Transform.OnRotationChanged.RemoveListener(cachedSetNeedsRecalculationFromRotation);
+        Transform.OnRotationChanged.RemoveListener(delegateSetNeedsRecalculationFromRotation);
     }
 
     public void Detect(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionDetected?.Invoke(this, collisionDetectionInformation);

Engine.Physics2D/PhysicsCoroutineManager.cs

@@ -7,7 +7,7 @@ namespace Syntriax.Engine.Physics2D;
 
 public class PhysicsCoroutineManager : UniverseObject
 {
-    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler cachedOnUpdate = null!;
+    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler delegateOnUpdate = null!;
 
     private readonly List<IEnumerator> enumerators = [];
     private IPhysicsEngine2D? physicsEngine = null;
@@ -51,7 +51,7 @@ public class PhysicsCoroutineManager : UniverseObject
         universe.OnUpdate.RemoveListener(OnUpdate);
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         if (Universe is not IUniverse universe)
             return;
@@ -66,6 +66,6 @@ public class PhysicsCoroutineManager : UniverseObject
 
     public PhysicsCoroutineManager()
     {
-        cachedOnUpdate = OnUpdate;
+        delegateOnUpdate = OnUpdate;
     }
 }

Engine.Physics2D/PhysicsEngine2D.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Physics2D;
@@ -7,7 +9,7 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
     public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
 
-    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler cachedOnPreUpdate = null!;
+    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler delegateOnPreUpdate = null!;
 
     private float physicsTicker = 0f;
     private int _iterationPerStep = 1;
@@ -16,7 +18,7 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     protected readonly ICollisionDetector2D collisionDetector = null!;
     protected readonly ICollisionResolver2D collisionResolver = null!;
 
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
+    private static Comparer<IBehaviour> SortByPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
     protected ActiveBehaviourCollectorSorted<IPrePhysicsUpdate> physicsPreUpdateCollector = new() { SortBy = SortByPriority() };
     protected ActiveBehaviourCollectorSorted<IPhysicsUpdate> physicsUpdateCollector = new() { SortBy = SortByPriority() };
     protected ActiveBehaviourCollectorSorted<IPostPhysicsUpdate> physicsPostUpdateCollector = new() { SortBy = SortByPriority() };
@@ -77,10 +79,10 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     {
         float intervalDeltaTime = deltaTime / IterationPerStep;
 
-        System.Collections.Generic.List<ICollider2D> childColliders = [];
+        List<ICollider2D> childColliders = [];
-        System.Collections.Generic.List<IPrePhysicsUpdate> physicsPreUpdates = [];
+        List<IPrePhysicsUpdate> physicsPreUpdates = [];
-        System.Collections.Generic.List<IPhysicsUpdate> physicsUpdates = [];
+        List<IPhysicsUpdate> physicsUpdates = [];
-        System.Collections.Generic.List<IPostPhysicsUpdate> physicsPostUpdates = [];
+        List<IPostPhysicsUpdate> physicsPostUpdates = [];
 
         rigidBody.BehaviourController.GetBehavioursInChildren(childColliders);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsPreUpdates);
@@ -194,9 +196,9 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         universe.OnPreUpdate.RemoveListener(OnEnginePreUpdate);
     }
 
-    private void OnEnginePreUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnEnginePreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
-        physicsTicker += arguments.EngineTime.DeltaTime;
+        physicsTicker += args.EngineTime.DeltaTime;
 
         while (physicsTicker >= IterationPeriod)
         {
@@ -210,7 +212,7 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
 
-        cachedOnPreUpdate = OnEnginePreUpdate;
+        delegateOnPreUpdate = OnEnginePreUpdate;
     }
 
     public PhysicsEngine2D(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
@@ -218,6 +220,6 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
 
-        cachedOnPreUpdate = OnEnginePreUpdate;
+        delegateOnPreUpdate = OnEnginePreUpdate;
     }
 }

Engine.Physics2D/PhysicsEngine2DStandalone.cs

@@ -9,8 +9,8 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
     public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
     public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAdded = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemoved = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
 
     private readonly List<IRigidBody2D> rigidBodies = new(32);
     private readonly List<ICollider2D> colliders = new(64);
@@ -32,16 +32,16 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         foreach (ICollider2D collider2D in rigidBody.BehaviourController.GetBehaviours<ICollider2D>())
             colliders.Add(collider2D);
 
-        rigidBody.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
+        rigidBody.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
-        rigidBody.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);
+        rigidBody.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
     }
 
     public void RemoveRigidBody(IRigidBody2D rigidBody)
     {
         rigidBodies.Remove(rigidBody);
 
-        rigidBody.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
+        rigidBody.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
-        rigidBody.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);
+        rigidBody.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
     }
 
     public void Step(float deltaTime)
@@ -178,17 +178,17 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
     }
 
-    private void OnBehaviourAdded(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAdded(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not ICollider2D collider2D)
+        if (args.BehaviourAdded is not ICollider2D collider2D)
             return;
 
         colliders.Add(collider2D);
     }
 
-    private void OnBehaviourRemoved(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemoved(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is not ICollider2D collider2D)
+        if (args.BehaviourRemoved is not ICollider2D collider2D)
             return;
 
         colliders.Remove(collider2D);
@@ -199,8 +199,8 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
 
-        cachedOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 
     public PhysicsEngine2DStandalone(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
@@ -208,7 +208,7 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
 
-        cachedOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 }

Engine.Systems/StateMachine/StateMachine.cs

@@ -7,13 +7,13 @@ public class StateMachine : Behaviour
 {
     public Event<StateMachine, StateChangedArguments> OnStateChanged { get; } = new();
 
-    private readonly Event<IState, IState.StateTransitionReadyArguments>.EventHandler cachedOnStateTransitionReady = null!;
+    private readonly Event<IState, IState.StateTransitionReadyArguments>.EventHandler delegateOnStateTransitionReady = null!;
 
     private IState _state = new State();
 
     public StateMachine()
     {
-        cachedOnStateTransitionReady = OnStateTransitionReady;
+        delegateOnStateTransitionReady = OnStateTransitionReady;
     }
 
     [Serialize]
@@ -26,20 +26,20 @@ public class StateMachine : Behaviour
                 return;
 
             IState previousState = _state;
-            previousState.OnStateTransitionReady.RemoveListener(cachedOnStateTransitionReady);
+            previousState.OnStateTransitionReady.RemoveListener(delegateOnStateTransitionReady);
 
             _state = value;
             previousState.TransitionFrom(value);
             value.TransitionTo(_state);
             OnStateChanged?.Invoke(this, new(value, previousState));
 
-            value.OnStateTransitionReady.AddListener(cachedOnStateTransitionReady);
+            value.OnStateTransitionReady.AddListener(delegateOnStateTransitionReady);
         }
     }
 
-    private void OnStateTransitionReady(IState sender, IState.StateTransitionReadyArguments arguments)
+    private void OnStateTransitionReady(IState sender, IState.StateTransitionReadyArguments args)
     {
-        State = arguments.ToState;
+        State = args.ToState;
         while (State.GetNextState() is IState nextState)
             State = nextState;
     }

Engine.Systems/Tween/TweenManager.cs

@@ -8,9 +8,9 @@ namespace Syntriax.Engine.Systems.Tween;
 public class TweenManager : UniverseObject, ITweenManager
 {
     private CoroutineManager coroutineManager = null!;
-    private readonly Queue<Tween> queue = new();
 
     private readonly Dictionary<ITween, IEnumerator> runningCoroutines = [];
+    private readonly Queue<Tween> pool = new();
 
     public ITween StartTween(float duration, ITweenManager.TweenSetCallback? setCallback = null)
     {
@@ -22,7 +22,7 @@ public class TweenManager : UniverseObject, ITweenManager
 
     private Tween Get(float duration)
     {
-        if (!queue.TryDequeue(out Tween? result))
+        if (!pool.TryDequeue(out Tween? result))
             result = new(duration);
 
         result.Duration = duration;
@@ -31,11 +31,11 @@ public class TweenManager : UniverseObject, ITweenManager
 
     private void Return(Tween tween)
     {
-        if (queue.Contains(tween))
+        if (pool.Contains(tween))
             return;
 
         tween.Wipe();
-        queue.Enqueue(tween);
+        pool.Enqueue(tween);
     }
 
     private IEnumerator RunTween(Tween tween)
@@ -70,6 +70,7 @@ public class TweenManager : UniverseObject, ITweenManager
         tween.State = TweenState.Cancelled;
         coroutineManager.StopCoroutine(runningCoroutine);
         runningCoroutines.Remove(tween);
+        Return((Tween)tween);
     }
 
     protected override void OnEnteringUniverse(IUniverse universe)