chore: debumped .NET Core version to 8

Engine.Core/Abstract/Assignable/IAssignable.cs

@@ -8,7 +8,7 @@ public interface IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IAssignable"/>'s fields are unassigned and completely ready to recycle.
     /// </summary> 
-    Event<IAssignable>? OnUnassigned { get; }
+    event UnassignEventHandler? OnUnassigned;
 
     /// <summary>
     /// Unassign <see cref="IAssignable"/>'s all fields and make it ready to recycle.
@@ -17,4 +17,6 @@ public interface IAssignable
     /// <see cref="true"/>, if the fields are unsigned successfully, <see cref="false"/> if not.
     /// </returns>
     bool Unassign();
+
+    delegate void UnassignEventHandler(IAssignable sender);
 }

Engine.Core/Abstract/Assignable/IHasBehaviourController.cs

@@ -8,7 +8,7 @@ public interface IHasBehaviourController : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IBehaviourController"/> value has has been assigned a new value.
     /// </summary>
-    Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; }
+    event BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned;
 
     /// <inheritdoc cref="IBehaviourController" />
     IBehaviourController BehaviourController { get; }
@@ -21,4 +21,6 @@ public interface IHasBehaviourController : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IBehaviourController behaviourController);
+
+    delegate void BehaviourControllerAssignedEventHandler(IHasBehaviourController sender);
 }

Engine.Core/Abstract/Assignable/IHasEntity.cs

@@ -8,7 +8,7 @@ public interface IHasEntity : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IEntity"/> value has has been assigned a new value.
     /// </summary>
-    Event<IHasEntity> OnEntityAssigned { get; }
+    event EntityAssignedEventHandler? OnEntityAssigned;
 
     /// <inheritdoc cref="IEntity" />
     IEntity Entity { get; }
@@ -21,4 +21,6 @@ public interface IHasEntity : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IEntity entity);
+
+    delegate void EntityAssignedEventHandler(IHasEntity sender);
 }

Engine.Core/Abstract/Assignable/IHasStateEnable.cs

@@ -8,7 +8,7 @@ public interface IHasStateEnable : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IStateEnable"/> value has has been assigned a new value.
     /// </summary>
-    Event<IHasStateEnable> OnStateEnableAssigned { get; }
+    event StateEnableAssignedEventHandler? OnStateEnableAssigned;
 
     /// <inheritdoc cref="IStateEnable" />
     IStateEnable StateEnable { get; }
@@ -21,4 +21,6 @@ public interface IHasStateEnable : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IStateEnable stateEnable);
+
+    delegate void StateEnableAssignedEventHandler(IHasStateEnable sender);
 }

Engine.Core/Abstract/Assignable/IHasUniverse.cs

@@ -8,7 +8,7 @@ public interface IHasUniverse : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IUniverse"/> value has has been assigned a new value.
     /// </summary>
-    Event<IHasUniverse> OnUniverseAssigned { get; }
+    event UniverseAssignedEventHandler? OnUniverseAssigned;
 
     /// <inheritdoc cref="IUniverse" />
     IUniverse Universe { get; }
@@ -21,4 +21,6 @@ public interface IHasUniverse : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IUniverse universe);
+
+    delegate void UniverseAssignedEventHandler(IHasUniverse sender);
 }

Engine.Core/Abstract/Assignable/IHasUniverseObject.cs

@@ -8,7 +8,7 @@ public interface IHasUniverseObject : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> value has has been assigned a new value.
     /// </summary>
-    Event<IHasUniverseObject> OnUniverseObjectAssigned { get; }
+    event UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned;
 
     /// <inheritdoc cref="IUniverseObject" />
     IUniverseObject UniverseObject { get; }
@@ -21,4 +21,6 @@ public interface IHasUniverseObject : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IUniverseObject universeObject);
+
+    delegate void UniverseObjectAssignedEventHandler(IHasUniverseObject sender);
 }

Engine.Core/Abstract/IActive.cs

@@ -8,12 +8,12 @@ public interface IActive
     /// <summary>
     /// Event triggered when the <see cref="IsActive"/> state of the <see cref="IActive"/> changes.
     /// </summary>
-    Event<IActive, ActiveChangedArguments> OnActiveChanged { get; }
+    event ActiveChangedEventHandler? OnActiveChanged;
 
     /// <summary>
     /// The value indicating whether the <see cref="IActive"/> is enabled.
     /// </summary>
     bool IsActive { get; }
 
-    readonly record struct ActiveChangedArguments(bool PreviousState);
+    delegate void ActiveChangedEventHandler(IActive sender, bool previousState);
 }

Engine.Core/Abstract/IBehaviour.cs

@@ -8,12 +8,12 @@ public interface IBehaviour : IEntity, IActive, IHasBehaviourController, IHasSta
     /// <summary>
     /// Event triggered when the priority of the <see cref="IBehaviour"/> changes.
     /// </summary>
-    Event<IBehaviour, PriorityChangedArguments> OnPriorityChanged { get; }
+    event PriorityChangedEventHandler? OnPriorityChanged;
 
     /// <summary>
     /// The priority of the <see cref="IBehaviour"/>.
     /// </summary>
     int Priority { get; set; }
 
-    readonly record struct PriorityChangedArguments(int PreviousPriority);
+    delegate void PriorityChangedEventHandler(IBehaviour sender, int previousPriority);
 }

Engine.Core/Abstract/IBehaviourCollector.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace Syntriax.Engine.Core;
 
 /// <summary>
@@ -5,38 +7,29 @@ namespace Syntriax.Engine.Core;
 /// Provides mechanisms for tracking additions and removals, and notifies subscribers when such events occur on the assigned <see cref="IUniverse"/>.
 /// </summary>
 /// <typeparam name="T">The type of objects tracked by the collector.</typeparam>
-public interface IBehaviourCollector<T> : IHasUniverse where T : class
+public interface IBehaviourCollector<T> : IHasUniverse, IEnumerable<T> where T : class
 {
     /// <summary>
     /// Event triggered when an object of type <typeparamref name="T"/> is added to the collector.
     /// </summary>
-    Event<IBehaviourCollector<T>, BehaviourCollectedArguments> OnCollected { get; }
+    event CollectedEventHandler? OnCollected;
 
     /// <summary>
     /// Event triggered when an object of type <typeparamref name="T"/> is removed from the collector.
     /// </summary>
-    Event<IBehaviourCollector<T>, BehaviourRemovedArguments> OnRemoved { get; }
+    event RemovedEventHandler? OnRemoved;
-
-    /// <summary>
-    /// Amount of <typeparamref name="T"/> collected.
-    /// </summary>
-    int Count { get; }
-
-    /// <summary>
-    /// Get a <typeparamref name="T"/> collected by it's index.
-    /// </summary>
-    T this[System.Index index] { get; }
 
     /// <summary>
     /// Delegate for handling the <see cref="OnCollected"/> event.
     /// </summary>
     /// <param name="sender">The instance of the <see cref="IBehaviourCollector{T}"/> that triggered the event.</param>
     /// <param name="behaviourCollected">The object of type <typeparamref name="T"/> that was added to the collector.</param>
-    readonly record struct BehaviourCollectedArguments(T BehaviourCollected);
+    delegate void CollectedEventHandler(IBehaviourCollector<T> sender, T behaviourCollected);
 
     /// <summary>
     /// Delegate for handling the <see cref="OnRemoved"/> event.
     /// </summary>
-    /// <param name="BehaviourRemoved">The object of type <typeparamref name="T"/> that was removed from the collector.</param>
+    /// <param name="sender">The instance of the <see cref="IBehaviourCollector{T}"/> that triggered the event.</param>
-    readonly record struct BehaviourRemovedArguments(T BehaviourRemoved);
+    /// <param name="behaviourRemoved">The object of type <typeparamref name="T"/> that was removed from the collector.</param>
+    delegate void RemovedEventHandler(IBehaviourCollector<T> sender, T behaviourRemoved);
 }

Engine.Core/Abstract/IBehaviourController.cs

@@ -3,29 +3,34 @@ using System.Collections.Generic;
 namespace Syntriax.Engine.Core;
 
 /// <summary>
-/// Represents a controller for managing <see cref="IBehaviour"/>s. Connected to an <see cref="IUniverseObject"/>.
+/// Represents a controller for managing <see cref="IBehaviour"/>s and notify them accordingly about the engine's updates. Connected to an <see cref="IUniverseObject"/>.
 /// </summary>
-public interface IBehaviourController : IEntity, IHasUniverseObject
+public interface IBehaviourController : IEntity, IHasUniverseObject, IEnumerable<IBehaviour>
 {
+    /// <summary>
+    /// Event triggered before the update of <see cref="IBehaviour"/>s.
+    /// </summary>
+    event PreUpdateEventHandler? OnPreUpdate;
+
+    /// <summary>
+    /// Event triggered during the update of <see cref="IBehaviour"/>s.
+    /// </summary>
+    event UpdateEventHandler? OnUpdate;
+
+    /// <summary>
+    /// Event triggered before the drawing phase.
+    /// </summary>
+    event PreDrawEventHandler? OnPreDraw;
+
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is added to the <see cref="IBehaviourController"/>.
     /// </summary>
-    Event<IBehaviourController, BehaviourAddedArguments> OnBehaviourAdded { get; }
+    event BehaviourAddedEventHandler? OnBehaviourAdded;
 
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is removed from the <see cref="IBehaviourController"/>.
     /// </summary>
-    Event<IBehaviourController, BehaviourRemovedArguments> OnBehaviourRemoved { get; }
+    event BehaviourRemovedEventHandler? OnBehaviourRemoved;
-
-    /// <summary>
-    /// Amount of <see cref="IBehaviour"/> collected.
-    /// </summary>
-    int Count { get; }
-
-    /// <summary>
-    /// Get a <see cref="IBehaviour"/> collected by it's index.
-    /// </summary>
-    IBehaviour this[System.Index index] { get; }
 
     /// <summary>
     /// Adds a <see cref="IBehaviour"/> to the <see cref="IBehaviourController"/>.
@@ -78,6 +83,20 @@ public interface IBehaviourController : IEntity, IHasUniverseObject
     /// <param name="behaviour">The <see cref="IBehaviour"/> to remove.</param>
     void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour;
 
-    readonly record struct BehaviourAddedArguments(IBehaviour BehaviourAdded);
+    /// <summary>
-    readonly record struct BehaviourRemovedArguments(IBehaviour BehaviourRemoved);
+    /// Updates all <see cref="IBehaviour"/>s in the <see cref="IBehaviourController"/>.
+    /// </summary>
+    void Update();
+
+    /// <summary>
+    /// Performs pre-draw operations.
+    /// </summary>
+    void UpdatePreDraw();
+
+    delegate void PreUpdateEventHandler(IBehaviourController sender);
+    delegate void UpdateEventHandler(IBehaviourController sender);
+    delegate void PreDrawEventHandler(IBehaviourController sender);
+    delegate void BehaviourAddedEventHandler(IBehaviourController sender, IBehaviour behaviourAdded);
+    delegate void BehaviourRemovedEventHandler(IBehaviourController sender, IBehaviour behaviourRemoved);
+
 }

Engine.Core/Abstract/IEntity.cs

@@ -9,12 +9,12 @@ public interface IEntity : IInitializable, IHasStateEnable
     /// Event triggered when the <see cref="Id"/> of the <see cref="IEntity"/> changes.
     /// The string action parameter is the previous <see cref="Id"/> of the <see cref="IEntity"/>. 
     /// </summary>
-    Event<IEntity, IdChangedArguments> OnIdChanged { get; }
+    event IdChangedEventHandler? OnIdChanged;
 
     /// <summary>
     /// The ID of the <see cref="IEntity"/>.
     /// </summary>
     string Id { get; set; }
 
-    readonly record struct IdChangedArguments(string PreviousId);
+    delegate void IdChangedEventHandler(IEntity sender, string previousId);
 }

Engine.Core/Abstract/IInitializable.cs

@@ -8,12 +8,12 @@ public interface IInitializable
     /// <summary>
     /// Event triggered when the <see cref="Initialize"/> method is called successfully.
     /// </summary>
-    Event<IInitializable> OnInitialized { get; }
+    event InitializedEventHandler? OnInitialized;
 
     /// <summary>
     /// Event triggered when the <see cref="IInitializable"/> method is called successfully.
     /// </summary>
-    Event<IInitializable> OnFinalized { get; }
+    event FinalizedEventHandler? OnFinalized;
 
     /// <summary>
     /// The value indicating whether the entity has been initialized.
@@ -31,4 +31,7 @@ public interface IInitializable
     /// </summary>
     /// <returns><see cref="true"/> if finalization is successful, otherwise <see cref="false"/>.</returns>
     bool Finalize();
+
+    delegate void InitializedEventHandler(IInitializable sender);
+    delegate void FinalizedEventHandler(IInitializable sender);
 }

Engine.Core/Abstract/INameable.cs

@@ -8,12 +8,12 @@ public interface INameable
     /// <summary>
     /// Event triggered when the name of the entity changes.
     /// </summary>
-    Event<INameable, NameChangedArguments> OnNameChanged { get; }
+    event NameChangedEventHandler? OnNameChanged;
 
     /// <summary>
     /// The name of the entity.
     /// </summary>
     string Name { get; set; }
 
-    readonly record struct NameChangedArguments(string PreviousName);
+    delegate void NameChangedEventHandler(INameable sender, string previousName);
 }

Engine.Core/Abstract/IStateEnable.cs

@@ -8,12 +8,12 @@ public interface IStateEnable : IHasEntity
     /// <summary>
     /// Event triggered when the <see cref="Enabled"/> state of the <see cref="IStateEnable"/> changes.
     /// </summary>
-    Event<IStateEnable, EnabledChangedArguments> OnEnabledChanged { get; }
+    event EnabledChangedEventHandler? OnEnabledChanged;
 
     /// <summary>
     /// The value indicating whether the <see cref="IStateEnable"/> is enabled.
     /// </summary>
     bool Enabled { get; set; }
 
-    readonly record struct EnabledChangedArguments(bool PreviousState);
+    delegate void EnabledChangedEventHandler(IStateEnable sender, bool previousState);
 }

Engine.Core/Abstract/ITransform2D.cs

@@ -8,17 +8,17 @@ public interface ITransform2D : IBehaviour
     /// <summary>
     /// Event triggered when the <see cref="Position"/> of the <see cref="ITransform2D"/> changes.
     /// </summary>
-    Event<ITransform2D, PositionChangedArguments> OnPositionChanged { get; }
+    event PositionChangedEventHandler? OnPositionChanged;
 
     /// <summary>
     /// Event triggered when the <see cref="Scale"/> of the <see cref="ITransform2D"/> changes.
     /// </summary>
-    Event<ITransform2D, ScaleChangedArguments> OnScaleChanged { get; }
+    event ScaleChangedEventHandler? OnScaleChanged;
 
     /// <summary>
     /// Event triggered when the <see cref="Rotation"/> of the <see cref="ITransform"/> changes.
     /// </summary>
-    Event<ITransform2D, RotationChangedArguments> OnRotationChanged { get; }
+    event RotationChangedEventHandler? OnRotationChanged;
 
     /// <summary>
     /// The world position of the <see cref="ITransform2D"/> in 2D space.
@@ -51,20 +51,23 @@ public interface ITransform2D : IBehaviour
     float LocalRotation { get; set; }
 
     /// <summary>
-    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="PreviousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
+    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
-    readonly record struct PositionChangedArguments(Vector2D PreviousPosition);
+    /// <param name="previousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
+    delegate void PositionChangedEventHandler(ITransform2D sender, Vector2D previousPosition);
 
     /// <summary>
-    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="PreviousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
+    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
-    readonly record struct ScaleChangedArguments(Vector2D PreviousScale);
+    /// <param name="previousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
+    delegate void ScaleChangedEventHandler(ITransform2D sender, Vector2D previousScale);
 
     /// <summary>
-    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="PreviousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
+    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
-    readonly record struct RotationChangedArguments(float PreviousRotation);
+    /// <param name="previousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
+    delegate void RotationChangedEventHandler(ITransform2D sender, float previousRotation);
 }

Engine.Core/Abstract/IUniverse.cs

@@ -10,47 +10,32 @@ public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
     /// <summary>
     /// Event triggered when <see cref="Update(UniverseTime)"/> is about to be called called on the <see cref="IUniverse"/>.
     /// </summary>
-    Event<IUniverse, UpdateArguments> OnPreUpdate { get; }
+    event UpdateEventHandler? OnPreUpdate;
 
     /// <summary>
     /// Event triggered when <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    Event<IUniverse, UpdateArguments> OnUpdate { get; }
+    event UpdateEventHandler? OnUpdate;
 
     /// <summary>
-    /// Event triggered after <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
+    /// Event triggered when <see cref="PreDraw"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    Event<IUniverse, UpdateArguments> OnPostUpdate { get; }
+    event PreDrawEventHandler? OnPreDraw;
-
-    /// <summary>
-    /// Event triggered when <see cref="Draw"/> is about to be called called on the <see cref="IUniverse"/>.
-    /// </summary>
-    Event<IUniverse> OnPreDraw { get; }
-
-    /// <summary>
-    /// Event triggered when <see cref="Draw"/> is called on the <see cref="IUniverse"/>.
-    /// </summary>
-    Event<IUniverse> OnDraw { get; }
-
-    /// <summary>
-    /// Event triggered after <see cref="Draw"/> is called on the <see cref="IUniverse"/>.
-    /// </summary>
-    Event<IUniverse> OnPostDraw { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is registered to the <see cref="IUniverse"/>.
     /// </summary>
-    Event<IUniverse, UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; }
+    event UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered;
 
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is unregistered from the <see cref="IUniverse"/>.
     /// </summary>
-    Event<IUniverse, UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; }
+    event UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered;
 
     /// <summary>
     /// Event triggered when <see cref="TimeScale"/> is changed on the <see cref="IUniverse"/>.
     /// </summary>
-    Event<IUniverse, TimeScaleChangedArguments> OnTimeScaleChanged { get; }
+    event TimeScaleChangedEventHandler? OnTimeScaleChanged;
 
     /// <summary>
     /// Current time scale the <see cref="IUniverse"/> operates on.
@@ -99,12 +84,15 @@ public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
     void Update(UniverseTime universeTime);
 
     /// <summary>
-    /// Performs operations that should be done to the draw.
+    /// Performs operations that should be done before the draw calls.
     /// </summary>
-    void Draw();
+    void PreDraw();
 
-    readonly record struct TimeScaleChangedArguments(float PreviousTimeScale);
+    delegate void TimeScaleChangedEventHandler(IUniverse sender, float previousTimeScale);
-    readonly record struct UpdateArguments(UniverseTime EngineTime);
+
-    readonly record struct UniverseObjectRegisteredArguments(IUniverseObject UniverseObjectRegistered);
+    delegate void UpdateEventHandler(IUniverse sender, UniverseTime engineTime);
-    readonly record struct UniverseObjectUnRegisteredArguments(IUniverseObject UniverseObjectUnregistered);
+    delegate void PreDrawEventHandler(IUniverse sender);
+
+    delegate void UniverseObjectRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectRegistered);
+    delegate void UniverseObjectUnRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectUnregistered);
 }

Engine.Core/Abstract/IUniverseObject.cs

@@ -12,27 +12,27 @@ public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourCon
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> enters the universe.
     /// </summary>
-    Event<IUniverseObject, EnteredUniverseArguments> OnEnteredUniverse { get; }
+    event EnteredUniverseEventHandler? OnEnteredUniverse;
 
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> exits the universe.
     /// </summary>
-    Event<IUniverseObject, ExitedUniverseArguments> OnExitedUniverse { get; }
+    event ExitedUniverseEventHandler? OnExitedUniverse;
 
     /// <summary>
     /// Event triggered when the <see cref="Parent"/> of the <see cref="IUniverseObject"/> changes. The second parameter is the old <see cref="IUniverseObject"/>.
     /// </summary>
-    Event<IUniverseObject, ParentChangedArguments> OnParentChanged { get; }
+    event ParentChangedEventHandler? OnParentChanged;
 
     /// <summary>
     /// Event triggered when a new <see cref="IUniverseObject"/> is added to the <see cref="Children"/>.
     /// </summary>
-    Event<IUniverseObject, ChildrenAddedArguments> OnChildrenAdded { get; }
+    event ChildrenAddedEventHandler? OnChildrenAdded;
 
     /// <summary>
     /// Event triggered when an <see cref="IUniverseObject"/> is removed from the <see cref="Children"/>.
     /// </summary>
-    Event<IUniverseObject, ChildrenRemovedArguments> OnChildrenRemoved { get; }
+    event ChildrenRemovedEventHandler? OnChildrenRemoved;
 
     /// <summary>
     /// Gets the <see cref="IUniverse"/> this <see cref="IUniverseObject"/> is connected to, if any.
@@ -94,38 +94,38 @@ public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourCon
     void RemoveChild(IUniverseObject universeObject);
 
     /// <summary>
