feat: basic universe object tests

Use IUniverseObject.Children to access children

Engine.Core/Abstract/IUniverse.cs

@@ -37,11 +37,21 @@ public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
     /// </summary>
     Event<IUniverse> OnPostDraw { get; }
 
+    /// <summary>
+    /// Event triggered when a <see cref="IUniverseObject"/> is about to be registered to the <see cref="IUniverse"/>.
+    /// </summary>
+    Event<IUniverse, UniverseObjectRegisteredArguments> OnPreUniverseObjectRegistered { get; }
+
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is registered to the <see cref="IUniverse"/>.
     /// </summary>
     Event<IUniverse, UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; }
 
+    /// <summary>
+    /// Event triggered when a <see cref="IUniverseObject"/> is about to be unregistered from the <see cref="IUniverse"/>.
+    /// </summary>
+    Event<IUniverse, UniverseObjectUnRegisteredArguments> OnPreUniverseObjectUnRegistered { get; }
+
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is unregistered from the <see cref="IUniverse"/>.
     /// </summary>

Engine.Core/Abstract/IUniverseObject.cs

@@ -7,7 +7,7 @@ namespace Syntriax.Engine.Core;
 /// This interface allows for tracking the object's presence in the universe and provides events 
 /// for notifying when the see enters or exits the universe.
 /// </summary>
-public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourController, IEnumerable<IUniverseObject>
+public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourController
 {
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> enters the universe.
@@ -47,7 +47,7 @@ public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourCon
     /// <summary>
     /// The parent <see cref="IUniverseObject"/> of the <see cref="IUniverseObject"/>.
     /// </summary>
-    IUniverseObject? Parent { get; }
+    IUniverseObject? Parent { get; set; }
 
     /// <summary>
     /// The <see cref="IUniverseObject"/>s that have this <see cref="IUniverseObject"/> as their <see cref="Parent"/>.
@@ -75,12 +75,6 @@ public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourCon
     /// </returns>
     internal bool ExitUniverse();
 
-    /// <summary>
-    /// Sets the parent <see cref="IUniverseObject"/> of this <see cref="IUniverseObject"/>.
-    /// </summary>
-    /// <param name="universeObject">The parent <see cref="IUniverseObject"/> to set.</param>
-    void SetParent(IUniverseObject? universeObject);
-
     /// <summary>
     /// Adds a child <see cref="IUniverseObject"/> to this <see cref="IUniverseObject"/>.
     /// </summary>

Engine.Core/BehaviourBase.cs

@@ -44,6 +44,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         _behaviourController = behaviourController;
         OnAssign(behaviourController);
         behaviourController.OnUniverseObjectAssigned.AddListener(delegateOnUniverseObjectAssigned);
+        behaviourController.StateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
         if (behaviourController.UniverseObject is not null)
             OnUniverseObjectAssigned(behaviourController);
         OnBehaviourControllerAssigned?.Invoke(this);
@@ -68,6 +69,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(delegateOnUniverseObjectActiveChanged);
         StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
         BehaviourController.OnUniverseObjectAssigned.RemoveListener(delegateOnUniverseObjectAssigned);
+        BehaviourController.StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
         base.UnassignInternal();
         _behaviourController = null!;
     }
@@ -76,6 +78,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     {
         Debug.Assert.AssertBehaviourControllerAssigned(this);
         Debug.Assert.AssertStateEnableAssigned(this);
+
+        UpdateActive();
     }
 
     private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
@@ -84,7 +88,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     private void UpdateActive()
     {
         bool previousActive = IsActive;
-        _isActive = StateEnable.Enabled && _behaviourController.UniverseObject.IsActive;
+        _isActive = StateEnable.Enabled && _behaviourController.StateEnable.Enabled && _behaviourController.UniverseObject.IsActive;
 
         if (previousActive != IsActive)
             OnActiveChanged?.Invoke(this, new(previousActive));

Engine.Core/BehaviourCollector.cs

@@ -76,7 +76,7 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
             OnUniverseObjectRegistered(universe, new(universeObject));
 
         universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
+        universe.OnPreUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnAssign(universe);
@@ -94,7 +94,7 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
             OnUniverseObjectUnregistered(Universe, new(universeObject));
 
         Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
+        Universe.OnPreUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);

Engine.Core/BehaviourController.cs

