fix: tween reset caused issues

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Engine.Serializers/YamlDotNet"]
+	path = Engine.Serializers/YamlDotNet
+	url = git@github.com:Syntriax/YamlDotNet.git

Engine.Core/.gitignore

@@ -482,3 +482,5 @@ $RECYCLE.BIN/
 
 # Vim temporary swap files
 *.swp
+
+!Debug

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 UnassignEventHandler? OnUnassigned;
+    Event<IAssignable>? OnUnassigned { get; }
 
     /// <summary>
     /// Unassign <see cref="IAssignable"/>'s all fields and make it ready to recycle.
@@ -17,6 +17,4 @@ 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 BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned;
+    Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; }
 
     /// <inheritdoc cref="IBehaviourController" />
     IBehaviourController BehaviourController { get; }
@@ -21,6 +21,4 @@ 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 EntityAssignedEventHandler? OnEntityAssigned;
+    Event<IHasEntity> OnEntityAssigned { get; }
 
     /// <inheritdoc cref="IEntity" />
     IEntity Entity { get; }
@@ -21,6 +21,4 @@ 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 StateEnableAssignedEventHandler? OnStateEnableAssigned;
+    Event<IHasStateEnable> OnStateEnableAssigned { get; }
 
     /// <inheritdoc cref="IStateEnable" />
     IStateEnable StateEnable { get; }
@@ -21,6 +21,4 @@ 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 UniverseAssignedEventHandler? OnUniverseAssigned;
+    Event<IHasUniverse> OnUniverseAssigned { get; }
 
     /// <inheritdoc cref="IUniverse" />
     IUniverse Universe { get; }
@@ -21,6 +21,4 @@ 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 UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned;
+    Event<IHasUniverseObject> OnUniverseObjectAssigned { get; }
 
     /// <inheritdoc cref="IUniverseObject" />
     IUniverseObject UniverseObject { get; }
@@ -21,6 +21,4 @@ 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 ActiveChangedEventHandler? OnActiveChanged;
+    Event<IActive, ActiveChangedArguments> OnActiveChanged { get; }
 
     /// <summary>
     /// The value indicating whether the <see cref="IActive"/> is enabled.
     /// </summary>
     bool IsActive { get; }
 
-    delegate void ActiveChangedEventHandler(IActive sender, bool previousState);
+    readonly record struct ActiveChangedArguments(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 PriorityChangedEventHandler? OnPriorityChanged;
+    Event<IBehaviour, PriorityChangedArguments> OnPriorityChanged { get; }
 
     /// <summary>
     /// The priority of the <see cref="IBehaviour"/>.
     /// </summary>
     int Priority { get; set; }
 
-    delegate void PriorityChangedEventHandler(IBehaviour sender, int previousPriority);
+    readonly record struct PriorityChangedArguments(int PreviousPriority);
 }

Engine.Core/Abstract/IBehaviourCollector.cs

@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace Syntriax.Engine.Core;
 
 /// <summary>
@@ -7,29 +5,38 @@ 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, IEnumerable<T> where T : class
+public interface IBehaviourCollector<T> : IHasUniverse where T : class
 {
     /// <summary>
     /// Event triggered when an object of type <typeparamref name="T"/> is added to the collector.
     /// </summary>
-    event CollectedEventHandler? OnCollected;
+    Event<IBehaviourCollector<T>, BehaviourCollectedArguments> OnCollected { get; }
 
     /// <summary>
     /// Event triggered when an object of type <typeparamref name="T"/> is removed from the collector.
     /// </summary>
-    event RemovedEventHandler? OnRemoved;
+    Event<IBehaviourCollector<T>, BehaviourRemovedArguments> OnRemoved { get; }
+
+    /// <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>
-    delegate void CollectedEventHandler(IBehaviourCollector<T> sender, T behaviourCollected);
+    readonly record struct BehaviourCollectedArguments(T BehaviourCollected);
 
     /// <summary>
     /// Delegate for handling the <see cref="OnRemoved"/> event.
     /// </summary>
-    /// <param name="sender">The instance of the <see cref="IBehaviourCollector{T}"/> that triggered the event.</param>
-    /// <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);
+    /// <param name="BehaviourRemoved">The object of type <typeparamref name="T"/> that was removed from the collector.</param>
+    readonly record struct BehaviourRemovedArguments(T BehaviourRemoved);
 }

Engine.Core/Abstract/IBehaviourController.cs

@@ -3,34 +3,29 @@ using System.Collections.Generic;
 namespace Syntriax.Engine.Core;
 
 /// <summary>
-/// Represents a controller for managing <see cref="IBehaviour"/>s and notify them accordingly about the engine's updates. Connected to an <see cref="IUniverseObject"/>.
+/// Represents a controller for managing <see cref="IBehaviour"/>s. Connected to an <see cref="IUniverseObject"/>.
 /// </summary>
-public interface IBehaviourController : IInitializable, IHasUniverseObject, IEnumerable<IBehaviour>
+public interface IBehaviourController : IEntity, IHasUniverseObject
 {
-    /// <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 BehaviourAddedEventHandler? OnBehaviourAdded;
+    Event<IBehaviourController, BehaviourAddedArguments> OnBehaviourAdded { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is removed from the <see cref="IBehaviourController"/>.
     /// </summary>
-    event BehaviourRemovedEventHandler? OnBehaviourRemoved;
+    Event<IBehaviourController, BehaviourRemovedArguments> OnBehaviourRemoved { get; }
+
+    /// <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"/>.
@@ -83,20 +78,6 @@ public interface IBehaviourController : IInitializable, IHasUniverseObject, IEnu
     /// <param name="behaviour">The <see cref="IBehaviour"/> to remove.</param>
     void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour;
 
-    /// <summary>
-    /// 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);
-
+    readonly record struct BehaviourAddedArguments(IBehaviour BehaviourAdded);
+    readonly record struct BehaviourRemovedArguments(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 IdChangedEventHandler? OnIdChanged;
+    Event<IEntity, IdChangedArguments> OnIdChanged { get; }
 
     /// <summary>
     /// The ID of the <see cref="IEntity"/>.
     /// </summary>
     string Id { get; set; }
 
-    delegate void IdChangedEventHandler(IEntity sender, string previousId);
+    readonly record struct IdChangedArguments(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 InitializedEventHandler? OnInitialized;
+    Event<IInitializable> OnInitialized { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="IInitializable"/> method is called successfully.
     /// </summary>
-    event FinalizedEventHandler? OnFinalized;
+    Event<IInitializable> OnFinalized { get; }
 
     /// <summary>
     /// The value indicating whether the entity has been initialized.
@@ -31,7 +31,4 @@ 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 NameChangedEventHandler? OnNameChanged;
+    Event<INameable, NameChangedArguments> OnNameChanged { get; }
 
     /// <summary>
     /// The name of the entity.
     /// </summary>
     string Name { get; set; }
 
-    delegate void NameChangedEventHandler(INameable sender, string previousName);
+    readonly record struct NameChangedArguments(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 EnabledChangedEventHandler? OnEnabledChanged;
+    Event<IStateEnable, EnabledChangedArguments> OnEnabledChanged { get; }
 
     /// <summary>
     /// The value indicating whether the <see cref="IStateEnable"/> is enabled.
     /// </summary>
     bool Enabled { get; set; }
 
-    delegate void EnabledChangedEventHandler(IStateEnable sender, bool previousState);
+    readonly record struct EnabledChangedArguments(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 PositionChangedEventHandler? OnPositionChanged;
+    Event<ITransform2D, PositionChangedArguments> OnPositionChanged { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="Scale"/> of the <see cref="ITransform2D"/> changes.
     /// </summary>
-    event ScaleChangedEventHandler? OnScaleChanged;
+    Event<ITransform2D, ScaleChangedArguments> OnScaleChanged { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="Rotation"/> of the <see cref="ITransform"/> changes.
     /// </summary>
-    event RotationChangedEventHandler? OnRotationChanged;
+    Event<ITransform2D, RotationChangedArguments> OnRotationChanged { get; }
 
     /// <summary>
     /// The world position of the <see cref="ITransform2D"/> in 2D space.
@@ -51,23 +51,20 @@ public interface ITransform2D : IBehaviour
     float LocalRotation { get; set; }
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
-    /// <param name="previousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
-    delegate void PositionChangedEventHandler(ITransform2D sender, Vector2D previousPosition);
+    /// <param name="PreviousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct PositionChangedArguments(Vector2D PreviousPosition);
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
-    /// <param name="previousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
-    delegate void ScaleChangedEventHandler(ITransform2D sender, Vector2D previousScale);
+    /// <param name="PreviousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct ScaleChangedArguments(Vector2D PreviousScale);
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
-    /// <param name="previousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
-    delegate void RotationChangedEventHandler(ITransform2D sender, float previousRotation);
+    /// <param name="PreviousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct RotationChangedArguments(float PreviousRotation);
 }

Engine.Core/Abstract/IUniverse.cs

@@ -10,32 +10,47 @@ 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 UpdateEventHandler? OnPreUpdate;
+    Event<IUniverse, UpdateArguments> OnPreUpdate { get; }
 
     /// <summary>
     /// Event triggered when <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    event UpdateEventHandler? OnUpdate;
+    Event<IUniverse, UpdateArguments> OnUpdate { get; }
 
     /// <summary>
-    /// Event triggered when <see cref="PreDraw"/> is called on the <see cref="IUniverse"/>.
+    /// Event triggered after <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    event PreDrawEventHandler? OnPreDraw;
+    Event<IUniverse, UpdateArguments> OnPostUpdate { get; }
+
+    /// <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 UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered;
+    Event<IUniverse, UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is unregistered from the <see cref="IUniverse"/>.
     /// </summary>
-    event UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered;
+    Event<IUniverse, UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; }
 
     /// <summary>
     /// Event triggered when <see cref="TimeScale"/> is changed on the <see cref="IUniverse"/>.
     /// </summary>
-    event TimeScaleChangedEventHandler? OnTimeScaleChanged;
+    Event<IUniverse, TimeScaleChangedArguments> OnTimeScaleChanged { get; }
 
     /// <summary>
     /// Current time scale the <see cref="IUniverse"/> operates on.
@@ -84,15 +99,12 @@ public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
     void Update(UniverseTime universeTime);
 
     /// <summary>
-    /// Performs operations that should be done before the draw calls.
+    /// Performs operations that should be done to the draw.
     /// </summary>
-    void PreDraw();
+    void Draw();
 
-    delegate void TimeScaleChangedEventHandler(IUniverse sender, float previousTimeScale);
-
-    delegate void UpdateEventHandler(IUniverse sender, UniverseTime engineTime);
-    delegate void PreDrawEventHandler(IUniverse sender);
-
-    delegate void UniverseObjectRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectRegistered);
-    delegate void UniverseObjectUnRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectUnregistered);
+    readonly record struct TimeScaleChangedArguments(float PreviousTimeScale);
+    readonly record struct UpdateArguments(UniverseTime EngineTime);
+    readonly record struct UniverseObjectRegisteredArguments(IUniverseObject UniverseObjectRegistered);
+    readonly record struct UniverseObjectUnRegisteredArguments(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 EnteredUniverseEventHandler? OnEnteredUniverse;
+    Event<IUniverseObject, EnteredUniverseArguments> OnEnteredUniverse { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> exits the universe.
     /// </summary>
-    event ExitedUniverseEventHandler? OnExitedUniverse;
+    Event<IUniverseObject, ExitedUniverseArguments> OnExitedUniverse { get; }
 
     /// <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 ParentChangedEventHandler? OnParentChanged;
+    Event<IUniverseObject, ParentChangedArguments> OnParentChanged { get; }
 
     /// <summary>
     /// Event triggered when a new <see cref="IUniverseObject"/> is added to the <see cref="Children"/>.
     /// </summary>
-    event ChildrenAddedEventHandler? OnChildrenAdded;
+    Event<IUniverseObject, ChildrenAddedArguments> OnChildrenAdded { get; }
 
     /// <summary>
     /// Event triggered when an <see cref="IUniverseObject"/> is removed from the <see cref="Children"/>.
     /// </summary>
-    event ChildrenRemovedEventHandler? OnChildrenRemoved;
+    Event<IUniverseObject, ChildrenRemovedArguments> OnChildrenRemoved { get; }
 
     /// <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>
-    /// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> enters the universe of a <see cref="IUniverse">.
+    /// Arguments 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>
-    delegate void EnteredUniverseEventHandler(IUniverseObject sender, IUniverse universe);
+    readonly record struct EnteredUniverseArguments(IUniverse Universe);
 
     /// <summary>
-    /// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> exits the universe of a <see cref="IUniverse">.
+    /// Arguments 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>
-    delegate void ExitedUniverseEventHandler(IUniverseObject sender, IUniverse universe);
+    readonly record struct ExitedUniverseArguments(IUniverse Universe);
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="IUniverseObject"/>'s parent changes.
+    /// Arguments 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>
-    delegate void ParentChangedEventHandler(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent);
+    readonly record struct ParentChangedArguments(IUniverseObject? PreviousParent, IUniverseObject? CurrentParent);
 
     /// <summary>
-    /// Delegate for the event triggered when a new <see cref="IUniverseObject"/> added as a child.
+    /// Arguments 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>
-    delegate void ChildrenAddedEventHandler(IUniverseObject sender, IUniverseObject childrenAdded);
+    readonly record struct ChildrenAddedArguments(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>
-    delegate void ChildrenRemovedEventHandler(IUniverseObject sender, IUniverseObject childrenRemoved);
+    readonly record struct ChildrenRemovedArguments(IUniverseObject ChildrenRemoved);
 }

Engine.Core/ActiveBehaviourCollector.cs

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

Engine.Core/ActiveBehaviourCollectorSorted.cs

@@ -22,7 +22,4 @@ public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> whe
         if (SortBy is not null)
             activeBehaviours.Sort(SortBy);
     }
-
-    public ActiveBehaviourCollectorSorted() { }
-    public ActiveBehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe) => SortBy = sortBy;
 }

Engine.Core/BaseEntity.cs

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

Engine.Core/Behaviour.cs

@@ -1,17 +1,23 @@
 namespace Syntriax.Engine.Core;
 
-public abstract class Behaviour : BehaviourBase
+public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
+    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 cachedEnteredUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler cachedExitedUniverse = null!;
+
     public Behaviour()
     {
-        OnInitialized += OnInitialize;
-        OnFinalized += OnFinalize;
-        OnUnassigned += OnUnassign;
+        OnInitialized.AddListener(OnInitialize);
+        OnFinalized.AddListener(OnFinalize);
+        OnUnassigned.AddListener(OnUnassign);
+
+        cachedEnteredUniverse = EnteredUniverse;
+        cachedExitedUniverse = ExitedUniverse;
     }
 
     protected virtual void OnUnassign() { }
@@ -20,64 +26,53 @@ public abstract class Behaviour : BehaviourBase
     protected virtual void OnInitialize() { }
     protected virtual void OnInitialize(IInitializable _)
     {
-        isInitializedThisFrame = true;
-
-        BehaviourController.OnPreUpdate += PreUpdate;
-        BehaviourController.OnPreDraw += PreDraw;
-        BehaviourController.OnUpdate += Update;
-        BehaviourController.UniverseObject.OnEnteredUniverse += EnteredUniverse;
-        BehaviourController.UniverseObject.OnExitedUniverse += ExitedUniverse;
+        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(cachedEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(cachedExitedUniverse);
 
         OnInitialize();
 
         if (UniverseObject.IsInUniverse)
-            EnteredUniverse(UniverseObject, Universe);
+            EnteredUniverse(UniverseObject, new(Universe));
     }
 
     protected virtual void OnFinalize() { }
     protected virtual void OnFinalize(IInitializable _)
     {
-        BehaviourController.OnPreUpdate -= PreUpdate;
-        BehaviourController.OnPreDraw -= PreDraw;
-        BehaviourController.OnUpdate -= Update;
-        BehaviourController.UniverseObject.OnEnteredUniverse -= EnteredUniverse;
-        BehaviourController.UniverseObject.OnExitedUniverse -= ExitedUniverse;
+        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(cachedEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(cachedExitedUniverse);
 
         OnFinalize();
 
         if (UniverseObject.IsInUniverse)
-            ExitedUniverse(UniverseObject, Universe);
+            ExitedUniverse(UniverseObject, new(Universe));
+    }
+
+    protected virtual void OnFirstActiveFrame() { }
+    void IFirstFrameUpdate.FirstActiveFrame()
+    {
+        Debug.Assert.AssertInitialized(this);
+        OnFirstActiveFrame();
     }
 
     protected virtual void OnPreUpdatePreActiveCheck() { }
     protected virtual void OnPreUpdate() { }
-    protected virtual void PreUpdate(IBehaviourController _)
+    void IPreUpdate.PreUpdate()
     {
-        Debug.AssertHelpers.AssertInitialized(this);
+        Debug.Assert.AssertInitialized(this);
 
         OnPreUpdatePreActiveCheck();
 
         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() { }
-    protected virtual void Update(IBehaviourController _)
+    void IUpdate.Update()
     {
-        Debug.AssertHelpers.AssertInitialized(this);
+        Debug.Assert.AssertInitialized(this);
 
         OnUpdatePreActiveCheck();
 
@@ -87,11 +82,25 @@ public abstract class Behaviour : BehaviourBase
         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() { }
-    protected virtual void PreDraw(IBehaviourController _)
+    void IPreDraw.PreDraw()
     {
-        Debug.AssertHelpers.AssertInitialized(this);
+        Debug.Assert.AssertInitialized(this);
 
         OnPreDrawPreActiveCheck();
 
@@ -101,9 +110,37 @@ public abstract class Behaviour : BehaviourBase
         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, IUniverse universe) => OnEnteredUniverse(universe);
+    protected virtual void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments arguments) => OnEnteredUniverse(arguments.Universe);
 
     protected virtual void OnExitedUniverse(IUniverse universe) { }
-    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverse universe) => OnExitedUniverse(universe);
+    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments) => OnExitedUniverse(arguments.Universe);
 }

Engine.Core/Behaviour2D.cs

@@ -17,10 +17,6 @@ public abstract class Behaviour2D : Behaviour, IBehaviour2D
     }
 
     protected sealed override void OnUnassign(IAssignable assignable) => base.OnUnassign(assignable);
-    protected sealed override void PreUpdate(IBehaviourController behaviourController) => base.PreUpdate(behaviourController);
-    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);
+    protected sealed override void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments arguments) => base.EnteredUniverse(sender, arguments);
+    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments) => base.ExitedUniverse(sender, arguments);
 }