-    /// Arguments for the event triggered when the <see cref="IUniverseObject"/> enters the universe of a <see cref="IUniverse">.
+    /// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> enters the universe of a <see cref="IUniverse">.
     /// </summary>
     /// <param name="sender">The <see cref="IUniverseObject"/> that entered the universe.</param>
     /// <param name="universe">The <see cref="IUniverse"/> that the <see cref="IUniverseObject"/> has entered it's universe.</param>
-    readonly record struct EnteredUniverseArguments(IUniverse Universe);
+    delegate void EnteredUniverseEventHandler(IUniverseObject sender, IUniverse universe);
 
     /// <summary>
-    /// Arguments for the event triggered when the <see cref="IUniverseObject"/> exits the universe of a <see cref="IUniverse">.
+    /// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> exits the universe of a <see cref="IUniverse">.
     /// </summary>
     /// <param name="sender">The <see cref="IUniverseObject"/> that exited the universe.</param>
     /// <param name="universe">The <see cref="IUniverse"/> that the <see cref="IUniverseObject"/> has exited it's universe.</param>
-    readonly record struct ExitedUniverseArguments(IUniverse Universe);
+    delegate void ExitedUniverseEventHandler(IUniverseObject sender, IUniverse universe);
 
     /// <summary>
-    /// Arguments for the event triggered when the <see cref="IUniverseObject"/>'s parent changes.
+    /// Delegate for the event triggered when the <see cref="IUniverseObject"/>'s parent changes.
     /// </summary>
     /// <param name="sender">The <see cref="IUniverseObject"/> that the parent has changed.</param>
     /// <param name="previousParent">The previous <see cref="IUniverseObject"/> the sender was a child of.</param>
     /// <param name="newParent">The new and current <see cref="IUniverseObject"/> the sender is a child of.</param>
-    readonly record struct ParentChangedArguments(IUniverseObject? PreviousParent, IUniverseObject? CurrentParent);
+    delegate void ParentChangedEventHandler(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent);
 
     /// <summary>
-    /// Arguments for the event triggered when a new <see cref="IUniverseObject"/> added as a child.
+    /// Delegate for the event triggered when a new <see cref="IUniverseObject"/> added as a child.
     /// </summary>
     /// <param name="sender">The parent <see cref="IUniverseObject"/> this event is being called from.</param>
     /// <param name="childrenAdded">The <see cref="IUniverseObject"/> that got removed as a children of the sender <see cref="IUniverseObject"/>.</param>
-    readonly record struct ChildrenAddedArguments(IUniverseObject ChildrenAdded);
+    delegate void ChildrenAddedEventHandler(IUniverseObject sender, IUniverseObject childrenAdded);
 
     /// <summary>
     /// Delegate for the event triggered when a new <see cref="IUniverseObject"/> removed from being a child.
     /// </summary>
     /// <param name="sender">The parent <see cref="IUniverseObject"/> this event is being called from.</param>
     /// <param name="childrenAdded">The <see cref="IUniverseObject"/> that got removed as a children of the sender <see cref="IUniverseObject"/>.</param>
-    readonly record struct ChildrenRemovedArguments(IUniverseObject ChildrenRemoved);
+    delegate void ChildrenRemovedEventHandler(IUniverseObject sender, IUniverseObject childrenRemoved);
 }

Engine.Core/ActiveBehaviourCollector.cs

@@ -1,91 +1,89 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : class, IBehaviour
 {
-    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourCollectedArguments> OnCollected { get; } = new();
+    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
-    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourRemovedArguments> OnRemoved { get; } = new();
+    public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;
-    public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
-    public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
+    public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
+    public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;
-    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnBehaviourStateChanged = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
     private readonly List<T> monitoringBehaviours = new(32);
     protected readonly List<T> activeBehaviours = new(32);
     protected readonly Dictionary<IActive, T> monitoringActiveToBehaviour = new(32);
 
+    public IReadOnlyList<T> Behaviours => activeBehaviours;
     public IUniverse Universe { get; private set; } = null!;
 
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
+    public T this[Index index] => activeBehaviours[index];
+
+    public ActiveBehaviourCollector() { }
+    public ActiveBehaviourCollector(IUniverse universe) => Assign(universe);
+
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
     {
-        IUniverseObject universeObject = args.UniverseObjectRegistered;
+        universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
+        universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
 
-        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        foreach (IBehaviour item in universeObject.BehaviourController)
-        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
+            OnBehaviourAdded(universeObject.BehaviourController, item);
-
-        for (int i = 0; i < universeObject.BehaviourController.Count; i++)
-            OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
     {
-        IUniverseObject universeObject = args.UniverseObjectUnregistered;
+        universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
+        universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
 
-        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        foreach (IBehaviour item in universeObject.BehaviourController)
-        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
+            OnBehaviourRemoved(universeObject.BehaviourController, item);
-
-        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 args)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
     {
-        if (args.BehaviourAdded is not T tBehaviour)
+        if (behaviour is not T tBehaviour)
             return;
 
         monitoringBehaviours.Add(tBehaviour);
         monitoringActiveToBehaviour.Add(tBehaviour, tBehaviour);
-        tBehaviour.OnActiveChanged.AddListener(delegateOnBehaviourStateChanged);
+        tBehaviour.OnActiveChanged += OnBehaviourStateChanged;
-        OnBehaviourStateChanged(tBehaviour, new(!tBehaviour.IsActive));
+        OnBehaviourStateChanged(tBehaviour, !tBehaviour.IsActive);
     }
 
-    private void OnBehaviourStateChanged(IActive sender, IActive.ActiveChangedArguments args)
+    private void OnBehaviourStateChanged(IActive sender, bool previousState)
     {
         T behaviour = monitoringActiveToBehaviour[sender];
         if (sender.IsActive)
         {
             activeBehaviours.Add(behaviour);
             OnBehaviourAdd(behaviour);
-            OnCollected?.Invoke(this, new(behaviour));
+            OnCollected?.InvokeSafe(this, behaviour);
         }
         else if (activeBehaviours.Remove(behaviour))
         {
             OnBehaviourRemove(behaviour);
-            OnRemoved?.Invoke(this, new(behaviour));
+            OnRemoved?.InvokeSafe(this, behaviour);
         }
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
     {
-        if (args.BehaviourRemoved is not T tBehaviour)
+        if (behaviour is not T tBehaviour)
             return;
 
         if (!monitoringBehaviours.Remove(tBehaviour) || !monitoringActiveToBehaviour.Remove(tBehaviour))
             return;
 
-        tBehaviour.OnActiveChanged.RemoveListener(delegateOnBehaviourStateChanged);
+        tBehaviour.OnActiveChanged -= OnBehaviourStateChanged;
         if (activeBehaviours.Remove(tBehaviour))
         {
             OnBehaviourRemove(tBehaviour);
-            OnRemoved?.Invoke(this, new(tBehaviour));
+            OnRemoved?.InvokeSafe(this, tBehaviour);
         }
     }
 
@@ -95,13 +93,13 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
             return false;
 
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
-            OnUniverseObjectRegistered(universe, new(universeObject));
+            OnUniverseObjectRegistered(universe, universeObject);
 
-        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
+        universe.OnUniverseObjectRegistered += OnUniverseObjectRegistered;
-        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
+        universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;
 
         Universe = universe;
-        OnUniverseAssigned?.Invoke(this);
+        OnUniverseAssigned?.InvokeSafe(this);
 
         return true;
     }
@@ -112,36 +110,16 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
             return false;
 
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
-            OnUniverseObjectUnregistered(Universe, new(universeObject));
+            OnUniverseObjectUnregistered(Universe, universeObject);
 
-        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
+        Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
+        Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;
 
         Universe = null!;
-        OnUnassigned?.Invoke(this);
+        OnUnassigned?.InvokeSafe(this);
         return true;
     }
 
-    public int Count => activeBehaviours.Count;
+    public IEnumerator<T> GetEnumerator() => activeBehaviours.GetEnumerator();
-    public T this[Index index] => activeBehaviours[index];
+    IEnumerator IEnumerable.GetEnumerator() => activeBehaviours.GetEnumerator();
-
-    public ActiveBehaviourCollector()
-    {
-        delegateOnBehaviourAdded = OnBehaviourAdded;
-        delegateOnBehaviourRemoved = OnBehaviourRemoved;
-        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
-        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
-    }
-
-    public ActiveBehaviourCollector(IUniverse universe)
-    {
-        delegateOnBehaviourAdded = OnBehaviourAdded;
-        delegateOnBehaviourRemoved = OnBehaviourRemoved;
-        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
-        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
-
-        Assign(universe);
-    }
 }

Engine.Core/BaseEntity.cs

@@ -4,11 +4,13 @@ namespace Syntriax.Engine.Core;
 
 public abstract class BaseEntity : IEntity
 {
-    public Event<IEntity, IEntity.IdChangedArguments> OnIdChanged { get; } = new();
+    public event IEntity.IdChangedEventHandler? OnIdChanged = null;
-    public Event<IInitializable> OnInitialized { get; } = new();
+
-    public Event<IInitializable> OnFinalized { get; } = new();
+    public event IInitializable.InitializedEventHandler? OnInitialized = null;
-    public Event<IHasStateEnable> OnStateEnableAssigned { get; } = new();
+    public event IInitializable.FinalizedEventHandler? OnFinalized = null;
-    public Event<IAssignable> OnUnassigned { get; } = new();
+
+    public event IHasStateEnable.StateEnableAssignedEventHandler? OnStateEnableAssigned = null;
+    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
 
     private IStateEnable _stateEnable = null!;
 
@@ -31,7 +33,7 @@ public abstract class BaseEntity : IEntity
             string previousId = _id;
 
             _id = value;
-            OnIdChanged?.Invoke(this, new(previousId));
+            OnIdChanged?.InvokeSafe(this, previousId);
         }
     }
 
@@ -45,9 +47,9 @@ public abstract class BaseEntity : IEntity
 
             _initialized = value;
             if (value)
-                OnInitialized?.Invoke(this);
+                OnInitialized?.InvokeSafe(this);
             else
-                OnFinalized?.Invoke(this);
+                OnFinalized?.InvokeSafe(this);
         }
     }
 
@@ -60,7 +62,7 @@ public abstract class BaseEntity : IEntity
         _stateEnable = stateEnable;
         _stateEnable.Assign(this);
         OnAssign(stateEnable);
-        OnStateEnableAssigned?.Invoke(this);
+        OnStateEnableAssigned?.InvokeSafe(this);
         return true;
     }
 
@@ -74,7 +76,7 @@ public abstract class BaseEntity : IEntity
 
         _stateEnable = null!;
         _stateEnable.Unassign();
-        OnUnassigned?.Invoke(this);
+        OnUnassigned?.InvokeSafe(this);
         return true;
     }
 

Engine.Core/Behaviour.cs

@@ -1,23 +1,17 @@
 namespace Syntriax.Engine.Core;
 
-public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
+public abstract class Behaviour : BehaviourBase
-    IPreUpdate, IUpdate, IPostUpdate,
-    IPreDraw, IDraw, IPostDraw
 {
+    private bool isInitializedThisFrame = false;
+
     protected IUniverse Universe => BehaviourController.UniverseObject.Universe;
     protected IUniverseObject UniverseObject => BehaviourController.UniverseObject;
 
-    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler delegateEnteredUniverse = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateExitedUniverse = null!;
-
     public Behaviour()
     {
-        OnInitialized.AddListener(OnInitialize);
+        OnInitialized += OnInitialize;
-        OnFinalized.AddListener(OnFinalize);
+        OnFinalized += OnFinalize;
-        OnUnassigned.AddListener(OnUnassign);
+        OnUnassigned += OnUnassign;
-
-        delegateEnteredUniverse = EnteredUniverse;
-        delegateExitedUniverse = ExitedUniverse;
     }
 
     protected virtual void OnUnassign() { }
@@ -26,37 +20,38 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
     protected virtual void OnInitialize() { }
     protected virtual void OnInitialize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(delegateEnteredUniverse);
+        isInitializedThisFrame = true;
-        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(delegateExitedUniverse);
+
+        BehaviourController.OnPreUpdate += PreUpdate;
+        BehaviourController.OnPreDraw += PreDraw;
+        BehaviourController.OnUpdate += Update;
+        BehaviourController.UniverseObject.OnEnteredUniverse += EnteredUniverse;
+        BehaviourController.UniverseObject.OnExitedUniverse += ExitedUniverse;
 
         OnInitialize();
 
         if (UniverseObject.IsInUniverse)
-            EnteredUniverse(UniverseObject, new(Universe));
+            EnteredUniverse(UniverseObject, Universe);
     }
 
     protected virtual void OnFinalize() { }
     protected virtual void OnFinalize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(delegateEnteredUniverse);
+        BehaviourController.OnPreUpdate -= PreUpdate;
-        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(delegateExitedUniverse);
+        BehaviourController.OnPreDraw -= PreDraw;
+        BehaviourController.OnUpdate -= Update;
+        BehaviourController.UniverseObject.OnEnteredUniverse -= EnteredUniverse;
+        BehaviourController.UniverseObject.OnExitedUniverse -= ExitedUniverse;
 
         OnFinalize();
 
         if (UniverseObject.IsInUniverse)
-            ExitedUniverse(UniverseObject, new(Universe));
+            ExitedUniverse(UniverseObject, Universe);
-    }
-
-    protected virtual void OnFirstActiveFrame() { }
-    void IFirstFrameUpdate.FirstActiveFrame()
-    {
-        Debug.Assert.AssertInitialized(this);
-        OnFirstActiveFrame();
     }
 
     protected virtual void OnPreUpdatePreActiveCheck() { }
     protected virtual void OnPreUpdate() { }
-    void IPreUpdate.PreUpdate()
+    protected virtual void PreUpdate(IBehaviourController _)
     {
         Debug.Assert.AssertInitialized(this);
 
@@ -65,12 +60,22 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
         if (!IsActive)
             return;
 
+        if (isInitializedThisFrame)
+            FirstActiveFrame();
+
         OnPreUpdate();
     }
 
+    protected virtual void OnFirstActiveFrame() { }
+    protected virtual void FirstActiveFrame()
+    {
+        OnFirstActiveFrame();
+        isInitializedThisFrame = false;
+    }
+
     protected virtual void OnUpdatePreActiveCheck() { }
     protected virtual void OnUpdate() { }
-    void IUpdate.Update()
+    protected virtual void Update(IBehaviourController _)
     {
         Debug.Assert.AssertInitialized(this);
 
@@ -82,23 +87,9 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
         OnUpdate();
     }
 
-    protected virtual void OnPostUpdatePreActiveCheck() { }
-    protected virtual void OnPostUpdate() { }
-    void IPostUpdate.PostUpdate()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnPostUpdatePreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPostUpdate();
-    }
-
     protected virtual void OnPreDrawPreActiveCheck() { }
     protected virtual void OnPreDraw() { }
-    void IPreDraw.PreDraw()
+    protected virtual void PreDraw(IBehaviourController _)
     {
         Debug.Assert.AssertInitialized(this);
 
@@ -110,37 +101,9 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
         OnPreDraw();
     }
 
-    protected virtual void OnDrawPreActiveCheck() { }
-    protected virtual void OnDraw() { }
-    void IDraw.Draw()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnDrawPreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnDraw();
-    }
-
-    protected virtual void OnPostDrawPreActiveCheck() { }
-    protected virtual void OnPostDraw() { }
-    void IPostDraw.PostDraw()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnPostDrawPreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPostDraw();
-    }
-
     protected virtual void OnEnteredUniverse(IUniverse universe) { }
-    protected virtual void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => OnEnteredUniverse(args.Universe);
+    protected virtual void EnteredUniverse(IUniverseObject sender, IUniverse universe) => OnEnteredUniverse(universe);
 
     protected virtual void OnExitedUniverse(IUniverse universe) { }
-    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args) => OnExitedUniverse(args.Universe);
+    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverse universe) => OnExitedUniverse(universe);
 }

Engine.Core/Behaviour2D.cs

@@ -17,6 +17,10 @@ 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 args) => base.EnteredUniverse(sender, args);
+    protected sealed override void PreUpdate(IBehaviourController behaviourController) => base.PreUpdate(behaviourController);
-    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args) => base.ExitedUniverse(sender, args);
+    protected sealed override void FirstActiveFrame() => base.FirstActiveFrame();
+    protected sealed override void Update(IBehaviourController behaviourController) => base.Update(behaviourController);
+    protected sealed override void PreDraw(IBehaviourController behaviourController) => base.PreDraw(behaviourController);
+    protected sealed override void EnteredUniverse(IUniverseObject sender, IUniverse universe) => base.EnteredUniverse(sender, universe);
+    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverse universe) => base.ExitedUniverse(sender, universe);
 }

Engine.Core/BehaviourBase.cs

@@ -3,13 +3,9 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("{GetType().Name, nq}, Priority: {Priority}, Initialized: {Initialized}")]
 public abstract class BehaviourBase : BaseEntity, IBehaviour
 {
-    public Event<IBehaviour, IBehaviour.PriorityChangedArguments> OnPriorityChanged { get; } = new();
+    public event IHasBehaviourController.BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned = null;
-    public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
+    public event IBehaviour.PriorityChangedEventHandler? OnPriorityChanged = null;
-    public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
+    public event IActive.ActiveChangedEventHandler? OnActiveChanged = null;
-
-    private readonly Event<IHasUniverseObject>.EventHandler delegateOnUniverseObjectAssigned = null!;
-    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnUniverseObjectActiveChanged = null!;
-    private readonly Event<IStateEnable, IStateEnable.EnabledChangedArguments>.EventHandler delegateOnStateEnabledChanged = null!;
 
     private IBehaviourController _behaviourController = null!;
     public IBehaviourController BehaviourController => _behaviourController;
@@ -25,7 +21,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
             int previousPriority = _priority;
             _priority = value;
-            OnPriorityChanged?.Invoke(this, new(previousPriority));
+            OnPriorityChanged?.InvokeSafe(this, previousPriority);
         }
     }
 
@@ -40,16 +36,16 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
         _behaviourController = behaviourController;
         OnAssign(behaviourController);
-        behaviourController.OnUniverseObjectAssigned.AddListener(delegateOnUniverseObjectAssigned);
+        behaviourController.OnUniverseObjectAssigned += OnUniverseObjectAssigned;
         if (behaviourController.UniverseObject is not null)
             OnUniverseObjectAssigned(behaviourController);
-        OnBehaviourControllerAssigned?.Invoke(this);
+        OnBehaviourControllerAssigned?.InvokeSafe(this);
         return true;
     }
 
     private void OnUniverseObjectAssigned(IHasUniverseObject sender)
     {
-        sender.UniverseObject.OnActiveChanged.AddListener(delegateOnUniverseObjectActiveChanged);
+        sender.UniverseObject.OnActiveChanged += OnUniverseObjectActiveChanged;
         UpdateActive();
     }
 
@@ -57,14 +53,13 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     {
         base.OnAssign(stateEnable);
 
-        stateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
+        stateEnable.OnEnabledChanged += OnStateEnabledChanged;
     }
 
     protected override void UnassignInternal()
     {
-        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(delegateOnUniverseObjectActiveChanged);
+        StateEnable.OnEnabledChanged -= OnStateEnabledChanged;
-        StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
+        BehaviourController.OnUniverseObjectAssigned -= OnUniverseObjectAssigned;
-        BehaviourController.OnUniverseObjectAssigned.RemoveListener(delegateOnUniverseObjectAssigned);
         base.UnassignInternal();
         _behaviourController = null!;
     }
@@ -75,8 +70,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         Debug.Assert.AssertStateEnableAssigned(this);
     }
 
-    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, bool previousState) => UpdateActive();
-    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
+    private void OnUniverseObjectActiveChanged(IActive sender, bool previousState) => UpdateActive();
 
     private void UpdateActive()
     {
@@ -84,13 +79,6 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         _isActive = StateEnable.Enabled && _behaviourController.UniverseObject.IsActive;
 
         if (previousActive != IsActive)
-            OnActiveChanged?.Invoke(this, new(previousActive));
+            OnActiveChanged?.InvokeSafe(this, previousActive);
-    }
-
-    protected BehaviourBase()
-    {
-        delegateOnUniverseObjectAssigned = OnUniverseObjectAssigned;
-        delegateOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
-        delegateOnStateEnabledChanged = OnStateEnabledChanged;
     }
 }

Engine.Core/BehaviourCollector.cs