@@ -72,7 +72,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
 
     public void RemoveBehaviour<T>(bool removeAll = false) where T : class, IBehaviour
     {
-        for (int i = behaviours.Count; i >= 0; i--)
+        for (int i = behaviours.Count - 1; i >= 0; i--)
         {
             if (behaviours[i] is not T behaviour)
                 continue;

Engine.Core/Debug/AssertHelpers.cs

@@ -10,21 +10,21 @@ public static class Assert
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void AssertBehaviourControllerAssigned(IHasBehaviourController assignable)
-        => System.Diagnostics.Debug.Assert(assignable.BehaviourController is not null, $"{assignable.GetType().Name} must be initialized");
+        => System.Diagnostics.Debug.Assert(assignable.BehaviourController is not null, $"{assignable.GetType().Name} must be assigned an {nameof(IBehaviourController)}");
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void AssertEntityAssigned(IHasEntity assignable)
-        => System.Diagnostics.Debug.Assert(assignable.Entity is not null, $"{assignable.GetType().Name} must be initialized");
+        => System.Diagnostics.Debug.Assert(assignable.Entity is not null, $"{assignable.GetType().Name} must be assigned an {nameof(IEntity)}");
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void AssertUniverseAssigned(IHasUniverse assignable)
-        => System.Diagnostics.Debug.Assert(assignable.Universe is not null, $"{assignable.GetType().Name} must be initialized");
+        => System.Diagnostics.Debug.Assert(assignable.Universe is not null, $"{assignable.GetType().Name} must be assigned an {nameof(IUniverse)}");
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void AssertUniverseObjectAssigned(IHasUniverseObject assignable)
-        => System.Diagnostics.Debug.Assert(assignable.UniverseObject is not null, $"{assignable.GetType().Name} must be initialized");
+        => System.Diagnostics.Debug.Assert(assignable.UniverseObject is not null, $"{assignable.GetType().Name} must be assigned an {nameof(IUniverseObject)}");
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void AssertStateEnableAssigned(IHasStateEnable assignable)
-        => System.Diagnostics.Debug.Assert(assignable.StateEnable is not null, $"{assignable.GetType().Name} must be initialized");
+        => System.Diagnostics.Debug.Assert(assignable.StateEnable is not null, $"{assignable.GetType().Name} must be assigned an {nameof(IStateEnable)}");
 }

Engine.Core/Extensions/BehaviourControllerExtensions.cs

@@ -27,7 +27,7 @@ public static class BehaviourControllerExtensions
     /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
     /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
     public static T GetRequiredBehaviour<T>(this IBehaviourController behaviourController) where T : class
-        => behaviourController.GetBehaviour<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName}");
+        => behaviourController.GetBehaviour<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject?.Name ?? "NULL"}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName}");
 
     /// <summary>
     /// Gets an existing <see cref="IBehaviour"/> of the specified type, or adds and returns a new one if it doesn't exist.
@@ -93,7 +93,7 @@ public static class BehaviourControllerExtensions
     /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
     /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
     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");
+        => behaviourController.GetBehaviourInParent<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject?.Name ?? "NULL"}'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.
@@ -140,7 +140,7 @@ public static class BehaviourControllerExtensions
         if (behaviourController.GetBehaviour<T>() is T localBehaviour)
             return localBehaviour;
 
-        foreach (IUniverseObject child in behaviourController.UniverseObject)
+        foreach (IUniverseObject child in behaviourController.UniverseObject.Children)
             if (GetBehaviourInChildren<T>(child.BehaviourController) is T behaviour)
                 return behaviour;
 
@@ -154,7 +154,7 @@ public static class BehaviourControllerExtensions
     /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
     /// <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 ");
+        => behaviourController.GetBehaviourInChildren<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject?.Name ?? "NULL"}'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.
@@ -176,7 +176,7 @@ public static class BehaviourControllerExtensions
         foreach (T behaviour in cache)
             behaviours.Add(behaviour);
 
-        foreach (IUniverseObject child in universeObject)
+        foreach (IUniverseObject child in universeObject.Children)
             TraverseChildrenForBehaviour(child, behaviours, cache);
     }
 }

Engine.Core/Extensions/UniverseObjectExtensions.cs

@@ -12,7 +12,7 @@ public static class UniverseObjectExtensions
         if (!string.IsNullOrWhiteSpace(name))
             universeObject.Name = name;
         if (parent is not null)
-            universeObject.SetParent(parent);
+            universeObject.Parent = parent;
         return universeObject;
     }
 
@@ -81,7 +81,7 @@ public static class UniverseObjectExtensions
     /// <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)
+        if (universeObject.Children.GetUniverseObject<T>() is T localUniverseObject)
             return localUniverseObject;
 
         IUniverseObject? parent = universeObject;
@@ -129,10 +129,10 @@ public static class UniverseObjectExtensions
     /// <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)
+        if (universeObject.Children.GetUniverseObject<T>() is T localUniverseObject)
             return localUniverseObject;
 
-        foreach (IUniverseObject child in universeObject)
+        foreach (IUniverseObject child in universeObject.Children)
             if (GetUniverseObjectInChildren<T>(child) is T behaviour)
                 return behaviour;
 
@@ -246,7 +246,7 @@ public static class UniverseObjectExtensions
 
         foreach (IUniverseObject universeObject in universeObjects)
         {
-            universeObject.Find(cache);
+            universeObject.Children.Find(cache);
             foreach (T behaviour in cache)
                 instances.Add(behaviour);
         }

Engine.Core/Factory/BehaviourControllerFactory.cs

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

Engine.Core/Factory/BehaviourFactory.cs