Engine.Core/BehaviourBase.cs

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

Engine.Core/BehaviourCollector.cs

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

Engine.Core/BehaviourCollectorSorted.cs

@@ -22,7 +22,4 @@ public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
         if (SortBy is not null)
             behaviours.Sort(SortBy);
     }
-
-    public BehaviourCollectorSorted() { }
-    public BehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe) => SortBy = sortBy;
 }

Engine.Core/BehaviourController.cs

@@ -1,64 +1,42 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace Syntriax.Engine.Core;
 
 [System.Diagnostics.DebuggerDisplay("Behaviour Count: {behaviours.Count}")]
-public class BehaviourController : IBehaviourController
+public class BehaviourController : BaseEntity, IBehaviourController
 {
-    public event IBehaviourController.PreUpdateEventHandler? OnPreUpdate = null;
-    public event IBehaviourController.UpdateEventHandler? OnUpdate = null;
-    public event IBehaviourController.PreDrawEventHandler? OnPreDraw = null;
+    public Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments> OnBehaviourAdded { get; } = new();
+    public Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments> OnBehaviourRemoved { get; } = new();
+    public Event<IHasUniverseObject> OnUniverseObjectAssigned { get; } = new();
 
-    public event IBehaviourController.BehaviourAddedEventHandler? OnBehaviourAdded = null;
-    public event IBehaviourController.BehaviourRemovedEventHandler? OnBehaviourRemoved = null;
-    public event IHasUniverseObject.UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned = null;
-
-    public event IInitializable.InitializedEventHandler? OnInitialized = null;
-    public event IInitializable.FinalizedEventHandler? OnFinalized = null;
-
-    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
-
-    private readonly IList<IBehaviour> behaviours = new List<IBehaviour>(Constants.BEHAVIOURS_SIZE_INITIAL);
+    private readonly List<IBehaviour> behaviours = new(Constants.BEHAVIOURS_SIZE_INITIAL);
 
     private IUniverseObject _universeObject = null!;
-    private bool _initialized = false;
 
     public IUniverseObject UniverseObject => _universeObject;
-
-    public bool IsInitialized
-    {
-        get => _initialized;
-        private set
-        {
-            if (value == _initialized)
-                return;
-
-            _initialized = value;
-            if (value)
-                OnInitialized?.InvokeSafe(this);
-            else
-                OnFinalized?.InvokeSafe(this);
-        }
-    }
+    public int Count => behaviours.Count;
+    public IBehaviour this[Index index] => behaviours[index];
 
     public T AddBehaviour<T>(T behaviour) where T : class, IBehaviour
     {
         InsertBehaviourByPriority(behaviour);
 
         behaviour.Assign(this);
-        behaviour.Assign(Factory.StateEnableFactory.Instantiate(behaviour));
 
-        behaviour.Initialize();
-        behaviour.OnPriorityChanged += OnPriorityChange;
-        OnBehaviourAdded?.InvokeSafe(this, behaviour);
+        if (IsInitialized)
+            behaviour.Initialize();
+        behaviour.OnPriorityChanged.AddListener(OnPriorityChange);
+        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>()
     {
@@ -115,10 +93,10 @@ public class BehaviourController : IBehaviourController
         if (!behaviours.Contains(behaviour))
             throw new Exception($"{behaviour.GetType().Name} does not exist in {UniverseObject.Name}'s {nameof(IBehaviourController)}.");
 
-        behaviour.OnPriorityChanged -= OnPriorityChange;
+        behaviour.OnPriorityChanged.RemoveListener(OnPriorityChange);
         behaviour.Finalize();
         behaviours.Remove(behaviour);
-        OnBehaviourRemoved?.InvokeSafe(this, behaviour);
+        OnBehaviourRemoved?.Invoke(this, new(behaviour));
     }
 
     protected virtual void OnAssign(IUniverseObject universeObject) { }
@@ -129,61 +107,22 @@ public class BehaviourController : IBehaviourController
 
         _universeObject = universeObject;
         OnAssign(universeObject);
-        OnUniverseObjectAssigned?.InvokeSafe(this);
+        OnUniverseObjectAssigned?.Invoke(this);
         return true;
     }
 
-    public bool Initialize()
+    protected override void InitializeInternal()
     {
-        if (IsInitialized)
-            return false;
-
-        Debug.AssertHelpers.AssertUniverseObjectAssigned(this);
+        Debug.Assert.AssertUniverseObjectAssigned(this);
 
         foreach (IBehaviour behaviour in behaviours)
             behaviour.Initialize();
-
-        IsInitialized = true;
-        return true;
     }
 
-    public bool Finalize()
+    protected override void FinalizeInternal()
     {
-        if (!IsInitialized)
-            return false;
-
         foreach (IBehaviour behaviour in behaviours)
             behaviour.Finalize();
-
-        IsInitialized = false;
-        return true;
-    }
-
-    public bool Unassign()
-    {
-        if (IsInitialized)
-            return false;
-
-        _universeObject = null!;
-        OnUnassigned?.InvokeSafe(this);
-        return true;
-    }
-
-    public void Update()
-    {
-        if (!UniverseObject.StateEnable.Enabled)
-            return;
-
-        OnPreUpdate?.InvokeSafe(this);
-        OnUpdate?.InvokeSafe(this);
-    }
-
-    public void UpdatePreDraw()
-    {
-        if (!UniverseObject.StateEnable.Enabled)
-            return;
-
-        OnPreDraw?.InvokeSafe(this);
     }
 
     public BehaviourController() { }
@@ -206,12 +145,9 @@ public class BehaviourController : IBehaviourController
             behaviours.Add(behaviour);
     }
 
-    private void OnPriorityChange(IBehaviour sender, int previousPriority)
+    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments arguments)
     {
         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 += OnUpdate;
+        universe.OnUpdate.AddListener(OnUpdate);
     }
 
     protected override void OnExitingUniverse(IUniverse universe)
     {
-        universe.OnUpdate -= OnUpdate;
+        universe.OnUpdate.RemoveListener(OnUpdate);
     }
 
-    private void OnUpdate(IUniverse sender, UniverseTime time)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
     {
         for (int i = enumerators.Count - 1; i >= 0; i--)
         {

Engine.Core/Debug/AssertHelpers.cs

@@ -2,7 +2,7 @@ using System.Runtime.CompilerServices;
 
 namespace Syntriax.Engine.Core.Debug;
 
-public class AssertHelpers
+public static class Assert
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void AssertInitialized(IInitializable initializable)

Engine.Core/Debug/ConsoleLogger.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace Syntriax.Engine.Core.Debug;
+
+public class ConsoleLogger : LoggerBase
+{
+    protected override void Write(string message) => Console.WriteLine(message);
+}

Engine.Core/Debug/FileLogger.cs

@@ -0,0 +1,20 @@
+using System;
+using System.IO;
+
+namespace Syntriax.Engine.Core.Debug;
+
+public class FileLogger : LoggerBase
+{
+    public readonly string FilePath;
+
+    public FileLogger(string filePath)
+    {
+        FilePath = filePath;
+        File.Open(filePath, FileMode.Create).Close();
+    }
+
+    protected override void Write(string message)
+    {
+        File.AppendAllTextAsync(FilePath, $"{message}{Environment.NewLine}");
+    }
+}

Engine.Core/Debug/ILogger.cs

@@ -0,0 +1,15 @@
+namespace Syntriax.Engine.Core.Debug;
+
+public interface ILogger
+{
+    Level FilterLevel { get; set; }
+
+    void Log(string message, Level level = Level.Info, bool force = false);
+
+    enum Level
+    {
+        Info,
+        Warning,
+        Error,
+    };
+}

Engine.Core/Debug/LoggerBase.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Syntriax.Engine.Core.Debug;
+
+public abstract class LoggerBase : ILogger
+{
+    public ILogger.Level FilterLevel { get; set; } = ILogger.Level.Info;
+
+    public void Log(string message, ILogger.Level level = ILogger.Level.Info, bool force = false)
+    {
+        if (!force && level < FilterLevel)
+            return;
+
+        string timestamp = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss tt");
+
+        Write($"[{timestamp}] [{level}] \t{message}");
+    }
+
+    protected abstract void Write(string message);
+}

Engine.Core/Debug/LoggerExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Diagnostics;
+
+namespace Syntriax.Engine.Core.Debug;
+
+public static class LoggerExtensions
+{
+    public static void Log<T>(this ILogger logger, T caller, string message, ILogger.Level level = ILogger.Level.Info, bool force = false)
+    {
+        string body = $"{caller?.GetType().Name ?? typeof(T).Name}: {message}";
+        logger.Log(body, level, force);
+    }
+
+    public static void LogWarning<T>(this ILogger logger, T caller, string message, bool force = false) => Log(logger, caller, message, ILogger.Level.Info, force);
+
+    public static void LogError<T>(this ILogger logger, T caller, string message, bool force = false)
+    {
+        Log(logger, caller, message, ILogger.Level.Error, force);
+        Log(logger, caller, $"{nameof(StackTrace)}:{Environment.NewLine}{new StackTrace()}");
+    }
+
+    public static void LogException<T>(this ILogger logger, T caller, Exception exception, bool force = false)
+    {
+        Log(logger, caller, $"Message: {exception.Message}", ILogger.Level.Error, force);
+        Log(logger, caller, $"InnerException: {exception.InnerException}", ILogger.Level.Error, force);
+        Log(logger, caller, $"{nameof(StackTrace)}:{Environment.NewLine}{exception.StackTrace}");
+    }
+}

Engine.Core/Engine.Core.csproj

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

Engine.Core/Exceptions/BehaviourNotFoundException.cs

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

Engine.Core/Exceptions/NotFoundException.cs

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

Engine.Core/Extensions/BehaviourControllerExtensions.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 using Syntriax.Engine.Core.Exceptions;
@@ -38,6 +39,19 @@ 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>
@@ -81,6 +95,27 @@ 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>
@@ -120,4 +155,28 @@ 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

@@ -1,34 +0,0 @@
-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,9 +7,30 @@ 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,6 +1,8 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
+using Syntriax.Engine.Core.Exceptions;
+
 namespace Syntriax.Engine.Core;
 
 public static class UniverseObjectExtensions
@@ -14,6 +16,13 @@ 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)
@@ -23,17 +32,224 @@ public static class UniverseObjectExtensions
         return default;
     }
 