@@ -1,68 +1,67 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
 {
-    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourCollectedArguments> OnCollected { get; } = new();
+    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
-    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourRemovedArguments> OnRemoved { get; } = new();
+    public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;
-    public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
-    public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
+    public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
+    public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
     protected readonly List<T> behaviours = new(32);
 
+    public IReadOnlyList<T> Behaviours => behaviours;
     public IUniverse Universe { get; private set; } = null!;
 
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
+    public T this[Index index] => behaviours[index];
+
+    public BehaviourCollector() { }
+    public BehaviourCollector(IUniverse universe) => Assign(universe);
+
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
     {
-        IUniverseObject universeObject = args.UniverseObjectRegistered;
+        universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
+        universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
 
-        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        foreach (IBehaviour item in universeObject.BehaviourController)
-        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
+            OnBehaviourAdded(universeObject.BehaviourController, item);
-
-        for (int i = 0; i < universeObject.BehaviourController.Count; i++)
-            OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
     {
-        IUniverseObject universeObject = args.UniverseObjectUnregistered;
+        universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
+        universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
 
-        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        foreach (IBehaviour item in universeObject.BehaviourController)
-        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
+            OnBehaviourRemoved(universeObject.BehaviourController, item);
-
-        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 args)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
     {
-        if (args.BehaviourAdded is not T tBehaviour)
+        if (behaviour is not T tBehaviour)
             return;
 
         behaviours.Add(tBehaviour);
-        OnBehaviourAdd(args.BehaviourAdded);
+        OnBehaviourAdd(behaviour);
-        OnCollected?.Invoke(this, new(tBehaviour));
+        OnCollected?.InvokeSafe(this, tBehaviour);
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
     {
-        if (args.BehaviourRemoved is not T tBehaviour)
+        if (behaviour is not T tBehaviour)
             return;
 
         if (!behaviours.Remove(tBehaviour))
             return;
 
-        OnBehaviourRemove(args.BehaviourRemoved);
+        OnBehaviourRemove(behaviour);
-        OnRemoved?.Invoke(this, new(tBehaviour));
+        OnRemoved?.InvokeSafe(this, tBehaviour);
     }
 
     protected virtual void OnAssign(IUniverse universe) { }
@@ -72,14 +71,14 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
             return false;
 
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
-            OnUniverseObjectRegistered(universe, new(universeObject));
+            OnUniverseObjectRegistered(universe, universeObject);
 
-        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
+        universe.OnUniverseObjectRegistered += OnUniverseObjectRegistered;
-        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
+        universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;
 
         Universe = universe;
         OnAssign(universe);
-        OnUniverseAssigned?.Invoke(this);
+        OnUniverseAssigned?.InvokeSafe(this);
 
         return true;
     }
@@ -90,34 +89,16 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
             return false;
 
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
-            OnUniverseObjectUnregistered(Universe, new(universeObject));
+            OnUniverseObjectUnregistered(Universe, universeObject);
 
-        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
+        Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
+        Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;
 
         Universe = null!;
-        OnUnassigned?.Invoke(this);
+        OnUnassigned?.InvokeSafe(this);
         return true;
     }
 
-    public int Count => behaviours.Count;
+    public IEnumerator<T> GetEnumerator() => behaviours.GetEnumerator();
-    public T this[Index index] => behaviours[index];
+    IEnumerator IEnumerable.GetEnumerator() => behaviours.GetEnumerator();
-
-    public BehaviourCollector()
-    {
-        delegateOnBehaviourAdded = OnBehaviourAdded;
-        delegateOnBehaviourRemoved = OnBehaviourRemoved;
-        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
-    }
-
-    public BehaviourCollector(IUniverse universe)
-    {
-        delegateOnBehaviourAdded = OnBehaviourAdded;
-        delegateOnBehaviourRemoved = OnBehaviourRemoved;
-        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
-
-        Assign(universe);
-    }
 }

Engine.Core/BehaviourController.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -7,17 +8,19 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("Behaviour Count: {behaviours.Count}")]
 public class BehaviourController : BaseEntity, IBehaviourController
 {
-    public Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments> OnBehaviourAdded { get; } = new();
+    public event IBehaviourController.PreUpdateEventHandler? OnPreUpdate = null;
-    public Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments> OnBehaviourRemoved { get; } = new();
+    public event IBehaviourController.UpdateEventHandler? OnUpdate = null;
-    public Event<IHasUniverseObject> OnUniverseObjectAssigned { get; } = new();
+    public event IBehaviourController.PreDrawEventHandler? OnPreDraw = null;
 
-    private readonly List<IBehaviour> behaviours = new(Constants.BEHAVIOURS_SIZE_INITIAL);
+    public event IBehaviourController.BehaviourAddedEventHandler? OnBehaviourAdded = null;
+    public event IBehaviourController.BehaviourRemovedEventHandler? OnBehaviourRemoved = null;
+    public event IHasUniverseObject.UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned = null;
+
+    private readonly IList<IBehaviour> behaviours = new List<IBehaviour>(Constants.BEHAVIOURS_SIZE_INITIAL);
 
     private IUniverseObject _universeObject = null!;
 
     public IUniverseObject UniverseObject => _universeObject;
-    public int Count => behaviours.Count;
-    public IBehaviour this[Index index] => behaviours[index];
 
     public T AddBehaviour<T>(T behaviour) where T : class, IBehaviour
     {
@@ -27,17 +30,13 @@ public class BehaviourController : BaseEntity, IBehaviourController
 
         if (IsInitialized)
             behaviour.Initialize();
-
+        behaviour.OnPriorityChanged += OnPriorityChange;
-        behaviour.OnPriorityChanged.AddListener(OnPriorityChange);
+        OnBehaviourAdded?.InvokeSafe(this, behaviour);
-        OnBehaviourAdded?.Invoke(this, new(behaviour));
         return behaviour;
     }
 
     public T AddBehaviour<T>(params object?[]? args) where T : class, IBehaviour
-    {
+        => AddBehaviour(Factory.BehaviourFactory.Instantiate<T>(_universeObject, args));
-        T behaviour = Factory.BehaviourFactory.Instantiate<T>(args);
-        return AddBehaviour(behaviour);
-    }
 
     public T? GetBehaviour<T>()
     {
@@ -94,10 +93,10 @@ public class BehaviourController : BaseEntity, IBehaviourController
         if (!behaviours.Contains(behaviour))
             throw new Exception($"{behaviour.GetType().Name} does not exist in {UniverseObject.Name}'s {nameof(IBehaviourController)}.");
 
-        behaviour.OnPriorityChanged.RemoveListener(OnPriorityChange);
+        behaviour.OnPriorityChanged -= OnPriorityChange;
         behaviour.Finalize();
         behaviours.Remove(behaviour);
-        OnBehaviourRemoved?.Invoke(this, new(behaviour));
+        OnBehaviourRemoved?.InvokeSafe(this, behaviour);
     }
 
     protected virtual void OnAssign(IUniverseObject universeObject) { }
@@ -108,7 +107,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
 
         _universeObject = universeObject;
         OnAssign(universeObject);
-        OnUniverseObjectAssigned?.Invoke(this);
+        OnUniverseObjectAssigned?.InvokeSafe(this);
         return true;
     }
 
@@ -126,6 +125,27 @@ public class BehaviourController : BaseEntity, IBehaviourController
             behaviour.Finalize();
     }
 
+    public void Update()
+    {
+        Debug.Assert.AssertInitialized(this);
+
+        if (!UniverseObject.StateEnable.Enabled || !StateEnable.Enabled)
+            return;
+
+        OnPreUpdate?.InvokeSafe(this);
+        OnUpdate?.InvokeSafe(this);
+    }
+
+    public void UpdatePreDraw()
+    {
+        Debug.Assert.AssertInitialized(this);
+
+        if (!UniverseObject.StateEnable.Enabled || !StateEnable.Enabled)
+            return;
+
+        OnPreDraw?.InvokeSafe(this);
+    }
+
     public BehaviourController() { }
     public BehaviourController(IUniverseObject universeObject) => Assign(universeObject);
 
@@ -146,9 +166,12 @@ public class BehaviourController : BaseEntity, IBehaviourController
             behaviours.Add(behaviour);
     }
 
-    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
+    private void OnPriorityChange(IBehaviour sender, int previousPriority)
     {
         behaviours.Remove(sender);
         InsertBehaviourByPriority(sender);
     }
+
+    public IEnumerator<IBehaviour> GetEnumerator() => behaviours.GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => behaviours.GetEnumerator();
 }

Engine.Core/CoroutineManager.cs

@@ -20,15 +20,15 @@ public class CoroutineManager : UniverseObject
 
     protected override void OnEnteringUniverse(IUniverse universe)
     {
-        universe.OnUpdate.AddListener(OnUpdate);
+        universe.OnUpdate += OnUpdate;
     }
 
     protected override void OnExitingUniverse(IUniverse universe)
     {
-        universe.OnUpdate.RemoveListener(OnUpdate);
+        universe.OnUpdate -= OnUpdate;
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
+    private void OnUpdate(IUniverse sender, UniverseTime time)
     {
         for (int i = enumerators.Count - 1; i >= 0; i--)
         {

Engine.Core/Engine.Core.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>false</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>Syntriax.Engine.Core</RootNamespace>

Engine.Core/Exceptions/BehaviourNotFoundException.cs

@@ -1,3 +1,9 @@
+using System;
+
 namespace Syntriax.Engine.Core.Exceptions;
 
-public class BehaviourNotFoundException(string? message) : NotFoundException(message);
+public class BehaviourNotFoundException(string? message) : Exception(message)
+{
+    public static NotAssignedException FromType<TBehaviour>()
+        => new($"{typeof(TBehaviour).FullName} was not found");
+}

Engine.Core/Exceptions/NotFoundException.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace Syntriax.Engine.Core.Exceptions;
-
-public class NotFoundException(string? message) : Exception(message)
-{
-    public static NotAssignedException FromType<T>()
-        => new($"{typeof(T).FullName} was not found");
-}

Engine.Core/Exceptions/UniverseObjectNotFoundException.cs

@@ -1,3 +1,9 @@
+using System;
+
 namespace Syntriax.Engine.Core.Exceptions;
 
-public class UniverseObjectNotFoundException(string? message) : NotFoundException(message);
+public class UniverseObjectNotFoundException(string? message) : Exception(message)
+{
+    public static NotAssignedException FromType<TUniverseObject>()
+        => new($"{typeof(TUniverseObject).FullName} was not found");
+}

Engine.Core/Extensions/BehaviourControllerExtensions.cs

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 using Syntriax.Engine.Core.Exceptions;
@@ -39,19 +38,6 @@ public static class BehaviourControllerExtensions
     public static T GetOrAddBehaviour<T>(this IBehaviourController behaviourController, params object?[]? args) where T : class, IBehaviour
         => behaviourController.GetBehaviour<T>() ?? behaviourController.AddBehaviour<T>(args);
 
-    /// <summary>
-    /// Gets an existing <see cref="IBehaviour"/> of the specified type, or adds and returns the fallback type if it doesn't exist.
-    /// </summary>
-    /// <typeparam name="TOriginal">The type of <see cref="IBehaviour"/> to get.</typeparam>
-    /// <typeparam name="TFallback">The type of <see cref="IBehaviour"/> to add. It must be assignable from <typeparamref name="TOriginal"/></typeparam>
-    /// <param name="behaviourController">The <see cref="IBehaviourController"/> to search in.</param>
-    /// <param name="args">Optional arguments to pass to the constructor of the <see cref="IBehaviour"/> if a new one is added.</param>
-    /// <returns>The existing or newly added <see cref="IBehaviour"/> of the specified type.</returns>
-    public static TOriginal GetOrAddBehaviour<TOriginal, TFallback>(this IBehaviourController behaviourController, params object?[]? args)
-            where TOriginal : class
-            where TFallback : class, IBehaviour, TOriginal
-        => behaviourController.GetBehaviour<TOriginal>() ?? behaviourController.AddBehaviour<TFallback>(args);
-
     /// <summary>
     /// Tries to get a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively.
     /// </summary>
@@ -95,27 +81,6 @@ public static class BehaviourControllerExtensions
     public static T GetRequiredBehaviourInParent<T>(this IBehaviourController behaviourController) where T : class
         => behaviourController.GetBehaviourInParent<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any parent");
 
-    /// <summary>
-    /// Gets all <see cref="IBehaviour"/>s of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively and stores them in the provided list.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/>s to get.</typeparam>
-    /// <param name="behavioursInParent">The list to store the <see cref="IBehaviour"/>s.</param>
-    public static void GetBehavioursInParent<T>(this IBehaviourController behaviourController, IList<T> behavioursInParent) where T : class
-    {
-        IBehaviourController? controller = behaviourController;
-        List<T> cache = [];
-        behavioursInParent.Clear();
-
-        while (controller is not null)
-        {
-            controller.GetBehaviours(cache);
-            foreach (T behaviour in cache)
-                behavioursInParent.Add(behaviour);
-
-            controller = controller.UniverseObject.Parent?.BehaviourController;
-        }
-    }
-
     /// <summary>
     /// Tries to get a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s children recursively.
     /// </summary>
@@ -155,28 +120,4 @@ public static class BehaviourControllerExtensions
     /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
     public static T GetRequiredBehaviourInChildren<T>(this IBehaviourController behaviourController) where T : class
         => behaviourController.GetBehaviourInChildren<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any children ");
-
-    /// <summary>
-    /// Gets all <see cref="IBehaviour"/>s of the specified type in it's <see cref="IUniverseObject"/>'s children recursively and stores them in the provided list.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/>s to get.</typeparam>
-    /// <param name="behavioursInChildren">The list to store the <see cref="IBehaviour"/>s.</param>
-    public static void GetBehavioursInChildren<T>(this IBehaviourController behaviourController, IList<T> behavioursInChildren) where T : class
-    {
-        List<T> cache = [];
-        behavioursInChildren.Clear();
-
-        TraverseChildrenForBehaviour(behaviourController.UniverseObject, behavioursInChildren, cache);
-    }
-
-    private static void TraverseChildrenForBehaviour<T>(IUniverseObject universeObject, IList<T> behaviours, IList<T> cache) where T : class
-    {
-        universeObject.BehaviourController.GetBehaviours(cache);
-
-        foreach (T behaviour in cache)
-            behaviours.Add(behaviour);
-
-        foreach (IUniverseObject child in universeObject)
-            TraverseChildrenForBehaviour(child, behaviours, cache);
-    }
 }

Engine.Core/Extensions/BehaviourExtensions.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Syntriax.Engine.Core;
+
+public static class BehaviourExtensions
+{
+    public static T? FindBehaviour<T>(this IEnumerable<IUniverseObject> universeObjects) where T : class
+    {
+        foreach (IUniverseObject universeObject in universeObjects)
+            if (universeObject.BehaviourController.GetBehaviour<T>() is T behaviour)
+                return behaviour;
+
+        return default;
+    }
+
+    public static bool TryFindBehaviour<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
+    {
+        behaviour = FindBehaviour<T>(universeObjects);
+        return behaviour is not null;
+    }
+
+    public static void FindBehaviours<T>(this IEnumerable<IUniverseObject> universeObjects, List<T> behaviours) where T : class
+    {
+        behaviours.Clear();
+        List<T> cache = [];
+
+        foreach (IUniverseObject universeObject in universeObjects)
+        {
+            universeObject.BehaviourController.GetBehaviours(cache);
+            behaviours.AddRange(cache);
+        }
+    }
+}

Engine.Core/Extensions/UniverseExtensions.cs

@@ -7,30 +7,9 @@ public static class UniverseExtensions
     public static IUniverseObject InstantiateUniverseObject(this IUniverse universe, params object?[]? args)
         => universe.InstantiateUniverseObject<UniverseObject>(args);
 
-    /// <summary>
-    /// Searches through all <see cref="IUniverseObject"/>s to find the specified instance of the type.
-    /// </summary>
-    /// <typeparam name="T">Type to be searched through the <see cref="IUniverse"/>.</typeparam>
-    /// <returns>The specified type if found; otherwise, throws <see cref="UniverseObjectNotFoundException"/>.</returns>
     public static T GetRequiredUniverseObject<T>(this IUniverse universe) where T : class
         => universe.GetUniverseObject<T>() ?? throw new UniverseObjectNotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} object of type {typeof(T).FullName}");
 
-    /// <summary>
-    /// Searches through all <see cref="IBehaviours"/>s to find the specified instance of the type.
-    /// </summary>
-    /// <typeparam name="T">Type to be searched through the <see cref="IUniverse"/>.</typeparam>
-    /// <returns>The specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
     public static T FindRequiredBehaviour<T>(this IUniverse universe) where T : class
         => universe.FindBehaviour<T>() ?? throw new BehaviourNotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} with {nameof(IBehaviour)} of type {typeof(T).FullName}");
-
-    /// <summary>
-    /// Searches through all <see cref="IUniverseObject"/>s and <see cref="IBehaviours"/>s to find the specified instance of the type.
-    /// </summary>
-    /// <remarks>
-    /// WARNING: This is more expensive compared to <see cref="GetRequiredUniverseObject{T}(IUniverse)"/> or <see cref="FindRequiredBehaviour{T}(IUniverse)"/> as it combines the two. If you know whether the type is either a type that gets implemented on an <see cref="IBehaviour"/> or <see cref="IUniverseObject"/> use the method appropriate for it for performance.
-    /// </remarks>
-    /// <typeparam name="T">Type to be searched through the <see cref="IUniverse"/>.</typeparam>
-    /// <returns>The specified type if found; otherwise, throws <see cref="NotFoundException"/>.</returns>
-    public static T FindRequired<T>(this IUniverse universe) where T : class
-        => universe.Find<T>() ?? throw new NotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} or {nameof(IBehaviour)} of type {typeof(T).FullName}");
 }

Engine.Core/Extensions/UniverseObjectExtensions.cs

@@ -1,8 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
-using Syntriax.Engine.Core.Exceptions;
-
 namespace Syntriax.Engine.Core;
 
 public static class UniverseObjectExtensions
@@ -16,13 +14,6 @@ public static class UniverseObjectExtensions
         return universeObject;
     }
 
-    #region Universe Object Search
-    /// <summary>
-    /// Gets a <see cref="IUniverseObject"/> of the specified type.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObjects">The <see cref="IUniverseObject"/>s to search.</param>
-    /// <returns>The first found <see cref="IUniverseObject"/> of the specified type; otherwise, null.</returns>
     public static T? GetUniverseObject<T>(this IEnumerable<IUniverseObject> universeObjects) where T : class
     {
         foreach (IUniverseObject universeObject in universeObjects)
@@ -32,224 +23,17 @@ public static class UniverseObjectExtensions
         return default;
     }
 