@@ -12,12 +12,15 @@ public class BehaviourFactory
     {
         T behaviour = TypeFactory.Get<T>(args);
 
-        stateEnable ??= TypeFactory.Get<StateEnable>();
+        if (stateEnable is not null)
-        if (!stateEnable.Assign(behaviour))
+        {
-            throw AssignFailedException.From(stateEnable, behaviour);
+            if (!stateEnable.Assign(behaviour))
-
+                throw AssignFailedException.From(stateEnable, behaviour);
-        if (!behaviour.Assign(stateEnable))
+            if (!behaviour.Assign(stateEnable))
-            throw AssignFailedException.From(behaviour, stateEnable);
+                throw AssignFailedException.From(behaviour, stateEnable);
+        }
+        else
+            StateEnableFactory.Instantiate(behaviour);
 
         return behaviour;
     }

Engine.Core/Factory/UniverseObjectFactory.cs

@@ -18,18 +18,25 @@ public class UniverseObjectFactory
     {
         T universeObject = TypeFactory.Get<T>(args);
 
-        behaviourController ??= TypeFactory.Get<BehaviourController>();
+        if (behaviourController is not null)
-        stateEnable ??= TypeFactory.Get<StateEnable>();
+        {
+            if (!behaviourController.Assign(universeObject))
+                throw AssignFailedException.From(behaviourController, universeObject);
+            if (!universeObject.Assign(behaviourController))
+                throw AssignFailedException.From(universeObject, behaviourController);
+        }
+        else
+            BehaviourControllerFactory.Instantiate(universeObject);
 
-        if (!behaviourController.Assign(universeObject))
+        if (stateEnable is not null)
-            throw AssignFailedException.From(behaviourController, universeObject);
+        {
-        if (!stateEnable.Assign(universeObject))
+            if (!stateEnable.Assign(universeObject))
-            throw AssignFailedException.From(stateEnable, universeObject);
+                throw AssignFailedException.From(stateEnable, universeObject);
-
+            if (!universeObject.Assign(stateEnable))
-        if (!universeObject.Assign(behaviourController))
+                throw AssignFailedException.From(universeObject, stateEnable);
-            throw AssignFailedException.From(universeObject, behaviourController);
+        }
-        if (!universeObject.Assign(stateEnable))
+        else
-            throw AssignFailedException.From(universeObject, stateEnable);
+            StateEnableFactory.Instantiate(universeObject);
 
         return universeObject;
     }

Engine.Core/Systems/Abstract/IEnterUniverse.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Core;
+
+public interface IEnterUniverse : IBehaviour
+{
+    void EnterUniverse(IUniverse universe);
+}

Engine.Core/Systems/Abstract/IExitUniverse.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Core;
+
+public interface IExitUniverse : IBehaviour
+{
+    void ExitUniverse(IUniverse universe);
+}

Engine.Core/Systems/Abstract/ILastFrameUpdate.cs

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