-    public static bool TryGetUniverseObject<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
+    /// <summary>
+    /// 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
     {
-        behaviour = GetUniverseObject<T>(universeObjects);
+        universeObject = 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;
     }
 
-    public static void GetUniverseObjects<T>(this IEnumerable<IUniverseObject> universeObjects, List<T> behaviours) where T : class
+    /// <summary>
+    /// 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)
-                behaviours.Add(@object);
+        {
+            universeObject.BehaviourController.GetBehaviours(cache);
+            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>(IUniverseObject universeObject, params object?[]? args) where T : class, IBehaviour
-        => Instantiate<T>(universeObject, stateEnable: null, args);
+    public static T Instantiate<T>(params object?[]? args) where T : class, IBehaviour
+        => Instantiate<T>(stateEnable: null, args);
 
-    public static T Instantiate<T>(IUniverseObject universeObject, IStateEnable? stateEnable, params object?[]? args)
+    public static T Instantiate<T>(IStateEnable? stateEnable, params object?[]? args)
         where T : class, IBehaviour
     {
         T behaviour = TypeFactory.Get<T>(args);
@@ -18,8 +18,6 @@ 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/Factory/TypeFactory.cs

@@ -1,21 +1,59 @@
 using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Syntriax.Engine.Core.Factory;
 
 public static class TypeFactory
 {
-    public static T Get<T>(params object?[]? args) where T : class
+    private static readonly ConcurrentDictionary<string, Type> registeredTypes = [];
+
+    public static string GetTypeName(Type type) => type.FullName ?? throw new ArgumentException($"{type.Name} must be a resolvable type");
+
+    public static T Get<T>(params object?[]? args) where T : class => (T)Get(typeof(T), args);
+    public static object Get(string fullName, params object?[]? args) => Get(GetType(fullName), args);
+    public static object Get(Type type, params object?[]? args)
     {
-        T? result;
+        object? result;
 
         if (args is not null && args.Length != 0)
-            result = Activator.CreateInstance(typeof(T), args) as T;
+            result = Activator.CreateInstance(type, args);
         else
-            result = Activator.CreateInstance(typeof(T)) as T;
+            result = Activator.CreateInstance(type);
 
         if (result is null)
-            throw new Exception($"{typeof(T).Name} of type {typeof(T).Name} could not be created.");
+            throw new Exception($"Type {type.Name} could not be created.");
 
         return result;
     }
+
+    public static Type GetType(string fullName)
+    {
+        if (registeredTypes.TryGetValue(fullName, out Type? result))
+            return result;
+
+        ReloadTypes();
+
+        if (registeredTypes.TryGetValue(fullName, out Type? reloadedType))
+            return reloadedType;
+
+        throw new Exception($"Type {fullName} could not be found in the current domain.");
+    }
+
+    public static void ReloadTypes()
+    {
+        registeredTypes.Clear();
+
+        IEnumerable<Type> domainTypes = AppDomain.CurrentDomain
+            .GetAssemblies()
+            .SelectMany(a => a.GetTypes());
+
+        // TODO: Replace this
+        // There are some system & compiler generated types with duplicated names, 
+        // it is ugly it will cause headaches in the future because it will not 
+        // throw an error if there's a type with an unintended duplicate name
+        foreach (Type type in domainTypes)
+            registeredTypes.TryAdd(GetTypeName(type), type);
+    }
 }

Engine.Core/Helpers/DelegateExtensions.cs

@@ -2,11 +2,12 @@ using System;
 
 namespace Syntriax.Engine.Core;
 
-public static class DelegateHelpers
+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.GetInvocationList())
+        foreach (Delegate invocation in Delegate.EnumerateInvocationList(@delegate))
             try { invocation.DynamicInvoke(args); }
             catch (Exception exception)
             {

Engine.Core/Helpers/Event.cs

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

Engine.Core/Helpers/Progression/IProgressionTracker.cs

@@ -0,0 +1,7 @@
+namespace Syntriax.Engine.Core;
+
+public interface IProgressionTracker : IReadOnlyProgressionTracker
+{
+    void Set(float progression, string status);
+    void Reset();
+}

Engine.Core/Helpers/Progression/IReadOnlyProgressionTracker.cs

@@ -0,0 +1,12 @@
+namespace Syntriax.Engine.Core;
+
+public interface IReadOnlyProgressionTracker
+{
+    Event<IReadOnlyProgressionTracker, ProgressionUpdatedArguments> OnUpdated { get; }
+    Event<IReadOnlyProgressionTracker> OnEnded { get; }
+
+    float Progression { get; }
+    string Status { get; }
+
+    readonly record struct ProgressionUpdatedArguments(float PreviousProgression, string PreviousStatus);
+}

Engine.Core/Helpers/Progression/ProgressionTracker.cs

@@ -0,0 +1,36 @@
+namespace Syntriax.Engine.Core;
+
+public class ProgressionTracker : IProgressionTracker
+{
+    public Event<IReadOnlyProgressionTracker, IReadOnlyProgressionTracker.ProgressionUpdatedArguments> OnUpdated { get; } = new();
+    public Event<IReadOnlyProgressionTracker> OnEnded { get; } = new();
+
+    public float Progression { get; private set; } = 0f;
+    public string Status { get; private set; } = "Default";
+
+    void IProgressionTracker.Set(float progression, string status)
+    {
+        if (Progression >= 1f)
+            return;
+
+        float previousProgression = Progression;
+        string previousStatus = Status;
+
+        Progression = progression.Clamp(Progression, 1f);
+        Status = status;
+
+        OnUpdated?.Invoke(this, new(previousProgression, previousStatus));
+
+        if (progression >= 1f)
+            OnEnded?.Invoke(this);
+    }
+
+    void IProgressionTracker.Reset()
+    {
+        Progression = 0f;
+        Status = "Default";
+
+        OnUpdated.Clear();
+        OnEnded.Clear();
+    }
+}

Engine.Core/Helpers/Progression/ProgressiveTask.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Syntriax.Engine.Core;
+
+public record struct ProgressiveTask<T>(IReadOnlyProgressionTracker ProgressionTracker, Task<T> Task)
+{
+    public static implicit operator (IReadOnlyProgressionTracker progressionTracker, Task<T> task)(ProgressiveTask<T> value) => (value.ProgressionTracker, value.Task);
+    public static implicit operator ProgressiveTask<T>((IReadOnlyProgressionTracker progressionTracker, Task<T> task) value) => new(value.progressionTracker, value.task);
+}

Engine.Core/Math.cs

@@ -30,6 +30,64 @@ public static class Math
     /// </summary>
     public const float DegreeToRadian = PI / 180f;
 
+    /// <summary>
+    /// Gets one minus of given <see cref="T"/>.
+    /// </summary>
+    /// <param name="value">The value <see cref="T"/>.</param>
+    /// <returns>One minus of given <see cref="T"/>.</returns>
+    public static T OneMinus<T>(T value) where T : INumber<T> => T.One - value;
+
+    /// <summary>
+    /// Adds two <see cref="T"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="T"/>.</param>
+    /// <param name="value">The second <see cref="T"/>.</param>
+    /// <returns>The sum of the two <see cref="T"/>s.</returns>
+    public static T Add<T>(T left, T value) where T : INumber<T> => left + value;
+
+    /// <summary>
+    /// Subtracts one <see cref="T"/> from another.
+    /// </summary>
+    /// <param name="left">The <see cref="T"/> to subtract from.</param>
+    /// <param name="value">The <see cref="T"/> to subtract.</param>
+    /// <returns>The result of subtracting the second <see cref="T"/> from the first.</returns>
+    public static T Subtract<T>(T left, T value) where T : INumber<T> => left - value;
+
+    /// <summary>
+    /// Multiplies a <see cref="T"/> by a scalar value.
+    /// </summary>
+    /// <param name="left">The <see cref="T"/>.</param>
+    /// <param name="multiplier">The scalar value.</param>
+    /// <returns>The result of multiplying the <see cref="T"/> by the scalar value.</returns>
+    public static T Multiply<T>(T left, T multiplier) where T : INumber<T> => left * multiplier;
+
+    /// <summary>
+    /// Divides a <see cref="T"/> by a scalar value.
+    /// </summary>
+    /// <param name="left">The <see cref="T"/>.</param>
+    /// <param name="divider">The scalar value.</param>
+    /// <returns>The result of dividing the <see cref="T"/> by the scalar value.</returns>
+    public static T Divide<T>(T left, T divider) where T : INumber<T> => left / divider;
+
+    /// <summary>
+    /// Returns the true mathematical modulus of a <see cref="T"/> value. 
+    /// Unlike the remainder operator (%), this result is always non-negative,
+    /// even when the <paramref name="value"/> operand is negative.
+    /// </summary>
+    /// <typeparam name="T">A numeric type that implements <see cref="INumber{T}"/>.</typeparam>
+    /// <param name="value">The dividend <see cref="T"/> value.</param>
+    /// <param name="modulus">The modulus <see cref="T"/> value (must be non-zero).</param>
+    /// <returns>
+    /// The non-negative remainder of <paramref name="value"/> divided by <paramref name="modulus"/>.
+    /// </returns>
+    public static T Mod<T>(T value, T modulus) where T : INumber<T>
+    {
+        T result = value % modulus;
+        if (result < T.Zero)
+            result += modulus;
+        return result;
+    }
+
     /// <summary>
     /// Returns the absolute value of a number.
     /// </summary>
@@ -190,6 +248,15 @@ public static class Math
     /// <returns>The number <paramref name="x"/> rounded to <paramref name="digits"/> fractional digits.</returns>
     public static float Round(float x, int digits, MidpointRounding mode) => MathF.Round(x, digits, mode);
 
+    /// <summary>
+    /// Rounds a number to an integer.
+    /// </summary>
+    /// <param name="x">The number to round.</param>
+    /// <param name="roundMode">Specification for how to round <paramref name="x"/> if it's midway between two numbers</param>
+    /// <returns></returns>
+    public static int RoundToInt(float x, RoundMode roundMode = RoundMode.Ceil) => (int)MathF.Round(x, 0, roundMode == RoundMode.Ceil ? MidpointRounding.ToPositiveInfinity : MidpointRounding.ToNegativeInfinity);
+    public enum RoundMode { Ceil, Floor };
+
     /// <summary>
     /// Returns the square of a number.
     /// </summary>

Engine.Core/MathExtensions.cs

@@ -5,6 +5,24 @@ namespace Syntriax.Engine.Core;
 
 public static class MathExtensions
 {
+    /// <inheritdoc cref="Math.OneMinus{T}(T)" />
+    public static T OneMinus<T>(this T value) where T : INumber<T> => Math.OneMinus(value);
+
+    /// <inheritdoc cref="Math.Add{T}(T, T)" />
+    public static T Add<T>(this T left, T value) where T : INumber<T> => Math.Add(left, value);
+
+    /// <inheritdoc cref="Math.Subtract{T}(T, T)" />
+    public static T Subtract<T>(this T left, T value) where T : INumber<T> => Math.Subtract(left, value);
+
+    /// <inheritdoc cref="Math.Multiply{T}(T, T)" />
+    public static T Multiply<T>(this T left, T multiplier) where T : INumber<T> => Math.Multiply(left, multiplier);
+
+    /// <inheritdoc cref="Math.Divide{T}(T, T)" />
+    public static T Divide<T>(this T left, T divider) where T : INumber<T> => Math.Divide(left, divider);
+
+    /// <inheritdoc cref="Math.Mod{T}(T, T)" />
+    public static T Mod<T>(this T value, T modulus) where T : INumber<T> => Math.Mod(value, modulus);
+
     /// <inheritdoc cref="Math.Abs{T}(T)" />
     public static T Abs<T>(this T x) where T : INumber<T> => Math.Abs(x);
 
@@ -65,6 +83,9 @@ public static class MathExtensions
     /// <inheritdoc cref="Math.Round(float, int, MidpointRounding)" />
     public static float Round(this float x, int digits, MidpointRounding mode) => Math.Round(x, digits, mode);
 
+    /// <inheritdoc cref="Math.RoundToInt(float, Math.RoundMode)" />
+    public static int RoundToInt(this float x, Math.RoundMode roundMode = Math.RoundMode.Ceil) => Math.RoundToInt(x, roundMode);
+
     /// <inheritdoc cref="Math.Sqr{T}(T)" />
     public static T Sqr<T>(this T x) where T : INumber<T> => Math.Sqr(x);
 

Engine.Core/Preserver.cs

@@ -0,0 +1,10 @@
+namespace Syntriax.Engine.Core
+{
+    // This is pretty much so the assembly gets loaded automatically because 
+    // the builds include the assembly but sometimes doesn't link load it at startup.
+    // I will hopefully one day fix it and remove this. 
+    public static class Preserver
+    {
+        public static void Preserve() { }
+    }
+}

Engine.Core/Primitives/ColorHSV.cs

@@ -0,0 +1,185 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an HSV color.
+/// </summary>
+/// <param name="hue">Hue of the <see cref="ColorHSV"/>.</param>
+/// <param name="saturation">Saturation of the <see cref="ColorHSV"/>.</param>
+/// <param name="value">Value of the <see cref="ColorHSV"/>.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="ColorHSV"/> struct with the specified values.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("{ToString(),nq}")]
+public readonly struct ColorHSV(float hue, float saturation, float value)
+{
+    /// <summary>
+    /// The Hue value of the <see cref="ColorHSV"/>.
+    /// </summary>
+    public readonly float Hue = hue.Clamp(0f, 1f);
+
+    /// <summary>
+    /// The Saturation value of the <see cref="ColorHSV"/>.
+    /// </summary>
+    public readonly float Saturation = saturation.Clamp(0f, 1f);
+
+    /// <summary>
+    /// The Value value of the <see cref="ColorHSV"/>.
+    /// </summary>
+    public readonly float Value = value.Clamp(0f, 1f);
+
+    public static ColorHSV operator -(ColorHSV color) => new(color.Hue.OneMinus().Clamp(0f, 1f), color.Saturation.OneMinus().Clamp(0f, 1f), color.Value.OneMinus().Clamp(0f, 1f));
+    public static ColorHSV operator +(ColorHSV left, ColorHSV right) => new((left.Hue + right.Hue).Clamp(0f, 1f), (left.Saturation + right.Saturation).Clamp(0f, 1f), (left.Value + right.Value).Clamp(0f, 1f));
+    public static ColorHSV operator -(ColorHSV left, ColorHSV right) => new((left.Hue - right.Hue).Clamp(0f, 1f), (left.Saturation - right.Saturation).Clamp(0f, 1f), (left.Value - right.Value).Clamp(0f, 1f));
+    public static ColorHSV operator *(ColorHSV left, ColorHSV right) => new((left.Hue * right.Hue).Clamp(0f, 1f), (left.Saturation * right.Saturation).Clamp(0f, 1f), (left.Value * right.Value).Clamp(0f, 1f));
+    public static ColorHSV operator *(ColorHSV color, float value) => new((color.Hue * value).Clamp(0f, 1f), (color.Saturation * value).Clamp(0f, 1f), (color.Value * value).Clamp(0f, 1f));
+    public static ColorHSV operator *(float value, ColorHSV color) => new((color.Hue * value).Clamp(0f, 1f), (color.Saturation * value).Clamp(0f, 1f), (color.Value * value).Clamp(0f, 1f));
+    public static ColorHSV operator /(ColorHSV color, float value) => new((color.Hue / value).Clamp(0f, 1f), (color.Saturation / value).Clamp(0f, 1f), (color.Value / value).Clamp(0f, 1f));
+    public static bool operator ==(ColorHSV left, ColorHSV right) => left.Hue.ApproximatelyEquals(right.Hue) && left.Saturation.ApproximatelyEquals(right.Saturation) && left.Value.ApproximatelyEquals(right.Value);
+    public static bool operator !=(ColorHSV left, ColorHSV right) => !left.Hue.ApproximatelyEquals(right.Hue) || !left.Saturation.ApproximatelyEquals(right.Saturation) || !left.Value.ApproximatelyEquals(right.Value);
+
+    public static implicit operator ColorHSV(ColorRGBA rgba) => (ColorRGB)rgba;
+    public static implicit operator ColorHSV(ColorRGB rgb)
+    {
+        float hue;
+        float saturation;
+        float value;
+
+        float rd = rgb.R / 255f;
+        float gd = rgb.G / 255f;
+        float bd = rgb.B / 255f;
+
+        float max = Math.Max(rd, Math.Max(gd, bd));
+        float min = Math.Min(rd, Math.Min(gd, bd));
+        float delta = max - min;
+
+        if (delta.ApproximatelyEquals(0))
+            hue = 0f;
+        else if (max.ApproximatelyEquals(rd))
+            hue = 60f * ((gd - bd) / delta % 6f);
+        else if (max.ApproximatelyEquals(gd))
+            hue = 60f * (((bd - rd) / delta) + 2f);
+        else
+            hue = 60f * (((rd - gd) / delta) + 4f);
+
+        if (hue < 0f)
+            hue += 360f;
+
+        hue /= 360f;
+        saturation = max.ApproximatelyEquals(0f) ? 0f : delta / max;
+        value = max;
+
+        return new(hue, saturation, value);
+    }
+
+    /// <summary>
+    /// Inverts the given <see cref="ColorHSV"/>.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorHSV"/>.</param>
+    /// <returns>The inverted <see cref="ColorHSV"/>.</returns>
+    public static ColorHSV Invert(ColorHSV color) => -color;
+
+    /// <summary>
+    /// Adds two <see cref="ColorHSV"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="ColorHSV"/>.</param>
+    /// <param name="right">The second <see cref="ColorHSV"/>.</param>
+    /// <returns>The sum of the two <see cref="ColorHSV"/>s.</returns>
+    public static ColorHSV Add(ColorHSV left, ColorHSV right) => left + right;
+
+    /// <summary>
+    /// Subtracts one <see cref="ColorHSV"/> from another.
+    /// </summary>
+    /// <param name="left">The <see cref="ColorHSV"/> to subtract from.</param>
+    /// <param name="right">The <see cref="ColorHSV"/> to subtract.</param>
+    /// <returns>The result of subtracting the second <see cref="ColorHSV"/> from the first.</returns>
+    public static ColorHSV Subtract(ColorHSV left, ColorHSV right) => left - right;
+
+    /// <summary>
+    /// Multiplies a <see cref="ColorHSV"/> by a scalar value.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorHSV"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of multiplying the <see cref="ColorHSV"/> by the scalar value.</returns>
+    public static ColorHSV Multiply(ColorHSV color, float value) => color * value;
+
+    /// <summary>
+    /// Divides a <see cref="ColorHSV"/> by a scalar value.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorHSV"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of dividing the <see cref="ColorHSV"/> by the scalar value.</returns>
+    public static ColorHSV Divide(ColorHSV color, float value) => color / value;
+
+    /// <summary>
+    /// Calculates the <see cref="ColorHSV"/> from one point to another.
+    /// </summary>
+    /// <param name="from">The starting point.</param>
+    /// <param name="to">The ending point.</param>
+    /// <returns>The <see cref="ColorHSV"/> from the starting point to the ending point.</returns>
+    public static ColorHSV FromTo(ColorHSV from, ColorHSV to) => to - from;
+
+    /// <summary>
+    /// Performs linear interpolation between two <see cref="ColorHSV"/>s.
+    /// </summary>
+    /// <param name="from">The starting <see cref="ColorHSV"/> (t = 0).</param>
+    /// <param name="to">The ending <see cref="ColorHSV"/> (t = 1).</param>
+    /// <param name="t">The interpolation parameter.</param>
+    /// <returns>The interpolated <see cref="ColorHSV"/>.</returns>
+    public static ColorHSV Lerp(ColorHSV from, ColorHSV to, float t) => from + FromTo(from, to) * t;
+
+    /// <summary>
+    /// Converts the <see cref="ColorHSV"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="ColorHSV"/>.</returns>
+    public override string ToString() => $"{nameof(ColorHSV)}({Hue}, {Saturation}, {Value})";
+
+    /// <summary>
+    /// Checks if two <see cref="ColorHSV"/>s are approximately equal within a specified epsilon range.
+    /// </summary>
+    /// <param name="left">The first <see cref="ColorHSV"/>.</param>
+    /// <param name="right">The second <see cref="ColorHSV"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns><see cref="true"/> if the <see cref="ColorHSV"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
+    public static bool ApproximatelyEquals(ColorHSV left, ColorHSV right, float epsilon = float.Epsilon)
+        => left.Hue.ApproximatelyEquals(right.Hue, epsilon) && left.Saturation.ApproximatelyEquals(right.Saturation, epsilon) && left.Value.ApproximatelyEquals(right.Value, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="ColorHSV"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="ColorHSV"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="ColorHSV"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is ColorHSV objVec && Hue.Equals(objVec.Hue) && Saturation.Equals(objVec.Saturation) && Value.Equals(objVec.Value);
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="ColorHSV"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="ColorHSV"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(Hue, Saturation, Value);
+}
+
+/// <summary>
+/// Provides extension methods for <see cref="ColorHSV"/> type.
+/// </summary>
+public static class ColorHSVExtensions
+{
+    /// <inheritdoc cref="ColorHSV.Add(ColorHSV, ColorHSV)" />
+    public static ColorHSV Add(this ColorHSV color, ColorHSV value) => ColorHSV.Add(color, value);
+
+    /// <inheritdoc cref="ColorHSV.Subtract(ColorHSV, ColorHSV)" />
+    public static ColorHSV Subtract(this ColorHSV color, ColorHSV value) => ColorHSV.Subtract(color, value);
+
+    /// <inheritdoc cref="ColorHSV.Multiply(ColorHSV, ColorHSV)" />
+    public static ColorHSV Multiply(this ColorHSV color, float value) => ColorHSV.Multiply(color, value);
+
+    /// <inheritdoc cref="ColorHSV.Divide(ColorHSV, ColorHSV)" />
+    public static ColorHSV Divide(this ColorHSV color, float value) => ColorHSV.Divide(color, value);
+
+    /// <inheritdoc cref="ColorHSV.FromTo(ColorHSV, ColorHSV)" />
+    public static ColorHSV FromTo(this ColorHSV from, ColorHSV to) => ColorHSV.FromTo(from, to);
+
+    /// <inheritdoc cref="ColorHSV.Lerp(ColorHSV, ColorHSV, float)" />
+    public static ColorHSV Lerp(this ColorHSV from, ColorHSV to, float t) => ColorHSV.Lerp(from, to, t);
+
+    /// <inheritdoc cref="ColorHSV.ApproximatelyEquals(ColorHSV, ColorHSV, float) " />
+    public static bool ApproximatelyEquals(this ColorHSV left, ColorHSV right, float epsilon = float.Epsilon) => ColorHSV.ApproximatelyEquals(left, right, epsilon);
+}

Engine.Core/Primitives/ColorRGB.cs

@@ -0,0 +1,164 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an RGB color.
+/// </summary>
+/// <param name="r">Red value of the <see cref="ColorRGB"/>.</param>
+/// <param name="g">Green value of the <see cref="ColorRGB"/>.</param>
+/// <param name="b">Blue value of the <see cref="ColorRGB"/>.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="ColorRGB"/> struct with the specified values.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("{ToString(),nq}")]
+public readonly struct ColorRGB(byte r, byte g, byte b)
+{
+    /// <summary>
+    /// The Red value of the <see cref="ColorRGB"/>.
+    /// </summary>
+    public readonly byte R = r;
+
+    /// <summary>
+    /// The Green value of the <see cref="ColorRGB"/>.
+    /// </summary>
+    public readonly byte G = g;
+
+    /// <summary>
+    /// The Blue value of the <see cref="ColorRGB"/>.
+    /// </summary>
+    public readonly byte B = b;
+
+    public static ColorRGB operator -(ColorRGB color) => new((byte)(255 - color.R), (byte)(255 - color.G), (byte)(255 - color.B));
+    public static ColorRGB operator +(ColorRGB left, ColorRGB right) => new((byte)(left.R + right.R).Clamp(0, 255), (byte)(left.G + right.G).Clamp(0, 255), (byte)(left.B + right.B).Clamp(0, 255));
+    public static ColorRGB operator -(ColorRGB left, ColorRGB right) => new((byte)(left.R - right.R).Clamp(0, 255), (byte)(left.G - right.G).Clamp(0, 255), (byte)(left.B - right.B).Clamp(0, 255));
+    public static ColorRGB operator *(ColorRGB left, ColorRGB right) => new((byte)(left.R * right.R).Clamp(0, 255), (byte)(left.G * right.G).Clamp(0, 255), (byte)(left.B * right.B).Clamp(0, 255));
+    public static ColorRGB operator *(ColorRGB color, float value) => new((byte)(color.R * value).Clamp(0, 255), (byte)(color.G * value).Clamp(0, 255), (byte)(color.B * value).Clamp(0, 255));
+    public static ColorRGB operator *(float value, ColorRGB color) => new((byte)(color.R * value).Clamp(0, 255), (byte)(color.G * value).Clamp(0, 255), (byte)(color.B * value).Clamp(0, 255));
+    public static ColorRGB operator /(ColorRGB color, float value) => new((byte)(color.R / value).Clamp(0, 255), (byte)(color.G / value).Clamp(0, 255), (byte)(color.B / value).Clamp(0, 255));
+    public static bool operator ==(ColorRGB left, ColorRGB right) => left.R == right.R && left.G == right.G && left.B == right.B;
+    public static bool operator !=(ColorRGB left, ColorRGB right) => left.R != right.R || left.G != right.G || left.B != right.B;
+
+    public static implicit operator ColorRGB(ColorRGBA rgba) => new(rgba.R, rgba.G, rgba.B);
+    public static implicit operator ColorRGB(ColorHSV hsv)
+    {
+        float hue = hsv.Hue * 360f;
+        float chroma = hsv.Value * hsv.Saturation;
+        float x = chroma * (1f - Math.Abs(hue / 60f % 2f - 1f));
+        float m = hsv.Value - chroma;
+
+        float r1 = 0f;
+        float g1 = 0f;
+        float b1 = 0f;
+
+        if (hue < 60) { r1 = chroma; g1 = x; b1 = 0; }
+        else if (hue < 120) { r1 = x; g1 = chroma; b1 = 0; }
+        else if (hue < 180) { r1 = 0; g1 = chroma; b1 = x; }
+        else if (hue < 240) { r1 = 0; g1 = x; b1 = chroma; }
+        else if (hue < 300) { r1 = x; g1 = 0; b1 = chroma; }
+        else if (hue <= 360) { r1 = chroma; g1 = 0; b1 = x; }
+
+        byte r = (byte)Math.RoundToInt((r1 + m) * 255);
+        byte g = (byte)Math.RoundToInt((g1 + m) * 255);
+        byte b = (byte)Math.RoundToInt((b1 + m) * 255);
+
+        return new(r, g, b);
+    }
+
+    /// <summary>
+    /// Inverts the given <see cref="ColorRGB"/>.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorRGB"/>.</param>
+    /// <returns>The inverted <see cref="ColorRGB"/>.</returns>
+    public static ColorRGB Invert(ColorRGB color) => -color;
+
+    /// <summary>
+    /// Adds two <see cref="ColorRGB"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="ColorRGB"/>.</param>
+    /// <param name="right">The second <see cref="ColorRGB"/>.</param>
+    /// <returns>The sum of the two <see cref="ColorRGB"/>s.</returns>
+    public static ColorRGB Add(ColorRGB left, ColorRGB right) => left + right;
+
+    /// <summary>
+    /// Subtracts one <see cref="ColorRGB"/> from another.
+    /// </summary>
+    /// <param name="left">The <see cref="ColorRGB"/> to subtract from.</param>
+    /// <param name="right">The <see cref="ColorRGB"/> to subtract.</param>
+    /// <returns>The result of subtracting the second <see cref="ColorRGB"/> from the first.</returns>
+    public static ColorRGB Subtract(ColorRGB left, ColorRGB right) => left - right;
+
+    /// <summary>
+    /// Multiplies a <see cref="ColorRGB"/> by a scalar value.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorRGB"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of multiplying the <see cref="ColorRGB"/> by the scalar value.</returns>
+    public static ColorRGB Multiply(ColorRGB color, float value) => color * value;
+
+    /// <summary>
+    /// Divides a <see cref="ColorRGB"/> by a scalar value.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorRGB"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of dividing the <see cref="ColorRGB"/> by the scalar value.</returns>
+    public static ColorRGB Divide(ColorRGB color, float value) => color / value;
+
+    /// <summary>
+    /// Calculates the <see cref="ColorRGB"/> from one point to another.
+    /// </summary>
+    /// <param name="from">The starting point.</param>
+    /// <param name="to">The ending point.</param>
+    /// <returns>The <see cref="ColorRGB"/> from the starting point to the ending point.</returns>
+    public static ColorRGB FromTo(ColorRGB from, ColorRGB to) => to - from;
+
+    /// <summary>
+    /// Performs linear interpolation between two <see cref="ColorRGB"/>s.
+    /// </summary>
+    /// <param name="from">The starting <see cref="ColorRGB"/> (t = 0).</param>
+    /// <param name="to">The ending <see cref="ColorRGB"/> (t = 1).</param>
+    /// <param name="t">The interpolation parameter.</param>
+    /// <returns>The interpolated <see cref="ColorRGB"/>.</returns>
+    public static ColorRGB Lerp(ColorRGB from, ColorRGB to, float t) => from + FromTo(from, to) * t;
+
+    /// <summary>
+    /// Converts the <see cref="ColorRGB"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="ColorRGB"/>.</returns>
+    public override string ToString() => $"{nameof(ColorRGB)}({R}, {G}, {B})";
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="ColorRGB"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="ColorRGB"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="ColorRGB"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is ColorRGB objVec && R.Equals(objVec.R) && G.Equals(objVec.G) && B.Equals(objVec.B);
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="ColorRGB"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="ColorRGB"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(R, G, B);
+}
+
+/// <summary>
+/// Provides extension methods for <see cref="ColorRGB"/> type.
+/// </summary>
+public static class ColorRGBExtensions
+{
+    /// <inheritdoc cref="ColorRGB.Add(ColorRGB, ColorRGB)" />
+    public static ColorRGB Add(this ColorRGB color, ColorRGB value) => ColorRGB.Add(color, value);
+
+    /// <inheritdoc cref="ColorRGB.Subtract(ColorRGB, ColorRGB)" />
+    public static ColorRGB Subtract(this ColorRGB color, ColorRGB value) => ColorRGB.Subtract(color, value);
+
+    /// <inheritdoc cref="ColorRGB.Multiply(ColorRGB, ColorRGB)" />
+    public static ColorRGB Multiply(this ColorRGB color, float value) => ColorRGB.Multiply(color, value);
+
+    /// <inheritdoc cref="ColorRGB.Divide(ColorRGB, ColorRGB)" />
+    public static ColorRGB Divide(this ColorRGB color, float value) => ColorRGB.Divide(color, value);
+
+    /// <inheritdoc cref="ColorRGB.FromTo(ColorRGB, ColorRGB)" />
+    public static ColorRGB FromTo(this ColorRGB from, ColorRGB to) => ColorRGB.FromTo(from, to);
+
+    /// <inheritdoc cref="ColorRGB.Lerp(ColorRGB, ColorRGB, float)" />
+    public static ColorRGB Lerp(this ColorRGB from, ColorRGB to, float t) => ColorRGB.Lerp(from, to, t);
+}

Engine.Core/Primitives/ColorRGBA.cs

@@ -0,0 +1,147 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an RGBA color.
+/// </summary>
+/// <param name="r">Red value of the <see cref="ColorRGBA"/>.</param>
+/// <param name="g">Green value of the <see cref="ColorRGBA"/>.</param>
+/// <param name="b">Blue value of the <see cref="ColorRGBA"/>.</param>
+/// <param name="a">Alpha value of the <see cref="ColorRGBA"/>.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="ColorRGBA"/> struct with the specified values.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("{ToString(),nq}")]
+public readonly struct ColorRGBA(byte r, byte g, byte b, byte a = 255)
+{
+    /// <summary>
+    /// The Red value of the <see cref="ColorRGBA"/>.
+    /// </summary>
+    public readonly byte R = r;
+
+    /// <summary>
+    /// The Green value of the <see cref="ColorRGBA"/>.
+    /// </summary>
+    public readonly byte G = g;
+
+    /// <summary>
+    /// The Blue value of the <see cref="ColorRGBA"/>.
+    /// </summary>
+    public readonly byte B = b;
+
+    /// <summary>
+    /// The Alpha value of the <see cref="ColorRGBA"/>.
+    /// </summary>
+    public readonly byte A = a;
+
+    public static ColorRGBA operator -(ColorRGBA color) => new((byte)(255 - color.R), (byte)(255 - color.G), (byte)(255 - color.B), color.A);
+    public static ColorRGBA operator +(ColorRGBA left, ColorRGBA right) => new((byte)(left.R + right.R).Clamp(0, 255), (byte)(left.G + right.G).Clamp(0, 255), (byte)(left.B + right.B).Clamp(0, 255), (byte)(left.A + right.A).Clamp(0, 255));
+    public static ColorRGBA operator -(ColorRGBA left, ColorRGBA right) => new((byte)(left.R - right.R).Clamp(0, 255), (byte)(left.G - right.G).Clamp(0, 255), (byte)(left.B - right.B).Clamp(0, 255), (byte)(left.A - right.A).Clamp(0, 255));
+    public static ColorRGBA operator *(ColorRGBA left, ColorRGBA right) => new((byte)(left.R * right.R).Clamp(0, 255), (byte)(left.G * right.G).Clamp(0, 255), (byte)(left.B * right.B).Clamp(0, 255), (byte)(left.A * right.A).Clamp(0, 255));
+    public static ColorRGBA operator *(ColorRGBA color, float value) => new((byte)(color.R * value).Clamp(0, 255), (byte)(color.G * value).Clamp(0, 255), (byte)(color.B * value).Clamp(0, 255), (byte)(color.A * value).Clamp(0, 255));
+    public static ColorRGBA operator *(float value, ColorRGBA color) => new((byte)(color.R * value).Clamp(0, 255), (byte)(color.G * value).Clamp(0, 255), (byte)(color.B * value).Clamp(0, 255), (byte)(color.A * value).Clamp(0, 255));
+    public static ColorRGBA operator /(ColorRGBA color, float value) => new((byte)(color.R / value).Clamp(0, 255), (byte)(color.G / value).Clamp(0, 255), (byte)(color.B / value).Clamp(0, 255), (byte)(color.A / value).Clamp(0, 255));
+    public static bool operator ==(ColorRGBA left, ColorRGBA right) => left.R == right.R && left.G == right.G && left.B == right.B && left.A == right.A;
+    public static bool operator !=(ColorRGBA left, ColorRGBA right) => left.R != right.R || left.G != right.G || left.B != right.B || left.A != right.A;
+
+    public static implicit operator ColorRGBA(ColorRGB rgb) => new(rgb.R, rgb.G, rgb.B, 255);
+    public static implicit operator ColorRGBA(ColorHSV hsv) => (ColorRGB)hsv;
+
+    /// <summary>
+    /// Inverts the given <see cref="ColorRGBA"/>.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorRGBA"/>.</param>
+    /// <returns>The inverted <see cref="ColorRGBA"/>.</returns>
+    public static ColorRGBA Invert(ColorRGBA color) => -color;
+
+    /// <summary>
+    /// Adds two <see cref="ColorRGBA"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="ColorRGBA"/>.</param>
+    /// <param name="right">The second <see cref="ColorRGBA"/>.</param>
+    /// <returns>The sum of the two <see cref="ColorRGBA"/>s.</returns>
+    public static ColorRGBA Add(ColorRGBA left, ColorRGBA right) => left + right;
+
+    /// <summary>
+    /// Subtracts one <see cref="ColorRGBA"/> from another.
+    /// </summary>
+    /// <param name="left">The <see cref="ColorRGBA"/> to subtract from.</param>
+    /// <param name="right">The <see cref="ColorRGBA"/> to subtract.</param>
+    /// <returns>The result of subtracting the second <see cref="ColorRGBA"/> from the first.</returns>
+    public static ColorRGBA Subtract(ColorRGBA left, ColorRGBA right) => left - right;
+
+    /// <summary>
+    /// Multiplies a <see cref="ColorRGBA"/> by a scalar value.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorRGBA"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of multiplying the <see cref="ColorRGBA"/> by the scalar value.</returns>
+    public static ColorRGBA Multiply(ColorRGBA color, float value) => color * value;
+
+    /// <summary>
+    /// Divides a <see cref="ColorRGBA"/> by a scalar value.
+    /// </summary>
+    /// <param name="color">The <see cref="ColorRGBA"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of dividing the <see cref="ColorRGBA"/> by the scalar value.</returns>
+    public static ColorRGBA Divide(ColorRGBA color, float value) => color / value;
+
+    /// <summary>
+    /// Calculates the <see cref="ColorRGBA"/> from one point to another.
+    /// </summary>
+    /// <param name="from">The starting point.</param>
+    /// <param name="to">The ending point.</param>
+    /// <returns>The <see cref="ColorRGBA"/> from the starting point to the ending point.</returns>
+    public static ColorRGBA FromTo(ColorRGBA from, ColorRGBA to) => to - from;
+
+    /// <summary>
+    /// Performs linear interpolation between two <see cref="ColorRGBA"/>s.
+    /// </summary>
+    /// <param name="from">The starting <see cref="ColorRGBA"/> (t = 0).</param>
+    /// <param name="to">The ending <see cref="ColorRGBA"/> (t = 1).</param>
+    /// <param name="t">The interpolation parameter.</param>
+    /// <returns>The interpolated <see cref="ColorRGBA"/>.</returns>
+    public static ColorRGBA Lerp(ColorRGBA from, ColorRGBA to, float t) => from + FromTo(from, to) * t;
+
+    /// <summary>
+    /// Converts the <see cref="ColorRGBA"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="ColorRGBA"/>.</returns>
+    public override string ToString() => $"{nameof(ColorRGBA)}({R}, {G}, {B}, {A})";
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="ColorRGBA"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="ColorRGBA"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="ColorRGBA"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is ColorRGBA objVec && R.Equals(objVec.R) && G.Equals(objVec.G) && B.Equals(objVec.B) && A.Equals(objVec.A);
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="ColorRGBA"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="ColorRGBA"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(R, G, B, A);
+}
+
+/// <summary>
+/// Provides extension methods for <see cref="ColorRGBA"/> type.
+/// </summary>
+public static class ColorRGBAExtensions
+{
+    /// <inheritdoc cref="ColorRGBA.Add(ColorRGBA, ColorRGBA)" />
+    public static ColorRGBA Add(this ColorRGBA color, ColorRGBA value) => ColorRGBA.Add(color, value);
+
+    /// <inheritdoc cref="ColorRGBA.Subtract(ColorRGBA, ColorRGBA)" />
+    public static ColorRGBA Subtract(this ColorRGBA color, ColorRGBA value) => ColorRGBA.Subtract(color, value);
+
+    /// <inheritdoc cref="ColorRGBA.Multiply(ColorRGBA, ColorRGBA)" />
+    public static ColorRGBA Multiply(this ColorRGBA color, float value) => ColorRGBA.Multiply(color, value);
+
+    /// <inheritdoc cref="ColorRGBA.Divide(ColorRGBA, ColorRGBA)" />
+    public static ColorRGBA Divide(this ColorRGBA color, float value) => ColorRGBA.Divide(color, value);
+
+    /// <inheritdoc cref="ColorRGBA.FromTo(ColorRGBA, ColorRGBA)" />
+    public static ColorRGBA FromTo(this ColorRGBA from, ColorRGBA to) => ColorRGBA.FromTo(from, to);
+
+    /// <inheritdoc cref="ColorRGBA.Lerp(ColorRGBA, ColorRGBA, float)" />
+    public static ColorRGBA Lerp(this ColorRGBA from, ColorRGBA to, float t) => ColorRGBA.Lerp(from, to, t);
+}

Engine.Core/Primitives/Line2D.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Syntriax.Engine.Core;
@@ -68,12 +67,12 @@ public readonly struct Line2D(Vector2D from, Vector2D to)
     /// </summary>
     public static float GetT(Line2D line, Vector2D point)
     {
-        float fromX = MathF.Abs(line.From.X);
-        float toX = MathF.Abs(line.To.X);
-        float pointX = MathF.Abs(point.X);
+        float fromX = Math.Abs(line.From.X);
+        float toX = Math.Abs(line.To.X);
+        float pointX = Math.Abs(point.X);
 
-        float min = MathF.Min(fromX, toX);
-        float max = MathF.Max(fromX, toX) - min;
+        float min = Math.Min(fromX, toX);
+        float max = Math.Max(fromX, toX) - min;
 
         pointX -= min;
 
@@ -114,8 +113,8 @@ public readonly struct Line2D(Vector2D from, Vector2D to)
     /// </summary>
     public static bool OnSegment(Line2D line, Vector2D point)
     {
-        if (point.X <= MathF.Max(line.From.X, line.To.X) && point.X >= MathF.Min(line.From.X, line.To.X) &&
-            point.Y <= MathF.Max(line.From.Y, line.To.Y) && point.Y >= MathF.Min(line.From.Y, line.To.Y))
+        if (point.X <= Math.Max(line.From.X, line.To.X) && point.X >= Math.Min(line.From.X, line.To.X) &&
+            point.Y <= Math.Max(line.From.Y, line.To.Y) && point.Y >= Math.Min(line.From.Y, line.To.Y))
             return true;
 
         return false;
@@ -173,7 +172,7 @@ public readonly struct Line2D(Vector2D from, Vector2D to)
 
         float t = (pointVector.X * edgeVector.X + pointVector.Y * edgeVector.Y) / (edgeVector.X * edgeVector.X + edgeVector.Y * edgeVector.Y);
 
-        t = MathF.Max(0, MathF.Min(1, t));
+        t = Math.Max(0, Math.Min(1, t));
 
         float closestX = line.From.X + t * edgeVector.X;
         float closestY = line.From.Y + t * edgeVector.Y;

Engine.Core/Primitives/Quaternion.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Syntriax.Engine.Core;
 
 /// <summary>
@@ -178,11 +176,11 @@ public readonly struct Quaternion(float x, float y, float z, float w)
         if (dot > 0.9995f)
             return Lerp(from, to, t);
 
-        float angle = MathF.Acos(dot);
-        float sinAngle = MathF.Sin(angle);
+        float angle = Math.Acos(dot);
+        float sinAngle = Math.Sin(angle);
 
-        float fromWeight = MathF.Sin((1f - t) * angle) / sinAngle;
-        float toWeight = MathF.Sin(t * angle) / sinAngle;
+        float fromWeight = Math.Sin((1f - t) * angle) / sinAngle;
+        float toWeight = Math.Sin(t * angle) / sinAngle;
 
         return from * fromWeight + to * toWeight;
     }
@@ -213,8 +211,8 @@ public readonly struct Quaternion(float x, float y, float z, float w)
     public static Quaternion FromAxisAngle(Vector3D axis, float angle)
     {
         float halfAngle = angle * .5f;
-        float sinHalf = MathF.Sin(halfAngle);
-        return new Quaternion(axis.X * sinHalf, axis.Y * sinHalf, axis.Z * sinHalf, MathF.Cos(halfAngle));
+        float sinHalf = Math.Sin(halfAngle);
+        return new Quaternion(axis.X * sinHalf, axis.Y * sinHalf, axis.Z * sinHalf, Math.Cos(halfAngle));
     }
 
     /// <summary>
@@ -301,7 +299,7 @@ public readonly struct Quaternion(float x, float y, float z, float w)
     /// Generates a hash code for the <see cref="Quaternion"/>.
     /// </summary>
     /// <returns>A hash code for the <see cref="Quaternion"/>.</returns>
-    public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+    public override int GetHashCode() => System.HashCode.Combine(X, Y, Z);
 }
 
 /// <summary>

Engine.Core/Primitives/Shape2D.cs

@@ -11,19 +11,33 @@ namespace Syntriax.Engine.Core;
 /// Initializes a new instance of a <see cref="Shape2D"/> struct with the specified vertices.
 /// </remarks>
 [System.Diagnostics.DebuggerDisplay("Vertices Count: {Vertices.Count}")]
-public readonly struct Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
+public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
 {
-    public static readonly Shape2D Triangle = CreateNgon(3, Vector2D.Up);
-    public static readonly Shape2D Square = CreateNgon(4, Vector2D.One);
-    public static readonly Shape2D Pentagon = CreateNgon(5, Vector2D.Up);
-    public static readonly Shape2D Hexagon = CreateNgon(6, Vector2D.Right);
+    public static Shape2D Triangle => CreateNgon(3, Vector2D.Up);
+    public static Shape2D Square => CreateNgon(4, Vector2D.One);
+    public static Shape2D Pentagon => CreateNgon(5, Vector2D.Up);
+    public static Shape2D Hexagon => CreateNgon(6, Vector2D.Right);
 
-    private readonly List<Vector2D> _verticesList = vertices;
+    public Event<Shape2D> OnShapeUpdated { get; } = new();
+
+    private List<Vector2D> _vertices = vertices;
 
     /// <summary>
     /// Gets the vertices of the <see cref="Shape2D"/>.
     /// </summary>
-    public IReadOnlyList<Vector2D> Vertices => _verticesList;
+    public IReadOnlyList<Vector2D> Vertices
+    {
+        get => _vertices;
+        set
+        {
+            _vertices.Clear();
+
+            foreach (Vector2D vertex in value)
+                _vertices.Add(vertex);
+
+            OnShapeUpdated?.Invoke(this);
+        }
+    }
 
     /// <summary>
     /// The vertex at the specified index.
@@ -207,13 +221,15 @@ public readonly struct Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
     /// <param name="from">The <see cref="Shape2D"/> to transform.</param>
     /// <param name="transform">The <see cref="ITransform2D"/> to apply.</param>
     /// <param name="to">The transformed <see cref="Shape2D"/>.</param>
-    public static void Transform(Shape2D from, ITransform2D transform, ref Shape2D to)
+    public static void Transform(Shape2D from, ITransform2D transform, Shape2D to)
     {
-        to._verticesList.Clear();
+        to._vertices.Clear();
 
-        int count = from._verticesList.Count;
+        int count = from._vertices.Count;
         for (int i = 0; i < count; i++)
-            to._verticesList.Add(transform.Transform(from[i]));
+            to._vertices.Add(transform.Transform(from[i]));
+
+        to.OnShapeUpdated?.Invoke(to);
     }
 
     /// <summary>
@@ -240,6 +256,8 @@ public readonly struct Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
 
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => Vertices.GetEnumerator();
+
+    public readonly record struct ShapeUpdatedArguments(Shape2D shape2D);
 }
 
 /// <summary>
@@ -275,13 +293,13 @@ public static class Shape2DExtensions
     public static Shape2D Transform(this ITransform2D transform, Shape2D shape) => Shape2D.Transform(shape, transform);
 
     /// <inheritdoc cref="Shape2D.Transform(Shape2D, ITransform2D, Shape2D)" />
-    public static void Transform(this ITransform2D transform, Shape2D from, ref Shape2D to) => Shape2D.Transform(from, transform, ref to);
+    public static void Transform(this ITransform2D transform, Shape2D from, Shape2D to) => Shape2D.Transform(from, transform, to);
 
     /// <inheritdoc cref="Shape2D.Transform(Shape2D, ITransform2D)" />
     public static Shape2D Transform(this Shape2D shape, ITransform2D transform) => Shape2D.Transform(shape, transform);
 
-    /// <inheritdoc cref="Shape2D.Transform(Shape2D, ITransform2D, ref Shape2D)" />
-    public static void Transform(this Shape2D from, ITransform2D transform, ref Shape2D to) => Shape2D.Transform(from, transform, ref to);
+    /// <inheritdoc cref="Shape2D.Transform(Shape2D, ITransform2D,Shape2D)" />
+    public static void Transform(this Shape2D from, ITransform2D transform, Shape2D to) => Shape2D.Transform(from, transform, to);
 
     /// <inheritdoc cref="Shape2D.ApproximatelyEquals(Shape2D, Shape2D, float)" />
     public static bool ApproximatelyEquals(this Shape2D left, Shape2D right, float epsilon = float.Epsilon) => Shape2D.ApproximatelyEquals(left, right, epsilon);

Engine.Core/Primitives/Triangle.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Syntriax.Engine.Core;
 
 [System.Diagnostics.DebuggerDisplay("A: {A.ToString(), nq}, B: {B.ToString(), nq}, B: {C.ToString(), nq}")]
@@ -10,7 +8,7 @@ public readonly struct Triangle(Vector2D A, Vector2D B, Vector2D C)
     public readonly Vector2D C { get; init; } = C;
 
     public readonly float Area
-        => .5f * MathF.Abs(
+        => .5f * Math.Abs(
                 A.X * (B.Y - C.Y) +
                 B.X * (C.Y - A.Y) +
                 C.X * (A.Y - B.Y)
@@ -25,7 +23,7 @@ public readonly struct Triangle(Vector2D A, Vector2D B, Vector2D C)
         float slopeBC = (triangle.C.Y - triangle.B.Y) / (triangle.C.X - triangle.B.X);
 
         Vector2D center;
-        if (MathF.Abs(slopeAB - slopeBC) > float.Epsilon)
+        if (Math.Abs(slopeAB - slopeBC) > float.Epsilon)
         {
             float x = (slopeAB * slopeBC * (triangle.A.Y - triangle.C.Y) + slopeBC * (triangle.A.X + triangle.B.X) - slopeAB * (triangle.B.X + triangle.C.X)) / (2f * (slopeBC - slopeAB));
             float y = -(x - (triangle.A.X + triangle.B.X) / 2f) / slopeAB + (triangle.A.Y + triangle.B.Y) / 2f;

Engine.Core/Primitives/Vector2D.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Syntriax.Engine.Core;
 
 /// <summary>
@@ -316,7 +314,7 @@ public readonly struct Vector2D(float x, float y)
     /// Generates a hash code for the <see cref="Vector2D"/>.
     /// </summary>
     /// <returns>A hash code for the <see cref="Vector2D"/>.</returns>
-    public override int GetHashCode() => HashCode.Combine(X, Y);
+    public override int GetHashCode() => System.HashCode.Combine(X, Y);
 }
 
 /// <summary>

Engine.Core/Primitives/Vector3D.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Syntriax.Engine.Core;
 
 /// <summary>
@@ -290,7 +288,7 @@ public readonly struct Vector3D(float x, float y, float z)
     /// Generates a hash code for the <see cref="Vector3D"/>.
     /// </summary>
     /// <returns>A hash code for the <see cref="Vector3D"/>.</returns>
-    public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+    public override int GetHashCode() => System.HashCode.Combine(X, Y, Z);
 }
 
 /// <summary>

Engine.Core/Serialization/Attributes/IgnoreSerializationAttribute.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Class)]
+public class IgnoreSerializationAttribute : Attribute;

Engine.Core/Serialization/Attributes/SerializeAllAttribute.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
+public class SerializeAllAttribute : Attribute;

Engine.Core/Serialization/Attributes/SerializeAttribute.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+public class SerializeAttribute : Attribute;

Engine.Core/Serialization/EntityReference.cs

@@ -0,0 +1,3 @@
+namespace Syntriax.Engine.Core.Serialization;
+
+public record class EntityReference(string? Id = null);

Engine.Core/Serialization/EntityRegistry.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+public class EntityRegistry
+{
+    public Event<EntityRegistry, EntityRegisteredArguments> OnEntityRegistered = null!;
+
+    private readonly Dictionary<string, Action<IEntity>?> assignCallbacks = [];
+    private readonly Dictionary<string, IEntity> registeredEntities = [];
+    public IReadOnlyDictionary<string, IEntity> RegisteredEntities => registeredEntities;
+
+    public void Add(IEntity entity)
+    {
+        if (registeredEntities.TryAdd(entity.Id, entity))
+            OnEntityRegistered?.Invoke(this, new(entity));
+    }
+
+    public void QueueAssign(string id, Action<IEntity> setMethod)
+    {
+        assignCallbacks.TryAdd(id, null);
+        assignCallbacks[id] = assignCallbacks[id] + setMethod;
+    }
+
+    public void AssignAll()
+    {
+        foreach ((string id, Action<IEntity>? action) in assignCallbacks)
+            action?.Invoke(registeredEntities[id]);
+    }
+
+    public void Reset()
+    {
+        assignCallbacks.Clear();
+        registeredEntities.Clear();
+    }
+
+    public readonly record struct EntityRegisteredArguments(IEntity Entity);
+}

Engine.Core/Serialization/ISerializer.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+public interface ISerializer
+{
+    object Deserialize(string configuration);
+    object Deserialize(string configuration, Type type);
+    T Deserialize<T>(string configuration);
+
+    string Serialize(object instance);
+
+    ProgressiveTask<object> DeserializeAsync(string configuration);
+    ProgressiveTask<object> DeserializeAsync(string configuration, Type type);
+    ProgressiveTask<T> DeserializeAsync<T>(string configuration);
+
+    ProgressiveTask<string> SerializeAsync(object instance);
+}

Engine.Core/Serialization/SerializedClass.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using Syntriax.Engine.Core.Factory;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+public class SerializedClass
+{
+    private const BindingFlags PRIVATE_BINDING_FLAGS = BindingFlags.Instance | BindingFlags.NonPublic;
+    private const BindingFlags PUBLIC_BINDING_FLAGS = BindingFlags.Instance | BindingFlags.Public;
+
+    public string Type { get; set; } = string.Empty;
+    public Dictionary<string, object?> Public { get; set; } = [];
+    public Dictionary<string, object?> Private { get; set; } = [];
+
+    public SerializedClass() { }
+    public SerializedClass(object @class)
+    {
+        UpdateClass(@class);
+    }
+
+    private void UpdateClass(object @class)
+    {
+        Type type = @class.GetType();
+        Type = type.FullName ?? type.Name;
+
+        bool shouldSerializeAll = type.HasAttribute<SerializeAllAttribute>();
+
+        Public.Clear();
+        Private.Clear();
+
+        foreach (PropertyInfo privatePropertyInfo in Utils.GetPropertyInfosIncludingBaseClasses(type, PRIVATE_BINDING_FLAGS))
+        {
+            if (privatePropertyInfo.HasAttribute<IgnoreSerializationAttribute>())
+                continue;
+
+            if (privatePropertyInfo.SetMethod is null)
+                continue;
+
+            if (!shouldSerializeAll && !privatePropertyInfo.HasAttribute<SerializeAttribute>())
+                continue;
+
+            object? value = privatePropertyInfo.GetValue(@class);
+            if (value is IEntity entity)
+                Private.Add(privatePropertyInfo.Name, entity.Id);
+            else
+                Private.Add(privatePropertyInfo.Name, value);
+        }
+
+        foreach (PropertyInfo publicPropertyInfo in Utils.GetPropertyInfosIncludingBaseClasses(type, PUBLIC_BINDING_FLAGS))
+        {
+            if (publicPropertyInfo.HasAttribute<IgnoreSerializationAttribute>())
+                continue;
+
+            if (publicPropertyInfo.SetMethod is null)
+                continue;
+
+            if (!shouldSerializeAll && !publicPropertyInfo.HasAttribute<SerializeAttribute>())
+                continue;
+
+            object? value = publicPropertyInfo.GetValue(@class);
+            if (value is IEntity entity)
+                Public.Add(publicPropertyInfo.Name, entity.Id);
+            else
+                Public.Add(publicPropertyInfo.Name, value);
+        }
+
+        foreach (FieldInfo privateFieldInfo in Utils.GetFieldInfosIncludingBaseClasses(type, PRIVATE_BINDING_FLAGS))
+        {
+            if (privateFieldInfo.HasAttribute<System.Runtime.CompilerServices.CompilerGeneratedAttribute>())
+                continue;
+
+            if (!shouldSerializeAll && !privateFieldInfo.HasAttribute<SerializeAttribute>())
+                continue;
+
+            object? value = privateFieldInfo.GetValue(@class);
+            if (value is IEntity entity)
+                Private.Add(privateFieldInfo.Name, entity.Id);
+            else
+                Private.Add(privateFieldInfo.Name, value);
+        }
+
+        foreach (FieldInfo publicFieldInfo in Utils.GetFieldInfosIncludingBaseClasses(type, PUBLIC_BINDING_FLAGS))
+        {
+            if (publicFieldInfo.HasAttribute<System.Runtime.CompilerServices.CompilerGeneratedAttribute>())
+                continue;
+
+            if (!shouldSerializeAll && !publicFieldInfo.HasAttribute<SerializeAttribute>())
+                continue;
+
+            object? value = publicFieldInfo.GetValue(@class);
+            if (value is IEntity entity)
+                Public.Add(publicFieldInfo.Name, entity.Id);
+            else
+                Public.Add(publicFieldInfo.Name, value);
+        }
+    }
+
+    public object CreateInstance()
+    {
+        Type type = TypeFactory.GetType(Type);
+        object instance = TypeFactory.Get(type);
+
+        foreach ((string key, object? value) in Private)
+            AssignVariable(key, type, instance, value, PRIVATE_BINDING_FLAGS);
+
+        foreach ((string key, object? value) in Public)
+            AssignVariable(key, type, instance, value, PUBLIC_BINDING_FLAGS);
+
+        return instance;
+    }
+
+    public object CreateInstance(EntityRegistry? entityRegistry)
+    {
+        if (entityRegistry is null)
+            return CreateInstance();
+
+        Type type = TypeFactory.GetType(Type);
+        object instance = TypeFactory.Get(type);
+
+        foreach ((string key, object? value) in Private)
+            AssignVariable(key, type, instance, value, PRIVATE_BINDING_FLAGS, entityRegistry);
+
+        foreach ((string key, object? value) in Public)
+            AssignVariable(key, type, instance, value, PUBLIC_BINDING_FLAGS, entityRegistry);
+
+        return instance;
+    }
+
+    private static void AssignVariable(string key, Type type, object instance, object? value, BindingFlags bindingFlags, EntityRegistry entityRegistry)
+    {
+        if (type.GetField(key, bindingFlags) is FieldInfo fieldInfo)
+        {
+            if (typeof(IEntity).IsAssignableFrom(fieldInfo.FieldType))
+                entityRegistry.QueueAssign(value?.ToString() ?? "", (entity) => fieldInfo.SetValue(instance, entity));
+            else
+                fieldInfo.SetValue(instance, value);
+        }
+        else if (type.GetProperty(key, bindingFlags) is PropertyInfo propertyInfo)
+        {
+            if (typeof(IEntity).IsAssignableFrom(propertyInfo.PropertyType))
+                entityRegistry.QueueAssign(value?.ToString() ?? "", (entity) => propertyInfo.SetValue(instance, entity));
+            else
+                propertyInfo.SetValue(instance, value);
+        }
+    }
+
+    private static void AssignVariable(string key, Type type, object instance, object? value, BindingFlags bindingFlags)
+    {
+        if (type.GetField(key, bindingFlags) is FieldInfo fieldInfo)
+            fieldInfo.SetValue(instance, value);
+        else if (type.GetProperty(key, bindingFlags) is PropertyInfo propertyInfo)
+            propertyInfo.SetValue(instance, value);
+    }
+}

Engine.Core/Serialization/TypeContainer.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+public class TypeContainer
+{
+    public object? Value { get; set; } = string.Empty;
+    public string Type { get; set; } = string.Empty;
+
+    public TypeContainer() { }
+    public TypeContainer(Type type) { Type = type.FullName ?? string.Empty; }
+    public TypeContainer(object? value) { Value = value; Type = value?.GetType().FullName ?? string.Empty; }
+}

Engine.Core/Serialization/Utils.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Syntriax.Engine.Core.Serialization;
+
+public static class Utils
+{
+    public static bool HasAttribute<T>(this MemberInfo memberInfo) where T : Attribute => memberInfo.GetCustomAttribute<T>() is not null;
+    public static bool IsEnumerable(this Type type) => typeof(System.Collections.IEnumerable).IsAssignableFrom(type) && type != typeof(string);
+
+    public static TypeData GetTypeData(this Type objectType)
+    {
+        List<EventInfo> eventInfos = objectType.GetEvents(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
+            .OrderBy(ei => ei.Name)
+            .ToList();
+
+        List<FieldInfo> fieldInfos = GetFieldInfosIncludingBaseClasses(objectType, BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public)
+                .Where(pi => !eventInfos.Any(ei => pi.Name.CompareTo(ei.Name) == 0)).ToList();
+
+        List<PropertyInfo> propertyInfos = GetPropertyInfosIncludingBaseClasses(objectType, BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.Public)
+            .Where(pi => pi.SetMethod is not null && !eventInfos.Any(ei => pi.Name.CompareTo(ei.Name) == 0))
+            .ToList();
+
+        return new TypeData(fieldInfos, propertyInfos);
+    }
+
+    public static List<FieldInfo> GetFieldInfosIncludingBaseClasses(Type type, BindingFlags bindingFlags)
+    {
+        if (type.BaseType is null)
+            return [.. type.GetFields(bindingFlags)];
+
+        Type currentType = type;
+        FieldInfoComparer fieldComparer = new();
+        HashSet<FieldInfo> fieldInfoList = new(type.GetFields(bindingFlags), fieldComparer);
+
+        while (currentType.BaseType is Type baseType)
+        {
+            currentType = baseType;
+            fieldInfoList.UnionWith(currentType!.GetFields(bindingFlags));
+        }
+
+        return [.. fieldInfoList.OrderBy(fi => fi.Name)];
+    }
+
+    public static List<PropertyInfo> GetPropertyInfosIncludingBaseClasses(Type type, BindingFlags bindingFlags)
+    {
+        if (type.BaseType is null)
+            return [.. type.GetProperties(bindingFlags)];
+
+        Type currentType = type;
+        PropertyInfoComparer propertyComparer = new();
+        HashSet<PropertyInfo> propertyInfoList = new(type.GetProperties(bindingFlags), propertyComparer);
+
+        while (currentType.BaseType is Type baseType)
+        {
+            currentType = baseType;
+            propertyInfoList.UnionWith(currentType.GetProperties(bindingFlags));
+        }
+
+        return [.. propertyInfoList.OrderBy(pi => pi.Name)];
+    }
+
+    private class FieldInfoComparer : IEqualityComparer<FieldInfo>
+    {
+        public bool Equals(FieldInfo? x, FieldInfo? y) => x?.DeclaringType == y?.DeclaringType && x?.Name == y?.Name;
+        public int GetHashCode(FieldInfo obj) => obj.Name.GetHashCode() ^ obj.DeclaringType!.GetHashCode();
+    }
+
+    private class PropertyInfoComparer : IEqualityComparer<PropertyInfo>
+    {
+        public bool Equals(PropertyInfo? x, PropertyInfo? y) => x?.DeclaringType == y?.DeclaringType && x?.Name == y?.Name;
+        public int GetHashCode(PropertyInfo obj) => obj.Name.GetHashCode() ^ obj.DeclaringType!.GetHashCode();
+    }
+}
+
+public record struct TypeData(IEnumerable<FieldInfo> Fields, IEnumerable<PropertyInfo> Properties)
+{
+    public static implicit operator (IEnumerable<FieldInfo> fields, IEnumerable<PropertyInfo> properties)(TypeData value) => (value.Fields, value.Properties);
+    public static implicit operator TypeData((IEnumerable<FieldInfo> fields, IEnumerable<PropertyInfo> properties) value) => new(value.fields, value.properties);
+}

Engine.Core/StateEnable.cs

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

Engine.Core/Systems/Abstract/IDraw.cs

@@ -0,0 +1,12 @@
+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

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

Engine.Core/Systems/Abstract/IPostDraw.cs

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,51 @@
+
+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

@@ -0,0 +1,74 @@
+
+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 arguments)
+    {
+        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 arguments)
+    {
+        for (int i = updateEntities.Count - 1; i >= 0; i--)
+            updateEntities[i].Update();
+    }
+
+    private void OnPostUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    {
+        for (int i = postUpdateEntities.Count - 1; i >= 0; i--)
+            postUpdateEntities[i].PostUpdate();
+    }
+
+    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments arguments)
+    {
+        toCallFirstFrameUpdates.Add(arguments.BehaviourCollected);
+    }
+
+    public UpdateManager()
+    {
+        firstFrameUpdates.OnCollected.AddListener(OnFirstFrameCollected);
+    }
+}

Engine.Core/Transform2D.cs

@@ -1,19 +1,21 @@
+using Syntriax.Engine.Core.Serialization;
+
 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.PositionChangedEventHandler? OnPositionChanged = null;
-    public event ITransform2D.ScaleChangedEventHandler? OnScaleChanged = null;
-    public event ITransform2D.RotationChangedEventHandler? OnRotationChanged = null;
+    public Event<ITransform2D, ITransform2D.PositionChangedArguments> OnPositionChanged { get; } = new();
+    public Event<ITransform2D, ITransform2D.ScaleChangedArguments> OnScaleChanged { get; } = new();
+    public Event<ITransform2D, ITransform2D.RotationChangedArguments> OnRotationChanged { get; } = new();
 
     private Vector2D _position = Vector2D.Zero;
     private Vector2D _scale = Vector2D.One;
     private float _rotation = 0f;
 
-    private Vector2D _localPosition = Vector2D.Zero;
-    private Vector2D _localScale = Vector2D.One;
-    private float _localRotation = 0f;
+    [Serialize] private Vector2D _localPosition = Vector2D.Zero;
+    [Serialize] private Vector2D _localScale = Vector2D.One;
+    [Serialize] private float _localRotation = 0f;
 
     private ITransform2D? parentTransform = null;
 
@@ -29,7 +31,7 @@ public class Transform2D : Behaviour, ITransform2D
             _position = value;
 
             UpdateLocalPosition();
-            OnPositionChanged?.InvokeSafe(this, _position);
+            OnPositionChanged?.Invoke(this, new(previousPosition));
         }
     }
 