-    /// <summary>
+    public static bool TryGetUniverseObject<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
-    /// Tries to get a <see cref="IUniverseObject"/> of the specified type.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObjects">The <see cref="IUniverseObject"/>s to search.</param>
-    /// <returns><see cref="true"/> if a <see cref="IUniverseObject"/> of the specified type was found in the universe objects; otherwise, <see cref="false"/>.</returns>
-    public static bool TryGetUniverseObject<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? universeObject) where T : class
     {
-        universeObject = GetUniverseObject<T>(universeObjects);
+        behaviour = GetUniverseObject<T>(universeObjects);
-        return universeObject is not null;
-    }
-
-    /// <summary>
-    /// Searches through the provided <see cref="IUniverseObject"/>s to collect a list of <see cref="IUniverseObject"/>s of the specified type.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObject">The <see cref="IUniverseObject"/> to search.</param>
-    /// <returns>The found <see cref="IUniverseObject"/>s of the specified types</returns>
-    public static void GetUniverseObjects<T>(this IEnumerable<IUniverseObject> universeObjects, IList<T> foundUniverseObjects) where T : class
-    {
-        foundUniverseObjects.Clear();
-
-        foreach (IUniverseObject universeObject in universeObjects)
-            if (universeObject is T @object)
-                foundUniverseObjects.Add(@object);
-    }
-    #endregion
-
-    #region Universe Object Search In Parent
-    /// <summary>
-    /// Tries to get a <see cref="IUniverseObject"/> of the specified type in it's parents recursively.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="behaviour">When this method returns, contains the <see cref="IUniverseObject"/> of the specified type, if found; otherwise, null.</param>
-    /// <returns><see cref="true"/> if a <see cref="IUniverseObject"/> of the specified type was found in the parent universe objects; otherwise, <see cref="false"/>.</returns>
-    public static bool TryGetUniverseObjectInParent<T>(this IUniverseObject universeObject, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
-    {
-        behaviour = GetUniverseObjectInParent<T>(universeObject);
         return behaviour is not null;
     }
 
-    /// <summary>
+    public static void GetUniverseObjects<T>(this IEnumerable<IUniverseObject> universeObjects, List<T> behaviours) where T : class
-    /// Gets a <see cref="IUniverseObject"/> of the specified type in it's parents recursively.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObject">The <see cref="IUniverseObject"/> to start searching from.</param>
-    /// <returns>The <see cref="IUniverseObject"/> of the specified type if found; otherwise, null.</returns>
-    public static T? GetUniverseObjectInParent<T>(this IUniverseObject universeObject) where T : class
-    {
-        if (universeObject.GetUniverseObject<T>() is T localUniverseObject)
-            return localUniverseObject;
-
-        IUniverseObject? parent = universeObject;
-
-        while (parent is not null)
-        {
-            if (parent is T behaviour)
-                return behaviour;
-
-            parent = universeObject.Parent;
-        }
-
-        return default;
-    }
-
-    /// <summary>
-    /// Gets a <see cref="IUniverseObject"/> of the specified type in the parents recursively. Throws an error if not found.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObject">The <see cref="IUniverseObject"/> to start searching from.</param>
-    /// <returns>The <see cref="IUniverseObject"/> of the specified type if found; otherwise, throws <see cref="UniverseObjectNotFoundException"/>.</returns>
-    public static T GetRequiredUniverseObjectInParent<T>(this IUniverseObject universeObject) where T : class
-        => universeObject.GetUniverseObjectInParent<T>() ?? throw new UniverseObjectNotFoundException($"{universeObject.Name}'s {nameof(IUniverseObject)} does not contain any {typeof(T).FullName} on any parent ");
-
-    #endregion
-
-    #region Universe Object Search In Children
-    /// <summary>
-    /// Tries to get a <see cref="IUniverseObject"/> of the specified type in it's children recursively.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="behaviour">When this method returns, contains the <see cref="IUniverseObject"/> of the specified type, if found; otherwise, null.</param>
-    /// <returns><see cref="true"/> if a <see cref="IUniverseObject"/> of the specified type was found in the child universe objects; otherwise, <see cref="false"/>.</returns>
-    public static bool TryGetUniverseObjectInChildren<T>(this IUniverseObject universeObject, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
-    {
-        behaviour = GetUniverseObjectInChildren<T>(universeObject);
-        return behaviour is not null;
-    }
-
-    /// <summary>
-    /// Gets a <see cref="IUniverseObject"/> of the specified type in it's children recursively.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObject">The <see cref="IUniverseObject"/> to start searching from.</param>
-    /// <returns>The <see cref="IUniverseObject"/> of the specified type if found; otherwise, null.</returns>
-    public static T? GetUniverseObjectInChildren<T>(this IUniverseObject universeObject) where T : class
-    {
-        if (universeObject.GetUniverseObject<T>() is T localUniverseObject)
-            return localUniverseObject;
-
-        foreach (IUniverseObject child in universeObject)
-            if (GetUniverseObjectInChildren<T>(child) is T behaviour)
-                return behaviour;
-
-        return default;
-    }
-
-    /// <summary>
-    /// Gets a <see cref="IUniverseObject"/> of the specified type in the children recursively. Throws an error if not found.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to get.</typeparam>
-    /// <param name="universeObject">The <see cref="IUniverseObject"/> to start searching from.</param>
-    /// <returns>The <see cref="IUniverseObject"/> of the specified type if found; otherwise, throws <see cref="UniverseObjectNotFoundException"/>.</returns>
-    public static T GetRequiredUniverseObjectInChildren<T>(this IUniverseObject universeObject) where T : class
-        => universeObject.GetUniverseObjectInChildren<T>() ?? throw new UniverseObjectNotFoundException($"{universeObject.Name}'s {nameof(IUniverseObject)} does not contain any {typeof(T).FullName} on any children ");
-    #endregion
-
-    #region Behaviour Search
-    /// <summary>
-    /// Finds a <see cref="IBehaviour"/> of the specified type in the provided <see cref="IUniverseObject"/>s.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to find.</typeparam>
-    /// <returns>The first found <see cref="IBehaviour"/> of the specified type; otherwise, null.</returns>
-    public static T? FindBehaviour<T>(this IEnumerable<IUniverseObject> universeObjects) where T : class
-    {
-        foreach (IUniverseObject universeObject in universeObjects)
-            if (universeObject.BehaviourController.GetBehaviour<T>() is T behaviour)
-                return behaviour;
-
-        return default;
-    }
-
-    /// <summary>
-    /// Tries to find a <see cref="IBehaviour"/> of the specified type in the provided <see cref="IUniverseObject"/>s.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to find.</typeparam>
-    /// <param name="behaviour">When this method returns, contains the <see cref="IUniverseObject"/> of the specified type, if found; otherwise, null.</param>
-    /// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found in the provided <see cref="IUniverseObject"/>s; otherwise, <see cref="false"/>.</returns>
-    public static bool TryFindBehaviour<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
-    {
-        behaviour = FindBehaviour<T>(universeObjects);
-        return behaviour is not null;
-    }
-
-    /// <summary>
-    /// Searches through the provided <see cref="IUniverseObject"/>s to collect a list of <see cref="IBehaviour"/>s of the specified type.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
-    /// <param name="universeObjects">The <see cref="IUniverseObject"/>s to search.</param>
-    public static void FindBehaviours<T>(this IEnumerable<IUniverseObject> universeObjects, IList<T> behaviours) where T : class
     {
         behaviours.Clear();
-        List<T> cache = [];
-
         foreach (IUniverseObject universeObject in universeObjects)
-        {
+            if (universeObject is T @object)
-            universeObject.BehaviourController.GetBehaviours(cache);
+                behaviours.Add(@object);
-            foreach (T behaviour in cache)
-                behaviours.Add(behaviour);
-        }
     }
-    #endregion
-
-    #region General Search
-    /// <summary>
-    /// Finds an object of the specified type in the provided <see cref="IUniverseObject"/>s and their <see cref="IBehaviour"/>s.
-    /// </summary>
-    /// <remarks>
-    /// WARNING: This is more expensive compared to <see cref="GetUniverseObject{T}(IEnumerable{IUniverseObject})"/> or <see cref="FindBehaviour{T}(IEnumerable{IUniverseObject})"/> as it combines the two. If you know whether the type is either a type that gets implemented on an <see cref="IBehaviour"/> or <see cref="IUniverseObject"/> use the method appropriate for it for performance.
-    /// </remarks>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to find.</typeparam>
-    /// <returns>The first found instance of the specified type; otherwise, null.</returns>
-    public static T? Find<T>(this IEnumerable<IUniverseObject> universeObjects) where T : class
-    {
-        if (universeObjects.GetUniverseObject<T>() is T foundUniverseObject)
-            return foundUniverseObject;
-
-        if (universeObjects.FindBehaviour<T>() is T foundBehaviour)
-            return foundBehaviour;
-
-        return null;
-    }
-
-    /// <summary>
-    /// Tries to find an object of the specified type in the provided <see cref="IUniverseObject"/>s and their <see cref="IBehaviour"/>s.
-    /// </summary>
-    /// <remarks>
-    /// WARNING: This is more expensive compared to <see cref="TryGetUniverseObject{T}(IEnumerable{IUniverseObject}, out T?)"/> or <see cref="TryFindBehaviour{T}(IEnumerable{IUniverseObject}, out T?)"/> as it combines the two. If you know whether the type is either a type that gets implemented on an <see cref="IBehaviour"/> or <see cref="IUniverseObject"/> use the method appropriate for it for performance.
-    /// </remarks>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to find.</typeparam>
-    /// <param name="behaviour">When this method returns, contains the <see cref="IUniverseObject"/> of the specified type, if found; otherwise, null.</param>
-    /// <returns><see cref="true"/> if an object of the specified type was found in the provided <see cref="IUniverseObject"/>s; otherwise, <see cref="false"/>.</returns>
-    public static bool TryFind<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
-    {
-        behaviour = Find<T>(universeObjects);
-        return behaviour is not null;
-    }
-
-    /// <summary>
-    /// Searches through the provided <see cref="IUniverseObject"/>s and their <see cref="IBehaviour"/>s to collect a list of the specified type.
-    /// </summary>
-    /// <remarks>
-    /// WARNING: This is more expensive compared to <see cref="GetUniverseObjects{T}(IEnumerable{IUniverseObject}, IList{T})"/> or <see cref="FindBehaviours{T}(IEnumerable{IUniverseObject}, IList{T})"/> as it combines the two. If you know whether the type is either a type that gets implemented on an <see cref="IBehaviour"/> or <see cref="IUniverseObject"/> use the method appropriate for it for performance.
-    /// </remarks>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
-    /// <param name="instances">List of objects found wit the specified type.</param>
-    /// <param name="universeObjects">The <see cref="IUniverseObject"/>s to search.</param>
-    public static void Find<T>(this IEnumerable<IUniverseObject> universeObjects, IList<T> instances) where T : class
-    {
-        instances.Clear();
-        List<T> cache = [];
-
-        foreach (IUniverseObject universeObject in universeObjects)
-        {
-            universeObject.Find(cache);
-            foreach (T behaviour in cache)
-                instances.Add(behaviour);
-        }
-    }
-    #endregion
 }

Engine.Core/Factory/BehaviourFactory.cs

@@ -4,10 +4,10 @@ namespace Syntriax.Engine.Core.Factory;
 
 public class BehaviourFactory
 {
-    public static T Instantiate<T>(params object?[]? args) where T : class, IBehaviour
+    public static T Instantiate<T>(IUniverseObject universeObject, params object?[]? args) where T : class, IBehaviour
-        => Instantiate<T>(stateEnable: null, args);
+        => Instantiate<T>(universeObject, stateEnable: null, args);
 
-    public static T Instantiate<T>(IStateEnable? stateEnable, params object?[]? args)
+    public static T Instantiate<T>(IUniverseObject universeObject, IStateEnable? stateEnable, params object?[]? args)
         where T : class, IBehaviour
     {
         T behaviour = TypeFactory.Get<T>(args);
@@ -18,6 +18,8 @@ public class BehaviourFactory
 
         if (!behaviour.Assign(stateEnable))
             throw AssignFailedException.From(behaviour, stateEnable);
+        if (!behaviour.Assign(universeObject.BehaviourController))
+            throw AssignFailedException.From(behaviour, universeObject.BehaviourController);
 
         return behaviour;
     }

Engine.Core/Helpers/DelegateExtensions.cs

@@ -4,10 +4,9 @@ namespace Syntriax.Engine.Core;
 
 public static class DelegateExtensions
 {
-    [Obsolete($"{nameof(InvokeSafe)} causes memory allocation, please use Invoke() instead.")]
     public static void InvokeSafe(this Delegate @delegate, params object?[] args)
     {
-        foreach (Delegate invocation in Delegate.EnumerateInvocationList(@delegate))
+        foreach (Delegate invocation in @delegate.GetInvocationList())
             try { invocation.DynamicInvoke(args); }
             catch (Exception exception)
             {

Engine.Core/Helpers/Event.cs

@@ -1,46 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Syntriax.Engine.Core;
-
-public class Event<TSender>
-{
-    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(TSender argument)
-    {
-        for (int i = 0; i < listeners.Count; i++)
-            try { listeners[i].Invoke(argument); }
-            catch (Exception exception)
-            {
-                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({argument})";
-                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
-            }
-    }
-
-    public delegate void EventHandler(TSender sender);
-}
-
-public class Event<TSender, TArguments>
-{
-    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(TSender sender, TArguments args)
-    {
-        for (int i = 0; i < listeners.Count; i++)
-            try { listeners[i].Invoke(sender, args); }
-            catch (Exception exception)
-            {
-                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 args);
-}

Engine.Core/Helpers/Progression/IReadOnlyProgressionTracker.cs

@@ -2,11 +2,12 @@ namespace Syntriax.Engine.Core;
 
 public interface IReadOnlyProgressionTracker
 {
-    Event<IReadOnlyProgressionTracker, ProgressionUpdatedArguments> OnUpdated { get; }
+    event ProgressionUpdatedEventHandler? OnUpdated;
-    Event<IReadOnlyProgressionTracker> OnEnded { get; }
+    event ProgressionEndedEventHandler? OnEnded;
 
     float Progression { get; }
     string Status { get; }
 
-    readonly record struct ProgressionUpdatedArguments(float PreviousProgression, string PreviousStatus);
+    delegate void ProgressionUpdatedEventHandler(IReadOnlyProgressionTracker sender, float previousProgression, string previousStatus);
+    delegate void ProgressionEndedEventHandler(IReadOnlyProgressionTracker sender);
 }

Engine.Core/Helpers/Progression/ProgressionTracker.cs

@@ -2,8 +2,8 @@ namespace Syntriax.Engine.Core;
 
 public class ProgressionTracker : IProgressionTracker
 {
-    public Event<IReadOnlyProgressionTracker, IReadOnlyProgressionTracker.ProgressionUpdatedArguments> OnUpdated { get; } = new();
+    public event IReadOnlyProgressionTracker.ProgressionUpdatedEventHandler? OnUpdated = null;
-    public Event<IReadOnlyProgressionTracker> OnEnded { get; } = new();
+    public event IReadOnlyProgressionTracker.ProgressionEndedEventHandler? OnEnded = null;
 
     public float Progression { get; private set; } = 0f;
     public string Status { get; private set; } = "Default";
@@ -19,10 +19,10 @@ public class ProgressionTracker : IProgressionTracker
         Progression = progression.Clamp(Progression, 1f);
         Status = status;
 
-        OnUpdated?.Invoke(this, new(previousProgression, previousStatus));
+        OnUpdated?.InvokeSafe(this, previousProgression, previousStatus);
 
         if (progression >= 1f)
-            OnEnded?.Invoke(this);
+            OnEnded?.InvokeSafe(this);
     }
 
     void IProgressionTracker.Reset()
@@ -30,7 +30,7 @@ public class ProgressionTracker : IProgressionTracker
         Progression = 0f;
         Status = "Default";
 
-        OnUpdated.Clear();
+        OnUpdated = null;
-        OnEnded.Clear();
+        OnEnded = null;
     }
 }

Engine.Core/Primitives/Shape2D.cs

@@ -18,7 +18,7 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
     public static Shape2D Pentagon => CreateNgon(5, Vector2D.Up);
     public static Shape2D Hexagon => CreateNgon(6, Vector2D.Right);
 
-    public Event<Shape2D> OnShapeUpdated { get; } = new();
+    public event ShapeUpdatedEventHandler? OnShapeUpdated = null;
 
     private List<Vector2D> _vertices = vertices;
 
@@ -35,7 +35,7 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
             foreach (Vector2D vertex in value)
                 _vertices.Add(vertex);
 
-            OnShapeUpdated?.Invoke(this);
+            OnShapeUpdated?.InvokeSafe(this);
         }
     }
 
@@ -229,7 +229,7 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
         for (int i = 0; i < count; i++)
             to._vertices.Add(transform.Transform(from[i]));
 
-        to.OnShapeUpdated?.Invoke(to);
+        to.OnShapeUpdated?.InvokeSafe(to);
     }
 
     /// <summary>
@@ -256,6 +256,8 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
 
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => Vertices.GetEnumerator();
+
+    public delegate void ShapeUpdatedEventHandler(Shape2D shape2D);
 }
 
 /// <summary>

Engine.Core/Serialization/EntityRegistry.cs

@@ -5,7 +5,7 @@ namespace Syntriax.Engine.Core.Serialization;
 
 public class EntityRegistry
 {
-    public Event<EntityRegistry, EntityRegisteredArguments> OnEntityRegistered = null!;
+    public event EntityRegisteredEventHandler? OnEntityRegistered = null!;
 
     private readonly Dictionary<string, Action<IEntity>?> assignCallbacks = [];
     private readonly Dictionary<string, IEntity> registeredEntities = [];
@@ -14,7 +14,7 @@ public class EntityRegistry
     public void Add(IEntity entity)
     {
         if (registeredEntities.TryAdd(entity.Id, entity))
-            OnEntityRegistered?.Invoke(this, new(entity));
+            OnEntityRegistered?.InvokeSafe(this, entity);
     }
 
     public void QueueAssign(string id, Action<IEntity> setMethod)
@@ -26,7 +26,7 @@ public class EntityRegistry
     public void AssignAll()
     {
         foreach ((string id, Action<IEntity>? action) in assignCallbacks)
-            action?.Invoke(registeredEntities[id]);
+            action?.InvokeSafe(registeredEntities[id]);
     }
 
     public void Reset()
@@ -35,5 +35,5 @@ public class EntityRegistry
         registeredEntities.Clear();
     }
 
-    public readonly record struct EntityRegisteredArguments(IEntity Entity);
+    public delegate void EntityRegisteredEventHandler(EntityRegistry sender, IEntity entity);
 }

Engine.Core/StateEnable.cs

@@ -2,9 +2,9 @@ namespace Syntriax.Engine.Core;
 
 public class StateEnable : IStateEnable
 {
-    public Event<IStateEnable, IStateEnable.EnabledChangedArguments> OnEnabledChanged { get; } = new();
+    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
-    public Event<IHasEntity> OnEntityAssigned { get; } = new();
+    public event IHasEntity.EntityAssignedEventHandler? OnEntityAssigned = null;
-    public Event<IAssignable>? OnUnassigned { get; } = new();
+    public event IStateEnable.EnabledChangedEventHandler? OnEnabledChanged = null;
 
     private bool _enabled = true;
     private IEntity _entity = null!;
@@ -21,7 +21,7 @@ public class StateEnable : IStateEnable
 
             bool previousState = _enabled;
             _enabled = value;
-            OnEnabledChanged?.Invoke(this, new(previousState));
+            OnEnabledChanged?.InvokeSafe(this, previousState);
         }
     }
 
@@ -33,7 +33,7 @@ public class StateEnable : IStateEnable
 
         _entity = entity;
         OnAssign(entity);
-        OnEntityAssigned?.Invoke(this);
+        OnEntityAssigned?.InvokeSafe(this);
         return true;
     }
 
@@ -43,7 +43,7 @@ public class StateEnable : IStateEnable
             return false;
 
         _entity = null!;
-        OnUnassigned?.Invoke(this);
+        OnUnassigned?.InvokeSafe(this);
         return true;
     }
 }

Engine.Core/Systems/Abstract/IDraw.cs

@@ -1,12 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> to be notified when the draw phase of the <see cref="IUniverse"/> occurs.
-/// </summary>
-public interface IDraw : IBehaviour
-{
-    /// <summary>
-    /// Calls draw logic for the <see cref="IBehaviour"/> to be displayed visually.
-    /// </summary>
-    void Draw();
-}

Engine.Core/Systems/Abstract/IFirstFrameUpdate.cs

@@ -1,6 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-public interface IFirstFrameUpdate : IBehaviour
-{
-    void FirstActiveFrame();
-}

Engine.Core/Systems/Abstract/IPostDraw.cs

@@ -1,12 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> to be notified after the draw phase of the <see cref="IUniverse"/> occurs.
-/// </summary>
-public interface IPostDraw : IBehaviour
-{
-    /// <summary>
-    /// Updates the state of the <see cref="IBehaviour"/> after the main draw phase happens.
-    /// </summary>
-    void PostDraw();
-}

Engine.Core/Systems/Abstract/IPostUpdate.cs

@@ -1,12 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> to be notified after the update phase of the <see cref="IUniverse"/> occurs.
-/// </summary>
-public interface IPostUpdate : IBehaviour
-{
-    /// <summary>
-    /// Updates the state of the <see cref="IBehaviour"/> after the main update phase happens.
-    /// </summary>
-    void PostUpdate();
-}

Engine.Core/Systems/Abstract/IPreDraw.cs

@@ -1,12 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> to be notified before the draw phase of the <see cref="IUniverse"/> occurs.
-/// </summary>
-public interface IPreDraw : IBehaviour
-{
-    /// <summary>
-    /// Updates the state of the <see cref="IBehaviour"/> before the main draw phase happens.
-    /// </summary>
-    void PreDraw();
-}

Engine.Core/Systems/Abstract/IPreUpdate.cs

@@ -1,12 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> to be notified before the update phase of the <see cref="IUniverse"/> occurs.
-/// </summary>
-public interface IPreUpdate : IBehaviour
-{
-    /// <summary>
-    /// Updates the state of the <see cref="IBehaviour"/> before the main update phase happens.
-    /// </summary>
-    void PreUpdate();
-}

Engine.Core/Systems/Abstract/IUpdate.cs

@@ -1,12 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> to be notified when the update phase of the <see cref="IUniverse"/> occurs.
-/// </summary>
-public interface IUpdate : IBehaviour
-{
-    /// <summary>
-    /// Updates the state of the <see cref="IBehaviour"/>.
-    /// </summary>
-    void Update();
-}

Engine.Core/Systems/DrawManager.cs

@@ -1,50 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-public class DrawManager : UniverseObject
-{
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
-
-    private readonly ActiveBehaviourCollectorSorted<IPreDraw> preDrawEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IDraw> drawEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPostDraw> postDrawEntities = new() { SortBy = SortByPriority() };
-
-    private void OnPreDraw(IUniverse sender)
-    {
-        for (int i = preDrawEntities.Count - 1; i >= 0; i--)
-            preDrawEntities[i].PreDraw();
-    }
-
-    private void OnDraw(IUniverse sender)
-    {
-        for (int i = drawEntities.Count - 1; i >= 0; i--)
-            drawEntities[i].Draw();
-    }
-
-    private void OnPostDraw(IUniverse sender)
-    {
-        for (int i = postDrawEntities.Count - 1; i >= 0; i--)
-            postDrawEntities[i].PostDraw();
-    }
-
-    protected override void OnEnteringUniverse(IUniverse universe)
-    {
-        preDrawEntities.Assign(universe);
-        drawEntities.Assign(universe);
-        postDrawEntities.Assign(universe);
-
-        universe.OnPreDraw.AddListener(OnPreDraw);
-        universe.OnDraw.AddListener(OnDraw);
-        universe.OnPostDraw.AddListener(OnPostDraw);
-    }
-
-    protected override void OnExitingUniverse(IUniverse universe)
-    {
-        preDrawEntities.Unassign();
-        drawEntities.Unassign();
-        postDrawEntities.Unassign();
-
-        universe.OnPreDraw.RemoveListener(OnPreDraw);
-        universe.OnDraw.RemoveListener(OnDraw);
-        universe.OnPostDraw.RemoveListener(OnPostDraw);
-    }
-}