Engine.Core/Systems/UniverseEntranceManager.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class UniverseEntranceManager : Behaviour
+{
+    // We use Ascending order because we are using reverse for loop to call them
+    private static Comparer<IBehaviour> SortByAscendingPriority() => Comparer<IBehaviour>.Create((x, y) => x.Priority.CompareTo(y.Priority));
+
+    private readonly ActiveBehaviourCollectorSorted<IEnterUniverse> enterUniverses = new() { SortBy = SortByAscendingPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IExitUniverse> exitUniverses = new() { SortBy = SortByAscendingPriority() };
+
+    private readonly List<IEnterUniverse> toCallEnterUniverses = new(32);
+    private readonly List<IExitUniverse> toCallExitUniverses = new(32);
+
+    protected override void OnEnteredUniverse(IUniverse universe)
+    {
+        enterUniverses.Assign(universe);
+
+        foreach (IUniverseObject universeObject in Universe.UniverseObjects)
+            OnUniverseObjectRegistered(Universe, new(universeObject));
+
+        universe.OnUniverseObjectRegistered.AddListener(OnUniverseObjectRegistered);
+        universe.OnUniverseObjectUnRegistered.AddListener(OnUniverseObjectUnRegistered);
+    }
+
+    protected override void OnExitedUniverse(IUniverse universe)
+    {
+        enterUniverses.Unassign();
+
+        foreach (IUniverseObject universeObject in Universe.UniverseObjects)
+            OnUniverseObjectUnRegistered(Universe, new(universeObject));
+
+        universe.OnUniverseObjectRegistered.RemoveListener(OnUniverseObjectRegistered);
+        universe.OnUniverseObjectUnRegistered.RemoveListener(OnUniverseObjectUnRegistered);
+    }
+
+    private void OnUniverseObjectUnRegistered(IUniverse sender, IUniverse.UniverseObjectUnRegisteredArguments args)
+    {
+        for (int i = toCallExitUniverses.Count - 1; i >= 0; i--)
+        {
+            toCallExitUniverses[i].ExitUniverse(Universe);
+            toCallExitUniverses.RemoveAt(i);
+        }
+    }
+
+    private void OnUniverseObjectRegistered(IUniverse sender, IUniverse.UniverseObjectRegisteredArguments args)
+    {
+        for (int i = toCallEnterUniverses.Count - 1; i >= 0; i--)
+        {
+            toCallEnterUniverses[i].EnterUniverse(Universe);
+            toCallEnterUniverses.RemoveAt(i);
+        }
+    }
+
+    private void OnEnterUniverseCollected(IBehaviourCollector<IEnterUniverse> sender, IBehaviourCollector<IEnterUniverse>.BehaviourCollectedArguments args)
+    {
+        toCallEnterUniverses.Add(args.BehaviourCollected);
+    }
+
+    private void OnExitUniverseCollected(IBehaviourCollector<IExitUniverse> sender, IBehaviourCollector<IExitUniverse>.BehaviourCollectedArguments args)
+    {
+        toCallExitUniverses.Add(args.BehaviourCollected);
+    }
+
+    public UniverseEntranceManager()
+    {
+        enterUniverses.OnCollected.AddListener(OnEnterUniverseCollected);
+        exitUniverses.OnCollected.AddListener(OnExitUniverseCollected);
+    }
+}

Engine.Core/Systems/UpdateManager.cs

@@ -8,6 +8,7 @@ public class UpdateManager : Behaviour
     private static Comparer<IBehaviour> SortByAscendingPriority() => Comparer<IBehaviour>.Create((x, y) => x.Priority.CompareTo(y.Priority));
 
     private readonly ActiveBehaviourCollectorSorted<IFirstFrameUpdate> firstFrameUpdates = new() { SortBy = SortByAscendingPriority() };
+    private readonly ActiveBehaviourCollector<ILastFrameUpdate> lastFrameUpdates = new();
     private readonly ActiveBehaviourCollectorSorted<IPreUpdate> preUpdateEntities = new() { SortBy = SortByAscendingPriority() };
     private readonly ActiveBehaviourCollectorSorted<IUpdate> updateEntities = new() { SortBy = SortByAscendingPriority() };
     private readonly ActiveBehaviourCollectorSorted<IPostUpdate> postUpdateEntities = new() { SortBy = SortByAscendingPriority() };
@@ -17,6 +18,7 @@ public class UpdateManager : Behaviour
     protected override void OnEnteredUniverse(IUniverse universe)
     {
         firstFrameUpdates.Assign(universe);
+        lastFrameUpdates.Assign(universe);
         preUpdateEntities.Assign(universe);
         updateEntities.Assign(universe);
         postUpdateEntities.Assign(universe);
@@ -29,6 +31,7 @@ public class UpdateManager : Behaviour
     protected override void OnExitedUniverse(IUniverse universe)
     {
         firstFrameUpdates.Unassign();
+        lastFrameUpdates.Unassign();
         preUpdateEntities.Unassign();
         updateEntities.Unassign();
         postUpdateEntities.Unassign();
@@ -67,8 +70,14 @@ public class UpdateManager : Behaviour
         toCallFirstFrameUpdates.Add(args.BehaviourCollected);
     }
 
+    private void OnLastFrameRemoved(IBehaviourCollector<ILastFrameUpdate> sender, IBehaviourCollector<ILastFrameUpdate>.BehaviourRemovedArguments args)
+    {
+        args.BehaviourRemoved.LastActiveFrame();
+    }
+
     public UpdateManager()
     {
         firstFrameUpdates.OnCollected.AddListener(OnFirstFrameCollected);
+        lastFrameUpdates.OnRemoved.AddListener(OnLastFrameRemoved);
     }
 }

Engine.Core/Universe.cs

@@ -13,7 +13,9 @@ public class Universe : BaseEntity, IUniverse
     public Event<IUniverse> OnPreDraw { get; } = new();
     public Event<IUniverse> OnDraw { get; } = new();
     public Event<IUniverse> OnPostDraw { get; } = new();
+    public Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments> OnPreUniverseObjectRegistered { get; } = new();
     public Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; } = new();
+    public Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments> OnPreUniverseObjectUnRegistered { get; } = new();
     public Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; } = new();
     public Event<IUniverse, IUniverse.TimeScaleChangedArguments> OnTimeScaleChanged { get; } = new();
 
@@ -53,6 +55,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)}.");
 
+        OnPreUniverseObjectRegistered?.Invoke(this, new(universeObject));
+
         universeObject.OnFinalized.AddListener(delegateOnUniverseObjectFinalize);
         universeObject.OnExitedUniverse.AddListener(delegateOnUniverseObjectExitedUniverse);
 
@@ -79,7 +83,7 @@ public class Universe : BaseEntity, IUniverse
 
     public void Remove(IUniverseObject universeObject)
     {
-        universeObject.SetParent(null);
+        universeObject.Parent = null;
         RemoveIncursive(universeObject);
     }
 
@@ -88,6 +92,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)}.");
 
+        OnPreUniverseObjectUnRegistered?.Invoke(this, new(universeObject));
+
         universeObject.OnFinalized.RemoveListener(delegateOnUniverseObjectFinalize);
         universeObject.OnExitedUniverse.RemoveListener(delegateOnUniverseObjectExitedUniverse);
 

Engine.Core/UniverseObject.cs

@@ -1,4 +1,3 @@
-using System.Collections;
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
@@ -21,8 +20,8 @@ public class UniverseObject : BaseEntity, IUniverseObject
     private IBehaviourController _behaviourController = null!;
     private bool _isActive = false;
     private readonly List<IUniverseObject> _children = [];