@@ -45,7 +47,7 @@ public class Transform2D : Behaviour, ITransform2D
             _scale = value;
 
             UpdateLocalScale();
-            OnScaleChanged?.InvokeSafe(this, previousScale);
+            OnScaleChanged?.Invoke(this, new(previousScale));
         }
     }
 
@@ -61,7 +63,7 @@ public class Transform2D : Behaviour, ITransform2D
             _rotation = value;
 
             UpdateLocalRotation();
-            OnRotationChanged?.InvokeSafe(this, previousRotation);
+            OnRotationChanged?.Invoke(this, new(previousRotation));
         }
     }
 
@@ -77,7 +79,7 @@ public class Transform2D : Behaviour, ITransform2D
             _localPosition = value;
 
             UpdatePosition();
-            OnPositionChanged?.InvokeSafe(this, previousPosition);
+            OnPositionChanged?.Invoke(this, new(previousPosition));
         }
     }
 
@@ -95,8 +97,8 @@ public class Transform2D : Behaviour, ITransform2D
 
             UpdateScale();
             UpdatePosition();
-            OnScaleChanged?.InvokeSafe(this, previousScale);
-            OnPositionChanged?.InvokeSafe(this, previousPosition);
+            OnScaleChanged?.Invoke(this, new(previousScale));
+            OnPositionChanged?.Invoke(this, new(previousPosition));
         }
     }
 