Engine.Core/Systems/UpdateManager.cs

@@ -1,73 +0,0 @@
-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 readonly ActiveBehaviourCollectorSorted<IFirstFrameUpdate> firstFrameUpdates = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPreUpdate> preUpdateEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IUpdate> updateEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPostUpdate> postUpdateEntities = new() { SortBy = SortByPriority() };
-
-    private readonly List<IFirstFrameUpdate> toCallFirstFrameUpdates = new(32);
-
-    protected override void OnEnteringUniverse(IUniverse universe)
-    {
-        firstFrameUpdates.Assign(universe);
-        preUpdateEntities.Assign(universe);
-        updateEntities.Assign(universe);
-        postUpdateEntities.Assign(universe);
-
-        universe.OnPreUpdate.AddListener(OnPreUpdate);
-        universe.OnUpdate.AddListener(OnUpdate);
-        universe.OnPostUpdate.AddListener(OnPostUpdate);
-    }
-
-    protected override void OnExitingUniverse(IUniverse universe)
-    {
-        firstFrameUpdates.Unassign();
-        preUpdateEntities.Unassign();
-        updateEntities.Unassign();
-        postUpdateEntities.Unassign();
-
-        universe.OnPreUpdate.RemoveListener(OnPreUpdate);
-        universe.OnUpdate.RemoveListener(OnUpdate);
-        universe.OnPostUpdate.RemoveListener(OnPostUpdate);
-    }
-
-    private void OnPreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
-    {
-        for (int i = toCallFirstFrameUpdates.Count - 1; i >= 0; i--)
-        {
-            toCallFirstFrameUpdates[i].FirstActiveFrame();
-            toCallFirstFrameUpdates.RemoveAt(i);
-        }
-
-        for (int i = preUpdateEntities.Count - 1; i >= 0; i--)
-            preUpdateEntities[i].PreUpdate();
-    }
-
-    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 args)
-    {
-        for (int i = postUpdateEntities.Count - 1; i >= 0; i--)
-            postUpdateEntities[i].PostUpdate();
-    }
-
-    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments args)
-    {
-        toCallFirstFrameUpdates.Add(args.BehaviourCollected);
-    }
-
-    public UpdateManager()
-    {
-        firstFrameUpdates.OnCollected.AddListener(OnFirstFrameCollected);
-    }
-}

Engine.Core/Transform2D.cs

@@ -5,9 +5,9 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("Name: {UniverseObject.Name, nq} Position: {Position.ToString(), nq}, Scale: {Scale.ToString(), nq}, Rotation: {Rotation}")]
 public class Transform2D : Behaviour, ITransform2D
 {
-    public Event<ITransform2D, ITransform2D.PositionChangedArguments> OnPositionChanged { get; } = new();
+    public event ITransform2D.PositionChangedEventHandler? OnPositionChanged = null;
-    public Event<ITransform2D, ITransform2D.ScaleChangedArguments> OnScaleChanged { get; } = new();
+    public event ITransform2D.ScaleChangedEventHandler? OnScaleChanged = null;
-    public Event<ITransform2D, ITransform2D.RotationChangedArguments> OnRotationChanged { get; } = new();
+    public event ITransform2D.RotationChangedEventHandler? OnRotationChanged = null;
 
     private Vector2D _position = Vector2D.Zero;
     private Vector2D _scale = Vector2D.One;
@@ -31,7 +31,7 @@ public class Transform2D : Behaviour, ITransform2D
             _position = value;
 
             UpdateLocalPosition();
-            OnPositionChanged?.Invoke(this, new(previousPosition));
+            OnPositionChanged?.InvokeSafe(this, previousPosition);
         }
     }
 
@@ -47,7 +47,7 @@ public class Transform2D : Behaviour, ITransform2D
             _scale = value;
 
             UpdateLocalScale();
-            OnScaleChanged?.Invoke(this, new(previousScale));
+            OnScaleChanged?.InvokeSafe(this, previousScale);
         }
     }
 
@@ -63,7 +63,7 @@ public class Transform2D : Behaviour, ITransform2D
             _rotation = value;
 
             UpdateLocalRotation();
-            OnRotationChanged?.Invoke(this, new(previousRotation));
+            OnRotationChanged?.InvokeSafe(this, previousRotation);
         }
     }
 
@@ -79,7 +79,7 @@ public class Transform2D : Behaviour, ITransform2D
             _localPosition = value;
 
             UpdatePosition();
-            OnPositionChanged?.Invoke(this, new(previousPosition));
+            OnPositionChanged?.InvokeSafe(this, previousPosition);
         }
     }
 
@@ -97,8 +97,8 @@ public class Transform2D : Behaviour, ITransform2D
 
             UpdateScale();
             UpdatePosition();
-            OnScaleChanged?.Invoke(this, new(previousScale));
+            OnScaleChanged?.InvokeSafe(this, previousScale);
-            OnPositionChanged?.Invoke(this, new(previousPosition));
+            OnPositionChanged?.InvokeSafe(this, previousPosition);
         }
     }
 
@@ -114,21 +114,21 @@ public class Transform2D : Behaviour, ITransform2D
             _localRotation = value;
 
             UpdateRotation();
-            OnRotationChanged?.Invoke(this, new(previousRotation));
+            OnRotationChanged?.InvokeSafe(this, previousRotation);
         }
     }
 
-    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments args)
+    private void RecalculatePosition(ITransform2D _, Vector2D previousPosition)
     {
         if (parentTransform is null)
             return;
 
         UpdatePosition();
 
-        OnPositionChanged?.Invoke(this, args);
+        OnPositionChanged?.InvokeSafe(this, previousPosition);
     }
 
-    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments args)
+    private void RecalculateScale(ITransform2D _, Vector2D previousScale)
     {
         if (parentTransform is null)
             return;
@@ -138,11 +138,11 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateScale();
         UpdatePosition();
 
-        OnScaleChanged?.Invoke(this, args);
+        OnScaleChanged?.InvokeSafe(this, previousScale);
-        OnPositionChanged?.Invoke(this, new(previousPosition));
+        OnPositionChanged?.InvokeSafe(this, previousPosition);
     }
 
-    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments args)
+    private void RecalculateRotation(ITransform2D _, float previousRotation)
     {
         if (parentTransform is null)
             return;
@@ -152,8 +152,8 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateRotation();
         UpdatePosition();
 
-        OnRotationChanged?.Invoke(this, args);
+        OnRotationChanged?.InvokeSafe(this, previousRotation);
-        OnPositionChanged?.Invoke(this, new(previousPosition));
+        OnPositionChanged?.InvokeSafe(this, previousPosition);
     }
 
     private void UpdateLocalPosition()
@@ -207,12 +207,12 @@ public class Transform2D : Behaviour, ITransform2D
     protected override void InitializeInternal()
     {
         UpdateReferences(UniverseObject.Parent);
-        UniverseObject.OnParentChanged.AddListener(OnParentChanged);
+        UniverseObject.OnParentChanged += OnParentChanged;
     }
 
     protected override void FinalizeInternal()
     {
-        UniverseObject.OnParentChanged.RemoveListener(OnParentChanged);
+        UniverseObject.OnParentChanged -= OnParentChanged;
     }
 
     private void UpdateReferences(IUniverseObject? parent)
@@ -220,48 +220,48 @@ public class Transform2D : Behaviour, ITransform2D
         ITransform2D? previousParent = parentTransform;
         if (previousParent is not null)
         {
-            previousParent.OnPositionChanged.RemoveListener(RecalculatePosition);
+            previousParent.OnPositionChanged -= RecalculatePosition;
-            previousParent.OnScaleChanged.RemoveListener(RecalculateScale);
+            previousParent.OnScaleChanged -= RecalculateScale;
-            previousParent.OnRotationChanged.RemoveListener(RecalculateRotation);
+            previousParent.OnRotationChanged -= RecalculateRotation;
-            previousParent.BehaviourController.UniverseObject.OnParentChanged.RemoveListener(OnParentChanged);
+            previousParent.BehaviourController.UniverseObject.OnParentChanged -= OnParentChanged;
-            previousParent.BehaviourController.OnBehaviourAdded.RemoveListener(LookForTransform2D);
+            previousParent.BehaviourController.OnBehaviourAdded -= LookForTransform2D;
         }
 
         parentTransform = parent?.BehaviourController.GetBehaviour<ITransform2D>();
 
         if (parentTransform is not null)
         {
-            parentTransform.OnPositionChanged.AddListener(RecalculatePosition);
+            parentTransform.OnPositionChanged += RecalculatePosition;
-            parentTransform.OnScaleChanged.AddListener(RecalculateScale);
+            parentTransform.OnScaleChanged += RecalculateScale;
-            parentTransform.OnRotationChanged.AddListener(RecalculateRotation);
+            parentTransform.OnRotationChanged += RecalculateRotation;
-            parentTransform.BehaviourController.UniverseObject.OnParentChanged.AddListener(OnParentChanged);
+            parentTransform.BehaviourController.UniverseObject.OnParentChanged += OnParentChanged;
 
             UpdatePosition();
             UpdateScale();
             UpdateRotation();
         }
         else if (UniverseObject.Parent is not null)
-            UniverseObject.Parent.BehaviourController.OnBehaviourAdded.AddListener(LookForTransform2D);
+            UniverseObject.Parent.BehaviourController.OnBehaviourAdded += LookForTransform2D;
 
         UpdateLocalPosition();
         UpdateLocalScale();
         UpdateLocalRotation();
 
-        OnPositionChanged?.Invoke(this, new(Position));
+        OnPositionChanged?.InvokeSafe(this, Position);
-        OnScaleChanged?.Invoke(this, new(Scale));
+        OnScaleChanged?.InvokeSafe(this, Scale);
-        OnRotationChanged?.Invoke(this, new(Rotation));
+        OnRotationChanged?.InvokeSafe(this, Rotation);
     }
 
-    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
+    private void LookForTransform2D(IBehaviourController sender, IBehaviour behaviourAdded)
     {
-        if (args.BehaviourAdded is not ITransform2D)
+        if (behaviourAdded is not ITransform2D transform2D)
             return;
 
         UpdateReferences(UniverseObject.Parent);
     }
 
-    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
+    private void OnParentChanged(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
     {
-        UpdateReferences(args.CurrentParent);
+        UpdateReferences(newParent);
     }
 }

Engine.Core/Universe.cs

@@ -7,28 +7,18 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("UniverseObject Count: {_universeObjects.Count}")]
 public class Universe : BaseEntity, IUniverse
 {
-    public Event<IUniverse, IUniverse.UpdateArguments> OnPreUpdate { get; } = new();
+    public event IUniverse.UpdateEventHandler? OnPreUpdate = null;
-    public Event<IUniverse, IUniverse.UpdateArguments> OnUpdate { get; } = new();
+    public event IUniverse.UpdateEventHandler? OnUpdate = null;
-    public Event<IUniverse, IUniverse.UpdateArguments> OnPostUpdate { get; } = new();
+    public event IUniverse.PreDrawEventHandler? OnPreDraw = null;
-    public Event<IUniverse> OnPreDraw { get; } = new();
-    public Event<IUniverse> OnDraw { get; } = new();
-    public Event<IUniverse> OnPostDraw { get; } = new();
-    public Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; } = new();
-    public Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; } = new();
-    public Event<IUniverse, IUniverse.TimeScaleChangedArguments> OnTimeScaleChanged { get; } = new();
 
-    private readonly Event<IInitializable>.EventHandler delegateOnUniverseObjectFinalize = null!;
+    public event IUniverse.UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered = null;
-    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateOnUniverseObjectExitedUniverse = null!;
+    public event IUniverse.UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered = null;
+
+    public event IUniverse.TimeScaleChangedEventHandler? OnTimeScaleChanged = null;
 
     private readonly List<IUniverseObject> _universeObjects = new(Constants.UNIVERSE_OBJECTS_SIZE_INITIAL);
     private float _timeScale = 1f;
 
-    public Universe()
-    {
-        delegateOnUniverseObjectFinalize = OnUniverseObjectFinalize;
-        delegateOnUniverseObjectExitedUniverse = OnUniverseObjectExitedUniverse;
-    }
-
     public IReadOnlyList<IUniverseObject> UniverseObjects => _universeObjects;
 
     public UniverseTime Time { get; private set; } = new();
@@ -44,7 +34,7 @@ public class Universe : BaseEntity, IUniverse
 
             float previousTimeScale = _timeScale;
             _timeScale = value;
-            OnTimeScaleChanged?.Invoke(this, new(previousTimeScale));
+            OnTimeScaleChanged?.InvokeSafe(this, previousTimeScale);
         }
     }
 
@@ -53,8 +43,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(delegateOnUniverseObjectFinalize);
+        universeObject.OnFinalized += OnUniverseObjectFinalize;
-        universeObject.OnExitedUniverse.AddListener(delegateOnUniverseObjectExitedUniverse);
+        universeObject.OnExitedUniverse += OnUniverseObjectExitedUniverse;
 
         if (!universeObject.Initialize())
             throw new Exception($"{universeObject.Name} can't be initialized");
@@ -67,7 +57,7 @@ public class Universe : BaseEntity, IUniverse
         if (!universeObject.EnterUniverse(this))
             throw new Exception($"{universeObject.Name} can't enter the universe");
 
-        OnUniverseObjectRegistered?.Invoke(this, new(universeObject));
+        OnUniverseObjectRegistered?.InvokeSafe(this, universeObject);
     }
 
     public T InstantiateUniverseObject<T>(params object?[]? args) where T : class, IUniverseObject
@@ -88,8 +78,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(delegateOnUniverseObjectFinalize);
+        universeObject.OnFinalized -= OnUniverseObjectFinalize;
-        universeObject.OnExitedUniverse.RemoveListener(delegateOnUniverseObjectExitedUniverse);
+        universeObject.OnExitedUniverse -= OnUniverseObjectExitedUniverse;
 
         for (int i = universeObject.Children.Count - 1; i >= 0; i--)
             Remove(universeObject.Children[i]);
@@ -102,7 +92,7 @@ public class Universe : BaseEntity, IUniverse
         if (!universeObject.Finalize())
             throw new Exception($"{universeObject.Name} can't be finalized");
 
-        OnUniverseObjectUnRegistered?.Invoke(this, new(universeObject));
+        OnUniverseObjectUnRegistered?.InvokeSafe(this, universeObject);
     }
 
     protected override void InitializeInternal()
@@ -125,18 +115,22 @@ public class Universe : BaseEntity, IUniverse
         UnscaledTime = engineTime;
         Time = new(TimeSpan.FromTicks((long)(Time.TimeSinceStart.Ticks + engineTime.DeltaSpan.Ticks * TimeScale)), TimeSpan.FromTicks((long)(engineTime.DeltaSpan.Ticks * TimeScale)));
 
-        OnPreUpdate?.Invoke(this, new(Time));
+        OnPreUpdate?.InvokeSafe(this, Time);
-        OnUpdate?.Invoke(this, new(Time));
+
-        OnPostUpdate?.Invoke(this, new(Time));
+        for (int i = 0; i < UniverseObjects.Count; i++)
+            UniverseObjects[i].BehaviourController.Update();
+
+        OnUpdate?.InvokeSafe(this, Time);
     }
 
-    public void Draw()
+    public void PreDraw()
     {
         Debug.Assert.AssertInitialized(this);
 
-        OnPreDraw?.Invoke(this);
+        for (int i = 0; i < UniverseObjects.Count; i++)
-        OnDraw?.Invoke(this);
+            UniverseObjects[i].BehaviourController.UpdatePreDraw();
-        OnPostDraw?.Invoke(this);
+
+        OnPreDraw?.InvokeSafe(this);
     }
 
     private void OnUniverseObjectFinalize(IInitializable initializable)
@@ -145,7 +139,7 @@ public class Universe : BaseEntity, IUniverse
             Remove(universeObject);
     }
 
-    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args)
+    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverse universe)
     {
         if (sender is IUniverseObject universeObject)
             Remove(universeObject);

Engine.Core/UniverseObject.cs

@@ -6,15 +6,14 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("Name: {Name}, Initialized: {Initialized}")]
 public class UniverseObject : BaseEntity, IUniverseObject
 {
-    public Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments> OnEnteredUniverse { get; } = new();
+    public event IUniverseObject.EnteredUniverseEventHandler? OnEnteredUniverse = null;
-    public Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments> OnExitedUniverse { get; } = new();
+    public event IUniverseObject.ExitedUniverseEventHandler? OnExitedUniverse = null;
-    public Event<IUniverseObject, IUniverseObject.ParentChangedArguments> OnParentChanged { get; } = new();
+    public event IUniverseObject.ParentChangedEventHandler? OnParentChanged = null;
-    public Event<IUniverseObject, IUniverseObject.ChildrenAddedArguments> OnChildrenAdded { get; } = new();
+    public event IUniverseObject.ChildrenAddedEventHandler? OnChildrenAdded = null;
-    public Event<IUniverseObject, IUniverseObject.ChildrenRemovedArguments> OnChildrenRemoved { get; } = new();
+    public event IUniverseObject.ChildrenRemovedEventHandler? OnChildrenRemoved = null;
-
+    public event IHasBehaviourController.BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned = null;
-    public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
+    public event INameable.NameChangedEventHandler? OnNameChanged = null;
-    public Event<INameable, INameable.NameChangedArguments> OnNameChanged { get; } = new();
+    public event IActive.ActiveChangedEventHandler? OnActiveChanged = null;
-    public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
 
     private string _name = nameof(UniverseObject);
     private IUniverse _universe = null!;
@@ -38,7 +37,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
             string previousName = _name;
             _name = value;
-            OnNameChanged?.Invoke(this, new(previousName));
+            OnNameChanged?.InvokeSafe(this, previousName);
         }
     }
 
@@ -51,7 +50,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
         _universe = universe;
         UpdateActive();
         OnEnteringUniverse(universe);
-        OnEnteredUniverse?.Invoke(this, new(universe));
+        OnEnteredUniverse?.InvokeSafe(this, universe);
         return true;
     }
 
@@ -63,7 +62,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
         OnExitingUniverse(universe);
         _universe = null!;
-        OnExitedUniverse?.Invoke(this, new(universe));
+        OnExitedUniverse?.InvokeSafe(this, universe);
         return true;
     }
 
@@ -79,7 +78,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
         if (previousParent is not null)
         {
             previousParent.RemoveChild(this);
-            previousParent.OnActiveChanged.RemoveListener(OnParentActiveChanged);
+            previousParent.OnActiveChanged -= OnParentActiveChanged;
         }
 
         Parent = parent;
@@ -90,11 +89,11 @@ public class UniverseObject : BaseEntity, IUniverseObject
                 parent.Universe.Register(this);
 
             parent.AddChild(this);
-            parent.OnActiveChanged.AddListener(OnParentActiveChanged);
+            parent.OnActiveChanged += OnParentActiveChanged;
         }
 
         UpdateActive();
-        OnParentChanged?.Invoke(this, new(previousParent, parent));
+        OnParentChanged?.InvokeSafe(this, previousParent, parent);
     }
 
     public void AddChild(IUniverseObject parent)
@@ -104,7 +103,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
         _children.Add(parent);
         parent.SetParent(this);
-        OnChildrenAdded?.Invoke(this, new(parent));
+        OnChildrenAdded?.InvokeSafe(this, parent);
     }
 
     public void RemoveChild(IUniverseObject child)
@@ -113,7 +112,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
             return;
 
         child.SetParent(null);
-        OnChildrenRemoved?.Invoke(this, new(child));
+        OnChildrenRemoved?.InvokeSafe(this, child);
     }
 
     protected virtual void OnAssign(IBehaviourController behaviourController) { }
@@ -124,7 +123,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
         _behaviourController = behaviourController;
         OnAssign(behaviourController);
-        OnBehaviourControllerAssigned?.Invoke(this);
+        OnBehaviourControllerAssigned?.InvokeSafe(this);
         return true;
     }
 
@@ -132,11 +131,11 @@ public class UniverseObject : BaseEntity, IUniverseObject
     {
         base.OnAssign(stateEnable);
 
-        stateEnable.OnEnabledChanged.AddListener(OnStateEnabledChanged);
+        stateEnable.OnEnabledChanged += OnStateEnabledChanged;
     }
 
-    private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
+    private void OnParentActiveChanged(IActive sender, bool previousState) => UpdateActive();
-    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, bool previousState) => UpdateActive();
 
     private void UpdateActive()
     {
@@ -144,13 +143,13 @@ public class UniverseObject : BaseEntity, IUniverseObject
         _isActive = StateEnable.Enabled && (Parent?.IsActive ?? true);
 
         if (previousActive != IsActive)
-            OnActiveChanged?.Invoke(this, new(previousActive));
+            OnActiveChanged?.InvokeSafe(this, previousActive);
     }
 
     protected override void UnassignInternal()
     {
         base.UnassignInternal();
-        StateEnable.OnEnabledChanged.RemoveListener(OnStateEnabledChanged);
+        StateEnable.OnEnabledChanged -= OnStateEnabledChanged;
     }
 
     protected override void InitializeInternal()