+    private IUniverseObject? _parent = null;
 
-    public IUniverseObject? Parent { get; private set; } = null;
     public IReadOnlyList<IUniverseObject> Children => _children;
     public IBehaviourController BehaviourController => _behaviourController;
     public IUniverse Universe => _universe;
@@ -42,6 +41,40 @@ public class UniverseObject : BaseEntity, IUniverseObject
         }
     }
 
+    public IUniverseObject? Parent
+    {
+        get => _parent;
+        set
+        {
+            if (value == this)
+                throw new Exceptions.AssignFailedException($"{Name} can not parent itself");
+
+            if (_parent == value)
+                return;
+
+            IUniverseObject? previousParent = Parent;
+            if (previousParent is not null)
+            {
+                previousParent.RemoveChild(this);
+                previousParent.OnActiveChanged.RemoveListener(OnParentActiveChanged);
+            }
+
+            _parent = value;
+
+            if (value is not null)
+            {
+                if (value.IsInUniverse && !IsInUniverse)
+                    value.Universe.Register(this);
+
+                value.AddChild(this);
+                value.OnActiveChanged.AddListener(OnParentActiveChanged);
+            }
+
+            UpdateActive();
+            OnParentChanged?.Invoke(this, new(previousParent, value));
+        }
+    }
+
     protected virtual void OnEnteringUniverse(IUniverse universe) { }
     bool IUniverseObject.EnterUniverse(IUniverse universe)
     {
@@ -67,43 +100,13 @@ public class UniverseObject : BaseEntity, IUniverseObject
         return true;
     }
 
-    public void SetParent(IUniverseObject? parent)
-    {
-        if (parent == this)
-            throw new Exceptions.AssignFailedException($"{Name} can not parent itself");
-
-        if (Parent == parent)
-            return;
-
-        IUniverseObject? previousParent = Parent;
-        if (previousParent is not null)
-        {
-            previousParent.RemoveChild(this);
-            previousParent.OnActiveChanged.RemoveListener(OnParentActiveChanged);
-        }
-
-        Parent = parent;
-
-        if (parent is not null)
-        {
-            if (parent.IsInUniverse && !IsInUniverse)
-                parent.Universe.Register(this);
-
-            parent.AddChild(this);
-            parent.OnActiveChanged.AddListener(OnParentActiveChanged);
-        }
-
-        UpdateActive();
-        OnParentChanged?.Invoke(this, new(previousParent, parent));
-    }
-
     public void AddChild(IUniverseObject parent)
     {
         if (_children.Contains(parent))
             return;
 
         _children.Add(parent);
-        parent.SetParent(this);
+        parent.Parent = this;
         OnChildrenAdded?.Invoke(this, new(parent));
     }
 
@@ -112,7 +115,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
         if (!_children.Remove(child))
             return;
 
-        child.SetParent(null);
+        child.Parent = null;
         OnChildrenRemoved?.Invoke(this, new(child));
     }
 
@@ -133,6 +136,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
         base.OnAssign(stateEnable);
 
         stateEnable.OnEnabledChanged.AddListener(OnStateEnabledChanged);
+        UpdateActive();
     }
 
     private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
@@ -164,7 +168,4 @@ public class UniverseObject : BaseEntity, IUniverseObject
     {
         _name = GetType().Name;
     }
-
-    public IEnumerator<IUniverseObject> GetEnumerator() => _children.GetEnumerator();
-    IEnumerator IEnumerable.GetEnumerator() => _children.GetEnumerator();
 }

Engine.Tests/Core/BehaviourController_Tests.cs