@@ -112,21 +114,21 @@ public class Transform2D : Behaviour, ITransform2D
             _localRotation = value;
 
             UpdateRotation();
-            OnRotationChanged?.InvokeSafe(this, previousRotation);
+            OnRotationChanged?.Invoke(this, new(previousRotation));
         }
     }
 
-    private void RecalculatePosition(ITransform2D _, Vector2D previousPosition)
+    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments arguments)
     {
         if (parentTransform is null)
             return;
 
         UpdatePosition();
 
-        OnPositionChanged?.InvokeSafe(this, previousPosition);
+        OnPositionChanged?.Invoke(this, arguments);
     }
 
-    private void RecalculateScale(ITransform2D _, Vector2D previousScale)
+    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments arguments)
     {
         if (parentTransform is null)
             return;
@@ -136,11 +138,11 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateScale();
         UpdatePosition();
 
-        OnScaleChanged?.InvokeSafe(this, previousScale);
-        OnPositionChanged?.InvokeSafe(this, previousPosition);
+        OnScaleChanged?.Invoke(this, arguments);
+        OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
-    private void RecalculateRotation(ITransform2D _, float previousRotation)
+    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments arguments)
     {
         if (parentTransform is null)
             return;
@@ -150,8 +152,8 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateRotation();
         UpdatePosition();
 
-        OnRotationChanged?.InvokeSafe(this, previousRotation);
-        OnPositionChanged?.InvokeSafe(this, previousPosition);
+        OnRotationChanged?.Invoke(this, arguments);
+        OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
     private void UpdateLocalPosition()
@@ -205,12 +207,12 @@ public class Transform2D : Behaviour, ITransform2D
     protected override void InitializeInternal()
     {
         UpdateReferences(UniverseObject.Parent);
-        UniverseObject.OnParentChanged += OnParentChanged;
+        UniverseObject.OnParentChanged.AddListener(OnParentChanged);
     }
 
     protected override void FinalizeInternal()
     {
-        UniverseObject.OnParentChanged -= OnParentChanged;
+        UniverseObject.OnParentChanged.RemoveListener(OnParentChanged);
     }
 
     private void UpdateReferences(IUniverseObject? parent)
@@ -218,48 +220,48 @@ public class Transform2D : Behaviour, ITransform2D
         ITransform2D? previousParent = parentTransform;
         if (previousParent is not null)
         {
-            previousParent.OnPositionChanged -= RecalculatePosition;
-            previousParent.OnScaleChanged -= RecalculateScale;
-            previousParent.OnRotationChanged -= RecalculateRotation;
-            previousParent.BehaviourController.UniverseObject.OnParentChanged -= OnParentChanged;
-            previousParent.BehaviourController.OnBehaviourAdded -= LookForTransform2D;
+            previousParent.OnPositionChanged.RemoveListener(RecalculatePosition);
+            previousParent.OnScaleChanged.RemoveListener(RecalculateScale);
+            previousParent.OnRotationChanged.RemoveListener(RecalculateRotation);
+            previousParent.BehaviourController.UniverseObject.OnParentChanged.RemoveListener(OnParentChanged);
+            previousParent.BehaviourController.OnBehaviourAdded.RemoveListener(LookForTransform2D);
         }
 
         parentTransform = parent?.BehaviourController.GetBehaviour<ITransform2D>();
 
         if (parentTransform is not null)
         {
-            parentTransform.OnPositionChanged += RecalculatePosition;
-            parentTransform.OnScaleChanged += RecalculateScale;
-            parentTransform.OnRotationChanged += RecalculateRotation;
-            parentTransform.BehaviourController.UniverseObject.OnParentChanged += OnParentChanged;
+            parentTransform.OnPositionChanged.AddListener(RecalculatePosition);
+            parentTransform.OnScaleChanged.AddListener(RecalculateScale);
+            parentTransform.OnRotationChanged.AddListener(RecalculateRotation);
+            parentTransform.BehaviourController.UniverseObject.OnParentChanged.AddListener(OnParentChanged);
 
             UpdatePosition();
             UpdateScale();
             UpdateRotation();
         }
         else if (UniverseObject.Parent is not null)
-            UniverseObject.Parent.BehaviourController.OnBehaviourAdded += LookForTransform2D;
+            UniverseObject.Parent.BehaviourController.OnBehaviourAdded.AddListener(LookForTransform2D);
 
         UpdateLocalPosition();
         UpdateLocalScale();
         UpdateLocalRotation();
 
-        OnPositionChanged?.InvokeSafe(this, Position);
-        OnScaleChanged?.InvokeSafe(this, Scale);
-        OnRotationChanged?.InvokeSafe(this, Rotation);
+        OnPositionChanged?.Invoke(this, new(Position));
+        OnScaleChanged?.Invoke(this, new(Scale));
+        OnRotationChanged?.Invoke(this, new(Rotation));
     }
 