Engine.Physics2D/Abstract/ICollider2D.cs

@@ -10,17 +10,17 @@ public interface ICollider2D : IBehaviour
     /// <summary>
     /// Event triggered when a collision is detected.
     /// </summary>
-    Event<ICollider2D, CollisionDetectionInformation> OnCollisionDetected { get; }
+    event CollisionDetectedEventHandler? OnCollisionDetected;
 
     /// <summary>
     /// Event triggered when a collision is resolved.
     /// </summary>
-    Event<ICollider2D, CollisionDetectionInformation> OnCollisionResolved { get; }
+    event CollisionResolvedEventHandler? OnCollisionResolved;
 
     /// <summary>
     /// Event triggered when another <see cref="ICollider2D"/> triggers this <see cref="ICollider2D"/>.
     /// </summary>
-    Event<ICollider2D, ICollider2D> OnTriggered { get; }
+    event TriggeredEventHandler? OnTriggered;
 
     /// <inheritdoc cref="ITransform2D" />
     ITransform2D Transform { get; }
@@ -44,7 +44,7 @@ public interface ICollider2D : IBehaviour
     void Resolve(CollisionDetectionInformation collisionDetectionInformation);
     void Trigger(ICollider2D initiator);
 
-    readonly record struct CollisionDetectedArguments(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
+    delegate void CollisionDetectedEventHandler(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
-    readonly record struct CollisionResolvedArguments(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
+    delegate void CollisionResolvedEventHandler(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
-    readonly record struct TriggeredArguments(ICollider2D sender, ICollider2D initiatorCollider);
+    delegate void TriggeredEventHandler(ICollider2D sender, ICollider2D initiatorCollider);
 }

Engine.Physics2D/Abstract/IPhysicsEngine2D.cs

@@ -1,5 +1,3 @@
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Physics2D;
 
 /// <summary>
@@ -10,12 +8,12 @@ public interface IPhysicsEngine2D
     /// <summary>
     /// Event triggered when the <see cref="IPhysicsEngine2D"/> has done a single physics iteration.
     /// </summary>
-    Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; }
+    event PhysicsIterationEventHandler? OnPhysicsIteration;
 
     /// <summary>
     /// Event triggered when the <see cref="IPhysicsEngine2D"/> has done a full physics step/>.
     /// </summary>
-    Event<IPhysicsEngine2D, float> OnPhysicsStep { get; }
+    event PhysicsStepEventHandler? OnPhysicsStep;
 
     /// <summary>
     /// The number of iterations the <see cref="IPhysicsEngine2D"/> performs per step.
@@ -28,13 +26,6 @@ public interface IPhysicsEngine2D
     /// <param name="deltaTime">The time step.</param>
     void Step(float deltaTime);
 
-    /// <summary>
+    delegate void PhysicsIterationEventHandler(IPhysicsEngine2D sender, float iterationDeltaTime);
-    /// Advances the physics simulation by the specified time on a single <see cref="IRigidBody2D"/>.
+    delegate void PhysicsStepEventHandler(IPhysicsEngine2D sender, float stepDeltaTime);
-    /// </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);
-
-    readonly record struct PhysicsIterationArguments(IPhysicsEngine2D sender, float iterationDeltaTime);
-    readonly record struct PhysicsStepArguments(IPhysicsEngine2D sender, float stepDeltaTime);
 }

Engine.Physics2D/Abstract/Updates/IPostPhysicsUpdate.cs

@@ -1,15 +0,0 @@
-using Syntriax.Engine.Core;
-
-namespace Syntriax.Engine.Physics2D;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> that listens to the phase after the physics simulation phase.
-/// </summary>
-public interface IPostPhysicsUpdate : IBehaviour
-{
-    /// <summary>
-    /// Execute logic that should occur after the physics simulation has been updated.
-    /// </summary>
-    /// <param name="delta">The time elapsed since the last physics update, typically in seconds.</param>
-    void PostPhysicsUpdate(float delta);
-}

Engine.Physics2D/Abstract/Updates/IPrePhysicsUpdate.cs

@@ -1,15 +0,0 @@
-using Syntriax.Engine.Core;
-
-namespace Syntriax.Engine.Physics2D;
-
-/// <summary>
-/// Represents a <see cref="IBehaviour"/> that listens to the phase before the physics simulation phase.
-/// </summary>
-public interface IPrePhysicsUpdate : IBehaviour
-{
-    /// <summary>
-    /// Execute logic that should occur before the physics simulation is updated.
-    /// </summary>
-    /// <param name="delta">The time elapsed since the last physics update, typically in seconds.</param>
-    void PrePhysicsUpdate(float delta);
-}

Engine.Physics2D/Collider2DBehaviourBase.cs

@@ -4,30 +4,13 @@ namespace Syntriax.Engine.Physics2D;
 
 public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
 {
-    public Event<ICollider2D, CollisionDetectionInformation> OnCollisionDetected { get; } = new();
+    public event ICollider2D.CollisionDetectedEventHandler? OnCollisionDetected = null;
-    public Event<ICollider2D, CollisionDetectionInformation> OnCollisionResolved { get; } = new();
+    public event ICollider2D.CollisionResolvedEventHandler? OnCollisionResolved = null;
-    public Event<ICollider2D, ICollider2D> OnTriggered { get; } = new();
+    public event ICollider2D.TriggeredEventHandler? OnTriggered = null;
-
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAddedToController = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemovedFromController = null!;
-    private readonly Event<ITransform2D, ITransform2D.PositionChangedArguments>.EventHandler delegateSetNeedsRecalculationFromPosition = null!;
-    private readonly Event<ITransform2D, ITransform2D.RotationChangedArguments>.EventHandler delegateSetNeedsRecalculationFromRotation = null!;
-    private readonly Event<ITransform2D, ITransform2D.ScaleChangedArguments>.EventHandler delegateSetNeedsRecalculationFromScale = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ParentChangedArguments>.EventHandler delegateUpdateRigidBody2D = null!;
 
     protected bool NeedsRecalculation { get; set; } = true;
     protected IRigidBody2D? _rigidBody2D = null;
 
-    protected Collider2DBehaviourBase()
-    {
-        delegateOnBehaviourAddedToController = OnBehaviourAddedToController;
-        delegateOnBehaviourRemovedFromController = OnBehaviourRemovedFromController;
-        delegateSetNeedsRecalculationFromPosition = SetNeedsRecalculationFromPosition;
-        delegateSetNeedsRecalculationFromRotation = SetNeedsRecalculationFromRotation;
-        delegateSetNeedsRecalculationFromScale = SetNeedsRecalculationFromScale;
-        delegateUpdateRigidBody2D = UpdateRigidBody2D;
-    }
-
     public IRigidBody2D? RigidBody2D => _rigidBody2D;
     public bool IsTrigger { get; set; } = false;
 
@@ -46,47 +29,47 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
     {
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
 
-        BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAddedToController);
+        BehaviourController.OnBehaviourAdded += OnBehaviourAddedToController;
-        BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemovedFromController);
+        BehaviourController.OnBehaviourRemoved += OnBehaviourRemovedFromController;
 
-        Transform.OnPositionChanged.AddListener(delegateSetNeedsRecalculationFromPosition);
+        Transform.OnPositionChanged += SetNeedsRecalculationFromPosition;
-        Transform.OnRotationChanged.AddListener(delegateSetNeedsRecalculationFromRotation);
+        Transform.OnRotationChanged += SetNeedsRecalculationFromRotation;
-        Transform.OnScaleChanged.AddListener(delegateSetNeedsRecalculationFromScale);
+        Transform.OnScaleChanged += SetNeedsRecalculationFromScale;
-        UniverseObject.OnParentChanged.AddListener(delegateUpdateRigidBody2D);
+        UniverseObject.OnParentChanged += UpdateRigidBody2D;
     }
 
-    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
+    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
     {
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
     }
 
-    private void OnBehaviourAddedToController(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
+    private void OnBehaviourAddedToController(IBehaviourController _, IBehaviour behaviour)
     {
-        if (args.BehaviourAdded is IRigidBody2D rigidBody)
+        if (behaviour is IRigidBody2D rigidBody)
             _rigidBody2D = rigidBody;
     }
 
-    private void OnBehaviourRemovedFromController(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
+    private void OnBehaviourRemovedFromController(IBehaviourController _, IBehaviour behaviour)
     {
-        if (args.BehaviourRemoved is IRigidBody2D)
+        if (behaviour is IRigidBody2D _)
             _rigidBody2D = null;
     }
 
-    private void SetNeedsRecalculationFromPosition(ITransform2D sender, ITransform2D.PositionChangedArguments args) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromScale(ITransform2D sender, Vector2D previousScale) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromScale(ITransform2D sender, ITransform2D.ScaleChangedArguments args) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromPosition(ITransform2D sender, Vector2D previousPosition) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromRotation(ITransform2D sender, ITransform2D.RotationChangedArguments args) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromRotation(ITransform2D sender, float previousRotation) => NeedsRecalculation = true;
 
     protected override void OnFinalize()
     {
-        BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAddedToController);
+        BehaviourController.OnBehaviourAdded -= OnBehaviourAddedToController;
-        BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemovedFromController);
+        BehaviourController.OnBehaviourRemoved -= OnBehaviourRemovedFromController;
-        Transform.OnScaleChanged.RemoveListener(delegateSetNeedsRecalculationFromScale);
+        Transform.OnScaleChanged -= SetNeedsRecalculationFromScale;
 
-        Transform.OnPositionChanged.RemoveListener(delegateSetNeedsRecalculationFromPosition);
+        Transform.OnPositionChanged -= SetNeedsRecalculationFromPosition;
-        Transform.OnRotationChanged.RemoveListener(delegateSetNeedsRecalculationFromRotation);
+        Transform.OnRotationChanged -= SetNeedsRecalculationFromRotation;
     }
 