@@ -0,0 +1,271 @@
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Exceptions;
+
+namespace Engine.Tests;
+
+public class BehaviourController_Tests
+{
+    [Fact]
+    public void GetRequiredBehaviour()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        behaviourController.AddBehaviour<BehaviourX>();
+        Assert.NotNull(behaviourController.GetRequiredBehaviour<BehaviourX>());
+    }
+
+    [Fact]
+    public void GetRequiredBehaviourRaisesExceptionIfNotFound()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        Assert.Throws<BehaviourNotFoundException>(behaviourController.GetRequiredBehaviour<BehaviourX>);
+    }
+
+    [Fact]
+    public void AddSingleBehaviour()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        Assert.NotNull(behaviourController.AddBehaviour<BehaviourX>());
+        Assert.NotNull(behaviourController.GetBehaviour<BehaviourX>());
+    }
+
+    [Fact]
+    public void AddMultipleBehaviours()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        BehaviourX behaviourX = behaviourController.AddBehaviour<BehaviourX>();
+        BehaviourY behaviourY = behaviourController.AddBehaviour<BehaviourY>();
+
+        bool isXFound = false;
+        bool isYFound = false;
+
+        foreach (IBehaviour behaviour in behaviourController.GetBehaviours<IBehaviour>())
+        {
+            if (behaviour == behaviourX) isXFound = true;
+            if (behaviour == behaviourY) isYFound = true;
+        }
+
+        Assert.True(isXFound && isYFound);
+    }
+
+    [Fact]
+    public void AddThenRemoveBehaviour()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        behaviourController.AddBehaviour<BehaviourX>();
+        behaviourController.RemoveBehaviour<BehaviourX>();
+        Assert.Null(behaviourController.GetBehaviour<BehaviourX>());
+    }
+
+    [Fact]
+    public void GetOrAddBehaviourExtension()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        Assert.Null(behaviourController.GetBehaviour<BehaviourX>());
+        Assert.NotNull(behaviourController.GetOrAddBehaviour<BehaviourX>());
+    }
+
+    [Fact]
+    public void GetOrAddBehaviourExtensionFallback()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        Assert.Null(behaviourController.GetBehaviour<IBehaviour>());
+        Assert.NotNull(behaviourController.GetOrAddBehaviour<IBehaviour, BehaviourX>());
+    }
+
+    [Fact]
+    public void RemoveSpecificBehaviourViaGeneric()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        behaviourController.AddBehaviour<BehaviourX>();
+        behaviourController.AddBehaviour<BehaviourY>();
+        behaviourController.RemoveBehaviour<BehaviourY>();
+
+        Assert.NotNull(behaviourController.GetBehaviour<BehaviourX>());
+        Assert.Null(behaviourController.GetBehaviour<BehaviourY>());
+    }
+
+    [Fact]
+    public void RemoveSpecificBehaviourViaReference()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        behaviourController.AddBehaviour<BehaviourX>();
+
+        BehaviourY behaviourYFirst = behaviourController.AddBehaviour<BehaviourY>();
+        BehaviourY behaviourYSecond = behaviourController.AddBehaviour<BehaviourY>();
+
+        behaviourController.RemoveBehaviour(behaviourYFirst);
+
+        Assert.Equal(behaviourController.GetBehaviour<BehaviourY>(), behaviourYSecond);
+        Assert.NotNull(behaviourController.GetBehaviour<BehaviourX>());
+    }
+
+    [Fact]
+    public void AddBehaviourSameTypeCreatesSeparateInstances()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        BehaviourY first = behaviourController.AddBehaviour<BehaviourY>();
+        BehaviourY second = behaviourController.AddBehaviour<BehaviourY>();
+
+        Assert.NotSame(first, second);
+    }
+
+    [Fact]
+    public void BehaviourAddedEvents()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        IBehaviourController? sender = null;
+        IBehaviourController.BehaviourAddedArguments? arguments = null;
+
+        behaviourController.OnBehaviourAdded.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        BehaviourX behaviour = behaviourController.AddBehaviour<BehaviourX>();
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+        Assert.Equal(behaviourController, sender);
+        Assert.Equal(behaviour, arguments.Value.BehaviourAdded);
+    }
+
+    [Fact]
+    public void BehaviourRemovedEvents()
+    {
+        IBehaviourController behaviourController = CreateUniverseObject().BehaviourController;
+
+        IBehaviourController? sender = null;
+        IBehaviourController.BehaviourRemovedArguments? arguments = null;
+
+        behaviourController.OnBehaviourRemoved.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        BehaviourX behaviour = behaviourController.AddBehaviour<BehaviourX>();
+        behaviourController.RemoveBehaviour<BehaviourX>();
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+        Assert.Equal(behaviourController, sender);
+        Assert.Equal(behaviour, arguments.Value.BehaviourRemoved);
+    }
+
+    #region Hierarchy Structure
+
+    private static IUniverseObject CreateUniverseObject()
+    {
+        UniverseObject universeObject = new();
+        BehaviourController behaviourController = new();
+
+        universeObject.Assign(new StateEnable());
+        universeObject.StateEnable.Assign(universeObject);
+
+        behaviourController.Assign(new StateEnable());
+        behaviourController.StateEnable.Assign(behaviourController);
+
+        behaviourController.Assign(universeObject);
+        universeObject.Assign(behaviourController);
+
+        universeObject.Initialize();
+        behaviourController.Initialize();
+
+        return universeObject;
+    }
+
+    public static IUniverseObject CreateParentChildScenario()
+    {
+        IUniverseObject parentUO = CreateUniverseObject().SetUniverseObject("Parent");
+        IUniverseObject middleUO = CreateUniverseObject().SetUniverseObject("Middle", parentUO);
+        IUniverseObject childUO = CreateUniverseObject().SetUniverseObject("Child", middleUO);
+
+        parentUO.BehaviourController.AddBehaviour<BehaviourY>();
+        middleUO.BehaviourController.AddBehaviour<BehaviourX>();
+        childUO.BehaviourController.AddBehaviour<BehaviourY>();
+
+        return middleUO;
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInParent()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.NotNull(universeObject.BehaviourController.GetBehaviourInParent<BehaviourY>());
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInChildren()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.NotNull(universeObject.BehaviourController.GetBehaviourInChildren<BehaviourY>());
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInChildrenOnSameObject()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.NotNull(universeObject.BehaviourController.GetBehaviourInChildren<BehaviourX>());
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInParentOnSameObject()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.NotNull(universeObject.BehaviourController.GetBehaviourInParent<BehaviourX>());
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInParentRaisesExceptionIfNotFound()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.Throws<BehaviourNotFoundException>(universeObject.BehaviourController.GetRequiredBehaviourInParent<BehaviourZ>);
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInChildrenRaisesExceptionIfNotFound()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.Throws<BehaviourNotFoundException>(universeObject.BehaviourController.GetRequiredBehaviourInChildren<BehaviourZ>);
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInChildrenOnSameObjectRaisesExceptionIfNotFound()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.Throws<BehaviourNotFoundException>(universeObject.BehaviourController.GetRequiredBehaviourInChildren<BehaviourZ>);
+    }
+
+    [Fact]
+    public void ParentChildScenarioGetBehaviourInParentOnSameObjectRaisesExceptionIfNotFound()
+    {
+        IUniverseObject universeObject = CreateParentChildScenario();
+
+        Assert.Throws<BehaviourNotFoundException>(universeObject.BehaviourController.GetRequiredBehaviourInParent<BehaviourZ>);
+    }
+
+    #endregion
+
+    private class BehaviourX : BehaviourBase;
+    private class BehaviourY : BehaviourBase;
+    private class BehaviourZ : BehaviourBase;
+}