-    private void LookForTransform2D(IBehaviourController sender, IBehaviour behaviourAdded)
+    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
     {
-        if (behaviourAdded is not ITransform2D transform2D)
+        if (arguments.BehaviourAdded is not ITransform2D)
             return;
 
         UpdateReferences(UniverseObject.Parent);
     }
 
-    private void OnParentChanged(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
+    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments arguments)
     {
-        UpdateReferences(newParent);
+        UpdateReferences(arguments.CurrentParent);
     }
 }

Engine.Core/Universe.cs

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

Engine.Core/UniverseObject.cs

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

Engine.Physics2D/Abstract/ICollider2D.cs

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

Engine.Physics2D/Abstract/IPhysicsEngine2D.cs

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

Engine.Physics2D/Abstract/Updates/IPostPhysicsUpdate.cs

@@ -0,0 +1,15 @@
+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

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

Engine.Physics2D/Collider2DShapeBehaviour.cs

@@ -18,7 +18,7 @@ public class Collider2DShapeBehaviour : Collider2DBehaviourBase, IShapeCollider2
     private Shape2D _shapeWorld = Shape2D.Square.CreateCopy();
     private Shape2D _shapeLocal = Shape2D.Square;
 
-    public override void CalculateCollider() => Transform.Transform(ShapeLocal, ref _shapeWorld);
+    public override void CalculateCollider() => ShapeLocal.Transform(Transform, _shapeWorld);
 
     public Collider2DShapeBehaviour() { }
     public Collider2DShapeBehaviour(Shape2D shape)