-    public void Detect(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionDetected?.Invoke(this, collisionDetectionInformation);
+    public void Detect(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionDetected?.InvokeSafe(this, collisionDetectionInformation);
-    public void Resolve(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionResolved?.Invoke(this, collisionDetectionInformation);
+    public void Resolve(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionResolved?.InvokeSafe(this, collisionDetectionInformation);
-    public void Trigger(ICollider2D initiator) => OnTriggered?.Invoke(this, initiator);
+    public void Trigger(ICollider2D initiator) => OnTriggered?.InvokeSafe(this, initiator);
 }

Engine.Physics2D/Engine.Physics2D.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>Syntriax.Engine.Physics2D</RootNamespace>

Engine.Physics2D/PhysicsCoroutineManager.cs

@@ -7,8 +7,6 @@ namespace Syntriax.Engine.Physics2D;
 
 public class PhysicsCoroutineManager : UniverseObject
 {
-    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler delegateOnUpdate = null!;
-
     private readonly List<IEnumerator> enumerators = [];
     private IPhysicsEngine2D? physicsEngine = null;
 
@@ -27,9 +25,9 @@ public class PhysicsCoroutineManager : UniverseObject
     {
         physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
         if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
-            foundPhysicsEngine.OnPhysicsStep.RemoveListener(OnPhysicsStep);
+            foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
         else
-            universe.OnUpdate.AddListener(OnUpdate);
+            universe.OnUpdate += OnUpdate;
     }
 
     private void OnPhysicsStep(IPhysicsEngine2D sender, float stepDeltaTime)
@@ -47,11 +45,11 @@ public class PhysicsCoroutineManager : UniverseObject
     protected override void OnExitingUniverse(IUniverse universe)
     {
         if (physicsEngine is IPhysicsEngine2D existingPhysicsEngine)
-            existingPhysicsEngine.OnPhysicsStep.RemoveListener(OnPhysicsStep);
+            existingPhysicsEngine.OnPhysicsStep -= OnPhysicsStep;
-        universe.OnUpdate.RemoveListener(OnUpdate);
+        universe.OnUpdate -= OnUpdate;
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
+    private void OnUpdate(IUniverse sender, UniverseTime engineTime)
     {
         if (Universe is not IUniverse universe)
             return;
@@ -59,13 +57,8 @@ public class PhysicsCoroutineManager : UniverseObject
         physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
         if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
         {
-            foundPhysicsEngine.OnPhysicsStep.AddListener(OnPhysicsStep);
+            foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
-            universe.OnUpdate.RemoveListener(OnUpdate);
+            universe.OnUpdate -= OnUpdate;
         }
     }
-
-    public PhysicsCoroutineManager()
-    {
-        delegateOnUpdate = OnUpdate;
-    }
 }

Engine.Physics2D/PhysicsEngine2D.cs

@@ -4,10 +4,8 @@ namespace Syntriax.Engine.Physics2D;
 
 public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
 {
-    public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
+    public event IPhysicsEngine2D.PhysicsIterationEventHandler? OnPhysicsIteration = null;
-    public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
+    public event IPhysicsEngine2D.PhysicsStepEventHandler? OnPhysicsStep = null;
-
-    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler delegateOnPreUpdate = null!;
 
     private float physicsTicker = 0f;
     private int _iterationPerStep = 1;
@@ -16,12 +14,9 @@ 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);
-    protected ActiveBehaviourCollectorSorted<IPrePhysicsUpdate> physicsPreUpdateCollector = new() { SortBy = SortByPriority() };
-    protected ActiveBehaviourCollectorSorted<IPhysicsUpdate> physicsUpdateCollector = new() { SortBy = SortByPriority() };
-    protected ActiveBehaviourCollectorSorted<IPostPhysicsUpdate> physicsPostUpdateCollector = new() { SortBy = SortByPriority() };
     protected BehaviourCollector<IRigidBody2D> rigidBodyCollector = new();
     protected BehaviourCollector<ICollider2D> colliderCollector = new();
+    protected BehaviourCollector<IPhysicsUpdate> physicsUpdateCollector = new();
 
     public int IterationPerStep { get => _iterationPerStep; set => _iterationPerStep = value < 1 ? 1 : value; }
     public float IterationPeriod { get => _iterationPeriod; set => _iterationPeriod = value.Max(0.0001f); }
@@ -30,137 +25,77 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     {
         float intervalDeltaTime = deltaTime / IterationPerStep;
 
-        for (int i = physicsPreUpdateCollector.Count - 1; i >= 0; i--)
-            physicsPreUpdateCollector[i].PrePhysicsUpdate(deltaTime);
-
-        for (int i = physicsUpdateCollector.Count - 1; i >= 0; i--)
-            physicsUpdateCollector[i].PhysicsUpdate(deltaTime);
-
         for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
         {
             // Can Parallel
-            for (int i = rigidBodyCollector.Count - 1; i >= 0; i--)
+            foreach (IRigidBody2D rigidBody in rigidBodyCollector)
-                StepRigidBody(rigidBodyCollector[i], intervalDeltaTime);
+                StepRigidBody(rigidBody, intervalDeltaTime);
 
             // Can Parallel
-            for (int i = colliderCollector.Count - 1; i >= 0; i--)
+            foreach (ICollider2D collider in colliderCollector)
-                colliderCollector[i].Recalculate();
+                collider.Recalculate();
 
             // Can Parallel
-            for (int x = 0; x < colliderCollector.Count; x++)
+            for (int x = 0; x < colliderCollector.Behaviours.Count; x++)
             {
-                ICollider2D? colliderX = colliderCollector[x];
+                ICollider2D? colliderX = colliderCollector.Behaviours[x];
                 if (!colliderX.IsActive)
-                    continue;
+                    return;
 
-                for (int y = x + 1; y < colliderCollector.Count; y++)
+                for (int y = x + 1; y < colliderCollector.Behaviours.Count; y++)
                 {
-                    ICollider2D? colliderY = colliderCollector[y];
+                    ICollider2D? colliderY = colliderCollector.Behaviours[y];
 
                     if (!colliderY.IsActive)
+                        return;
+
+                    if (colliderX.RigidBody2D == colliderY.RigidBody2D)
                         continue;
 
-                    ResolveColliders(colliderX, colliderY);
+                    bool bothCollidersAreTriggers = colliderX.IsTrigger && colliderX.IsTrigger == colliderY.IsTrigger;
+                    if (bothCollidersAreTriggers)
+                        continue;
+
+                    bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
+                    if (bothCollidersAreStatic)
+                        continue;
+
+                    if (collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
+                    {
+                        if (colliderX.IsTrigger)
+                        {
+                            colliderX.Trigger(colliderY);
+                            continue;
+                        }
+                        else if (colliderY.IsTrigger)
+                        {
+                            colliderY.Trigger(colliderX);
+                            continue;
+                        }
+
+                        if (information.Detector == colliderX)
+                        {
+                            colliderX.Detect(information);
+                            colliderY.Detect(information.Reverse());
+                        }
+                        else
+                        {
+                            colliderX.Detect(information.Reverse());
+                            colliderY.Detect(information);
+                        }
+
+                        collisionResolver?.Resolve(information);
+                    }
                 }
             }
 
-            OnPhysicsIteration?.Invoke(this, intervalDeltaTime);
+            OnPhysicsIteration?.InvokeSafe(this, intervalDeltaTime);
         }
 
-        for (int i = physicsPostUpdateCollector.Count - 1; i >= 0; i--)
+        foreach (IPhysicsUpdate physicsUpdate in physicsUpdateCollector)
-            physicsPostUpdateCollector[i].PostPhysicsUpdate(deltaTime);
-
-        OnPhysicsStep?.Invoke(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++)
+        OnPhysicsStep?.InvokeSafe(this, deltaTime);
-        {
-            StepRigidBody(rigidBody, intervalDeltaTime);
-
-            for (int i = childColliders.Count - 1; i >= 0; i--)
-                childColliders[i].Recalculate();
-
-            for (int x = 0; x < childColliders.Count; x++)
-            {
-                ICollider2D? colliderX = childColliders[x];
-                if (!colliderX.IsActive)
-                    continue;
-
-                for (int y = 0; y < colliderCollector.Count; y++)
-                {
-                    ICollider2D? colliderY = colliderCollector[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)
-            return;
-
-        bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
-        if (bothCollidersAreStatic)
-            return;
-
-        if (!collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
-            return;
-
-        if (colliderX.IsTrigger)
-        {
-            colliderX.Trigger(colliderY);
-            return;
-        }
-        else if (colliderY.IsTrigger)
-        {
-            colliderY.Trigger(colliderX);
-            return;
-        }
-
-        if (information.Detector == colliderX)
-        {
-            colliderX.Detect(information);
-            colliderY.Detect(information.Reverse());
-        }
-        else
-        {
-            colliderX.Detect(information.Reverse());
-            colliderY.Detect(information);
-        }
-
-        collisionResolver?.Resolve(information);
     }
 
     private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)
@@ -174,29 +109,25 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
 
     protected override void OnEnteringUniverse(IUniverse universe)
     {
-        physicsPreUpdateCollector.Assign(universe);
         physicsUpdateCollector.Assign(universe);
-        physicsPostUpdateCollector.Assign(universe);
         colliderCollector.Assign(universe);
         rigidBodyCollector.Assign(universe);
 
-        universe.OnPreUpdate.AddListener(OnEnginePreUpdate);
+        universe.OnPreUpdate += OnEnginePreUpdate;
     }
 
     protected override void OnExitingUniverse(IUniverse universe)
     {
-        physicsPreUpdateCollector.Unassign();
         physicsUpdateCollector.Unassign();
-        physicsPostUpdateCollector.Unassign();
         colliderCollector.Unassign();
         rigidBodyCollector.Unassign();
 
-        universe.OnPreUpdate.RemoveListener(OnEnginePreUpdate);
+        universe.OnPreUpdate -= OnEnginePreUpdate;
     }
 
-    private void OnEnginePreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
+    private void OnEnginePreUpdate(IUniverse sender, UniverseTime engineTime)
     {
-        physicsTicker += args.EngineTime.DeltaTime;
+        physicsTicker += engineTime.DeltaTime;
 
         while (physicsTicker >= IterationPeriod)
         {
@@ -209,15 +140,11 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     {
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
-
-        delegateOnPreUpdate = OnEnginePreUpdate;
     }
 
     public PhysicsEngine2D(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
     {
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
-
-        delegateOnPreUpdate = OnEnginePreUpdate;
     }
 }

Engine.Physics2D/PhysicsEngine2DStandalone.cs

@@ -6,11 +6,8 @@ namespace Syntriax.Engine.Physics2D;
 
 public class PhysicsEngine2DStandalone : IPhysicsEngine2D
 {
-    public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
+    public event IPhysicsEngine2D.PhysicsIterationEventHandler? OnPhysicsIteration = null;
-    public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
+    public event IPhysicsEngine2D.PhysicsStepEventHandler? OnPhysicsStep = null;
-
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = 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 +29,13 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         foreach (ICollider2D collider2D in rigidBody.BehaviourController.GetBehaviours<ICollider2D>())
             colliders.Add(collider2D);
 
-        rigidBody.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        rigidBody.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
-        rigidBody.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
+        rigidBody.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
     }
 
     public void RemoveRigidBody(IRigidBody2D rigidBody)
     {
         rigidBodies.Remove(rigidBody);
-
-        rigidBody.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
-        rigidBody.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
     }
 
     public void Step(float deltaTime)
@@ -51,122 +45,69 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
         {
             // Can Parallel
-            for (int i = rigidBodies.Count - 1; i >= 0; i--)
+            for (int i = 0; i < rigidBodies.Count; i++)
                 StepRigidBody(rigidBodies[i], intervalDeltaTime);
 
             // Can Parallel
-            for (int i = colliders.Count - 1; i >= 0; i--)
+            foreach (ICollider2D collider in colliders)
-                colliders[i].Recalculate();
+                collider.Recalculate();
 
             // Can Parallel
             for (int x = 0; x < colliders.Count; x++)
             {
                 ICollider2D? colliderX = colliders[x];
                 if (!colliderX.IsActive)
-                    continue;
+                    return;
 
                 for (int y = x + 1; y < colliders.Count; y++)
                 {
                     ICollider2D? colliderY = colliders[y];
+
                     if (!colliderY.IsActive)
                         return;
 
-                    ResolveColliders(colliderX, colliderY);
+                    if (colliderX.RigidBody2D == colliderY.RigidBody2D)
-                }
-            }
-            OnPhysicsIteration?.Invoke(this, intervalDeltaTime);
-        }
-        OnPhysicsStep?.Invoke(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);
+                    bool bothCollidersAreTriggers = colliderX.IsTrigger && colliderX.IsTrigger == colliderY.IsTrigger;
+                    if (bothCollidersAreTriggers)
+                        continue;
+
+                    bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
+                    if (bothCollidersAreStatic)
+                        continue;
+
+                    if (collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
+                    {
+                        if (colliderX.IsTrigger)
+                        {
+                            colliderX.Trigger(colliderY);
+                            continue;
+                        }
+                        else if (colliderY.IsTrigger)
+                        {
+                            colliderY.Trigger(colliderX);
+                            continue;
+                        }
+
+                        if (information.Detector == colliderX)
+                        {
+                            colliderX.Detect(information);
+                            colliderY.Detect(information.Reverse());
+                        }
+                        else
+                        {
+                            colliderX.Detect(information.Reverse());
+                            colliderY.Detect(information);
+                        }
+
+                        collisionResolver?.Resolve(information);
+                    }
                 }
             }
+            OnPhysicsIteration?.InvokeSafe(this, intervalDeltaTime);
         }
-
+        OnPhysicsStep?.InvokeSafe(this, deltaTime);
-        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)
-            return;
-
-        bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
-        if (bothCollidersAreStatic)
-            return;
-
-        if (!collisionDetector.TryDetect(colliderX, colliderY, out CollisionDetectionInformation information))
-            return;
-
-        if (colliderX.IsTrigger)
-        {
-            colliderX.Trigger(colliderY);
-            return;
-        }
-        else if (colliderY.IsTrigger)
-        {
-            colliderY.Trigger(colliderX);
-            return;
-        }
-
-        if (information.Detector == colliderX)
-        {
-            colliderX.Detect(information);
-            colliderY.Detect(information.Reverse());
-        }
-        else
-        {
-            colliderX.Detect(information.Reverse());
-            colliderY.Detect(information);
-        }
-
-        collisionResolver?.Resolve(information);
     }
 
     private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)
@@ -178,17 +119,17 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
     }
 
-    private void OnBehaviourAdded(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
     {
-        if (args.BehaviourAdded is not ICollider2D collider2D)
+        if (behaviour is not ICollider2D collider2D)
             return;
 
         colliders.Add(collider2D);
     }
 
-    private void OnBehaviourRemoved(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
     {
-        if (args.BehaviourRemoved is not ICollider2D collider2D)
+        if (behaviour is not ICollider2D collider2D)
             return;
 
         colliders.Remove(collider2D);
@@ -198,17 +139,11 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
     {
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
-
-        delegateOnBehaviourAdded = OnBehaviourAdded;
-        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 
     public PhysicsEngine2DStandalone(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
     {
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
-
-        delegateOnBehaviourAdded = OnBehaviourAdded;
-        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 }

Engine.Serializers/Engine.Serializers.Yaml/Engine.Serializers.Yaml.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>Syntriax.Engine.Serializers.Yaml</RootNamespace>

Engine.Serializers/Engine.Serializers.Yaml/YamlSerializer.cs

@@ -20,7 +20,7 @@ public class YamlSerializer : Core.Serialization.ISerializer
     private readonly EntityRegistry entityRegistry = null!;
     private readonly IProgressionTracker progressionTracker = null!;
 
-    private readonly System.Threading.Lock Lock = new();
+    private readonly object Lock = new();
 
     public YamlSerializer()
     {

Engine.Systems/Engine.Systems.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>Syntriax.Engine.Systems</RootNamespace>

Engine.Systems/Input/IButtonInputs.cs

@@ -4,15 +4,15 @@ namespace Syntriax.Engine.Systems.Input;
 
 public interface IButtonInputs<T> : IHasStateEnable
 {
-    Event<IButtonInputs<T>, ButtonCallbackArguments> OnAnyButtonPressed { get; }
+    event ButtonCallbackEventHandler? OnAnyButtonPressed;
-    Event<IButtonInputs<T>, ButtonCallbackArguments> OnAnyButtonReleased { get; }
+    event ButtonCallbackEventHandler? OnAnyButtonReleased;
 
-    void RegisterOnPress(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
+    void RegisterOnPress(T button, ButtonCallbackEventHandler callback);
-    void UnregisterOnPress(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
+    void UnregisterOnPress(T button, ButtonCallbackEventHandler callback);
-    void RegisterOnRelease(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
+    void RegisterOnRelease(T button, ButtonCallbackEventHandler callback);
-    void UnregisterOnRelease(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
+    void UnregisterOnRelease(T button, ButtonCallbackEventHandler callback);
 
     bool IsPressed(T button);
 
-    readonly record struct ButtonCallbackArguments(T Button);
+    delegate void ButtonCallbackEventHandler(IButtonInputs<T> buttonInputs, T button);
 }

Engine.Systems/StateMachine/IState.cs

@@ -4,10 +4,10 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public interface IState : IEntity, INameable
 {
-    Event<IState> OnStateUpdate { get; }
+    event StateUpdateEventHandler? OnStateUpdate;
-    Event<IState, StateTransitionedFromArguments> OnStateTransitionedFrom { get; }
+    event StateTransitionedFromEventHandler? OnStateTransitionedFrom;
-    Event<IState, StateTransitionedToArguments> OnStateTransitionedTo { get; }
+    event StateTransitionedToEventHandler? OnStateTransitionedTo;
-    Event<IState, StateTransitionReadyArguments> OnStateTransitionReady { get; }
+    event StateTransitionReadyEventHandler? OnStateTransitionReady;
 
     IState? GetNextState();
 
@@ -15,7 +15,8 @@ public interface IState : IEntity, INameable
     void TransitionTo(IState from);
     void TransitionFrom(IState to);
 
-    readonly record struct StateTransitionedFromArguments(IState ToState);
+    delegate void StateUpdateEventHandler(IState sender);
-    readonly record struct StateTransitionedToArguments(IState FromState);
+    delegate void StateTransitionedFromEventHandler(IState sender, IState toState);
-    readonly record struct StateTransitionReadyArguments(IState ToState);
+    delegate void StateTransitionedToEventHandler(IState sender, IState fromState);
+    delegate void StateTransitionReadyEventHandler(IState sender, IState toState);
 }

Engine.Systems/StateMachine/State.cs

@@ -6,11 +6,11 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public class State : BaseEntity, IState
 {
-    public Event<IState> OnStateUpdate { get; } = new();
+    public event IState.StateUpdateEventHandler? OnStateUpdate = null;
-    public Event<IState, IState.StateTransitionedFromArguments> OnStateTransitionedFrom { get; } = new();
+    public event IState.StateTransitionedFromEventHandler? OnStateTransitionedFrom = null;
-    public Event<IState, IState.StateTransitionedToArguments> OnStateTransitionedTo { get; } = new();
+    public event IState.StateTransitionedToEventHandler? OnStateTransitionedTo = null;
-    public Event<IState, IState.StateTransitionReadyArguments> OnStateTransitionReady { get; } = new();
+    public event IState.StateTransitionReadyEventHandler? OnStateTransitionReady = null;
-    public Event<INameable, INameable.NameChangedArguments> OnNameChanged { get; } = new();
+    public event INameable.NameChangedEventHandler? OnNameChanged = null;
 
     private readonly List<StateTransition> transitions = [];
     private readonly Dictionary<string, StateTransition> possibleTransitions = [];
@@ -28,7 +28,7 @@ public class State : BaseEntity, IState
 
             string previousName = _name;
             _name = value;
-            OnNameChanged?.Invoke(this, new(previousName));
+            OnNameChanged?.Invoke(this, previousName);
         }
     }
 
@@ -53,12 +53,12 @@ public class State : BaseEntity, IState
     public void Update()
     {
         if (GetNextState() is IState transitionState)
-            OnStateTransitionReady?.Invoke(this, new(transitionState));
+            OnStateTransitionReady?.InvokeSafe(this, transitionState);
-        OnStateUpdate?.Invoke(this);
+        OnStateUpdate?.InvokeSafe(this);
     }
 
-    public void TransitionTo(IState from) => OnStateTransitionedTo?.Invoke(this, new(from));
+    public void TransitionTo(IState from) => OnStateTransitionedTo?.InvokeSafe(this, from);
-    public void TransitionFrom(IState to) => OnStateTransitionedFrom?.Invoke(this, new(to));
+    public void TransitionFrom(IState to) => OnStateTransitionedFrom?.InvokeSafe(this, to);
 
     public IState? GetNextState()
     {

Engine.Systems/StateMachine/StateBehaviourBase.cs

@@ -4,11 +4,12 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public abstract class StateBehaviourBase : Behaviour, IState
 {
-    public Event<IState> OnStateUpdate { get; } = new();
+    public event IState.StateUpdateEventHandler? OnStateUpdate = null;
-    public Event<IState, IState.StateTransitionedFromArguments> OnStateTransitionedFrom { get; } = new();
+    public event IState.StateTransitionedFromEventHandler? OnStateTransitionedFrom = null;
-    public Event<IState, IState.StateTransitionedToArguments> OnStateTransitionedTo { get; } = new();
+    public event IState.StateTransitionedToEventHandler? OnStateTransitionedTo = null;
-    public Event<IState, IState.StateTransitionReadyArguments> OnStateTransitionReady { get; } = new();
+    public event INameable.NameChangedEventHandler? OnNameChanged = null;
-    public Event<INameable, INameable.NameChangedArguments> OnNameChanged { get; } = new();
+
+    public abstract event IState.StateTransitionReadyEventHandler? OnStateTransitionReady;
 
     private string _name = string.Empty;
     public string Name
@@ -21,7 +22,7 @@ public abstract class StateBehaviourBase : Behaviour, IState
 
             string previousName = _name;
             _name = value;
-            OnNameChanged?.Invoke(this, new(previousName));
+            OnNameChanged?.Invoke(this, previousName);
         }
     }
 
@@ -29,21 +30,21 @@ public abstract class StateBehaviourBase : Behaviour, IState
     public void Update()
     {
         OnUpdateState();
-        OnStateUpdate?.Invoke(this);
+        OnStateUpdate?.InvokeSafe(this);
     }
 
     protected virtual void OnTransitionedToState(IState from) { }
     public void TransitionTo(IState from)
     {
         OnTransitionedToState(from);
-        OnStateTransitionedTo?.Invoke(this, new(from));
+        OnStateTransitionedTo?.InvokeSafe(this, from);
     }
 
     protected virtual void OnTransitionedFromState(IState to) { }
     public void TransitionFrom(IState to)
     {
         OnTransitionedFromState(to);
-        OnStateTransitionedFrom?.Invoke(this, new(to));
+        OnStateTransitionedFrom?.InvokeSafe(this, to);
     }
 
     public abstract IState? GetNextState();

Engine.Systems/StateMachine/StateMachine.cs

@@ -5,17 +5,9 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public class StateMachine : Behaviour
 {
-    public Event<StateMachine, StateChangedArguments> OnStateChanged { get; } = new();
+    public event StateChangedEventHandler? OnStateChanged = null;
-
-    private readonly Event<IState, IState.StateTransitionReadyArguments>.EventHandler delegateOnStateTransitionReady = null!;
 
     private IState _state = new State();
-
-    public StateMachine()
-    {
-        delegateOnStateTransitionReady = OnStateTransitionReady;
-    }
-
     [Serialize]
     public IState State
     {
@@ -26,20 +18,20 @@ public class StateMachine : Behaviour
                 return;
 
             IState previousState = _state;
-            previousState.OnStateTransitionReady.RemoveListener(delegateOnStateTransitionReady);
+            previousState.OnStateTransitionReady -= OnStateTransitionReady;
 
             _state = value;
             previousState.TransitionFrom(value);
             value.TransitionTo(_state);
-            OnStateChanged?.Invoke(this, new(value, previousState));
+            OnStateChanged?.InvokeSafe(this, previousState, value);
 
-            value.OnStateTransitionReady.AddListener(delegateOnStateTransitionReady);
+            value.OnStateTransitionReady += OnStateTransitionReady;
         }
     }
 
-    private void OnStateTransitionReady(IState sender, IState.StateTransitionReadyArguments args)
+    private void OnStateTransitionReady(IState sender, IState toState)
     {
-        State = args.ToState;
+        State = toState;
         while (State.GetNextState() is IState nextState)
             State = nextState;
     }
@@ -55,5 +47,5 @@ public class StateMachine : Behaviour
         State.Update();
     }
 
-    public readonly record struct StateChangedArguments(IState CurrentState, IState PreviousState);
+    public delegate void StateChangedEventHandler(StateMachine sender, IState previousState, IState newState);
 }

Engine.Systems/Time/IReadOnlyStopwatch.cs

@@ -1,19 +1,18 @@
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Systems.Time;
 
 public interface IReadOnlyStopwatch
 {
-    Event<IReadOnlyStopwatch> OnStarted { get; }
+    event StopwatchEventHandler? OnStarted;
-    Event<IReadOnlyStopwatch, StopwatchDeltaArguments> OnDelta { get; }
+    event StopwatchDeltaEventHandler? OnDelta;
-    Event<IReadOnlyStopwatch> OnStopped { get; }
+    event StopwatchEventHandler? OnStopped;
 
     double Time { get; }
 
     TimerState State { get; }
 
-    Event<IReadOnlyStopwatch> OnPaused { get; }
+    event StopwatchEventHandler? OnPaused;
-    Event<IReadOnlyStopwatch> OnResumed { get; }
+    event StopwatchEventHandler? OnResumed;
 
-    readonly record struct StopwatchDeltaArguments(double Delta);
+    delegate void StopwatchEventHandler(IReadOnlyStopwatch sender);
+    delegate void StopwatchDeltaEventHandler(IReadOnlyStopwatch sender, double delta);
 }

Engine.Systems/Time/IReadOnlyTicker.cs

@@ -1,11 +1,11 @@
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Systems.Time;
 
 public interface IReadOnlyTicker : IReadOnlyStopwatch
 {
-    Event<IReadOnlyTicker> OnTick { get; }
+    event TickerTickEventHandler? OnTick;
 
     int TickCounter { get; }
     double TickPeriod { get; set; }
+
+    delegate void TickerTickEventHandler(IReadOnlyTicker sender);
 }

Engine.Systems/Time/IReadOnlyTimer.cs

@@ -1,15 +1,13 @@
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Systems.Time;
 
 public interface IReadOnlyTimer
 {
-    Event<IReadOnlyTimer> OnStarted { get; }
+    event TimerEventHandler? OnStarted;
-    Event<IReadOnlyTimer, TimerDeltaArguments> OnDelta { get; }
+    event TimerDeltaEventHandler? OnDelta;
-    Event<IReadOnlyTimer> OnStopped { get; }
+    event TimerEventHandler? OnStopped;
 
-    Event<IReadOnlyTimer> OnPaused { get; }
+    event TimerEventHandler? OnPaused;
-    Event<IReadOnlyTimer> OnResumed { get; }
+    event TimerEventHandler? OnResumed;
 
     double StartTime { get; }
     double Remaining { get; }
@@ -18,6 +16,7 @@ public interface IReadOnlyTimer
 
     TimerState State { get; }
 
-    readonly record struct TimerDeltaArguments(double delta);
+    delegate void TimerEventHandler(IReadOnlyTimer sender);
+    delegate void TimerDeltaEventHandler(IReadOnlyTimer sender, double delta);
 
 }

Engine.Systems/Time/ITicker.cs

@@ -1,11 +1,11 @@
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Systems.Time;
 
 public interface ITicker : IStopwatch
 {
-    Event<ITicker> OnTick { get; }
+    event TickerTickEventHandler? OnTick;
 
     int TickCounter { get; }
     double Period { get; set; }
+
+    delegate void TickerTickEventHandler(ITicker sender);
 }

Engine.Systems/Time/StopwatchBehaviour.cs

@@ -4,11 +4,11 @@ namespace Syntriax.Engine.Systems.Time;
 
 public class StopwatchBehaviour : Behaviour, IStopwatch
 {
-    public Event<IReadOnlyStopwatch> OnStarted { get; } = new();
+    public event IReadOnlyStopwatch.StopwatchEventHandler? OnStarted = null;
-    public Event<IReadOnlyStopwatch, IReadOnlyStopwatch.StopwatchDeltaArguments> OnDelta { get; } = new();
+    public event IReadOnlyStopwatch.StopwatchDeltaEventHandler? OnDelta = null;
-    public Event<IReadOnlyStopwatch> OnStopped { get; } = new();
+    public event IReadOnlyStopwatch.StopwatchEventHandler? OnStopped = null;
-    public Event<IReadOnlyStopwatch> OnPaused { get; } = new();
+    public event IReadOnlyStopwatch.StopwatchEventHandler? OnPaused = null;
-    public Event<IReadOnlyStopwatch> OnResumed { get; } = new();
+    public event IReadOnlyStopwatch.StopwatchEventHandler? OnResumed = null;
 
     public double Time { get; protected set; } = 0f;
     public TimerState State { get; protected set; } = TimerState.Idle;
@@ -35,7 +35,7 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
         shouldBeTicking = false;
 
         State = TimerState.Stopped;
-        OnStopped?.Invoke(this);
+        OnStopped?.InvokeSafe(this);
     }
 
     protected override void OnUpdate()
@@ -46,7 +46,7 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
         double delta = Universe.Time.DeltaSpan.TotalSeconds;
 
         Time += delta;
-        OnDelta?.Invoke(this, new(delta));
+        OnDelta?.InvokeSafe(this, delta);
     }
 
     protected override void OnEnteredUniverse(IUniverse universe)
@@ -71,13 +71,13 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
     public virtual void Pause()
     {
         State = TimerState.Paused;
-        OnPaused?.Invoke(this);
+        OnPaused?.InvokeSafe(this);
     }
 
     public virtual void Resume()
     {
         State = TimerState.Ticking;
-        OnResumed?.Invoke(this);
+        OnResumed?.InvokeSafe(this);
     }
 
     private void StartStopwatch()
@@ -85,7 +85,7 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
         hasStartedTickingBefore = true;
 
         State = TimerState.Ticking;
-        OnStarted?.Invoke(this);
+        OnStarted?.InvokeSafe(this);
     }
 
     protected override void OnFinalize()

Engine.Systems/Time/TickerBehaviour.cs

@@ -4,7 +4,7 @@ namespace Syntriax.Engine.Systems.Time;
 
 public class TickerBehaviour : StopwatchBehaviour, ITicker
 {
-    public Event<ITicker> OnTick { get; } = new();
+    public event ITicker.TickerTickEventHandler? OnTick = null;
 
     public double Period { get; set; } = 1f;
     public int TickCounter { get; private set; } = 0;
@@ -26,7 +26,7 @@ public class TickerBehaviour : StopwatchBehaviour, ITicker
         {
             nextTick += Period;
             TickCounter++;
-            OnTick?.Invoke(this);
+            OnTick?.InvokeSafe(this);
         }
     }
 

Engine.Systems/Time/TimerBehaviour.cs

@@ -4,11 +4,11 @@ namespace Syntriax.Engine.Systems.Time;
 
 public class TimerBehaviour : Behaviour, ITimer
 {
-    public Event<IReadOnlyTimer> OnStarted { get; } = new();
+    public event IReadOnlyTimer.TimerEventHandler? OnStarted = null;
-    public Event<IReadOnlyTimer, IReadOnlyTimer.TimerDeltaArguments> OnDelta { get; } = new();
+    public event IReadOnlyTimer.TimerDeltaEventHandler? OnDelta = null;
-    public Event<IReadOnlyTimer> OnStopped { get; } = new();
+    public event IReadOnlyTimer.TimerEventHandler? OnStopped = null;
-    public Event<IReadOnlyTimer> OnPaused { get; } = new();
+    public event IReadOnlyTimer.TimerEventHandler? OnPaused = null;
-    public Event<IReadOnlyTimer> OnResumed { get; } = new();
+    public event IReadOnlyTimer.TimerEventHandler? OnResumed = null;
 
     public TimerState State { get; protected set; } = TimerState.Idle;
     public double StartTime { get; protected set; } = 0f;
@@ -50,7 +50,7 @@ public class TimerBehaviour : Behaviour, ITimer
         shouldBeTicking = false;
 
         State = TimerState.Stopped;
-        OnStopped?.Invoke(this);
+        OnStopped?.InvokeSafe(this);
     }
 
     protected override void OnUpdate()
@@ -61,7 +61,7 @@ public class TimerBehaviour : Behaviour, ITimer
         double delta = Universe.Time.DeltaSpan.TotalSeconds;
 
         Remaining -= delta;
-        OnDelta?.Invoke(this, new(delta));
+        OnDelta?.InvokeSafe(this, delta);
 
         if (Remaining <= .0f)
             Stop();
@@ -89,13 +89,13 @@ public class TimerBehaviour : Behaviour, ITimer
     public virtual void Pause()
     {
         State = TimerState.Paused;
-        OnPaused?.Invoke(this);
+        OnPaused?.InvokeSafe(this);
     }
 
     public virtual void Resume()
     {
         State = TimerState.Ticking;
-        OnResumed?.Invoke(this);
+        OnResumed?.InvokeSafe(this);
     }
 
     private void StartTimer()
@@ -103,7 +103,7 @@ public class TimerBehaviour : Behaviour, ITimer
         hasStartedTickingBefore = true;
 
         State = TimerState.Ticking;
-        OnStarted?.Invoke(this);
+        OnStarted?.InvokeSafe(this);
     }
 
     protected override void OnFinalize()

Engine.Systems/Tween/EngineExtensions/TweenAABBExtensions.cs

@@ -6,5 +6,5 @@ namespace Syntriax.Engine.Systems.Tween;
 public static class TweenAABBExtensions
 {
     public static ITween TweenAABB(this AABB initialAABB, ITweenManager tweenManager, float duration, AABB targetAABB, Action<AABB> setMethod)
-        => tweenManager.StartTween(duration, t => setMethod?.Invoke(new AABB(initialAABB.LowerBoundary.Lerp(targetAABB.LowerBoundary, t), initialAABB.UpperBoundary.Lerp(targetAABB.UpperBoundary, t))));
+        => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(new AABB(initialAABB.LowerBoundary.Lerp(targetAABB.LowerBoundary, t), initialAABB.UpperBoundary.Lerp(targetAABB.UpperBoundary, t))));
 }

Engine.Systems/Tween/EngineExtensions/TweenCircleExtensions.cs

@@ -6,7 +6,7 @@ public static class TweenCircleExtensions
 {
     public static ITween TweenCircle(this Circle initialCircle, ITweenManager tweenManager, float duration, Circle targetCircle, System.Action<Circle> setMethod)
         => tweenManager.StartTween(duration,
-            t => setMethod?.Invoke(
+            t => setMethod?.InvokeSafe(
                 new Circle(
                     initialCircle.Center.Lerp(targetCircle.Center, t),
                     initialCircle.Diameter.Lerp(targetCircle.Diameter, t)

Engine.Systems/Tween/EngineExtensions/TweenColorExtensions.cs

@@ -5,11 +5,11 @@ namespace Syntriax.Engine.Systems.Tween;
 public static class TweenColorExtensions
 {
     public static ITween TweenColor(this ColorRGB initialColorRGB, ITweenManager tweenManager, float duration, ColorRGB targetColorRGB, System.Action<ColorRGB> setMethod)
-        => tweenManager.StartTween(duration, t => setMethod?.Invoke(initialColorRGB.Lerp(targetColorRGB, t)));
+        => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(initialColorRGB.Lerp(targetColorRGB, t)));
 
     public static ITween TweenColor(this ColorRGBA initialColorRGBA, ITweenManager tweenManager, float duration, ColorRGBA targetColorRGBA, System.Action<ColorRGBA> setMethod)
-        => tweenManager.StartTween(duration, t => setMethod?.Invoke(initialColorRGBA.Lerp(targetColorRGBA, t)));
+        => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(initialColorRGBA.Lerp(targetColorRGBA, t)));
 
     public static ITween TweenColor(this ColorHSV initialColorHSV, ITweenManager tweenManager, float duration, ColorHSV targetColorHSV, System.Action<ColorHSV> setMethod)
-        => tweenManager.StartTween(duration, t => setMethod?.Invoke(initialColorHSV.Lerp(targetColorHSV, t)));
+        => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(initialColorHSV.Lerp(targetColorHSV, t)));
 }

Engine.Systems/Tween/EngineExtensions/TweenLine2DEquationExtensions.cs

@@ -6,7 +6,7 @@ public static class TweenLine2DEquationExtensions
 {
     public static ITween TweenLine2DEquation(this Line2DEquation initialLine2DEquation, ITweenManager tweenManager, float duration, Line2DEquation targetLine2DEquation, System.Action<Line2DEquation> setMethod)
         => tweenManager.StartTween(duration,
-            t => setMethod?.Invoke(
+            t => setMethod?.InvokeSafe(
                 new Line2DEquation(
                     initialLine2DEquation.Slope.Lerp(targetLine2DEquation.Slope, t),
                     initialLine2DEquation.OffsetY.Lerp(targetLine2DEquation.OffsetY, t)

Engine.Systems/Tween/EngineExtensions/TweenLine2DExtensions.cs

@@ -6,7 +6,7 @@ public static class TweenLine2DExtensions
 {
     public static ITween TweenLine2D(this Line2D initialLine2D, ITweenManager tweenManager, float duration, Line2D targetLine2D, System.Action<Line2D> setMethod)
         => tweenManager.StartTween(duration,
-            t => setMethod?.Invoke(
+            t => setMethod?.InvokeSafe(
                 new Line2D(
                     initialLine2D.From.Lerp(targetLine2D.From, t),
                     initialLine2D.To.Lerp(targetLine2D.To, t)

Engine.Systems/Tween/EngineExtensions/TweenProjection1DExtensions.cs

@@ -7,7 +7,7 @@ public static class TweenProjection1DExtensions
 {
     public static ITween TweenProjection1D(this Projection1D initialProjection1D, ITweenManager tweenManager, float duration, Projection1D targetProjection1D, Action<Projection1D> setMethod)
         => tweenManager.StartTween(duration,
-            t => setMethod?.Invoke(
+            t => setMethod?.InvokeSafe(
                 new Projection1D(
                     initialProjection1D.Min.Lerp(targetProjection1D.Min, t),
                     initialProjection1D.Max.Lerp(targetProjection1D.Max, t)

Engine.Systems/Tween/EngineExtensions/TweenQuaternionExtensions.cs

@@ -6,5 +6,5 @@ namespace Syntriax.Engine.Systems.Tween;
 public static class TweenQuaternionExtensions
 {
     public static ITween TweenQuaternion(this Quaternion initialQuaternion, ITweenManager tweenManager, float duration, Quaternion targetQuaternion, Action<Quaternion> setMethod)
-       => tweenManager.StartTween(duration, t => setMethod?.Invoke(initialQuaternion.SLerp(targetQuaternion, t)));
+       => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(initialQuaternion.SLerp(targetQuaternion, t)));
 }

Engine.Systems/Tween/EngineExtensions/TweenTransform2DExtensions.cs

@@ -39,69 +39,4 @@ public static class TweenTransform2DExtensions
         float initialLocalRotation = transform2D.LocalRotation;
         return tweenManager.StartTween(duration, t => transform2D.LocalRotation = initialLocalRotation.Lerp(targetLocalRotation, t));
     }
-    public static ITween TweenPositionAdditive(this ITransform2D transform2D, ITweenManager tweenManager, float duration, Vector2D additivePosition)
-    {
-        Vector2D progressedPosition = Vector2D.Zero;
-        return tweenManager.StartTween(duration, t =>
-        {
-            Vector2D displacement = Vector2D.Zero.Lerp(additivePosition, t) - progressedPosition;
-            transform2D.Position += displacement;
-            progressedPosition += displacement;
-        });
-    }
-
-    public static ITween TweenScaleAdditive(this ITransform2D transform2D, ITweenManager tweenManager, float duration, Vector2D additiveScale)
-    {
-        Vector2D progressedScale = Vector2D.Zero;
-        return tweenManager.StartTween(duration, t =>
-        {
-            Vector2D displacement = Vector2D.Zero.Lerp(additiveScale, t) - progressedScale;
-            transform2D.Scale += displacement;
-            progressedScale += displacement;
-        });
-    }
-
-    public static ITween TweenRotationAdditive(this ITransform2D transform2D, ITweenManager tweenManager, float duration, float additiveRotation)
-    {
-        float progressedRotation = 0f;
-        return tweenManager.StartTween(duration, t =>
-        {
-            float displacement = 0f.Lerp(additiveRotation, t) - progressedRotation;
-            transform2D.Rotation += displacement;
-            progressedRotation += displacement;
-        });
-    }
-
-    public static ITween TweenLocalPositionAdditive(this ITransform2D transform2D, ITweenManager tweenManager, float duration, Vector2D additiveLocalPosition)
-    {
-        Vector2D progressedLocalPosition = Vector2D.Zero;
-        return tweenManager.StartTween(duration, t =>
-        {
-            Vector2D displacement = Vector2D.Zero.Lerp(additiveLocalPosition, t) - progressedLocalPosition;
-            transform2D.LocalPosition += displacement;
-            progressedLocalPosition += displacement;
-        });
-    }
-
-    public static ITween TweenLocalScaleAdditive(this ITransform2D transform2D, ITweenManager tweenManager, float duration, Vector2D additiveLocalScale)
-    {
-        Vector2D progressedLocalScale = Vector2D.Zero;
-        return tweenManager.StartTween(duration, t =>
-        {
-            Vector2D displacement = Vector2D.Zero.Lerp(additiveLocalScale, t) - progressedLocalScale;
-            transform2D.LocalScale += displacement;
-            progressedLocalScale += displacement;
-        });
-    }
-
-    public static ITween TweenLocalRotationAdditive(this ITransform2D transform2D, ITweenManager tweenManager, float duration, float additiveLocalRotation)
-    {
-        float progressedLocalRotation = 0f;
-        return tweenManager.StartTween(duration, t =>
-        {
-            float displacement = 0f.Lerp(additiveLocalRotation, t) - progressedLocalRotation;
-            transform2D.LocalRotation += displacement;
-            progressedLocalRotation += displacement;
-        });
-    }
 }

Engine.Systems/Tween/EngineExtensions/TweenTriangleExtensions.cs

@@ -7,7 +7,7 @@ public static class TweenTriangleExtensions
 {
     public static ITween TweenTriangle(this Triangle initialTriangle, ITweenManager tweenManager, float duration, Triangle targetTriangle, Action<Triangle> setMethod)
        => tweenManager.StartTween(duration,
-            t => setMethod?.Invoke(
+            t => setMethod?.InvokeSafe(
                 new Triangle(
                     initialTriangle.A.Lerp(targetTriangle.A, t),
                     initialTriangle.B.Lerp(targetTriangle.B, t),

Engine.Systems/Tween/EngineExtensions/TweenVector2DExtensions.cs

@@ -5,5 +5,5 @@ namespace Syntriax.Engine.Systems.Tween;
 public static class TweenVector2DExtensions
 {
     public static ITween TweenVector2D(this Vector2D initialVector2D, ITweenManager tweenManager, float duration, Vector2D targetVector2D, System.Action<Vector2D> setMethod)
-        => tweenManager.StartTween(duration, t => setMethod?.Invoke(initialVector2D.Lerp(targetVector2D, t)));
+        => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(initialVector2D.Lerp(targetVector2D, t)));
 }

Engine.Systems/Tween/EngineExtensions/TweenVector3DExtensions.cs

@@ -5,5 +5,5 @@ namespace Syntriax.Engine.Systems.Tween;
 public static class TweenVector3DExtensions
 {
     public static ITween TweenVector3D(this Vector3D initialVector3D, ITweenManager tweenManager, float duration, Vector3D targetVector3D, System.Action<Vector3D> setMethod)
-        => tweenManager.StartTween(duration, t => setMethod?.Invoke(initialVector3D.Lerp(targetVector3D, t)));
+        => tweenManager.StartTween(duration, t => setMethod?.InvokeSafe(initialVector3D.Lerp(targetVector3D, t)));
 }

Engine.Systems/Tween/ITween.cs

@@ -1,18 +1,16 @@
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Systems.Tween;
 
 public interface ITween
 {
-    Event<ITween> OnStarted { get; }
+    event TweenEventHandler? OnStarted;
-    Event<ITween> OnPaused { get; }
+    event TweenEventHandler? OnPaused;
-    Event<ITween> OnResumed { get; }
+    event TweenEventHandler? OnResumed;
-    Event<ITween> OnCancelled { get; }
+    event TweenEventHandler? OnCancelled;
-    Event<ITween> OnCompleted { get; }
+    event TweenEventHandler? OnCompleted;
-    Event<ITween> OnEnded { get; }
+    event TweenEventHandler? OnEnded;
 
-    Event<ITween> OnUpdated { get; }
+    event TweenEventHandler? OnUpdated;
-    Event<ITween, TweenDeltaArguments> OnDeltaUpdated { get; }
+    event TweenDeltaEventHandler? OnDeltaUpdated;
 
     TweenState State { get; set; }
 
@@ -21,6 +19,7 @@ public interface ITween
     float Progress { get; }
     float Value { get; }
 
-    readonly record struct TweenDeltaArguments(float Delta);
+    delegate void TweenEventHandler(ITween sender);
+    delegate void TweenDeltaEventHandler(ITween sender, float delta);
 }
 

Engine.Systems/Tween/Tween.cs

@@ -4,14 +4,14 @@ namespace Syntriax.Engine.Systems.Tween;
 
 internal class Tween : ITween
 {
-    public Event<ITween> OnStarted { get; } = new();
+    public event ITween.TweenEventHandler? OnStarted = null;
-    public Event<ITween> OnPaused { get; } = new();
+    public event ITween.TweenEventHandler? OnPaused = null;
-    public Event<ITween> OnResumed { get; } = new();
+    public event ITween.TweenEventHandler? OnResumed = null;
-    public Event<ITween> OnCancelled { get; } = new();
+    public event ITween.TweenEventHandler? OnCancelled = null;
-    public Event<ITween> OnCompleted { get; } = new();
+    public event ITween.TweenEventHandler? OnCompleted = null;
-    public Event<ITween> OnEnded { get; } = new();
+    public event ITween.TweenEventHandler? OnEnded = null;
-    public Event<ITween> OnUpdated { get; } = new();
+    public event ITween.TweenEventHandler? OnUpdated = null;
-    public Event<ITween, ITween.TweenDeltaArguments> OnDeltaUpdated { get; } = new();
+    public event ITween.TweenDeltaEventHandler? OnDeltaUpdated = null;
 
     private TweenState _state = TweenState.Idle;
     public TweenState State
@@ -26,14 +26,14 @@ internal class Tween : ITween
             _state = value;
             switch (value)
             {
-                case TweenState.Completed: OnCompleted?.Invoke(this); OnEnded?.Invoke(this); break;
+                case TweenState.Completed: OnCompleted?.InvokeSafe(this); OnEnded?.InvokeSafe(this); break;
-                case TweenState.Cancelled: OnCancelled?.Invoke(this); OnEnded?.Invoke(this); break;
+                case TweenState.Cancelled: OnCancelled?.InvokeSafe(this); OnEnded?.InvokeSafe(this); break;
-                case TweenState.Paused: OnPaused?.Invoke(this); break;
+                case TweenState.Paused: OnPaused?.InvokeSafe(this); break;
                 case TweenState.Playing:
                     if (previousState == TweenState.Idle)
-                        OnStarted?.Invoke(this);
+                        OnStarted?.InvokeSafe(this);
                     else
-                        OnResumed?.Invoke(this);
+                        OnResumed?.InvokeSafe(this);
                     break;
             }
         }
@@ -58,9 +58,9 @@ internal class Tween : ITween
 
             _counter = value.Min(Duration).Max(0f);
             Progress = Counter / Duration;
-            OnUpdated?.Invoke(this);
+            OnUpdated?.InvokeSafe(this);
 
-            OnDeltaUpdated?.Invoke(this, new(Easing.Evaluate(Progress) - Easing.Evaluate(previousProgress)));
+            OnDeltaUpdated?.InvokeSafe(this, Easing.Evaluate(Progress) - Easing.Evaluate(previousProgress));
 
             if (_counter >= Duration)
                 State = TweenState.Completed;
@@ -74,22 +74,6 @@ internal class Tween : ITween
         State = TweenState.Idle;
     }
 
-    internal void Wipe()
-    {
-        OnStarted.Clear();
-        OnPaused.Clear();
-        OnResumed.Clear();
-        OnCancelled.Clear();
-        OnCompleted.Clear();
-        OnEnded.Clear();
-        OnUpdated.Clear();
-        OnDeltaUpdated.Clear();
-
-        Easing = EaseLinear.Instance;
-
-        Reset();
-    }
-
     public Tween() { }
     public Tween(float duration)
     {

Engine.Systems/Tween/TweenExtensions.cs

@@ -1,5 +1,7 @@
 using System;
 
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Systems.Tween;
 
 public static class TweenExtensions
@@ -9,14 +11,14 @@ public static class TweenExtensions
         Tween tweenConcrete = (Tween)tween;
         int counter = count;
 
-        tweenConcrete.OnCompleted.AddListener(_ =>
+        tweenConcrete.OnCompleted += _ =>
         {
             if (counter-- <= 0)
                 return;
 
             tweenConcrete.Reset();
             tweenConcrete.State = TweenState.Playing;
-        });
+        };
 
         return tween;
     }
@@ -24,11 +26,11 @@ public static class TweenExtensions
     public static ITween LoopInfinitely(this ITween tween)
     {
         Tween tweenConcrete = (Tween)tween;
-        tweenConcrete.OnCompleted.AddListener(_ =>
+        tweenConcrete.OnCompleted += _ =>
         {
             tweenConcrete.Reset();
             tweenConcrete.State = TweenState.Playing;
-        });
+        };
 
         return tween;
     }
@@ -43,49 +45,57 @@ public static class TweenExtensions
 
     public static ITween OnStart(this ITween tween, Action callback)
     {
-        tween.OnStarted.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnStarted += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnPause(this ITween tween, Action callback)
     {
-        tween.OnPaused.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnPaused += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnResume(this ITween tween, Action callback)
     {
-        tween.OnResumed.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnResumed += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnCancel(this ITween tween, Action callback)
     {
-        tween.OnCancelled.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnCancelled += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnComplete(this ITween tween, Action callback)
     {
-        tween.OnCompleted.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnCompleted += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnEnd(this ITween tween, Action callback)
     {
-        tween.OnEnded.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnEnded += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnUpdate(this ITween tween, Action callback)
     {
-        tween.OnUpdated.AddListener(_ => callback.Invoke());
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnUpdated += _ => callback.InvokeSafe();
         return tween;
     }
 
     public static ITween OnDeltaUpdate(this ITween tween, Action<float> callback)
     {
-        tween.OnDeltaUpdated.AddListener((_, arguments) => callback.Invoke(arguments.Delta));
+        Tween tweenConcrete = (Tween)tween;
+        tweenConcrete.OnDeltaUpdated += (_, delta) => callback.InvokeSafe(delta);
         return tween;
     }
 }

Engine.Systems/Tween/TweenManager.cs

@@ -8,36 +8,17 @@ 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 = [];
 
     public ITween StartTween(float duration, ITweenManager.TweenSetCallback? setCallback = null)
     {
-        Tween tween = Get(duration);
+        Tween tween = new(duration);
-        tween.OnUpdated.AddListener(tween => setCallback?.Invoke(tween.Value));
+        tween.OnUpdated += tween => setCallback?.InvokeSafe(tween.Value);
         runningCoroutines.Add(tween, coroutineManager.StartCoroutine(RunTween(tween)));
         return tween;
     }
 
-    private Tween Get(float duration)
-    {
-        if (!queue.TryDequeue(out Tween? result))
-            result = new(duration);
-
-        result.Duration = duration;
-        return result;
-    }
-
-    private void Return(Tween tween)
-    {
-        if (queue.Contains(tween))
-            return;
-
-        tween.Wipe();
-        queue.Enqueue(tween);
-    }
-
     private IEnumerator RunTween(Tween tween)
     {
         tween.State = TweenState.Playing;
@@ -59,7 +40,6 @@ public class TweenManager : UniverseObject, ITweenManager
         }
 
         runningCoroutines.Remove(tween);
-        Return(tween);
     }
 
     public void CancelTween(ITween tween)

Engine/Engine.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>Syntriax.Engine</RootNamespace>