Engine.Tests/Core/Behaviour_Tests.cs

@@ -0,0 +1,72 @@
+using Syntriax.Engine.Core;
+
+namespace Engine.Tests;
+
+public class Behaviour_Tests
+{
+    private static IUniverseObject CreateUniverseObject()
+    {
+        UniverseObject universeObject = new();
+        BehaviourController behaviourController = new();
+
+        universeObject.Assign(new StateEnable());
+        universeObject.StateEnable.Assign(universeObject);
+
+        behaviourController.Assign(new StateEnable());
+        behaviourController.StateEnable.Assign(behaviourController);
+
+        behaviourController.Assign(universeObject);
+        universeObject.Assign(behaviourController);
+
+        universeObject.Initialize();
+        behaviourController.Initialize();
+
+        return universeObject;
+    }
+
+    [Fact]
+    public void BehaviourActive()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+
+        BehaviourX behaviourX = universeObject.BehaviourController.AddBehaviour<BehaviourX>();
+        behaviourX.StateEnable.Enabled = true;
+
+        Assert.True(behaviourX.IsActive);
+    }
+
+    [Fact]
+    public void BehaviourNotActiveOnDisabled()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+
+        BehaviourX behaviourX = universeObject.BehaviourController.AddBehaviour<BehaviourX>();
+        behaviourX.StateEnable.Enabled = false;
+
+        Assert.False(behaviourX.IsActive);
+    }
+
+    [Fact]
+    public void BehaviourNotActiveOnBehaviourControllerDisabled()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+
+        BehaviourX behaviourX = universeObject.BehaviourController.AddBehaviour<BehaviourX>();
+        universeObject.BehaviourController.StateEnable.Enabled = false;
+
+        Assert.False(behaviourX.IsActive);
+    }
+
+    [Fact]
+    public void BehaviourNotActiveOnUniverseObjectDisabled()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+
+        BehaviourX behaviourX = universeObject.BehaviourController.AddBehaviour<BehaviourX>();
+        universeObject.StateEnable.Enabled = false;
+
+        Assert.False(behaviourX.IsActive);
+    }
+
+    public class BehaviourX : BehaviourBase;
+}

Engine.Tests/Core/UniverseObject_Tests.cs