Engine.Physics2D/Engine.Physics2D.csproj

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

Engine.Physics2D/Physics2D.cs

@@ -2,7 +2,7 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Physics2D;
 
-public static partial class Physics2D
+public static class Physics2D
 {
     public static bool Overlaps(this Shape2D shape, Vector2D point) => Overlaps(shape, point, out float _);
     public static bool Overlaps(this Shape2D shape, Vector2D point, out float depth)

Engine.Physics2D/PhysicsCoroutineManager.cs

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

Engine.Physics2D/PhysicsEngine2D.cs

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

Engine.Physics2D/PhysicsEngine2DStandalone.cs

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

Engine.Physics2D/Preserver.cs

@@ -0,0 +1,10 @@
+namespace Syntriax.Engine.Physics2D
+{
+    // This is pretty much so the assembly gets loaded automatically because 
+    // the builds include the assembly but sometimes doesn't link load it at startup.
+    // I will hopefully one day fix it and remove this. 
+    public static class Preserver
+    {
+        public static void Preserve() { }
+    }
+}

Engine.Serializers/Engine.Serializers.Yaml/Converters/Abstract/IEngineTypeYamlConverter.cs

@@ -0,0 +1,13 @@
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Serialization;
+
+using YamlDotNet.Serialization;
+
+namespace Syntriax.Engine.Serializers.Yaml;
+
+public interface IEngineTypeYamlConverter : IYamlTypeConverter
+{
+    YamlSerializer Serializer { get; set; }
+    EntityRegistry EntityRegistry { get; set; }
+    IProgressionTracker ProgressionTracker { get; set; }
+}

Engine.Serializers/Engine.Serializers.Yaml/Converters/BehaviourControllerConverter.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Serialization;
+
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace Syntriax.Engine.Serializers.Yaml;
+
+public class BehaviourControllerConverter : EngineTypeYamlSerializerBase<IBehaviourController>
+{
+    private const string BEHAVIOURS_SCALAR_NAME = "Behaviours";
+
+    public override IBehaviourController? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
+    {
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Reading behaviour controller");
+
+        string id;
+
+        IBehaviourController behaviourController;
+        IStateEnable stateEnable;
+        List<IBehaviour> behaviours;
+
+        parser.Consume<MappingStart>();
+
+        if (parser.Consume<Scalar>().Value.CompareTo(nameof(IBehaviourController.Id)) != 0)
+            throw new();
+        id = parser.Consume<Scalar>().Value;
+
+        if (parser.Consume<Scalar>().Value.CompareTo(SERIALIZED_SCALAR_NAME) != 0)
+            throw new();
+        SerializedClass instanceSerializedClass = (SerializedClass)rootDeserializer(typeof(SerializedClass))!;
+        ProgressionTracker.Set(isTrackingController ? .5f : ProgressionTracker.Progression, $"Creating {instanceSerializedClass.Type}");
+        behaviourController = (IBehaviourController)instanceSerializedClass.CreateInstance(EntityRegistry);
+
+        string value = parser.Consume<Scalar>().Value;
+        if (value.CompareTo(nameof(IBehaviourController.StateEnable)) != 0)
+            throw new();
+        stateEnable = (IStateEnable)rootDeserializer(typeof(IStateEnable))!;
+
+        if (parser.Consume<Scalar>().Value.CompareTo(BEHAVIOURS_SCALAR_NAME) != 0)
+            throw new();
+        behaviours = (List<IBehaviour>)rootDeserializer(typeof(List<IBehaviour>))!;
+
+        parser.Consume<MappingEnd>();
+
+        behaviourController.Id = id;
+
+        stateEnable.Assign(behaviourController);
+        behaviourController.Assign(stateEnable);
+
+        foreach (IBehaviour behaviour in behaviours)
+            behaviourController.AddBehaviour(behaviour);
+
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Created {instanceSerializedClass.Type}");
+        return behaviourController;
+    }
+
+    public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
+    {
+        IBehaviourController behaviourController = (IBehaviourController)value!;
+
+        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
+        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing behaviour controller");
+
+        emitter.Emit(new MappingStart());
+
+        emitter.Emit(new Scalar(nameof(IBehaviourController.Id)));
+        emitter.Emit(new Scalar(behaviourController.Id));
+
+        emitter.Emit(new Scalar(SERIALIZED_SCALAR_NAME));
+        serializer(new SerializedClass(behaviourController));
+
+        emitter.Emit(new Scalar(nameof(IBehaviourController.StateEnable)));
+        serializer(behaviourController.StateEnable);
+
+        emitter.Emit(new Scalar(BEHAVIOURS_SCALAR_NAME));
+        serializer(behaviourController.GetBehaviours<IBehaviour>().Where(b => !b.GetType().HasAttribute<IgnoreSerializationAttribute>()));
+
+        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized behaviour controller");
+        emitter.Emit(new MappingEnd());
+    }
+}