@@ -0,0 +1,272 @@
+using Syntriax.Engine.Core;
+
+namespace Engine.Tests;
+
+public class UniverseObject_Tests
+{
+    private static IUniverseObject CreateUniverseObject()
+    {
+        UniverseObject universeObject = new();
+        BehaviourController behaviourController = new();
+
+        universeObject.Assign(new StateEnable());
+
+        behaviourController.Assign(new StateEnable());
+        behaviourController.StateEnable.Assign(behaviourController);
+
+        behaviourController.Assign(universeObject);
+        universeObject.Assign(behaviourController);
+
+        universeObject.Initialize();
+        behaviourController.Initialize();
+
+        return universeObject;
+    }
+
+    [Fact]
+    public void AddChildren()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        parentUO.AddChild(childUO);
+        Assert.NotEmpty(parentUO.Children);
+        Assert.Equal(parentUO.Children[0], childUO);
+        Assert.Equal(childUO.Parent, parentUO);
+    }
+
+    [Fact]
+    public void RemoveChildren()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        parentUO.AddChild(childUO);
+        Assert.NotEmpty(parentUO.Children);
+        Assert.Contains(childUO, parentUO.Children);
+        Assert.Equal(childUO.Parent, parentUO);
+
+        parentUO.RemoveChild(childUO);
+        Assert.Empty(parentUO.Children);
+        Assert.Null(childUO.Parent);
+    }
+
+    [Fact]
+    public void SetParentValue()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        childUO.Parent = parentUO;
+        Assert.Contains(childUO, parentUO.Children);
+        Assert.Equal(childUO.Parent, parentUO);
+    }
+
+    [Fact]
+    public void SetParentNull()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        parentUO.AddChild(childUO);
+
+        childUO.Parent = null;
+        Assert.Empty(parentUO.Children);
+        Assert.Null(childUO.Parent);
+    }
+
+    [Fact]
+    public void AddChildrenEvents()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        IUniverseObject? sender = null;
+        IUniverseObject.ChildrenAddedArguments? arguments = null;
+
+        parentUO.OnChildrenAdded.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        parentUO.AddChild(childUO);
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+        Assert.Equal(parentUO, sender);
+        Assert.Equal(childUO, arguments.Value.ChildrenAdded);
+    }
+
+    [Fact]
+    public void RemoveChildrenEvents()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        IUniverseObject? sender = null;
+        IUniverseObject.ChildrenRemovedArguments? arguments = null;
+
+        parentUO.AddChild(childUO);
+
+        parentUO.OnChildrenRemoved.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        parentUO.RemoveChild(childUO);
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+        Assert.Equal(parentUO, sender);
+        Assert.Equal(childUO, arguments.Value.ChildrenRemoved);
+    }
+
+    [Fact]
+    public void SetParentEvents()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        IUniverseObject? sender = null;
+        IUniverseObject.ParentChangedArguments? arguments = null;
+
+        childUO.OnParentChanged.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        childUO.Parent = parentUO;
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+        Assert.Equal(childUO, sender);
+        Assert.Null(arguments.Value.PreviousParent);
+        Assert.Equal(parentUO, arguments.Value.CurrentParent);
+    }
+
+    [Fact]
+    public void UnsetParentEvents()
+    {
+        IUniverseObject parentUO = CreateUniverseObject();
+        IUniverseObject childUO = CreateUniverseObject();
+
+        IUniverseObject? sender = null;
+        IUniverseObject.ParentChangedArguments? arguments = null;
+
+        childUO.Parent = parentUO;
+
+        childUO.OnParentChanged.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        childUO.Parent = null;
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+        Assert.Equal(childUO, sender);
+        Assert.Equal(parentUO, arguments.Value.PreviousParent);
+        Assert.Null(arguments.Value.CurrentParent);
+    }
+
+    [Fact]
+    public void Active()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+        universeObject.StateEnable.Enabled = true;
+
+        Assert.True(universeObject.IsActive);
+    }
+
+    [Fact]
+    public void NotActiveWhenDisabled()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+        universeObject.StateEnable.Enabled = false;
+
+        Assert.False(universeObject.IsActive);
+    }
+
+    [Fact]
+    public void ActiveEvents()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+        universeObject.StateEnable.Enabled = true;
+
+        IActive? sender = null;
+        IActive.ActiveChangedArguments? arguments = null;
+
+        universeObject.OnActiveChanged.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        universeObject.StateEnable.Enabled = false;
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+
+        Assert.False(universeObject.IsActive);
+        Assert.True(arguments.Value.PreviousState);
+    }
+
+    [Fact]
+    public void NotActiveEvents()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+        universeObject.StateEnable.Enabled = false;
+
+        IActive? sender = null;
+        IActive.ActiveChangedArguments? arguments = null;
+
+        universeObject.OnActiveChanged.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        universeObject.StateEnable.Enabled = true;
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+
+        Assert.True(universeObject.IsActive);
+        Assert.False(arguments.Value.PreviousState);
+    }
+
+    [Fact]
+    public void SetName()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+        universeObject.Name = "Test";
+        Assert.Equal("Test", universeObject.Name);
+    }
+
+    [Fact]
+    public void SetNameEvents()
+    {
+        IUniverseObject universeObject = CreateUniverseObject();
+        universeObject.Name = "Previous";
+
+        INameable? sender = null;
+        INameable.NameChangedArguments? arguments = null;
+
+        universeObject.OnNameChanged.AddListener((s, a) =>
+        {
+            sender = s;
+            arguments = a;
+        });
+
+        universeObject.Name = "Test";
+
+        Assert.NotNull(sender);
+        Assert.NotNull(arguments);
+
+        Assert.Equal("Test", universeObject.Name);
+        Assert.Equal("Previous", arguments.Value.PreviousName);
+    }
+}

Engine.Tests/Engine.Tests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Engine\Engine.csproj" />
+    <ProjectReference Include="..\Engine.Core\Engine.Core.csproj" />
+    <ProjectReference Include="..\Engine.Physics2D\Engine.Physics2D.csproj" />
+    <ProjectReference Include="..\Engine.Systems\Engine.Systems.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

Engine.sln

@@ -19,7 +19,9 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "YamlDotNet", "Engine.Serial
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Integration", "Integration", "{823D4020-332D-2C13-F261-6F510F11A57E}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonoGame", "Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{C3438D33-0879-44E4-9DF0-D29F5621C44C}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Integration.MonoGame", "Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{C3438D33-0879-44E4-9DF0-D29F5621C44C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Tests", "Engine.Tests\Engine.Tests.csproj", "{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -115,6 +117,18 @@ Global
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x64.Build.0 = Release|Any CPU
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x86.ActiveCfg = Release|Any CPU
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x86.Build.0 = Release|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x64.Build.0 = Debug|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x86.Build.0 = Debug|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x64.ActiveCfg = Release|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x64.Build.0 = Release|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x86.ActiveCfg = Release|Any CPU
+		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE