feat: basic universe object tests

Use IUniverseObject.Children to access children

.editorconfig

@@ -0,0 +1,225 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Don't use tabs for indentation.
+[*]
+indent_style = space
+# (Please don't specify an indent_size here; that has too many unintended consequences.)
+spelling_exclusion_path = SpellingExclusions.dic
+
+# Code files
+[*.{cs,csx,vb,vbx}]
+indent_size = 4
+insert_final_newline = true
+charset = utf-8-bom
+
+# XML project files
+[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}]
+indent_size = 2
+
+# XML config files
+[*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}]
+indent_size = 2
+
+# JSON files
+[*.json]
+indent_size = 2
+
+# Powershell files
+[*.ps1]
+indent_size = 2
+
+# Shell script files
+[*.sh]
+end_of_line = lf
+indent_size = 2
+
+# Dotnet code style settings:
+[*.{cs,vb}]
+
+# Sort using and Import directives with System.* appearing first
+dotnet_sort_system_directives_first = true
+dotnet_separate_import_directive_groups = false
+# Avoid "this." and "Me." if not necessary
+dotnet_style_qualification_for_field = false:refactoring
+dotnet_style_qualification_for_property = false:refactoring
+dotnet_style_qualification_for_method = false:refactoring
+dotnet_style_qualification_for_event = false:refactoring
+
+# Use language keywords instead of framework type names for type references
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+
+# Suggest more modern language features when available
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_coalesce_expression = true:none
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_explicit_tuple_names = true:suggestion
+
+# Whitespace options
+dotnet_style_allow_multiple_blank_lines_experimental = false:error
+
+# IDE0055: Fix formatting
+# Workaround for https://github.com/dotnet/roslyn/issues/70570
+dotnet_diagnostic.IDE0055.severity = suggestion
+
+# https://github.com/dotnet/roslyn-analyzers/issues/7436 - False positives from valid GetDeclaredSymbol calls
+dotnet_diagnostic.RS1039.severity = none
+
+# CSharp code style settings:
+
+# IDE0029: Use coalesce expression
+dotnet_diagnostic.IDE0029.severity = none
+
+# IDE0040: Add accessibility modifiers
+dotnet_diagnostic.IDE0040.severity = warning
+
+[*.cs]
+# Newline settings
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_case_contents_when_block = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = flush_left
+
+# Whitespace options
+csharp_style_allow_embedded_statements_on_same_line_experimental = true
+csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false:error
+csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true
+csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true
+csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true
+
+# Prefer "var" everywhere
+csharp_style_var_for_built_in_types = false:warning
+csharp_style_var_when_type_is_apparent = false:warning
+csharp_style_var_elsewhere = false:warning
+
+# Prefer method-like constructs to have a block body
+csharp_style_expression_bodied_methods = false:none
+csharp_style_expression_bodied_constructors = false:none
+csharp_style_expression_bodied_operators = false:none
+
+# Prefer property-like constructs to have an expression-body
+csharp_style_expression_bodied_properties = true:none
+csharp_style_expression_bodied_indexers = true:none
+csharp_style_expression_bodied_accessors = true:none
+
+# Suggest more modern language features when available
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+csharp_style_throw_expression = true:suggestion
+csharp_style_conditional_delegate_call = true:suggestion
+csharp_style_prefer_extended_property_pattern = true:suggestion
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = do_not_ignore
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# Blocks are allowed
+csharp_prefer_braces = true:silent
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = true
+
+# IDE0060: Remove unused parameter
+dotnet_diagnostic.IDE0060.severity = warning
+
+[src/{Compilers,ExpressionEvaluator,Scripting}/**Test**/*.{cs,vb}]
+
+# IDE0060: Remove unused parameter
+dotnet_diagnostic.IDE0060.severity = none
+
+[src/{Analyzers,CodeStyle,Features,Workspaces,EditorFeatures,VisualStudio}/**/*.{cs,vb}]
+
+# IDE0011: Add braces
+csharp_prefer_braces = false:warning
+# NOTE: We need the below severity entry for Add Braces due to https://github.com/dotnet/roslyn/issues/44201
+dotnet_diagnostic.IDE0011.severity = warning
+
+# IDE0040: Add accessibility modifiers
+dotnet_diagnostic.IDE0040.severity = warning
+
+# IDE0052: Remove unread private member
+dotnet_diagnostic.IDE0052.severity = warning
+
+# IDE0059: Unnecessary assignment to a value
+dotnet_diagnostic.IDE0059.severity = warning
+
+# CA1012: Abstract types should not have public constructors
+dotnet_diagnostic.CA1012.severity = warning
+
+# CA1822: Make member static
+dotnet_diagnostic.CA1822.severity = warning
+
+# Prefer "var" everywhere
+dotnet_diagnostic.IDE0007.severity = warning
+csharp_style_var_for_built_in_types = false:warning
+csharp_style_var_when_type_is_apparent = false:warning
+csharp_style_var_elsewhere = false:warning
+
+# csharp_style_allow_embedded_statements_on_same_line_experimental
+dotnet_diagnostic.IDE2001.severity = warning
+
+# csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental
+dotnet_diagnostic.IDE2004.severity = warning
+
+# csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental
+dotnet_diagnostic.IDE2005.severity = warning
+
+# csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental
+dotnet_diagnostic.IDE2006.severity = warning
+
+[src/{VisualStudio}/**/*.{cs,vb}]
+# CA1822: Make member static
+# There is a risk of accidentally breaking an internal API that partners rely on though IVT.
+dotnet_code_quality.CA1822.api_surface = private
+
+[**/{ExternalAccess}/**/*.{cs,vb}]
+
+# RS0016: Only enable if API files are present
+dotnet_public_api_analyzer.require_api_files = true
+
+dotnet_diagnostic.RS0051.severity = error
+dotnet_diagnostic.RS0052.severity = error
+dotnet_diagnostic.RS0053.severity = error
+dotnet_diagnostic.RS0054.severity = error
+dotnet_diagnostic.RS0055.severity = error
+dotnet_diagnostic.RS0056.severity = error
+dotnet_diagnostic.RS0057.severity = error
+dotnet_diagnostic.RS0058.severity = error
+dotnet_diagnostic.RS0059.severity = error
+dotnet_diagnostic.RS0060.severity = error
+dotnet_diagnostic.RS0061.severity = error

.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

@@ -1,4 +1,4 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Indicates the class implementing it has Assignable fields that are necessary for the engine to work properly.
@@ -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 OnUnassignedDelegate? 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 OnUnassignedDelegate(IAssignable sender);
 }

Engine.Core/Abstract/Assignable/IAssignableGameManager.cs

@@ -1,26 +0,0 @@
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="ITransform"/> field.
-/// </summary>
-public interface IAssignableGameManager : IAssignable
-{
-    /// <summary>
-    /// Event triggered when the <see cref="IGameManager"/> value has has been assigned a new value.
-    /// </summary>
-    event OnGameManagerAssignedDelegate? OnGameManagerAssigned;
-
-    /// <inheritdoc cref="IGameManager" />
-    IGameManager GameManager { get; }
-
-    /// <summary>
-    /// Assign a value to the <see cref="IGameManager"/> field of this object.
-    /// </summary>
-    /// <param name="gameManager">New <see cref="IGameManager"/> to assign.</param>
-    /// <returns> 
-    /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
-    /// </returns>
-    bool Assign(IGameManager gameManager);
-
-    delegate void OnGameManagerAssignedDelegate(IAssignableGameManager sender);
-}

Engine.Core/Abstract/Assignable/IAssignableGameObject.cs

@@ -1,26 +0,0 @@
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IGameObject"/> field.
-/// </summary>
-public interface IAssignableGameObject : IAssignable
-{
-    /// <summary>
-    /// Event triggered when the <see cref="IGameObject"/> value has has been assigned a new value.
-    /// </summary>
-    event OnGameObjectAssignedDelegate? OnGameObjectAssigned;
-
-    /// <inheritdoc cref="IGameObject" />
-    IGameObject GameObject { get; }
-
-    /// <summary>
-    /// Assign a value to the <see cref="IGameObject"/> field of this object.
-    /// </summary>
-    /// <param name="gameObject">New <see cref="IGameObject"/> to assign.</param>
-    /// <returns> 
-    /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
-    /// </returns>
-    bool Assign(IGameObject gameObject);
-
-    delegate void OnGameObjectAssignedDelegate(IAssignableGameObject sender);
-}

Engine.Core/Abstract/Assignable/IAssignableTransform.cs

@@ -1,26 +0,0 @@
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="ITransform"/> field.
-/// </summary>
-public interface IAssignableTransform : IAssignable
-{
-    /// <summary>
-    /// Event triggered when the <see cref="ITransform"/> value has has been assigned a new value.
-    /// </summary>
-    event OnTransformAssignedDelegate? OnTransformAssigned;
-
-    /// <inheritdoc cref="ITransform" />
-    ITransform Transform { get; }
-
-    /// <summary>
-    /// Assign a value to the <see cref="ITransform"/> field of this object.
-    /// </summary>
-    /// <param name="transform">New <see cref="ITransform"/> to assign.</param>
-    /// <returns> 
-    /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
-    /// </returns>
-    bool Assign(ITransform transform);
-
-    delegate void OnTransformAssignedDelegate(IAssignableTransform sender);
-}

Engine.Core/Abstract/Assignable/IHasBehaviourController.cs

@@ -1,14 +1,14 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IBehaviourController"/> field.
 /// </summary>
-public interface IAssignableBehaviourController : IAssignable
+public interface IHasBehaviourController : IAssignable
 {
     /// <summary>
     /// Event triggered when the <see cref="IBehaviourController"/> value has has been assigned a new value.
     /// </summary>
-    event OnBehaviourControllerAssignedDelegate? OnBehaviourControllerAssigned;
+    Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; }
 
     /// <inheritdoc cref="IBehaviourController" />
     IBehaviourController BehaviourController { get; }
@@ -21,6 +21,4 @@ public interface IAssignableBehaviourController : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IBehaviourController behaviourController);
-
-    delegate void OnBehaviourControllerAssignedDelegate(IAssignableBehaviourController sender);
 }

Engine.Core/Abstract/Assignable/IHasEntity.cs

@@ -1,14 +1,14 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IEntity"/> field.
 /// </summary>
-public interface IAssignableEntity : IAssignable
+public interface IHasEntity : IAssignable
 {
     /// <summary>
     /// Event triggered when the <see cref="IEntity"/> value has has been assigned a new value.
     /// </summary>
-    event OnEntityAssignedDelegate? OnEntityAssigned;
+    Event<IHasEntity> OnEntityAssigned { get; }
 
     /// <inheritdoc cref="IEntity" />
     IEntity Entity { get; }
@@ -21,6 +21,4 @@ public interface IAssignableEntity : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IEntity entity);
-
-    delegate void OnEntityAssignedDelegate(IAssignableEntity sender);
 }

Engine.Core/Abstract/Assignable/IHasStateEnable.cs

@@ -1,14 +1,14 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IStateEnable"/> field.
 /// </summary>
-public interface IAssignableStateEnable : IAssignable
+public interface IHasStateEnable : IAssignable
 {
     /// <summary>
     /// Event triggered when the <see cref="IStateEnable"/> value has has been assigned a new value.
     /// </summary>
-    event OnStateEnableAssignedDelegate? OnStateEnableAssigned;
+    Event<IHasStateEnable> OnStateEnableAssigned { get; }
 
     /// <inheritdoc cref="IStateEnable" />
     IStateEnable StateEnable { get; }
@@ -21,6 +21,4 @@ public interface IAssignableStateEnable : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IStateEnable stateEnable);
-
-    delegate void OnStateEnableAssignedDelegate(IAssignableStateEnable sender);
 }

Engine.Core/Abstract/Assignable/IHasUniverse.cs

@@ -0,0 +1,24 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IUniverse"/> field.
+/// </summary>
+public interface IHasUniverse : IAssignable
+{
+    /// <summary>
+    /// Event triggered when the <see cref="IUniverse"/> value has has been assigned a new value.
+    /// </summary>
+    Event<IHasUniverse> OnUniverseAssigned { get; }
+
+    /// <inheritdoc cref="IUniverse" />
+    IUniverse Universe { get; }
+
+    /// <summary>
+    /// Assign a value to the <see cref="IUniverse"/> field of this object.
+    /// </summary>
+    /// <param name="universe">New <see cref="IUniverse"/> to assign.</param>
+    /// <returns> 
+    /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
+    /// </returns>
+    bool Assign(IUniverse universe);
+}

Engine.Core/Abstract/Assignable/IHasUniverseObject.cs

@@ -0,0 +1,24 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IUniverseObject"/> field.
+/// </summary>
+public interface IHasUniverseObject : IAssignable
+{
+    /// <summary>
+    /// Event triggered when the <see cref="IUniverseObject"/> value has has been assigned a new value.
+    /// </summary>
+    Event<IHasUniverseObject> OnUniverseObjectAssigned { get; }
+
+    /// <inheritdoc cref="IUniverseObject" />
+    IUniverseObject UniverseObject { get; }
+
+    /// <summary>
+    /// Assign a value to the <see cref="IUniverseObject"/> field of this object.
+    /// </summary>
+    /// <param name="universeObject">New <see cref="IUniverseObject"/> to assign.</param>
+    /// <returns> 
+    /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
+    /// </returns>
+    bool Assign(IUniverseObject universeObject);
+}

Engine.Core/Abstract/IActive.cs

@@ -0,0 +1,19 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an entity which can be active or not.
+/// </summary>
+public interface IActive
+{
+    /// <summary>
+    /// Event triggered when the <see cref="IsActive"/> state of the <see cref="IActive"/> changes.
+    /// </summary>
+    Event<IActive, ActiveChangedArguments> OnActiveChanged { get; }
+
+    /// <summary>
+    /// The value indicating whether the <see cref="IActive"/> is enabled.
+    /// </summary>
+    bool IsActive { get; }
+
+    readonly record struct ActiveChangedArguments(bool PreviousState);
+}

Engine.Core/Abstract/IBehaviour.cs

@@ -1,24 +1,19 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
-/// Represents a behaviour that any object in the game might use to interact with itself or other objects. 
+/// Represents a behaviour that any object in the engine that might use to interact with itself or other objects. 
 /// </summary>
-public interface IBehaviour : IEntity, IAssignableBehaviourController, IAssignableStateEnable, IInitialize
+public interface IBehaviour : IEntity, IActive, IHasBehaviourController, IHasStateEnable
 {
     /// <summary>
     /// Event triggered when the priority of the <see cref="IBehaviour"/> changes.
     /// </summary>
-    event OnPriorityChangedDelegate? OnPriorityChanged;
+    Event<IBehaviour, PriorityChangedArguments> OnPriorityChanged { get; }
 
     /// <summary>
     /// The priority of the <see cref="IBehaviour"/>.
     /// </summary>
     int Priority { get; set; }
 
-    /// <summary>
-    /// The value indicating whether the <see cref="IBehaviour"/> is active.
-    /// </summary>
-    bool IsActive { get; }
-
-    delegate void OnPriorityChangedDelegate(IBehaviour sender, int previousPriority);
+    readonly record struct PriorityChangedArguments(int PreviousPriority);
 }

Engine.Core/Abstract/IBehaviour2D.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Core;
+
+public interface IBehaviour2D : IBehaviour
+{
+    ITransform2D Transform { get; }
+}

Engine.Core/Abstract/IBehaviourCollector.cs

@@ -0,0 +1,42 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a collector for the class type of <typeparamref name="T"/>.
+/// Provides mechanisms for tracking additions and removals, and notifies subscribers when such events occur on the assigned <see cref="IUniverse"/>.
+/// </summary>
+/// <typeparam name="T">The type of objects tracked by the collector.</typeparam>
+public interface IBehaviourCollector<T> : IHasUniverse where T : class
+{
+    /// <summary>
+    /// Event triggered when an object of type <typeparamref name="T"/> is added to the collector.
+    /// </summary>
+    Event<IBehaviourCollector<T>, BehaviourCollectedArguments> OnCollected { get; }
+
+    /// <summary>
+    /// Event triggered when an object of type <typeparamref name="T"/> is removed from the collector.
+    /// </summary>
+    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>
+    readonly record struct BehaviourCollectedArguments(T BehaviourCollected);
+
+    /// <summary>
+    /// Delegate for handling the <see cref="OnRemoved"/> event.
+    /// </summary>
+    /// <param name="BehaviourRemoved">The object of type <typeparamref name="T"/> that was removed from the collector.</param>
+    readonly record struct BehaviourRemovedArguments(T BehaviourRemoved);
+}

Engine.Core/Abstract/IBehaviourController.cs

@@ -1,37 +1,31 @@
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 
-namespace Syntriax.Engine.Core.Abstract;
+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="IGameObject"/>.
+/// Represents a controller for managing <see cref="IBehaviour"/>s. Connected to an <see cref="IUniverseObject"/>.
 /// </summary>
-public interface IBehaviourController : IAssignableGameObject, IEnumerable<IBehaviour>
+public interface IBehaviourController : IEntity, IHasUniverseObject
 {
-    /// <summary>
-    /// Event triggered before the update of <see cref="IBehaviour"/>s.
-    /// </summary>
-    event OnPreUpdateDelegate? OnPreUpdate;
-
-    /// <summary>
-    /// Event triggered during the update of <see cref="IBehaviour"/>s.
-    /// </summary>
-    event OnUpdateDelegate? OnUpdate;
-
-    /// <summary>
-    /// Event triggered before the drawing phase.
-    /// </summary>
-    event OnPreDrawDelegate? OnPreDraw;
-
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is added to the <see cref="IBehaviourController"/>.
     /// </summary>
-    event OnBehaviourAddedDelegate? OnBehaviourAdded;
+    Event<IBehaviourController, BehaviourAddedArguments> OnBehaviourAdded { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is removed from the <see cref="IBehaviourController"/>.
     /// </summary>
-    event OnBehaviourRemovedDelegate? 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"/>.
@@ -56,27 +50,19 @@ public interface IBehaviourController : IAssignableGameObject, IEnumerable<IBeha
     /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, <see cref="null"/>.</returns>
     T? GetBehaviour<T>();
 
-    /// <summary>
-    /// Tries to get a <see cref="IBehaviour"/> of the specified type.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
-    /// <param name="behaviour">When this method returns, contains the <see cref="IBehaviour"/> of the specified type, if found; otherwise, see.</param>
-    /// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found; otherwise, <see cref="false"/>.</returns>
-    bool TryGetBehaviour<T>([NotNullWhen(returnValue: true)] out T? behaviour);
-
     /// <summary>
     /// Gets all <see cref="IBehaviour"/>s of the specified type.
     /// </summary>
     /// <typeparam name="T">The type of <see cref="IBehaviour"/>s to get.</typeparam>
     /// <returns>A list of <see cref="IBehaviour"/>s of the specified type.</returns>
-    IList<T> GetBehaviours<T>();
+    IReadOnlyList<T> GetBehaviours<T>();
 
     /// <summary>
     /// Gets all <see cref="IBehaviour"/>s of the specified type and stores them in the provided list.
     /// </summary>
     /// <typeparam name="T">The type of <see cref="IBehaviour"/>s to get.</typeparam>
-    /// <param name="behaviours">The list to store the <see cref="IBehaviour"/>s.</param>
-    void GetBehaviours<T>(List<T> behaviours);
+    /// <param name="results">The list to store the <see cref="IBehaviour"/>s.</param>
+    void GetBehaviours<T>(IList<T> results);
 
     /// <summary>
     /// Removes <see cref="IBehaviour"/>s of the specified type from the <see cref="IBehaviourController"/>.
@@ -92,20 +78,6 @@ public interface IBehaviourController : IAssignableGameObject, IEnumerable<IBeha
     /// <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 OnPreUpdateDelegate(IBehaviourController sender);
-    delegate void OnUpdateDelegate(IBehaviourController sender);
-    delegate void OnPreDrawDelegate(IBehaviourController sender);
-    delegate void OnBehaviourAddedDelegate(IBehaviourController sender, IBehaviour behaviourAdded);
-    delegate void OnBehaviourRemovedDelegate(IBehaviourController sender, IBehaviour behaviourRemoved);
-
+    readonly record struct BehaviourAddedArguments(IBehaviour BehaviourAdded);
+    readonly record struct BehaviourRemovedArguments(IBehaviour BehaviourRemoved);
 }

Engine.Core/Abstract/ICamera2D.cs

@@ -1,9 +1,9 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Represents a 2D camera in the engine.
 /// </summary>
-public interface ICamera2D : IBehaviour, IAssignableTransform
+public interface ICamera2D : IBehaviour2D
 {
     /// <summary>
     /// The zoom level of the camera.

Engine.Core/Abstract/ICoroutineYield.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Core;
+
+public interface ICoroutineYield
+{
+    bool Yield();
+}

Engine.Core/Abstract/IEntity.cs

@@ -1,20 +1,20 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Represents a basic entity in the engine.
 /// </summary>
-public interface IEntity : IInitialize, IAssignableStateEnable
+public interface IEntity : IInitializable, IHasStateEnable
 {
     /// <summary>
     /// 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 OnIdChangedDelegate? OnIdChanged;
+    Event<IEntity, IdChangedArguments> OnIdChanged { get; }
 
     /// <summary>
     /// The ID of the <see cref="IEntity"/>.
     /// </summary>
     string Id { get; set; }
 
-    delegate void OnIdChangedDelegate(IEntity sender, string previousId);
+    readonly record struct IdChangedArguments(string PreviousId);
 }

Engine.Core/Abstract/IGameManager.cs

@@ -1,59 +0,0 @@
-using System.Collections.Generic;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Represents a game world responsible for managing <see cref="IGameObject"/>s.
-/// </summary>
-public interface IGameManager : IEntity, IEnumerable<IGameObject>
-{
-    /// <summary>
-    /// Event triggered when a <see cref="IGameObject"/> is registered to the <see cref="IGameManager"/>.
-    /// </summary>
-    event OnGameObjectRegisteredDelegate? OnGameObjectRegistered;
-
-    /// <summary>
-    /// Event triggered when a <see cref="IGameObject"/> is unregistered from the <see cref="IGameManager"/>.
-    /// </summary>
-    event OnGameObjectUnRegisteredDelegate? OnGameObjectUnRegistered;
-
-    /// <summary>
-    /// Gets a read-only list of <see cref="IGameObject"/>s managed by the <see cref="IGameManager"/>.
-    /// </summary>
-    IReadOnlyList<IGameObject> GameObjects { get; }
-
-    /// <summary>
-    /// Registers a <see cref="IGameObject"/> to the <see cref="IGameManager"/>.
-    /// </summary>
-    /// <param name="gameObject">The <see cref="IGameObject"/> to register.</param>
-    void RegisterGameObject(IGameObject gameObject);
-
-    /// <summary>
-    /// Instantiates a <see cref="IGameObject"/> of type T with the given arguments and registers it to the <see cref="IGameManager"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of <see cref="IGameObject"/> to instantiate.</typeparam>
-    /// <param name="args">Constructor parameters for the given type of <see cref="IGameObject"/>.</param>
-    /// <returns>The instantiated <see cref="IGameObject"/>.</returns>
-    T InstantiateGameObject<T>(params object?[]? args) where T : class, IGameObject;
-
-    /// <summary>
-    /// Removes a <see cref="IGameObject"/> from the <see cref="IGameManager"/>.
-    /// </summary>
-    /// <param name="gameObject">The <see cref="IGameObject"/> to remove.</param>
-    /// <returns>The removed <see cref="IGameObject"/>.</returns>
-    IGameObject RemoveGameObject(IGameObject gameObject);
-
-    /// <summary>
-    /// Updates the <see cref="IGameManager"/> with the given engine time data.
-    /// </summary>
-    /// <param name="time">The engine time.</param>
-    void Update(EngineTime time);
-
-    /// <summary>
-    /// Performs operations that should be done before the draw calls.
-    /// </summary>
-    void PreDraw();
-
-    delegate void OnGameObjectRegisteredDelegate(IGameManager sender, IGameObject gameObjectRegistered);
-    delegate void OnGameObjectUnRegisteredDelegate(IGameManager sender, IGameObject gameObjectUnregistered);
-}

Engine.Core/Abstract/IGameObject.cs

@@ -1,19 +0,0 @@
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Represents a game object with various properties and functionalities.
-/// </summary>
-public interface IGameObject : IEntity, IAssignableGameManager, IAssignableTransform, IAssignableBehaviourController, INameable, IInitialize
-{
-    /// <summary>
-    /// Event triggered when the <see cref="Update"/> method is called.
-    /// </summary>
-    event OnUpdatedDelegate? OnUpdated;
-
-    /// <summary>
-    /// Updates the game object.
-    /// </summary>
-    void Update();
-
-    delegate void OnUpdatedDelegate(IGameObject sender);
-}

Engine.Core/Abstract/IInitializable.cs

@@ -1,24 +1,24 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Represents an entity that can be initialized and finalized. This information is useful for objects we know that are not in use and can be either recycled or dropped for garbage collection.
 /// </summary>
-public interface IInitialize
+public interface IInitializable
 {
     /// <summary>
     /// Event triggered when the <see cref="Initialize"/> method is called successfully.
     /// </summary>
-    event OnInitializedDelegate? OnInitialized;
+    Event<IInitializable> OnInitialized { get; }
 
     /// <summary>
-    /// Event triggered when the <see cref="Finalize"/> method is called successfully.
+    /// Event triggered when the <see cref="IInitializable"/> method is called successfully.
     /// </summary>
-    event OnFinalizedDelegate? OnFinalized;
+    Event<IInitializable> OnFinalized { get; }
 
     /// <summary>
     /// The value indicating whether the entity has been initialized.
     /// </summary>
-    bool Initialized { get; }
+    bool IsInitialized { get; }
 
     /// <summary>
     /// Initializes the entity.
@@ -31,7 +31,4 @@ public interface IInitialize
     /// </summary>
     /// <returns><see cref="true"/> if finalization is successful, otherwise <see cref="false"/>.</returns>
     bool Finalize();
-
-    delegate void OnInitializedDelegate(IInitialize sender);
-    delegate void OnFinalizedDelegate(IInitialize sender);
 }

Engine.Core/Abstract/INameable.cs

@@ -1,4 +1,4 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Represents an entity with a name.
@@ -8,12 +8,12 @@ public interface INameable
     /// <summary>
     /// Event triggered when the name of the entity changes.
     /// </summary>
-    event OnNameChangedDelegate? OnNameChanged;
+    Event<INameable, NameChangedArguments> OnNameChanged { get; }
 
     /// <summary>
     /// The name of the entity.
     /// </summary>
     string Name { get; set; }
 
-    delegate void OnNameChangedDelegate(INameable sender, string previousName);
+    readonly record struct NameChangedArguments(string PreviousName);
 }

Engine.Core/Abstract/IStateEnable.cs

@@ -1,19 +1,19 @@
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Represents an entity with an enable state that can be toggled.
 /// </summary>
-public interface IStateEnable : IAssignableEntity
+public interface IStateEnable : IHasEntity
 {
     /// <summary>
     /// Event triggered when the <see cref="Enabled"/> state of the <see cref="IStateEnable"/> changes.
     /// </summary>
-    event OnNameChangedDelegate? OnEnabledChanged;
+    Event<IStateEnable, EnabledChangedArguments> OnEnabledChanged { get; }
 
     /// <summary>
     /// The value indicating whether the <see cref="IStateEnable"/> is enabled.
     /// </summary>
     bool Enabled { get; set; }
 
-    delegate void OnNameChangedDelegate(IStateEnable sender, bool previousState);
+    readonly record struct EnabledChangedArguments(bool PreviousState);
 }

Engine.Core/Abstract/ITransform.cs

@@ -1,105 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Represents the transformation properties of an object such as position, scale, and rotation.
-/// </summary>
-public interface ITransform : IAssignableGameObject, IEnumerable<ITransform>
-{
-    /// <summary>
-    /// Event triggered when the <see cref="Position"/> of the <see cref="ITransform"/> changes.
-    /// </summary>
-    event OnPositionChangedDelegate? OnPositionChanged;
-
-    /// <summary>
-    /// Event triggered when the <see cref="Scale"/> of the <see cref="ITransform"/> changes.
-    /// </summary>
-    event OnScaleChangedDelegate? OnScaleChanged;
-
-    /// <summary>
-    /// Event triggered when the <see cref="Rotation"/> of the <see cref="ITransform"/> changes.
-    /// </summary>
-    event OnRotationChangedDelegate? OnRotationChanged;
-
-    /// <summary>
-    /// Event triggered when the <see cref="Parent"/> of the <see cref="ITransform"/> changes. The second parameter is the old <see cref="ITransform"/>.
-    /// </summary>
-    event OnParentChangedDelegate? OnParentChanged;
-
-    /// <summary>
-    /// Event triggered when a new <see cref="ITransform"/> is added to the <see cref="Children"/>.
-    /// </summary>
-    event OnChildrenAddedDelegate? OnChildrenAdded;
-
-    /// <summary>
-    /// Event triggered when an <see cref="ITransform"/> is removed from the <see cref="Children"/>.
-    /// </summary>
-    event OnChildrenRemovedDelegate? OnChildrenRemoved;
-
-    /// <summary>
-    /// The world position of the <see cref="ITransform"/> in 2D space.
-    /// </summary>
-    Vector2D Position { get; set; }
-
-    /// <summary>
-    /// The world scale of the <see cref="ITransform"/>.
-    /// </summary>
-    Vector2D Scale { get; set; }
-
-    /// <summary>
-    /// The world rotation of the <see cref="ITransform"/> in degrees.
-    /// </summary>
-    float Rotation { get; set; }
-
-    /// <summary>
-    /// The local position of the <see cref="ITransform"/> in 2D space.
-    /// </summary>
-    Vector2D LocalPosition { get; set; }
-
-    /// <summary>
-    /// The local scale of the <see cref="ITransform"/>.
-    /// </summary>
-    Vector2D LocalScale { get; set; }
-
-    /// <summary>
-    /// The local rotation of the <see cref="ITransform"/> in degrees.
-    /// </summary>
-    float LocalRotation { get; set; }
-
-    /// <summary>
-    /// The parent <see cref="ITransform"/> of the <see cref="ITransform"/>.
-    /// </summary>
-    ITransform? Parent { get; }
-
-    /// <summary>
-    /// The <see cref="ITransform"/>s that have this <see cref="ITransform"/> as their <see cref="Parent"/>.
-    /// </summary>
-    IReadOnlyList<ITransform> Children { get; }
-
-    /// <summary>
-    /// Sets the parent <see cref="ITransform"/> of this <see cref="ITransform"/>.
-    /// </summary>
-    /// <param name="transform">The parent <see cref="ITransform"/> to set.</param>
-    void SetParent(ITransform? transform);
-
-    /// <summary>
-    /// Adds a child <see cref="ITransform"/> to this <see cref="ITransform"/>.
-    /// </summary>
-    /// <param name="transform">The child <see cref="ITransform"/> to add.</param>
-    void AddChild(ITransform transform);
-
-    /// <summary>
-    /// Removes a child <see cref="ITransform"/> from this <see cref="ITransform"/>.
-    /// </summary>
-    /// <param name="transform">The child <see cref="ITransform"/> to remove.</param>
-    void RemoveChild(ITransform transform);
-
-    delegate void OnPositionChangedDelegate(ITransform sender);
-    delegate void OnScaleChangedDelegate(ITransform sender);
-    delegate void OnRotationChangedDelegate(ITransform sender);
-    delegate void OnParentChangedDelegate(ITransform sender, ITransform? newParent);
-    delegate void OnChildrenAddedDelegate(ITransform sender, ITransform childrenAdded);
-    delegate void OnChildrenRemovedDelegate(ITransform sender, ITransform childrenRemoved);
-}

Engine.Core/Abstract/ITransform2D.cs

@@ -0,0 +1,90 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents the transformation properties of an object such as position, scale, and rotation in 2D space.
+/// </summary>
+public interface ITransform2D : IBehaviour
+{
+    /// <summary>
+    /// Event triggered when the <see cref="Position"/> of the <see cref="ITransform2D"/> changes.
+    /// </summary>
+    Event<ITransform2D, PositionChangedArguments> OnPositionChanged { get; }
+
+    /// <summary>
+    /// Event triggered when the <see cref="Scale"/> of the <see cref="ITransform2D"/> changes.
+    /// </summary>
+    Event<ITransform2D, ScaleChangedArguments> OnScaleChanged { get; }
+
+    /// <summary>
+    /// Event triggered when the <see cref="Rotation"/> of the <see cref="ITransform"/> changes.
+    /// </summary>
+    Event<ITransform2D, RotationChangedArguments> OnRotationChanged { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Up { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Down { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Left { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Right { get; }
+
+    /// <summary>
+    /// The world position of the <see cref="ITransform2D"/> in 2D space.
+    /// </summary>
+    Vector2D Position { get; set; }
+
+    /// <summary>
+    /// The world scale of the <see cref="ITransform2D"/>.
+    /// </summary>
+    Vector2D Scale { get; set; }
+
+    /// <summary>
+    /// The world rotation of the <see cref="ITransform2D"/> in degrees.
+    /// </summary>
+    float Rotation { get; set; }
+
+    /// <summary>
+    /// The local position of the <see cref="ITransform2D"/> in 2D space.
+    /// </summary>
+    Vector2D LocalPosition { get; set; }
+
+    /// <summary>
+    /// The local scale of the <see cref="ITransform2D"/>.
+    /// </summary>
+    Vector2D LocalScale { get; set; }
+
+    /// <summary>
+    /// The local rotation of the <see cref="ITransform2D"/> in degrees.
+    /// </summary>
+    float LocalRotation { get; set; }
+
+    /// <summary>
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// </summary>
+    /// <param name="PreviousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct PositionChangedArguments(Vector2D PreviousPosition);
+
+    /// <summary>
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// </summary>
+    /// <param name="PreviousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct ScaleChangedArguments(Vector2D PreviousScale);
+
+    /// <summary>
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// </summary>
+    /// <param name="PreviousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct RotationChangedArguments(float PreviousRotation);
+}

Engine.Core/Abstract/IUniverse.cs

@@ -0,0 +1,120 @@
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a universe responsible for managing <see cref="IUniverseObject"/>s.
+/// </summary>
+public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
+{
+    /// <summary>
+    /// Event triggered when <see cref="Update(UniverseTime)"/> is about to be called called on the <see cref="IUniverse"/>.
+    /// </summary>
+    Event<IUniverse, UpdateArguments> OnPreUpdate { get; }
+
+    /// <summary>
+    /// Event triggered when <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
+    /// </summary>
+    Event<IUniverse, UpdateArguments> OnUpdate { get; }
+
+    /// <summary>
+    /// Event triggered after <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
+    /// </summary>
+    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 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>
+    Event<IUniverse, UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; }
+
+    /// <summary>
+    /// Event triggered when <see cref="TimeScale"/> is changed on the <see cref="IUniverse"/>.
+    /// </summary>
+    Event<IUniverse, TimeScaleChangedArguments> OnTimeScaleChanged { get; }
+
+    /// <summary>
+    /// Current time scale the <see cref="IUniverse"/> operates on.
+    /// </summary>
+    float TimeScale { get; set; }
+
+    /// <summary>
+    /// Contains time data related to this <see cref="IUniverse"/>.
+    /// </summary>
+    UniverseTime Time { get; }
+
+    /// <summary>
+    /// Contains unscaled time data related to this <see cref="IUniverse"/>.
+    /// </summary>
+    UniverseTime UnscaledTime { get; }
+
+    /// <summary>
+    /// Gets a read-only list of <see cref="IUniverseObject"/>s managed by the <see cref="IUniverse"/>.
+    /// </summary>
+    IReadOnlyList<IUniverseObject> UniverseObjects { get; }
+
+    /// <summary>
+    /// Registers an <see cref="IUniverseObject"/> to the <see cref="IUniverse"/>.
+    /// </summary>
+    /// <param name="universeObject">The <see cref="IUniverseObject"/> to register.</param>
+    void Register(IUniverseObject universeObject);
+
+    /// <summary>
+    /// Instantiates a <see cref="IUniverseObject"/> of type T with the given arguments and registers it to the <see cref="IUniverse"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IUniverseObject"/> to instantiate.</typeparam>
+    /// <param name="args">Constructor parameters for the given type of <see cref="IUniverseObject"/>.</param>
+    /// <returns>The instantiated <see cref="IUniverseObject"/>.</returns>
+    T InstantiateUniverseObject<T>(params object?[]? args) where T : class, IUniverseObject;
+
+    /// <summary>
+    /// Removes an <see cref="IUniverseObject"/> from the <see cref="IUniverse"/>.
+    /// </summary>
+    /// <param name="universeObject">The <see cref="IUniverseObject"/> to remove.</param>
+    void Remove(IUniverseObject universeObject);
+
+    /// <summary>
+    /// Updates the <see cref="IUniverse"/> with the given delta time.
+    /// </summary>
+    /// <param name="universeTime">Delta time.</param>
+    void Update(UniverseTime universeTime);
+
+    /// <summary>
+    /// Performs operations that should be done to the draw.
+    /// </summary>
+    void Draw();
+
+    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

@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an <see cref="IEntity"/> that can enter and exit a universe within the <see cref="IUniverse"/> system.
+/// 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
+{
+    /// <summary>
+    /// Event triggered when the <see cref="IUniverseObject"/> enters the universe.
+    /// </summary>
+    Event<IUniverseObject, EnteredUniverseArguments> OnEnteredUniverse { get; }
+
+    /// <summary>
+    /// Event triggered when the <see cref="IUniverseObject"/> exits the universe.
+    /// </summary>
+    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<IUniverseObject, ParentChangedArguments> OnParentChanged { get; }
+
+    /// <summary>
+    /// Event triggered when a new <see cref="IUniverseObject"/> is added to the <see cref="Children"/>.
+    /// </summary>
+    Event<IUniverseObject, ChildrenAddedArguments> OnChildrenAdded { get; }
+
+    /// <summary>
+    /// Event triggered when an <see cref="IUniverseObject"/> is removed from the <see cref="Children"/>.
+    /// </summary>
+    Event<IUniverseObject, ChildrenRemovedArguments> OnChildrenRemoved { get; }
+
+    /// <summary>
+    /// Gets the <see cref="IUniverse"/> this <see cref="IUniverseObject"/> is connected to, if any.
+    /// </summary>
+    IUniverse Universe { get; }
+
+    /// <summary>
+    /// Indicates whether the <see cref="IUniverseObject"/> is currently in the universe.
+    /// </summary>
+    bool IsInUniverse { get; }
+
+    /// <summary>
+    /// The parent <see cref="IUniverseObject"/> of the <see cref="IUniverseObject"/>.
+    /// </summary>
+    IUniverseObject? Parent { get; set; }
+
+    /// <summary>
+    /// The <see cref="IUniverseObject"/>s that have this <see cref="IUniverseObject"/> as their <see cref="Parent"/>.
+    /// </summary>
+    IReadOnlyList<IUniverseObject> Children { get; }
+
+    /// <summary>
+    /// Internal method to handle entering the universe.
+    /// This should be called by the system to properly manage universe states.
+    /// </summary>
+    /// <param name="universe">The <see cref="IUniverse"/> that is managing this universe.</param>
+    /// <returns>
+    /// <see cref="true"/> if the <see cref="IUniverseObject"/> successfully entered the universe; 
+    /// <see cref="false"/> if it failed to do so.
+    /// </returns>
+    internal bool EnterUniverse(IUniverse universe);
+
+    /// <summary>
+    /// Internal method to handle exiting the universe.
+    /// This should be called by the system to properly manage universe states.
+    /// </summary>
+    /// <returns>
+    /// <see cref="true"/> if the <see cref="IUniverseObject"/> successfully exited the universe; 
+    /// <see cref="false"/> if it failed to do so.
+    /// </returns>
+    internal bool ExitUniverse();
+
+    /// <summary>
+    /// Adds a child <see cref="IUniverseObject"/> to this <see cref="IUniverseObject"/>.
+    /// </summary>
+    /// <param name="universeObject">The child <see cref="IUniverseObject"/> to add.</param>
+    void AddChild(IUniverseObject universeObject);
+
+    /// <summary>
+    /// Removes a child <see cref="IUniverseObject"/> from this <see cref="IUniverseObject"/>.
+    /// </summary>
+    /// <param name="universeObject">The child <see cref="IUniverseObject"/> to remove.</param>
+    void RemoveChild(IUniverseObject universeObject);
+
+    /// <summary>
+    /// 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>
+    readonly record struct EnteredUniverseArguments(IUniverse Universe);
+
+    /// <summary>
+    /// 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>
+    readonly record struct ExitedUniverseArguments(IUniverse Universe);
+
+    /// <summary>
+    /// 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>
+    readonly record struct ParentChangedArguments(IUniverseObject? PreviousParent, IUniverseObject? CurrentParent);
+
+    /// <summary>
+    /// 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>
+    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>
+    readonly record struct ChildrenRemovedArguments(IUniverseObject ChildrenRemoved);
+}

Engine.Core/ActiveBehaviourCollector.cs

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

Engine.Core/ActiveBehaviourCollectorSorted.cs

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

Engine.Core/BaseEntity.cs

@@ -1,17 +1,14 @@
 using System;
 
-namespace Syntriax.Engine.Core.Abstract;
+namespace Syntriax.Engine.Core;
 
 public abstract class BaseEntity : IEntity
 {
-    public event IEntity.OnIdChangedDelegate? OnIdChanged = null;
-
-    public event IInitialize.OnInitializedDelegate? OnInitialized = null;
-    public event IInitialize.OnFinalizedDelegate? OnFinalized = null;
-
-    public event IAssignableStateEnable.OnStateEnableAssignedDelegate? OnStateEnableAssigned = null;
-    public event IAssignable.OnUnassignedDelegate? 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!;
 
@@ -20,24 +17,25 @@ public abstract class BaseEntity : IEntity
 
     public virtual IStateEnable StateEnable => _stateEnable;
 
-    public virtual bool IsActive => StateEnable.Enabled;
-
     public string Id
     {
         get => _id;
         set
         {
+            if (IsInitialized)
+                throw new($"Can't change {nameof(Id)} of {_id} because it's initialized");
+
             if (value == _id)
                 return;
 
             string previousId = _id;
 
             _id = value;
-            OnIdChanged?.Invoke(this, previousId);
+            OnIdChanged?.Invoke(this, new(previousId));
         }
     }
 
-    public bool Initialized
+    public bool IsInitialized
     {
         get => _initialized;
         private set
@@ -53,13 +51,15 @@ public abstract class BaseEntity : IEntity
         }
     }
 
+    protected virtual void OnAssign(IStateEnable stateEnable) { }
     public bool Assign(IStateEnable stateEnable)
     {
-        if (Initialized)
+        if (IsInitialized)
             return false;
 
         _stateEnable = stateEnable;
         _stateEnable.Assign(this);
+        OnAssign(stateEnable);
         OnStateEnableAssigned?.Invoke(this);
         return true;
     }
@@ -67,11 +67,13 @@ public abstract class BaseEntity : IEntity
     protected virtual void UnassignInternal() { }
     public bool Unassign()
     {
-        if (Initialized)
+        if (IsInitialized)
             return false;
 
         UnassignInternal();
 
+        _stateEnable = null!;
+        _stateEnable.Unassign();
         OnUnassigned?.Invoke(this);
         return true;
     }
@@ -79,24 +81,26 @@ public abstract class BaseEntity : IEntity
     protected virtual void InitializeInternal() { }
     public bool Initialize()
     {
-        if (Initialized)
+        if (IsInitialized)
             return false;
 
+        _stateEnable ??= Factory.StateEnableFactory.Instantiate(this);
+
         InitializeInternal();
 
-        Initialized = true;
+        IsInitialized = true;
         return true;
     }
 
     protected virtual void FinalizeInternal() { }
     public bool Finalize()
     {
-        if (!Initialized)
+        if (!IsInitialized)
             return false;
 
         FinalizeInternal();
 
-        Initialized = false;
+        IsInitialized = false;
         return true;
     }
 

Engine.Core/Behaviour.cs

@@ -1,59 +1,50 @@
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-
 namespace Syntriax.Engine.Core;
 
-[System.Diagnostics.DebuggerDisplay("{GetType().Name, nq}, Priority: {Priority}, Initialized: {Initialized}")]
-public abstract class Behaviour : BaseEntity, IBehaviour
+public abstract class Behaviour : BehaviourBase
 {
-    public event IAssignableBehaviourController.OnBehaviourControllerAssignedDelegate? OnBehaviourControllerAssigned = null;
+    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler delegateEnteredUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateExitedUniverse = null!;
 
-    public event IBehaviour.OnPriorityChangedDelegate? OnPriorityChanged = null;
-
-
-    private IBehaviourController _behaviourController = null!;
-
-    private int _priority = 0;
-
-
-    public IBehaviourController BehaviourController => _behaviourController;
-
-    public override bool IsActive => base.IsActive && BehaviourController.GameObject.StateEnable.Enabled;
-
-    public int Priority
+    public Behaviour()
     {
-        get => _priority;
-        set
-        {
-            if (value == _priority)
-                return;
+        OnInitialized.AddListener(OnInitialize);
+        OnFinalized.AddListener(OnFinalize);
+        OnUnassigned.AddListener(OnUnassign);
 
-            int previousPriority = _priority;
-            _priority = value;
-            OnPriorityChanged?.Invoke(this, previousPriority);
-        }
+        delegateEnteredUniverse = EnteredUniverse;
+        delegateExitedUniverse = ExitedUniverse;
     }
 
-    public bool Assign(IBehaviourController behaviourController)
-    {
-        if (Initialized)
-            return false;
+    protected virtual void OnUnassign() { }
+    protected void OnUnassign(IAssignable assignable) => OnUnassign();
 
-        _behaviourController = behaviourController;
-        OnBehaviourControllerAssigned?.Invoke(this);
-        return true;
+    protected virtual void OnInitialize() { }
+    protected void OnInitialize(IInitializable _)
+    {
+        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(delegateEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(delegateExitedUniverse);
+
+        OnInitialize();
+
+        if (UniverseObject.IsInUniverse)
+            EnteredUniverse(UniverseObject, new(Universe));
     }
 
-    protected override void UnassignInternal()
+    protected virtual void OnFinalize() { }
+    protected void OnFinalize(IInitializable _)
     {
-        base.UnassignInternal();
-        _behaviourController = null!;
+        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(delegateEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(delegateExitedUniverse);
+
+        OnFinalize();
+
+        if (UniverseObject.IsInUniverse)
+            ExitedUniverse(UniverseObject, new(Universe));
     }
 
-    protected override void InitializeInternal()
-    {
-        base.InitializeInternal();
-        NotAssignedException.Check(this, _behaviourController);
-        NotAssignedException.Check(this, StateEnable);
-    }
+    protected virtual void OnEnteredUniverse(IUniverse universe) { }
+    protected void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => OnEnteredUniverse(args.Universe);
+
+    protected virtual void OnExitedUniverse(IUniverse universe) { }
+    protected void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args) => OnExitedUniverse(args.Universe);
 }

Engine.Core/Behaviour2D.cs

@@ -0,0 +1,9 @@
+namespace Syntriax.Engine.Core;
+
+public abstract class Behaviour2D : Behaviour, IBehaviour2D
+{
+    public ITransform2D Transform { get; private set; } = null!;
+
+    protected override void OnInitialize() => Transform = BehaviourController.GetRequiredBehaviour<ITransform2D>();
+    protected override void OnFinalize() => Transform = null!;
+}

Engine.Core/BehaviourBase.cs

@@ -0,0 +1,103 @@
+namespace Syntriax.Engine.Core;
+
+[System.Diagnostics.DebuggerDisplay("{GetType().Name, nq}, Priority: {Priority}, Initialized: {Initialized}")]
+public abstract class BehaviourBase : BaseEntity, IBehaviour
+{
+    public Event<IBehaviour, IBehaviour.PriorityChangedArguments> OnPriorityChanged { get; } = new();
+    public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
+    public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
+
+    private readonly Event<IHasUniverseObject>.EventHandler delegateOnUniverseObjectAssigned = null!;
+    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnUniverseObjectActiveChanged = null!;
+    private readonly Event<IStateEnable, IStateEnable.EnabledChangedArguments>.EventHandler delegateOnStateEnabledChanged = null!;
+
+    public IUniverse Universe => BehaviourController.UniverseObject.Universe;
+    public IUniverseObject UniverseObject => BehaviourController.UniverseObject;
+
+    private IBehaviourController _behaviourController = null!;
+    public IBehaviourController BehaviourController => _behaviourController;
+
+    private int _priority = 0;
+    public int Priority
+    {
+        get => _priority;
+        set
+        {
+            if (value == _priority)
+                return;
+
+            int previousPriority = _priority;
+            _priority = value;
+            OnPriorityChanged?.Invoke(this, new(previousPriority));
+        }
+    }
+
+    private bool _isActive = false;
+    public bool IsActive => _isActive;
+
+    protected virtual void OnAssign(IBehaviourController behaviourController) { }
+    public bool Assign(IBehaviourController behaviourController)
+    {
+        if (IsInitialized)
+            return false;
+
+        _behaviourController = behaviourController;
+        OnAssign(behaviourController);
+        behaviourController.OnUniverseObjectAssigned.AddListener(delegateOnUniverseObjectAssigned);
+        behaviourController.StateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
+        if (behaviourController.UniverseObject is not null)
+            OnUniverseObjectAssigned(behaviourController);
+        OnBehaviourControllerAssigned?.Invoke(this);
+        return true;
+    }
+
+    private void OnUniverseObjectAssigned(IHasUniverseObject sender)
+    {
+        sender.UniverseObject.OnActiveChanged.AddListener(delegateOnUniverseObjectActiveChanged);
+        UpdateActive();
+    }
+
+    protected override void OnAssign(IStateEnable stateEnable)
+    {
+        base.OnAssign(stateEnable);
+
+        stateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
+    }
+
+    protected override void UnassignInternal()
+    {
+        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(delegateOnUniverseObjectActiveChanged);
+        StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
+        BehaviourController.OnUniverseObjectAssigned.RemoveListener(delegateOnUniverseObjectAssigned);
+        BehaviourController.StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
+        base.UnassignInternal();
+        _behaviourController = null!;
+    }
+
+    protected override void InitializeInternal()
+    {
+        Debug.Assert.AssertBehaviourControllerAssigned(this);
+        Debug.Assert.AssertStateEnableAssigned(this);
+
+        UpdateActive();
+    }
+
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
+    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
+
+    private void UpdateActive()
+    {
+        bool previousActive = IsActive;
+        _isActive = StateEnable.Enabled && _behaviourController.StateEnable.Enabled && _behaviourController.UniverseObject.IsActive;
+
+        if (previousActive != IsActive)
+            OnActiveChanged?.Invoke(this, new(previousActive));
+    }
+
+    protected BehaviourBase()
+    {
+        delegateOnUniverseObjectAssigned = OnUniverseObjectAssigned;
+        delegateOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
+        delegateOnStateEnabledChanged = OnStateEnabledChanged;
+    }
+}

Engine.Core/BehaviourCollector.cs

@@ -1,106 +1,124 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 
-using Syntriax.Engine.Core.Abstract;
-
 namespace Syntriax.Engine.Core;
 
-public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
+public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
 {
-    public event IAssignable.OnUnassignedDelegate? OnUnassigned = null;
-    public event IAssignableGameManager.OnGameManagerAssignedDelegate? OnGameManagerAssigned = 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 OnCollectedDelegate? OnCollected = null;
-    public event OnRemovedDelegate? OnRemoved = null;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
-    private readonly List<T> _behaviours = new(32);
+    protected readonly List<T> behaviours = new(32);
 
-    public IReadOnlyList<T> Behaviours => _behaviours;
-    public IGameManager GameManager { get; private set; } = null!;
+    public IUniverse Universe { get; private set; } = null!;
 
-    public T this[Index index] => _behaviours[index];
-
-    public BehaviourCollector() { }
-    public BehaviourCollector(IGameManager gameManager) => Assign(gameManager);
-
-    private void OnGameObjectRegistered(IGameManager manager, IGameObject gameObject)
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
     {
-        gameObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
-        gameObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
+
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
+
+        for (int i = 0; i < universeObject.BehaviourController.Count; i++)
+            OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnGameObjectUnregistered(IGameManager manager, IGameObject gameObject)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        gameObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
-        gameObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
+
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
+
+        for (int i = 0; i < universeObject.BehaviourController.Count; i++)
+            OnBehaviourRemoved(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
+    protected virtual void AddBehaviour(T behaviour) => behaviours.Add(behaviour);
+    protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (behaviour is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
-        _behaviours.Add(tBehaviour);
-        OnCollected?.Invoke(this, tBehaviour);
+        AddBehaviour(tBehaviour);
+        OnBehaviourAdd(args.BehaviourAdded);
+        OnCollected?.Invoke(this, new(tBehaviour));
     }
 
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
+    protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (behaviour is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
-        if (!_behaviours.Remove(tBehaviour))
+        if (!behaviours.Remove(tBehaviour))
             return;
 
-        OnRemoved?.Invoke(this, tBehaviour);
+        OnBehaviourRemove(args.BehaviourRemoved);
+        OnRemoved?.Invoke(this, new(tBehaviour));
     }
 
-    public bool Assign(IGameManager gameManager)
+    protected virtual void OnAssign(IUniverse universe) { }
+    public bool Assign(IUniverse universe)
     {
-        if (GameManager is not null)
+        if (Universe is not null)
             return false;
 
-        foreach (IGameObject gameObject in gameManager)
-        {
-            OnGameObjectRegistered(gameManager, gameObject);
-            foreach (IBehaviour behaviour in gameObject.BehaviourController)
-                OnBehaviourAdded(gameObject.BehaviourController, behaviour);
-        }
+        foreach (IUniverseObject universeObject in universe.UniverseObjects)
+            OnUniverseObjectRegistered(universe, new(universeObject));
 
-        gameManager.OnGameObjectRegistered += OnGameObjectRegistered;
-        gameManager.OnGameObjectUnRegistered += OnGameObjectUnregistered;
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
+        universe.OnPreUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
-        GameManager = gameManager;
-        OnGameManagerAssigned?.Invoke(this);
+        Universe = universe;
+        OnAssign(universe);
+        OnUniverseAssigned?.Invoke(this);
 
         return true;
     }
 
     public bool Unassign()
     {
-        if (GameManager is null)
+        if (Universe is null)
             return false;
 
-        foreach (IGameObject gameObject in GameManager)
-        {
-            OnGameObjectUnregistered(GameManager, gameObject);
-            foreach (IBehaviour behaviour in gameObject.BehaviourController)
-                OnBehaviourRemoved(gameObject.BehaviourController, behaviour);
-        }
+        foreach (IUniverseObject universeObject in Universe.UniverseObjects)
+            OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        GameManager.OnGameObjectRegistered -= OnGameObjectRegistered;
-        GameManager.OnGameObjectUnRegistered -= OnGameObjectUnregistered;
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
+        Universe.OnPreUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
-        GameManager = null!;
+        Universe = null!;
         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()
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
 
-    public delegate void OnCollectedDelegate(BehaviourCollector<T> sender, T behaviourCollected);
-    public delegate void OnRemovedDelegate(BehaviourCollector<T> sender, T behaviourRemoved);
+    public BehaviourCollector(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
+    }
 }

Engine.Core/BehaviourCollectorSorted.cs

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

Engine.Core/BehaviourController.cs

@@ -1,91 +1,78 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-
-using Syntriax.Engine.Core.Abstract;
 
 namespace Syntriax.Engine.Core;
 
 [System.Diagnostics.DebuggerDisplay("Behaviour Count: {behaviours.Count}")]
-public class BehaviourController : IBehaviourController
+public class BehaviourController : BaseEntity, IBehaviourController
 {
-    public event IBehaviourController.OnPreUpdateDelegate? OnPreUpdate = null;
-    public event IBehaviourController.OnUpdateDelegate? OnUpdate = null;
-    public event IBehaviourController.OnPreDrawDelegate? 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.OnBehaviourAddedDelegate? OnBehaviourAdded = null;
-    public event IBehaviourController.OnBehaviourRemovedDelegate? OnBehaviourRemoved = null;
-    public event IAssignable.OnUnassignedDelegate? OnUnassigned;
-    public event IAssignableGameObject.OnGameObjectAssignedDelegate? OnGameObjectAssigned = null;
+    private readonly List<IBehaviour> behaviours = new(Constants.BEHAVIOURS_SIZE_INITIAL);
 
+    private IUniverseObject _universeObject = null!;
 
-    private readonly IList<IBehaviour> behaviours = new List<IBehaviour>(Constants.BEHAVIOURS_SIZE_INITIAL);
-
-    private IGameObject _gameObject = null!;
-
-
-    public IGameObject GameObject => _gameObject;
+    public IUniverseObject UniverseObject => _universeObject;
+    public int Count => behaviours.Count;
+    public IBehaviour this[Index index] => behaviours[index];
 
     public T AddBehaviour<T>(T behaviour) where T : class, IBehaviour
     {
         InsertBehaviourByPriority(behaviour);
 
-        behaviour.Initialize();
-        behaviour.OnPriorityChanged += OnPriorityChange;
-        OnBehaviourAdded?.Invoke(this, behaviour);
+        behaviour.Assign(this);
+
+        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(new Factory.BehaviourFactory().Instantiate<T>(_gameObject, args));
+    {
+        T behaviour = Factory.BehaviourFactory.Instantiate<T>(args);
+        return AddBehaviour(behaviour);
+    }
 
     public T? GetBehaviour<T>()
     {
-        foreach (var behaviourItem in behaviours)
+        foreach (IBehaviour behaviourItem in behaviours)
             if (behaviourItem is T result)
                 return result;
 
         return default;
     }
 
-    public bool TryGetBehaviour<T>([NotNullWhen(returnValue: true)] out T? behaviour)
+    public IReadOnlyList<T> GetBehaviours<T>()
     {
-        behaviour = GetBehaviour<T>();
-        return behaviour is not null;
+        List<T> behaviours = [];
+
+        foreach (IBehaviour behaviourItem in this.behaviours)
+            if (behaviourItem is T behaviour)
+                behaviours.Add(behaviour);
+
+        return behaviours;
     }
 
-    public IList<T> GetBehaviours<T>()
+    public void GetBehaviours<T>(IList<T> results)
     {
-        List<T>? behaviours = null;
-        foreach (var behaviourItem in this.behaviours)
+        results.Clear();
+        foreach (IBehaviour behaviourItem in behaviours)
         {
             if (behaviourItem is not T behaviour)
                 continue;
 
-            behaviours ??= [];
-            behaviours.Add(behaviour);
-        }
-
-        return behaviours ?? Enumerable.Empty<T>().ToList();
-    }
-
-    public void GetBehaviours<T>(List<T> behaviors)
-    {
-        behaviors.Clear();
-        foreach (var behaviourItem in behaviours)
-        {
-            if (behaviourItem is not T _)
-                continue;
-
-            behaviours.Add(behaviourItem);
+            results.Add(behaviour);
         }
     }
 
     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;
@@ -100,53 +87,42 @@ public class BehaviourController : IBehaviourController
     public void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour
     {
         if (!behaviours.Contains(behaviour))
-            throw new Exception($"{behaviour.GetType().Name} does not exist in {GameObject.Name}'s {nameof(IBehaviourController)}.");
+            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?.Invoke(this, behaviour);
+        OnBehaviourRemoved?.Invoke(this, new(behaviour));
     }
 
-    public bool Assign(IGameObject gameObject)
+    protected virtual void OnAssign(IUniverseObject universeObject) { }
+    public bool Assign(IUniverseObject universeObject)
     {
-        if (GameObject is not null && GameObject.Initialized)
+        if (UniverseObject is not null && UniverseObject.IsInitialized)
             return false;
 
-        _gameObject = gameObject;
-        OnGameObjectAssigned?.Invoke(this);
+        _universeObject = universeObject;
+        OnAssign(universeObject);
+        OnUniverseObjectAssigned?.Invoke(this);
         return true;
     }
 
-    public bool Unassign()
+    protected override void InitializeInternal()
     {
-        if (GameObject is not null && GameObject.Initialized)
-            return false;
+        Debug.Assert.AssertUniverseObjectAssigned(this);
 
-        _gameObject = null!;
-        OnUnassigned?.Invoke(this);
-        return true;
+        foreach (IBehaviour behaviour in behaviours)
+            behaviour.Initialize();
     }
 
-    public void Update()
+    protected override void FinalizeInternal()
     {
-        if (!GameObject.StateEnable.Enabled)
-            return;
-
-        OnPreUpdate?.Invoke(this);
-        OnUpdate?.Invoke(this);
-    }
-
-    public void UpdatePreDraw()
-    {
-        if (!GameObject.StateEnable.Enabled)
-            return;
-
-        OnPreDraw?.Invoke(this);
+        foreach (IBehaviour behaviour in behaviours)
+            behaviour.Finalize();
     }
 
     public BehaviourController() { }
-    public BehaviourController(IGameObject gameObject) => Assign(gameObject);
+    public BehaviourController(IUniverseObject universeObject) => Assign(universeObject);
 
     private void InsertBehaviourByPriority<T>(T behaviour) where T : class, IBehaviour
     {
@@ -165,13 +141,9 @@ public class BehaviourController : IBehaviourController
             behaviours.Add(behaviour);
     }
 
-
-    private void OnPriorityChange(IBehaviour sender, int previousPriority)
+    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
     {
         behaviours.Remove(sender);
         InsertBehaviourByPriority(sender);
     }
-
-    public IEnumerator<IBehaviour> GetEnumerator() => behaviours.GetEnumerator();
-    IEnumerator IEnumerable.GetEnumerator() => behaviours.GetEnumerator();
 }

Engine.Core/BehaviourOverride.cs

@@ -1,87 +0,0 @@
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core;
-
-public abstract class BehaviourOverride : Behaviour
-{
-    private bool isInitializedThisFrame = false;
-
-    protected IGameObject GameObject => BehaviourController.GameObject;
-    protected ITransform Transform => BehaviourController.GameObject.Transform;
-
-    public BehaviourOverride()
-    {
-        OnInitialized += OnInitialize;
-        OnFinalized += OnFinalize;
-        OnUnassigned += OnUnassign;
-    }
-
-    protected virtual void OnUnassign() { }
-    private void OnUnassign(IAssignable assignable) => OnUnassign();
-
-    protected virtual void OnInitialize() { }
-    private void OnInitialize(IInitialize _)
-    {
-        isInitializedThisFrame = true;
-
-        BehaviourController.OnPreUpdate += PreUpdate;
-        BehaviourController.OnPreDraw += PreDraw;
-        BehaviourController.OnUpdate += Update;
-        OnInitialize();
-    }
-
-    protected virtual void OnFinalize() { }
-    private void OnFinalize(IInitialize _)
-    {
-        BehaviourController.OnPreUpdate -= PreUpdate;
-        BehaviourController.OnPreDraw -= PreDraw;
-        BehaviourController.OnUpdate -= Update;
-        OnFinalize();
-    }
-
-    protected virtual void OnPreUpdatePreActiveCheck() { }
-    protected virtual void OnPreUpdate() { }
-    private void PreUpdate(IBehaviourController _)
-    {
-        OnPreUpdatePreActiveCheck();
-
-        if (!IsActive)
-            return;
-
-        if (isInitializedThisFrame)
-            FirstActiveFrame();
-
-        OnPreUpdate();
-    }
-
-    protected virtual void OnFirstActiveFrame() { }
-    private void FirstActiveFrame()
-    {
-        OnFirstActiveFrame();
-        isInitializedThisFrame = false;
-    }
-
-    protected virtual void OnUpdatePreActiveCheck() { }
-    protected virtual void OnUpdate() { }
-    private void Update(IBehaviourController _)
-    {
-        OnUpdatePreActiveCheck();
-
-        if (!IsActive)
-            return;
-
-        OnUpdate();
-    }
-
-    protected virtual void OnPreDrawPreActiveCheck() { }
-    protected virtual void OnPreDraw() { }
-    private void PreDraw(IBehaviourController _)
-    {
-        OnPreDrawPreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPreDraw();
-    }
-}

Engine.Core/CoroutineManager.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class CoroutineManager : Behaviour, IUpdate
+{
+    private readonly List<IEnumerator> enumerators = [];
+
+    public IEnumerator StartCoroutine(IEnumerator enumerator)
+    {
+        enumerators.Add(enumerator);
+        return enumerator;
+    }
+
+    public void StopCoroutine(IEnumerator enumerator)
+    {
+        enumerators.Remove(enumerator);
+    }
+
+    void IUpdate.Update()
+    {
+        for (int i = enumerators.Count - 1; i >= 0; i--)
+        {
+            if (enumerators[i].Current is ICoroutineYield coroutineYield && coroutineYield.Yield())
+                continue;
+
+            if (!enumerators[i].MoveNext())
+                enumerators.RemoveAt(i);
+        }
+    }
+
+    public CoroutineManager() => Priority = int.MinValue;
+}

Engine.Core/CoroutineYield.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Syntriax.Engine.Core;
+
+public class CoroutineYield(Func<bool> condition) : ICoroutineYield
+{
+    private readonly Func<bool> condition = condition;
+
+    public bool Yield() => condition.Invoke();
+}

Engine.Core/Debug/AssertHelpers.cs

@@ -0,0 +1,30 @@
+using System.Runtime.CompilerServices;
+
+namespace Syntriax.Engine.Core.Debug;
+
+public static class Assert
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void AssertInitialized(IInitializable initializable)
+        => System.Diagnostics.Debug.Assert(initializable.IsInitialized, $"{initializable.GetType().Name} must be initialized");
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void AssertBehaviourControllerAssigned(IHasBehaviourController assignable)
+        => 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 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 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 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 assigned an {nameof(IStateEnable)}");
+}

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,29 @@
+using System;
+using System.IO;
+
+namespace Syntriax.Engine.Core.Debug;
+
+public class FileLogger : LoggerBase
+{
+    public readonly string FilePath;
+
+    protected override void Write(string message)
+    {
+        File.AppendAllTextAsync(FilePath, $"{message}{Environment.NewLine}");
+    }
+
+    public FileLogger(string filePath)
+    {
+        FilePath = filePath;
+
+        bool isRelativePath = Path.GetFullPath(filePath).CompareTo(filePath) != 0;
+
+        if (isRelativePath)
+            FilePath = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filePath));
+
+        if (Path.GetDirectoryName(FilePath) is string directoryPath)
+            Directory.CreateDirectory(directoryPath);
+
+        File.Open(FilePath, FileMode.Create).Close();
+    }
+}

Engine.Core/Debug/ILogger.cs

@@ -0,0 +1,18 @@
+namespace Syntriax.Engine.Core.Debug;
+
+public interface ILogger
+{
+    static ILogger Shared { get; set; } = new ConsoleLogger();
+
+    Level FilterLevel { get; set; }
+
+    void Log(string message, Level level = Level.Info, bool force = false);
+
+    enum Level
+    {
+        Trace,
+        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.Trace;
+
+    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/LoggerContainer.cs

@@ -0,0 +1,9 @@
+namespace Syntriax.Engine.Core.Debug;
+
+public class LoggerContainer : Behaviour, ILogger
+{
+    public ILogger Logger { get; set; } = ILogger.Shared;
+
+    public ILogger.Level FilterLevel { get => Logger.FilterLevel; set => Logger.FilterLevel = value; }
+    public void Log(string message, ILogger.Level level = ILogger.Level.Info, bool force = false) => Logger.Log(message, level, force);
+}

Engine.Core/Debug/LoggerExtensions.cs

@@ -0,0 +1,36 @@
+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);
+        LogTrace(logger, caller, new StackTrace(), force);
+    }
+
+    public static void LogException<T>(this ILogger logger, T caller, Exception exception, bool force = false)
+    {
+        Log(logger, caller, $"Exception of type {exception.GetType().Name} occured", ILogger.Level.Error, force);
+        Log(logger, caller, $"Message: {exception.Message}", ILogger.Level.Error, force);
+        Log(logger, caller, $"InnerException: {exception.InnerException}", ILogger.Level.Error, force);
+
+        // Not using LogTrace because exception.StackTrace is a type of string
+        Log(logger, caller, $"{nameof(StackTrace)}:{Environment.NewLine}{exception.StackTrace}", ILogger.Level.Trace);
+    }
+
+    public static void LogTrace<T>(this ILogger logger, T caller, StackTrace? stackTrace = null, bool force = false)
+    {
+        Log(logger, caller, $"{nameof(StackTrace)}:{Environment.NewLine}{stackTrace ?? new()}", ILogger.Level.Trace, force);
+    }
+}

Engine.Core/Debug/LoggerWrapper.cs

@@ -0,0 +1,23 @@
+namespace Syntriax.Engine.Core.Debug;
+
+public class LoggerWrapper(ILogger firstLogger, ILogger secondLogger) : ILogger
+{
+    private readonly ILogger firstLogger = firstLogger;
+    private readonly ILogger secondLogger = secondLogger;
+
+    public ILogger.Level FilterLevel
+    {
+        get => firstLogger.FilterLevel;
+        set
+        {
+            firstLogger.FilterLevel = value;
+            secondLogger.FilterLevel = value;
+        }
+    }
+
+    public void Log(string message, ILogger.Level level = ILogger.Level.Info, bool force = false)
+    {
+        firstLogger.Log(message, level, force);
+        secondLogger.Log(message, level, force);
+    }
+}

Engine.Core/Debug/LoggerWrapperExtensions.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Core.Debug;
+
+public static class LoggerWrapperExtensions
+{
+    public static ILogger WrapWith(this ILogger thisLogger, ILogger logger) => new LoggerWrapper(thisLogger, logger);
+}

Engine.Core/Engine.Core.csproj

@@ -1,8 +1,10 @@
 <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>
   </PropertyGroup>
+
 </Project>

Engine.Core/Engine.Core.puml

@@ -0,0 +1,46 @@
+@startuml "Core Engine Relations"
+
+top to bottom direction
+skinparam linetype ortho
+skinparam nodesep 100
+
+title Core Engine Relations
+
+interface Engine.Core.IEntity extends Engine.Core.IInitializable {}
+interface Engine.Core.IUniverseObject extends Engine.Core.IEntity, Engine.Core.INameable {}
+
+interface Engine.Core.INameable {}
+
+Engine.Core.IUniverseObject --> Engine.Core.IBehaviourController: has
+Engine.Core.IBehaviourController "1" --> "0..*" Engine.Core.IBehaviour: has
+
+interface Engine.Core.IBehaviourController {}
+interface Engine.Core.IBehaviour {}
+interface Engine.Core.IBehaviour2D extends Engine.Core.IBehaviour {}
+interface Engine.Core.IBehaviour3D extends Engine.Core.IBehaviour {}
+
+interface Engine.Core.IUniverse {}
+Engine.Core.IUniverse "1" -r-> "0..*" Engine.Core.IUniverseObject: has
+
+' together {
+'     interface Engine.Core.IAssignable {}
+'     interface Engine.Core.IHasStateEnable extends Engine.Core.IAssignable {}
+'     interface Engine.Core.IHasUniverse extends Engine.Core.IAssignable {}
+'     interface Engine.Core.IHasUniverseObject extends Engine.Core.IAssignable {}
+'     interface Engine.Core.IHasBehaviourController extends Engine.Core.IAssignable {}
+'     ' Engine.Core.IHasStateEnable --> Engine.Core.IStateEnable: has
+'     ' Engine.Core.IHasUniverse --> Engine.Core.IUniverse: has
+'     ' Engine.Core.IHasUniverseObject --> Engine.Core.IUniverseObject: has
+'     ' Engine.Core.IHasBehaviourController --> Engine.Core.IBehaviourController: has
+' }
+
+together {
+    interface Engine.Core.ITransform2D {}
+    interface Engine.Core.ICamera2D {}
+    interface Engine.Core.ICoroutineYield {}
+    interface Engine.Core.IStateEnable {}
+    interface Engine.Core.IInitializable {}
+    interface Engine.Core.IBehaviourCollector {}
+}
+
+@enduml

Engine.Core/EngineTime.cs

@@ -1,11 +0,0 @@
-using System;
-
-namespace Syntriax.Engine.Core;
-
-public readonly struct EngineTime(TimeSpan Total, TimeSpan Elapsed)
-{
-    public readonly TimeSpan Total = Total;
-    public readonly TimeSpan Elapsed = Elapsed;
-
-    public readonly float DeltaTimeFrame = (float)Elapsed.TotalMilliseconds;
-}

Engine.Core/Exceptions/AssignException.cs

@@ -1,20 +0,0 @@
-using System;
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core.Exceptions;
-
-public class AssignException : Exception
-{
-    public AssignException() : base("Assign operation has failed.") { }
-    public AssignException(string? message) : base(message) { }
-
-    // public static AssignException FromStateEnable(IStateEnable? stateEnable)
-    //     => new AssignException($"{nameof(IGameObject.AssignStateEnable)} failed on type {stateEnable?.GetType().ToString() ?? "\"null\""}");
-    public static AssignException From<T, T2>(T to, T2? value)
-        => new AssignException($"Assign operation has failed on T: {typeof(T).FullName}, value: {value?.GetType().ToString() ?? "\"null\""}");
-    // public static AssignException FromBehaviourController(IBehaviourController? behaviourController)
-    //     => new AssignException($"{nameof(IGameObject.AssignBehaviourController)} failed on type {behaviourController?.GetType().ToString() ?? "\"null\""}");
-}
-// throw new Exception($"{nameof(IGameObject.AssignTransform)} failed on type {transform?.GetType().ToString() ?? "null"} for type {typeof(T).FullName}");
-// throw new Exception($"{nameof(IGameObject.AssignBehaviourController)} failed on type {behaviourController?.GetType().ToString() ?? "null"} for type {typeof(T).FullName}");
-// throw new Exception($"{nameof(IGameObject.AssignStateEnable)} failed on type {stateEnable?.GetType().ToString() ?? "null"} for type {typeof(T).FullName}");

Engine.Core/Exceptions/AssignFailedException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Syntriax.Engine.Core.Exceptions;
+
+public class AssignFailedException(string? message) : Exception(message)
+{
+    public static AssignFailedException From<T, T2>(T to, T2? value)
+        => new($"Assign operation has failed on T: {to?.GetType().FullName ?? "\"null\""}, value: {value?.GetType().ToString() ?? "\"null\""}");
+}

Engine.Core/Exceptions/BehaviourNotFoundException.cs

@@ -0,0 +1,3 @@
+namespace Syntriax.Engine.Core.Exceptions;
+
+public class BehaviourNotFoundException(string? message) : NotFoundException(message);

Engine.Core/Exceptions/NotAssignedException.cs

@@ -1,21 +1,9 @@
 using System;
-using Syntriax.Engine.Core.Abstract;
 
 namespace Syntriax.Engine.Core.Exceptions;
 
-public class NotAssignedException : Exception
+public class NotAssignedException(string? message) : Exception(message)
 {
-    public NotAssignedException() : base("The object has not been assigned.") { }
-    public NotAssignedException(string? message) : base(message) { }
-
-    public static NotAssignedException From<T1, T2>(T1 to, T2? value) where T1 : IAssignable
-        => new NotAssignedException($"{typeof(T2).Name} has not been assigned to {typeof(T1).Name}");
-
-    public static void Check<T1, T2>(T1 to, T2? value) where T1 : IAssignable
-    {
-        if (value is not null)
-            return;
-
-        throw From(to, value);
-    }
+    public static NotAssignedException From<T1, T2>(T1 to, T2? value)
+        => new($"{value?.GetType().FullName ?? "\"null\""} has not been assigned to {to?.GetType().FullName ?? "\"null\""}");
 }

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

@@ -0,0 +1,3 @@
+namespace Syntriax.Engine.Core.Exceptions;
+
+public class UniverseObjectNotFoundException(string? message) : NotFoundException(message);

Engine.Core/Extensions/Abstract/TransformExtensions.cs

@@ -1,9 +0,0 @@
-namespace Syntriax.Engine.Core.Abstract;
-
-public static class TransformExtensions
-{
-    public static Vector2D TransformVector2D(this ITransform transform, Vector2D vector)
-        => vector.Scale(transform.Scale)
-                 .Rotate(transform.Rotation * Math.DegreeToRadian)
-                 .Add(transform.Position);
-}

Engine.Core/Extensions/BehaviourControllerExtensions.cs

@@ -1,47 +1,182 @@
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
-using Syntriax.Engine.Core.Abstract;
+using Syntriax.Engine.Core.Exceptions;
 
 namespace Syntriax.Engine.Core;
 
 public static class BehaviourControllerExtensions
 {
+    /// <summary>
+    /// Tries to get a <see cref="IBehaviour"/> of the specified type.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <param name="behaviourController">The <see cref="IBehaviourController"/> to search in.</param>
+    /// <param name="behaviour">When this method returns, contains the <see cref="IBehaviour"/> of the specified type, if found; otherwise, null.</param>
+    /// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found; otherwise, <see cref="false"/>.</returns>
+    public static bool TryGetBehaviour<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour)
+    {
+        behaviour = behaviourController.GetBehaviour<T>();
+        return behaviour is not null;
+    }
+
+    /// <summary>
+    /// Gets a <see cref="IBehaviour"/> of the specified type in the provided <see cref="IBehaviourController"/>. Throws an error if not found.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <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 ?? "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.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get or add.</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 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>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
+    /// <param name="behaviour">When this method returns, contains the <see cref="IBehaviour"/> 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 parent universe; otherwise, <see cref="false"/>.</returns>
     public static bool TryGetBehaviourInParent<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
     {
         behaviour = GetBehaviourInParent<T>(behaviourController);
         return behaviour is not null;
     }
 
+    /// <summary>
+    /// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
+    /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, null.</returns>
     public static T? GetBehaviourInParent<T>(this IBehaviourController behaviourController) where T : class
     {
         IBehaviourController? controller = behaviourController;
 
         while (controller is not null)
         {
-            if (behaviourController.GetBehaviour<T>() is T behaviour)
+            if (controller.GetBehaviour<T>() is T behaviour)
                 return behaviour;
 
-            controller = controller.GameObject.Transform.Parent?.GameObject.BehaviourController;
+            controller = controller.UniverseObject.Parent?.BehaviourController;
         }
 
         return default;
     }
 
+    /// <summary>
+    /// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively. Throws an error if not found.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <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 ?? "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.
+    /// </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>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
+    /// <param name="behaviour">When this method returns, contains the <see cref="IBehaviour"/> 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 child universe; otherwise, <see cref="false"/>.</returns>
     public static bool TryGetBehaviourInChildren<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
     {
         behaviour = GetBehaviourInChildren<T>(behaviourController);
         return behaviour is not null;
     }
 
+    /// <summary>
+    /// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s children recursively.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
+    /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, null.</returns>
     public static T? GetBehaviourInChildren<T>(this IBehaviourController behaviourController) where T : class
     {
         if (behaviourController.GetBehaviour<T>() is T localBehaviour)
             return localBehaviour;
 
-        foreach (ITransform transform in behaviourController.GameObject.Transform)
-            if (GetBehaviourInChildren<T>(transform.GameObject.BehaviourController) is T behaviour)
+        foreach (IUniverseObject child in behaviourController.UniverseObject.Children)
+            if (GetBehaviourInChildren<T>(child.BehaviourController) is T behaviour)
                 return behaviour;
 
         return default;
     }
+
+    /// <summary>
+    /// Gets a <see cref="IBehaviour"/> of the specified type in the children recursively. Throws an error if not found.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <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 ?? "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.
+    /// </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.Children)
+            TraverseChildrenForBehaviour(child, behaviours, cache);
+    }
 }

Engine.Core/Extensions/BehaviourExtensions.cs

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

Engine.Core/Extensions/EnumExtensions.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Syntriax.Engine.Core;
+
+public static class EnumExtensions
+{
+    public static bool CheckFlag(this Enum left, Enum right)
+        => ((int)(object)left & (int)(object)right) != 0;
+}

Engine.Core/Extensions/GameManagerExtensions.cs

@@ -1,9 +0,0 @@
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core;
-
-public static class GameManagerExtensions
-{
-    public static IGameObject InstantiateGameObject(this IGameManager gameManager, params object?[]? args)
-        => gameManager.InstantiateGameObject<GameObject>(args);
-}

Engine.Core/Extensions/GameObjectExtensions.cs

@@ -1,12 +0,0 @@
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core;
-
-public static class GameObjectExtensions
-{
-    public static IGameObject SetGameObject(this IGameObject gameObject, string name)
-    {
-        gameObject.Name = name;
-        return gameObject;
-    }
-}

Engine.Core/Extensions/TransformExtensions.cs

@@ -1,10 +1,8 @@
-using Syntriax.Engine.Core.Abstract;
-
 namespace Syntriax.Engine.Core;
 
 public static class TransformExtensions
 {
-    public static ITransform SetTransform(this ITransform transform,
+    public static ITransform2D SetTransform(this ITransform2D transform,
         Vector2D? position = null, float? rotation = null, Vector2D? scale = null,
         Vector2D? localPosition = null, float? localRotation = null, Vector2D? localScale = null)
     {

Engine.Core/Extensions/UniverseExtensions.cs

@@ -0,0 +1,36 @@
+using Syntriax.Engine.Core.Exceptions;
+
+namespace Syntriax.Engine.Core;
+
+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

@@ -0,0 +1,255 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+using Syntriax.Engine.Core.Exceptions;
+
+namespace Syntriax.Engine.Core;
+
+public static class UniverseObjectExtensions
+{
+    public static T SetUniverseObject<T>(this T universeObject, string? name = "", IUniverseObject? parent = null) where T : IUniverseObject
+    {
+        if (!string.IsNullOrWhiteSpace(name))
+            universeObject.Name = name;
+        if (parent is not null)
+            universeObject.Parent = parent;
+        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)
+            if (universeObject is T @object)
+                return @object;
+
+        return default;
+    }
+
+    /// <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
+    {
+        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;
+    }
+
+    /// <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.Children.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.Children.GetUniverseObject<T>() is T localUniverseObject)
+            return localUniverseObject;
+
+        foreach (IUniverseObject child in universeObject.Children)
+            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)
+        {
+            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.Children.Find(cache);
+            foreach (T behaviour in cache)
+                instances.Add(behaviour);
+        }
+    }
+    #endregion
+}

Engine.Core/Extensions/Vector2DExtensions.cs

@@ -1,188 +0,0 @@
-namespace Syntriax.Engine.Core;
-
-/// <summary>
-/// Provides extension methods for <see cref="Vector2D"/> type.
-/// </summary>
-public static class Vector2DExtensions
-{
-    /// <summary>
-    /// Calculates the length of the <see cref="Vector2D"/>.
-    /// </summary>
-    /// <param name="vector">The input <see cref="Vector2D"/>.</param>
-    /// <returns>The length of the <see cref="Vector2D"/>.</returns>
-    public static float Length(this Vector2D vector) => Vector2D.Length(vector);
-
-    /// <summary>
-    /// Calculates the squared length of the <see cref="Vector2D"/>.
-    /// </summary>
-    /// <param name="vector">The input <see cref="Vector2D"/>.</param>
-    /// <returns>The squared length of the <see cref="Vector2D"/>.</returns>
-    public static float LengthSquared(this Vector2D vector) => Vector2D.LengthSquared(vector);
-
-    /// <summary>
-    /// Calculates the distance between two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="from">The starting <see cref="Vector2D"/>.</param>
-    /// <param name="to">The ending <see cref="Vector2D"/>.</param>
-    /// <returns>The distance between the two <see cref="Vector2D"/>s.</returns>
-    public static float Distance(this Vector2D from, Vector2D to) => Vector2D.Distance(from, to);
-
-    /// <summary>
-    /// Returns the <see cref="Vector2D"/> with its components inverted.
-    /// </summary>
-    /// <param name="vector">The input <see cref="Vector2D"/>.</param>
-    /// <returns>The inverted <see cref="Vector2D"/>.</returns>
-    public static Vector2D Invert(this Vector2D vector) => Vector2D.Invert(vector);
-
-    /// <summary>
-    /// Adds two <see cref="Vector2D"/>s component-wise.
-    /// </summary>
-    /// <param name="vector">The first <see cref="Vector2D"/>.</param>
-    /// <param name="vectorToAdd">The vector <see cref="Vector2D"/> to be added.</param>
-    /// <returns>The result of the addition.</returns>
-    public static Vector2D Add(this Vector2D vector, Vector2D vectorToAdd) => Vector2D.Add(vector, vectorToAdd);
-
-    /// <summary>
-    /// Subtracts one <see cref="Vector2D"/> from another component-wise.
-    /// </summary>
-    /// <param name="vector">The first <see cref="Vector2D"/>.</param>
-    /// <param name="vectorToSubtract">The <see cref="Vector2D"/> to be subtracted.</param>
-    /// <returns>The result of the subtraction.</returns>
-    public static Vector2D Subtract(this Vector2D vector, Vector2D vectorToSubtract) => Vector2D.Subtract(vector, vectorToSubtract);
-
-    /// <summary>
-    /// Multiplies a <see cref="Vector2D"/> by a scalar value.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector2D"/> to multiply.</param>
-    /// <param name="value">The scalar value to multiply with.</param>
-    /// <returns>The result of the multiplication.</returns>
-    public static Vector2D Multiply(this Vector2D vector, float value) => Vector2D.Multiply(vector, value);
-
-    /// <summary>
-    /// Divides a <see cref="Vector2D"/> by a scalar value.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector2D"/> to divide.</param>
-    /// <param name="value">The scalar value to divide with.</param>
-    /// <returns>The result of the division.</returns>
-    public static Vector2D Divide(this Vector2D vector, float value) => Vector2D.Divide(vector, value);
-
-    /// <summary>
-    /// Returns a <see cref="Vector2D"/> with the absolute values of each component.
-    /// </summary>
-    /// <param name="vector">The input <see cref="Vector2D"/>.</param>
-    /// <returns>The <see cref="Vector2D"/> with absolute values.</returns>
-    public static Vector2D Abs(this Vector2D vector) => Vector2D.Abs(vector);
-
-    /// <summary>
-    /// Reflects a <see cref="Vector2D"/> off a surface with the specified normal.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector2D"/> to reflect.</param>
-    /// <param name="normal">The normal <see cref="Vector2D"/> of the reflecting surface.</param>
-    /// <returns>The reflected <see cref="Vector2D"/>.</returns>
-    public static Vector2D Reflect(this Vector2D vector, Vector2D normal) => Vector2D.Reflect(vector, normal);
-
-    /// <summary>
-    /// Normalizes the <see cref="Vector2D"/> (creates a <see cref="Vector2D"/> with the same direction but with a length of 1).
-    /// </summary>
-    /// <param name="vector">The input <see cref="Vector2D"/>.</param>
-    /// <returns>The normalized <see cref="Vector2D"/>.</returns>
-    public static Vector2D Normalize(this Vector2D vector) => Vector2D.Normalize(vector);
-
-    /// <summary>
-    /// Creates a <see cref="Vector2D"/> pointing from one point to another.
-    /// </summary>
-    /// <param name="from">The starting point.</param>
-    /// <param name="to">The ending point.</param>
-    /// <returns>The <see cref="Vector2D"/> pointing from <paramref name="from"/> to <paramref name="to"/>.</returns>
-    public static Vector2D FromTo(this Vector2D from, Vector2D to) => Vector2D.FromTo(from, to);
-
-    /// <summary>
-    /// Scales a <see cref="Vector2D"/> by another <see cref="Vector2D"/> component-wise.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector2D"/> to scale.</param>
-    /// <param name="scale">The <see cref="Vector2D"/> containing the scaling factors for each component.</param>
-    /// <returns>The scaled <see cref="Vector2D"/>.</returns>
-    public static Vector2D Scale(this Vector2D vector, Vector2D scale) => Vector2D.Scale(vector, scale);
-
-    /// <summary>
-    /// Calculates the perpendicular <see cref="Vector2D"/> to the given <see cref="Vector2D"/>.
-    /// </summary>
-    /// <param name="vector">The input <see cref="Vector2D"/>.</param>
-    /// <returns>A <see cref="Vector2D"/> perpendicular to the input <see cref="Vector2D"/>.</returns>
-    public static Vector2D Perpendicular(this Vector2D vector) => Vector2D.Perpendicular(vector);
-
-    /// <summary>
-    /// Rotates a <see cref="Vector2D"/> by the specified angle (in radians).
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector2D"/> to rotate.</param>
-    /// <param name="angleInRadian">The angle to rotate by, in radians.</param>
-    /// <returns>The rotated <see cref="Vector2D"/>.</returns>
-    public static Vector2D Rotate(this Vector2D vector, float angleInRadian) => Vector2D.Rotate(vector, angleInRadian);
-
-    /// <summary>
-    /// Returns the component-wise minimum of two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="left">The first <see cref="Vector2D"/>.</param>
-    /// <param name="right">The second <see cref="Vector2D"/>.</param>
-    /// <returns>The <see cref="Vector2D"/> containing the minimum components from both input <see cref="Vector2D"/>s.</returns>
-    public static Vector2D Min(this Vector2D left, Vector2D right) => Vector2D.Min(left, right);
-
-    /// <summary>
-    /// Returns the component-wise maximum of two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="left">The first <see cref="Vector2D"/>.</param>
-    /// <param name="right">The second <see cref="Vector2D"/>.</param>
-    /// <returns>The <see cref="Vector2D"/> containing the maximum components from both input <see cref="Vector2D"/>s.</returns>
-    public static Vector2D Max(this Vector2D left, Vector2D right) => Vector2D.Max(left, right);
-
-    /// <summary>
-    /// Clamps each component of a <see cref="Vector2D"/> between the corresponding component of two other <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector2D"/> to clamp.</param>
-    /// <param name="min">The <see cref="Vector2D"/> representing the minimum values for each component.</param>
-    /// <param name="max">The <see cref="Vector2D"/> representing the maximum values for each component.</param>
-    /// <returns>The clamped <see cref="Vector2D"/>.</returns>
-    public static Vector2D Clamp(this Vector2D vector, Vector2D min, Vector2D max) => Vector2D.Clamp(vector, min, max);
-
-    /// <summary>
-    /// Linearly interpolates between two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="from">The start <see cref="Vector2D"/>.</param>
-    /// <param name="to">The end <see cref="Vector2D"/>.</param>
-    /// <param name="t">The interpolation parameter (between 0 and 1).</param>
-    /// <returns>The interpolated <see cref="Vector2D"/>.</returns>
-    public static Vector2D Lerp(this Vector2D from, Vector2D to, float t) => Vector2D.Lerp(from, to, t);
-
-    /// <summary>
-    /// Calculates the cross product of two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="left">The first <see cref="Vector2D"/>.</param>
-    /// <param name="right">The second <see cref="Vector2D"/>.</param>
-    /// <returns>The cross product of the two <see cref="Vector2D"/>s.</returns>
-    public static float Cross(this Vector2D left, Vector2D right) => Vector2D.Cross(left, right);
-
-    /// <summary>
-    /// Calculates the angle in radians between two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="left">The first <see cref="Vector2D"/>.</param>
-    /// <param name="right">The second <see cref="Vector2D"/>.</param>
-    /// <returns>The angle between the two <see cref="Vector2D"/>s in radians.</returns>
-    public static float AngleBetween(this Vector2D left, Vector2D right) => Vector2D.Angle(left, right);
-
-    /// <summary>
-    /// Calculates the dot product of two <see cref="Vector2D"/>s.
-    /// </summary>
-    /// <param name="left">The first <see cref="Vector2D"/>.</param>
-    /// <param name="right">The second <see cref="Vector2D"/>.</param>
-    /// <returns>The dot product of the two <see cref="Vector2D"/>s.</returns>
-    public static float Dot(this Vector2D left, Vector2D right) => Vector2D.Dot(left, right);
-
-    /// <summary>
-    /// Checks whether two <see cref="Vector2D"/>s are approximately equal within a certain epsilon range.
-    /// </summary>
-    /// <param name="left">The first <see cref="Vector2D"/>.</param>
-    /// <param name="right">The second <see cref="Vector2D"/>.</param>
-    /// <param name="epsilon">The maximum difference allowed between components.</param>
-    /// <returns>True if the <see cref="Vector2D"/>s are approximately equal, false otherwise.</returns>
-    public static bool ApproximatelyEquals(this Vector2D left, Vector2D right, float epsilon = float.Epsilon) => Vector2D.ApproximatelyEquals(left, right, epsilon);
-}

Engine.Core/Factory/BehaviourControllerFactory.cs

@@ -1,20 +1,33 @@
-using Syntriax.Engine.Core.Abstract;
 using Syntriax.Engine.Core.Exceptions;
 
 namespace Syntriax.Engine.Core.Factory;
 
 public class BehaviourControllerFactory
 {
-    public IBehaviourController Instantiate(IGameObject gameObject)
-        => Instantiate<BehaviourController>(gameObject);
+    public static IBehaviourController Instantiate(IUniverseObject universeObject, IStateEnable? stateEnable = null)
+        => Instantiate<BehaviourController>(universeObject, stateEnable);
 
-    public T Instantiate<T>(IGameObject gameObject, 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);
 
-        if (!behaviourController.Assign(gameObject))
-            throw AssignException.From(behaviourController, gameObject);
+        if (!universeObject.Assign(behaviourController))
+            throw AssignFailedException.From(universeObject, behaviourController);
+
+        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

@@ -1,26 +1,26 @@
-using Syntriax.Engine.Core.Abstract;
 using Syntriax.Engine.Core.Exceptions;
 
 namespace Syntriax.Engine.Core.Factory;
 
 public class BehaviourFactory
 {
-    public T Instantiate<T>(IGameObject gameObject, params object?[]? args) where T : class, IBehaviour
-        => Instantiate<T>(gameObject, stateEnable: null, args);
+    public static T Instantiate<T>(params object?[]? args) where T : class, IBehaviour
+        => Instantiate<T>(stateEnable: null, args);
 
-    public T Instantiate<T>(IGameObject gameObject, 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);
 
-        stateEnable ??= TypeFactory.Get<StateEnable>();
-        if (!stateEnable.Assign(behaviour))
-            throw AssignException.From(stateEnable, behaviour);
-
-        if (!behaviour.Assign(gameObject.BehaviourController))
-            throw AssignException.From(behaviour, gameObject.BehaviourController);
-        if (!behaviour.Assign(stateEnable))
-            throw AssignException.From(behaviour, stateEnable);
+        if (stateEnable is not null)
+        {
+            if (!stateEnable.Assign(behaviour))
+                throw AssignFailedException.From(stateEnable, behaviour);
+            if (!behaviour.Assign(stateEnable))
+                throw AssignFailedException.From(behaviour, stateEnable);
+        }
+        else
+            StateEnableFactory.Instantiate(behaviour);
 
         return behaviour;
     }

Engine.Core/Factory/GameObjectFactory.cs

@@ -1,42 +0,0 @@
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-
-namespace Syntriax.Engine.Core.Factory;
-
-public class GameObjectFactory
-{
-    public T Instantiate<T>(params object?[]? args) where T : class, IGameObject
-        => Instantiate<T>(transform: null, behaviourController: null, stateEnable: null, args);
-
-    public T Instantiate<T>(
-        ITransform? transform = null,
-        IBehaviourController? behaviourController = null,
-        IStateEnable? stateEnable = null,
-        params object?[]? args
-    )
-        where T : class, IGameObject
-    {
-        T gameObject = TypeFactory.Get<T>(args);
-
-        transform ??= TypeFactory.Get<Transform>();
-        behaviourController ??= TypeFactory.Get<BehaviourController>();
-        stateEnable ??= TypeFactory.Get<StateEnable>();
-
-        if (!transform.Assign(gameObject))
-            throw AssignException.From(transform, gameObject);
-
-        if (!behaviourController.Assign(gameObject))
-            throw AssignException.From(behaviourController, gameObject);
-        if (!stateEnable.Assign(gameObject))
-            throw AssignException.From(stateEnable, gameObject);
-
-        if (!gameObject.Assign(transform))
-            throw AssignException.From(gameObject, transform);
-        if (!gameObject.Assign(behaviourController))
-            throw AssignException.From(gameObject, behaviourController);
-        if (!gameObject.Assign(stateEnable))
-            throw AssignException.From(gameObject, stateEnable);
-
-        return gameObject;
-    }
-}

Engine.Core/Factory/StateEnableFactory.cs

@@ -1,18 +1,20 @@
-using Syntriax.Engine.Core.Abstract;
 using Syntriax.Engine.Core.Exceptions;
 
 namespace Syntriax.Engine.Core.Factory;
 
 public class StateEnableFactory
 {
-    public IStateEnable Instantiate(IEntity entity) => Instantiate<StateEnable>(entity);
+    public static IStateEnable Instantiate(IEntity entity) => Instantiate<StateEnable>(entity);
 
-    public T Instantiate<T>(IEntity entity, params object?[]? args) where T : class, IStateEnable
+    public static T Instantiate<T>(IEntity entity, params object?[]? args) where T : class, IStateEnable
     {
         T stateEnable = TypeFactory.Get<T>(args);
 
+        if (!entity.Assign(stateEnable))
+            throw AssignFailedException.From(entity, stateEnable);
+
         if (!stateEnable.Assign(entity))
-            throw AssignException.From(stateEnable, entity);
+            throw AssignFailedException.From(stateEnable, entity);
 
         return stateEnable;
     }

Engine.Core/Factory/TransformFactory.cs

@@ -1,10 +1,8 @@
-using Syntriax.Engine.Core.Abstract;
-
 namespace Syntriax.Engine.Core.Factory;
 
 public class TransformFactory
 {
-    public ITransform Instantiate() => TypeFactory.Get<Transform>();
-    public T Instantiate<T>(params object?[]? args) where T : class, ITransform
+    public static ITransform2D Instantiate() => TypeFactory.Get<Transform2D>();
+    public static T Instantiate<T>(params object?[]? args) where T : class, ITransform2D
         => TypeFactory.Get<T>(args);
 }

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/Factory/UniverseObjectFactory.cs

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

Engine.Core/GameManager.cs

@@ -1,132 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-using Syntriax.Engine.Core.Factory;
-
-namespace Syntriax.Engine.Core;
-
-[System.Diagnostics.DebuggerDisplay("GameObject Count: {_gameObjects.Count}")]
-public class GameManager : BaseEntity, IGameManager
-{
-    public event IGameManager.OnGameObjectRegisteredDelegate? OnGameObjectRegistered = null;
-    public event IGameManager.OnGameObjectUnRegisteredDelegate? OnGameObjectUnRegistered = null;
-
-
-    private readonly List<IGameObject> _gameObjects = new(Constants.GAME_OBJECTS_SIZE_INITIAL);
-
-    private GameObjectFactory _gameObjectFactory = null!;
-
-    private GameObjectFactory GameObjectFactory
-    {
-        get
-        {
-            if (_gameObjectFactory is null)
-                _gameObjectFactory = new GameObjectFactory();
-            return _gameObjectFactory;
-        }
-    }
-
-    public IReadOnlyList<IGameObject> GameObjects => _gameObjects;
-
-    public override IStateEnable StateEnable
-    {
-        get
-        {
-            if (base.StateEnable is null)
-            {
-                Assign(new StateEnableFactory().Instantiate(this));
-                if (base.StateEnable is null)
-                    throw NotAssignedException.From(this, base.StateEnable);
-            }
-
-            return base.StateEnable;
-        }
-    }
-
-    public void RegisterGameObject(IGameObject gameObject)
-    {
-        if (_gameObjects.Contains(gameObject))
-            throw new Exception($"{nameof(IGameObject)} named {gameObject.Name} is already registered to the {nameof(GameManager)}.");
-
-        Register(gameObject);
-    }
-
-    public T InstantiateGameObject<T>(params object?[]? args) where T : class, IGameObject
-    {
-        T gameObject = GameObjectFactory.Instantiate<T>(args);
-        Register(gameObject);
-        return gameObject;
-    }
-
-    public IGameObject RemoveGameObject(IGameObject gameObject)
-    {
-        if (!_gameObjects.Contains(gameObject))
-            throw new Exception($"{nameof(IGameObject)} named {gameObject.Name} is not registered to the {nameof(GameManager)}.");
-
-        Unregister(gameObject);
-        return gameObject;
-    }
-
-    protected override void InitializeInternal()
-    {
-        base.InitializeInternal();
-        NotAssignedException.Check(this, StateEnable);
-
-        foreach (var gameObject in GameObjects)
-            gameObject.Initialize();
-    }
-
-    protected override void FinalizeInternal()
-    {
-        base.FinalizeInternal();
-        for (int i = GameObjects.Count; i >= 0; i--)
-            GameObjects[i].Finalize();
-    }
-
-    public void Update(EngineTime time)
-    {
-        Time.SetTime(time);
-        foreach (var gameObject in GameObjects)
-            gameObject.BehaviourController.Update();
-    }
-
-    public void PreDraw()
-    {
-        foreach (var gameObject in GameObjects)
-            gameObject.BehaviourController.UpdatePreDraw();
-    }
-
-    /////////////////////////////////////////////////////////////////
-
-    private void Register(IGameObject gameObject)
-    {
-        gameObject.Assign(this);
-
-        gameObject.OnFinalized += OnGameObjectFinalize;
-
-        _gameObjects.Add(gameObject);
-        OnGameObjectRegistered?.Invoke(this, gameObject);
-    }
-
-    private void Unregister(IGameObject gameObject)
-    {
-        gameObject.OnFinalized -= OnGameObjectFinalize;
-
-        _gameObjects.Remove(gameObject);
-        OnGameObjectUnRegistered?.Invoke(this, gameObject);
-    }
-
-    private void OnGameObjectFinalize(IInitialize initialize)
-    {
-        if (initialize is IGameObject gameObject)
-            Unregister(gameObject);
-    }
-
-    /////////////////////////////////////////////////////////////////
-
-    public IEnumerator<IGameObject> GetEnumerator() => _gameObjects.GetEnumerator();
-    IEnumerator IEnumerable.GetEnumerator() => _gameObjects.GetEnumerator();
-}

Engine.Core/GameObject.cs

@@ -1,117 +0,0 @@
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-
-namespace Syntriax.Engine.Core;
-
-[System.Diagnostics.DebuggerDisplay("Name: {Name}, Initialized: {Initialized}")]
-public class GameObject : BaseEntity, IGameObject
-{
-    public event IAssignableTransform.OnTransformAssignedDelegate? OnTransformAssigned = null;
-    public event IAssignableGameManager.OnGameManagerAssignedDelegate? OnGameManagerAssigned = null;
-    public event IAssignableBehaviourController.OnBehaviourControllerAssignedDelegate? OnBehaviourControllerAssigned = null;
-
-    public event INameable.OnNameChangedDelegate? OnNameChanged = null;
-
-    public event IGameObject.OnUpdatedDelegate? OnUpdated = null;
-
-
-    private ITransform _transform = null!;
-    private IBehaviourController _behaviourController = null!;
-    private IStateEnable _stateEnable = null!;
-    private IGameManager _gameManager = null!;
-
-    private string _name = nameof(GameObject);
-
-    public ITransform Transform => _transform;
-    public IBehaviourController BehaviourController => _behaviourController;
-    public IGameManager GameManager => _gameManager;
-
-    public string Name
-    {
-        get => _name;
-        set
-        {
-            if (value == _name) return;
-
-            string previousName = _name;
-            _name = value;
-            OnNameChanged?.Invoke(this, previousName);
-        }
-    }
-
-    protected override void InitializeInternal()
-    {
-        base.InitializeInternal();
-
-        NotAssignedException.Check(this, _transform);
-        NotAssignedException.Check(this, _behaviourController);
-        NotAssignedException.Check(this, _stateEnable);
-        NotAssignedException.Check(this, _gameManager);
-    }
-
-    public void Update()
-    {
-        if (!_stateEnable.Enabled)
-            return;
-
-        OnUpdated?.Invoke(this);
-    }
-
-    protected override void FinalizeInternal()
-    {
-        base.FinalizeInternal();
-
-        foreach (IBehaviour behaviour in _behaviourController.GetBehaviours<IBehaviour>())
-            behaviour.Finalize();
-    }
-
-    public bool Assign(ITransform transform)
-    {
-        if (Initialized)
-            return false;
-
-        _transform = transform;
-        OnTransformAssigned?.Invoke(this);
-        return true;
-    }
-
-    public bool Assign(IBehaviourController behaviourController)
-    {
-        if (Initialized)
-            return false;
-
-        _behaviourController = behaviourController;
-        OnBehaviourControllerAssigned?.Invoke(this);
-        return true;
-    }
-
-    public bool Assign(IGameManager gameManager)
-    {
-        if (Initialized)
-            return false;
-
-        _gameManager = gameManager;
-        OnGameManagerAssigned?.Invoke(this);
-        return true;
-    }
-
-    protected override void UnassignInternal()
-    {
-        base.UnassignInternal();
-
-        _stateEnable = null!;
-        _transform = null!;
-        _behaviourController = null!;
-        _gameManager = null!;
-    }
-
-    public GameObject() { OnBehaviourControllerAssigned += ConnectBehaviourController; }
-
-    private void ConnectBehaviourController(IAssignableBehaviourController controller)
-    {
-        controller.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
-        controller.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
-    }
-    private void OnBehaviourRemoved(IBehaviourController _, IBehaviour behaviour) { if (Initialized) behaviour.Initialize(); }
-    private void OnBehaviourAdded(IBehaviourController _, IBehaviour behaviour) { if (Initialized) behaviour.Finalize(); }
-}

Engine.Core/Helpers/Event.cs

@@ -0,0 +1,500 @@
+using System;
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core.Debug;
+
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a simple event with no parameters.
+/// <para>Example usage:</para> 
+/// <code>
+/// public class MyBehaviour : Behaviour, IUpdate
+/// {
+///     public readonly Event MyEvent = new();
+/// 
+///     public MyBehaviour()
+///     {
+///         MyEvent.AddListener(OnEventTriggered);
+///         MyEvent.AddOneTimeListener(OnEventTriggeredOneTime);
+///     }
+/// 
+///     public void Update()
+///     {
+///         MyEvent.Invoke();
+///     }
+/// 
+///     private void OnEventTriggered()
+///     {
+///         Console.WriteLine($"Event occurred!");
+///     }
+/// 
+///     private static void OnEventTriggeredOneTime()
+///     {
+///         Console.WriteLine($"Event called once!");
+///     }
+/// }
+/// </code>
+/// The output of the example code above would be: 
+/// <code>
+/// Event occurred!
+/// Event called once!
+/// Event occurred!
+/// Event occurred!
+/// Event occurred!
+/// ...
+/// </code>
+/// </summary>
+public class Event
+{
+    // We use Ascending order because draw calls are running from last to first
+    private static readonly Comparer<ListenerData> SortByAscendingPriority = Comparer<ListenerData>.Create((x, y) => x.Priority.CompareTo(y.Priority));
+
+    private ILogger _logger = ILogger.Shared;
+    public ILogger Logger { get => _logger; set => _logger = value ?? ILogger.Shared; }
+
+    private readonly List<ListenerData> listeners = null!;
+    private readonly List<ListenerData> onceListeners = null!;
+
+    /// <summary>
+    /// Subscribes the callback to be invoked whenever the event is triggered.
+    /// </summary>
+    /// <param name="listener">The callback to be called when the event is triggered.</param>
+    /// <param name="priority">Priority of the callback.</param>
+    public void AddListener(EventHandler listener, int priority = 0)
+    {
+        ListenerData listenerData = new(listener, priority);
+
+        int insertIndex = listeners.BinarySearch(listenerData, SortByAscendingPriority);
+        if (insertIndex < 0)
+            insertIndex = ~insertIndex;
+
+        listeners.Insert(insertIndex, listenerData);
+    }
+
+    /// <summary>
+    /// Subscribes the callback to be invoked the next time the event is triggered. The callback will be called only once.
+    /// </summary>
+    /// <param name="listener">The callback to be called the next time the event is triggered.</param>
+    /// <param name="priority">Priority of the callback.</param>
+    public void AddOneTimeListener(EventHandler listener, int priority = 0)
+    {
+        ListenerData listenerData = new(listener, priority);
+
+        int insertIndex = onceListeners.BinarySearch(listenerData, SortByAscendingPriority);
+        if (insertIndex < 0)
+            insertIndex = ~insertIndex;
+
+        onceListeners.Insert(insertIndex, listenerData);
+    }
+
+    /// <summary>
+    /// Unsubscribes the callback that was previously registered by <see cref="AddListener(EventHandler)"/>.
+    /// </summary>
+    /// <param name="listener">The callback that was previously registered by <see cref="AddListener(EventHandler)"/></param>
+    public void RemoveListener(EventHandler listener)
+    {
+        for (int i = listeners.Count - 1; i >= 0; i--)
+            if (listeners[i].Callback == listener)
+            {
+                listeners.RemoveAt(i);
+                return;
+            }
+    }
+
+    /// <summary>
+    /// Unsubscribes the callback that was previously registered by <see cref="AddOneTimeListener(EventHandler)"/>.
+    /// </summary>
+    /// <param name="listener">The callback that was previously registered by <see cref="AddOneTimeListener(EventHandler)"/></param>
+    public void RemoveOneTimeListener(EventHandler listener)
+    {
+        for (int i = 0; i < onceListeners.Count; i++)
+            if (onceListeners[i].Callback == listener)
+            {
+                onceListeners.RemoveAt(i);
+                return;
+            }
+    }
+
+    /// <summary>
+    /// Unsubscribes all listeners that was previously registered by either <see cref="AddListener(EventHandler)"/> or <see cref="AddOneTimeListener(EventHandler)"/>.
+    /// </summary>
+    public void Clear() { listeners.Clear(); onceListeners.Clear(); }
+
+    /// <summary>
+    /// Triggers the event.
+    /// </summary>
+    public void Invoke()
+    {
+        for (int i = listeners.Count - 1; i >= 0; i--)
+            try { listeners[i].Callback.Invoke(); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Callback.Method.DeclaringType?.FullName}.{listeners[i].Callback.Method.Name}()";
+                EventHelpers.LogInvocationException(listeners[i].Callback.Target ?? this, Logger, exception, methodCallRepresentation);
+            }
+
+        for (int i = onceListeners.Count - 1; i >= 0; i--)
+        {
+            try { onceListeners[i].Callback.Invoke(); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{onceListeners[i].Callback.Method.DeclaringType?.FullName}.{onceListeners[i].Callback.Method.Name}()";
+                EventHelpers.LogInvocationException(onceListeners[i].Callback.Target ?? this, Logger, exception, methodCallRepresentation);
+            }
+            onceListeners.RemoveAt(i);
+        }
+    }
+
+    public Event(int initialListenerCount = 4, int initialOnceListenerCount = 2)
+    {
+        listeners = new(initialListenerCount);
+        onceListeners = new(initialOnceListenerCount);
+    }
+
+    public Event()
+    {
+        listeners = new(4);
+        onceListeners = new(2);
+    }
+
+    public delegate void EventHandler();
+    private record struct ListenerData(EventHandler Callback, int Priority);
+}
+
+/// <summary>
+/// Represents an event with only sender parameters.
+/// <para>Example usage:</para> 
+/// <code>
+/// public class MyBehaviour : Behaviour, IUpdate
+/// {
+///     public readonly Event&lt;MyBehaviour&gt; MyEvent = new();
+/// 
+///     public MyBehaviour()
+///     {
+///         MyEvent.AddListener(OnEventTriggered);
+///         MyEvent.AddOneTimeListener(OnEventTriggeredOneTime);
+///     }
+/// 
+///     public void Update()
+///     {
+///         MyEvent.Invoke(this);
+///     }
+/// 
+///     private void OnEventTriggered(MyBehaviour sender)
+///     {
+///         Console.WriteLine($"{sender.Id}'s event occurred!");
+///     }
+/// 
+///     private static void OnEventTriggeredOneTime(MyBehaviour sender)
+///     {
+///         Console.WriteLine($"{sender.Id}'s event called once!");
+///     }
+/// }
+/// </code>
+/// The output of the example code above would be: 
+/// <code>
+/// [Id]'s event occurred!
+/// [Id]'s event called once!
+/// [Id]'s event occurred!
+/// [Id]'s event occurred!
+/// [Id]'s event occurred!
+/// ...
+/// </code>
+/// 
+/// </summary>
+/// <typeparam name="TSender">Sender type</typeparam>
+public class Event<TSender> where TSender : class
+{
+    // We use Ascending order because draw calls are running from last to first
+    private static readonly Comparer<ListenerData> SortByAscendingPriority = Comparer<ListenerData>.Create((x, y) => x.Priority.CompareTo(y.Priority));
+
+    private ILogger _logger = ILogger.Shared;
+    public ILogger Logger { get => _logger; set => _logger = value ?? ILogger.Shared; }
+
+    private readonly List<ListenerData> listeners = null!;
+    private readonly List<ListenerData> onceListeners = null!;
+
+    /// <summary>
+    /// Subscribes the callback to be invoked whenever the event is triggered.
+    /// </summary>
+    /// <param name="listener">The callback to be called when the event is triggered.</param>
+    /// <param name="priority">Priority of the callback.</param>
+    public void AddListener(EventHandler listener, int priority = 0)
+    {
+        ListenerData listenerData = new(listener, priority);
+
+        int insertIndex = listeners.BinarySearch(listenerData, SortByAscendingPriority);
+        if (insertIndex < 0)
+            insertIndex = ~insertIndex;
+
+        listeners.Insert(insertIndex, listenerData);
+    }
+
+    /// <summary>
+    /// Subscribes the callback to be invoked the next time the event is triggered. The callback will be called only once.
+    /// </summary>
+    /// <param name="listener">The callback to be called the next time the event is triggered.</param>
+    /// <param name="priority">Priority of the callback.</param>
+    public void AddOneTimeListener(EventHandler listener, int priority = 0)
+    {
+        ListenerData listenerData = new(listener, priority);
+
+        int insertIndex = onceListeners.BinarySearch(listenerData, SortByAscendingPriority);
+        if (insertIndex < 0)
+            insertIndex = ~insertIndex;
+
+        onceListeners.Insert(insertIndex, listenerData);
+    }
+
+    /// <summary>
+    /// Unsubscribes the callback that was previously registered by <see cref="AddListener(EventHandler)"/>.
+    /// </summary>
+    /// <param name="listener">The callback that was previously registered by <see cref="AddListener(EventHandler)"/></param>
+    public void RemoveListener(EventHandler listener)
+    {
+        for (int i = listeners.Count - 1; i >= 0; i--)
+            if (listeners[i].Callback == listener)
+            {
+                listeners.RemoveAt(i);
+                return;
+            }
+    }
+
+    /// <summary>
+    /// Unsubscribes the callback that was previously registered by <see cref="AddOneTimeListener(EventHandler)"/>.
+    /// </summary>
+    /// <param name="listener">The callback that was previously registered by <see cref="AddOneTimeListener(EventHandler)"/></param>
+    public void RemoveOneTimeListener(EventHandler listener)
+    {
+        for (int i = 0; i < onceListeners.Count; i++)
+            if (onceListeners[i].Callback == listener)
+            {
+                onceListeners.RemoveAt(i);
+                return;
+            }
+    }
+
+    /// <summary>
+    /// Unsubscribes all listeners that was previously registered by either <see cref="AddListener(EventHandler)"/> or <see cref="AddOneTimeListener(EventHandler)"/>.
+    /// </summary>
+    public void Clear() { listeners.Clear(); onceListeners.Clear(); }
+
+    /// <summary>
+    /// Triggers the event.
+    /// </summary>
+    /// <param name="sender">The caller that's triggering this event.</param>
+    public void Invoke(TSender sender)
+    {
+        for (int i = listeners.Count - 1; i >= 0; i--)
+            try { listeners[i].Callback.Invoke(sender); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Callback.Method.DeclaringType?.FullName}.{listeners[i].Callback.Method.Name}({sender})";
+                EventHelpers.LogInvocationException(listeners[i].Callback.Target ?? sender, Logger, exception, methodCallRepresentation);
+            }
+
+        for (int i = onceListeners.Count - 1; i >= 0; i--)
+        {
+            try { onceListeners[i].Callback.Invoke(sender); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{onceListeners[i].Callback.Method.DeclaringType?.FullName}.{onceListeners[i].Callback.Method.Name}({sender})";
+                EventHelpers.LogInvocationException(onceListeners[i].Callback.Target ?? sender, Logger, exception, methodCallRepresentation);
+            }
+            onceListeners.RemoveAt(i);
+        }
+    }
+
+    public Event(int initialListenerCount = 4, int initialOnceListenerCount = 2)
+    {
+        listeners = new(initialListenerCount);
+        onceListeners = new(initialOnceListenerCount);
+    }
+
+    public Event()
+    {
+        listeners = new(4);
+        onceListeners = new(2);
+    }
+
+    public delegate void EventHandler(TSender sender);
+    private record struct ListenerData(EventHandler Callback, int Priority);
+}
+
+/// <summary>
+/// Represents an event with sender and argument parameters.
+/// <para>Example usage:</para> 
+/// <code>
+/// public class MyBehaviour : Behaviour, IUpdate
+/// {
+///     public readonly Event&lt;MyBehaviour, MyArguments&gt; MyEvent = new();
+/// 
+///     private int myInt = 0;
+///     private bool myBool = false;
+/// 
+///     public MyBehaviour()
+///     {
+///         MyEvent.AddOneTimeListener(OnEventTriggeredOneTime);
+///         MyEvent.AddListener(OnEventTriggered);
+///     }
+/// 
+///     public void Update()
+///     {
+///         MyEvent.Invoke(this, new MyArguments(myInt, myBool));
+///         myInt++;
+///         myBool = !myBool;
+///     }
+/// 
+///     private void OnEventTriggered(MyBehaviour sender, MyArguments args)
+///     {
+///         Console.WriteLine($"{sender.Id}'s event occurred with MyInt: {args.MyInt} and MyBool {args.MyBool}!");
+///     }
+/// 
+///     private static void OnEventTriggeredOneTime(MyBehaviour sender, MyArguments args)
+///     {
+///         Console.WriteLine($"{sender.Id}'s event called once with MyInt: {args.MyInt} and MyBool {args.MyBool}!");
+///     }
+/// 
+///     public readonly record struct MyArguments(int MyInt, bool MyBool);
+/// }
+/// </code>
+/// The output of the example code above would be: 
+/// <code>
+/// [Id]'s event occurred with MyInt: 0 and MyBool False!
+/// [Id]'s event called once with MyInt: 0 and MyBool False!
+/// [Id]'s event occurred with MyInt: 1 and MyBool True!
+/// [Id]'s event occurred with MyInt: 2 and MyBool False!
+/// [Id]'s event occurred with MyInt: 3 and MyBool True!
+/// ...
+/// </code>
+/// 
+/// </summary>
+/// <typeparam name="TSender">Sender type</typeparam>
+public class Event<TSender, TArguments> where TSender : class
+{
+    // We use Ascending order because draw calls are running from last to first
+    private static readonly Comparer<ListenerData> SortByAscendingPriority = Comparer<ListenerData>.Create((x, y) => x.Priority.CompareTo(y.Priority));
+
+    private ILogger _logger = ILogger.Shared;
+    public ILogger Logger { get => _logger; set => _logger = value ?? ILogger.Shared; }
+
+    private readonly List<ListenerData> listeners = null!;
+    private readonly List<ListenerData> onceListeners = null!;
+
+    /// <summary>
+    /// Subscribes the callback to be invoked whenever the event is triggered.
+    /// </summary>
+    /// <param name="listener">The callback to be called when the event is triggered.</param>
+    /// <param name="priority">Priority of the callback.</param>
+    public void AddListener(EventHandler listener, int priority = 0)
+    {
+        ListenerData listenerData = new(listener, priority);
+
+        int insertIndex = listeners.BinarySearch(listenerData, SortByAscendingPriority);
+        if (insertIndex < 0)
+            insertIndex = ~insertIndex;
+
+        listeners.Insert(insertIndex, listenerData);
+    }
+
+    /// <summary>
+    /// Subscribes the callback to be invoked the next time the event is triggered. The callback will be called only once.
+    /// </summary>
+    /// <param name="listener">The callback to be called the next time the event is triggered.</param>
+    /// <param name="priority">Priority of the callback.</param>
+    public void AddOneTimeListener(EventHandler listener, int priority = 0)
+    {
+        ListenerData listenerData = new(listener, priority);
+
+        int insertIndex = onceListeners.BinarySearch(listenerData, SortByAscendingPriority);
+        if (insertIndex < 0)
+            insertIndex = ~insertIndex;
+
+        onceListeners.Insert(insertIndex, listenerData);
+    }
+
+    /// <summary>
+    /// Unsubscribes the callback that was previously registered by <see cref="AddListener(EventHandler)"/>.
+    /// </summary>
+    /// <param name="listener">The callback that was previously registered by <see cref="AddListener(EventHandler)"/></param>
+    public void RemoveListener(EventHandler listener)
+    {
+        for (int i = listeners.Count - 1; i >= 0; i--)
+            if (listeners[i].Callback == listener)
+            {
+                listeners.RemoveAt(i);
+                return;
+            }
+    }
+
+    /// <summary>
+    /// Unsubscribes the callback that was previously registered by <see cref="AddOneTimeListener(EventHandler)"/>.
+    /// </summary>
+    /// <param name="listener">The callback that was previously registered by <see cref="AddOneTimeListener(EventHandler)"/></param>
+    public void RemoveOneTimeListener(EventHandler listener)
+    {
+        for (int i = 0; i < onceListeners.Count; i++)
+            if (onceListeners[i].Callback == listener)
+            {
+                onceListeners.RemoveAt(i);
+                return;
+            }
+    }
+
+    /// <summary>
+    /// Unsubscribes all listeners that was previously registered by either <see cref="AddListener(EventHandler)"/> or <see cref="AddOneTimeListener(EventHandler)"/>.
+    /// </summary>
+    public void Clear() { listeners.Clear(); onceListeners.Clear(); }
+
+    /// <summary>
+    /// Triggers the event.
+    /// </summary>
+    /// <param name="sender">The caller that's triggering this event.</param>
+    /// <param name="args">The arguments provided for this event.</param>
+    public void Invoke(TSender sender, TArguments args)
+    {
+        for (int i = listeners.Count - 1; i >= 0; i--)
+            try { listeners[i].Callback.Invoke(sender, args); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Callback.Method.DeclaringType?.FullName}.{listeners[i].Callback.Method.Name}({sender}, {args})";
+                EventHelpers.LogInvocationException(listeners[i].Callback.Target ?? sender, Logger, exception, methodCallRepresentation);
+            }
+
+        for (int i = onceListeners.Count - 1; i >= 0; i--)
+        {
+            try { onceListeners[i].Callback.Invoke(sender, args); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{onceListeners[i].Callback.Method.DeclaringType?.FullName}.{onceListeners[i].Callback.Method.Name}({sender}, {args})";
+                EventHelpers.LogInvocationException(onceListeners[i].Callback.Target ?? sender, Logger, exception, methodCallRepresentation);
+            }
+            onceListeners.RemoveAt(i);
+        }
+    }
+
+    public Event(int initialListenerCount = 4, int initialOnceListenerCount = 2)
+    {
+        listeners = new(initialListenerCount);
+        onceListeners = new(initialOnceListenerCount);
+    }
+
+    public Event()
+    {
+        listeners = new(4);
+        onceListeners = new(2);
+    }
+
+    public delegate void EventHandler(TSender sender, TArguments args);
+    private record struct ListenerData(EventHandler Callback, int Priority);
+}
+
+internal static class EventHelpers
+{
+    public static void LogInvocationException(object sender, ILogger logger, Exception exception, string methodCallRepresentation)
+    {
+        logger.LogException(sender, exception);
+        logger.LogError(sender, $"Unexpected exception on invocation of method {methodCallRepresentation}");
+    }
+}

Engine.Core/Helpers/IPool.cs

@@ -0,0 +1,10 @@
+namespace Syntriax.Engine.Core;
+
+public interface IPool<T>
+{
+    Event<IPool<T>, T> OnRemoved { get; }
+    Event<IPool<T>, T> OnReturned { get; }
+
+    T Get();
+    void Return(T item);
+}

Engine.Core/Helpers/ListPool.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class ListPool<T> : IPool<List<T>>
+{
+    public Event<IPool<List<T>>, List<T>> OnReturned { get; } = new();
+    public Event<IPool<List<T>>, List<T>> OnRemoved { get; } = new();
+
+    private readonly Func<List<T>> generator = null!;
+    private readonly Queue<List<T>> queue = new();
+
+    public List<T> Get()
+    {
+        if (!queue.TryDequeue(out List<T>? result))
+            result = generator();
+
+        result.Clear();
+        OnRemoved?.Invoke(this, result);
+        return result;
+    }
+
+    public void Return(List<T> list)
+    {
+        if (queue.Contains(list))
+            return;
+
+        list.Clear();
+        queue.Enqueue(list);
+        OnReturned?.Invoke(this, list);
+    }
+
+    public ListPool(int initialListCount = 1, int initialListCapacity = 32)
+    {
+        generator = () => new(initialListCapacity);
+        for (int i = 0; i < initialListCount; i++)
+            queue.Enqueue(generator());
+    }
+}

Engine.Core/Helpers/Pool.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class Pool<T> : IPool<T>
+{
+    public Event<IPool<T>, T> OnRemoved { get; } = new();
+    public Event<IPool<T>, T> OnReturned { get; } = new();
+
+    private readonly Func<T> generator = null!;
+    private readonly Queue<T> queue = new();
+
+    public T Get()
+    {
+        if (!queue.TryDequeue(out T? result))
+            result = generator();
+
+        OnRemoved?.Invoke(this, result);
+        return result;
+    }
+
+    public void Return(T item)
+    {
+        if (queue.Contains(item))
+            return;
+
+        queue.Enqueue(item);
+        OnReturned?.Invoke(this, item);
+    }
+
+    public Pool(Func<T> generator, int initialCapacity = 1)
+    {
+        this.generator = generator;
+        for (int i = 0; i < initialCapacity; i++)
+            queue.Enqueue(generator());
+    }
+}

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

@@ -4,30 +4,89 @@ using System.Numerics;
 namespace Syntriax.Engine.Core;
 
 public static class Math
-{/// <summary>
- /// The value of Pi (π), a mathematical constant approximately equal to 3.14159.
- /// </summary>
-    public const float PI = 3.1415926535897932f;
-
+{
     /// <summary>
-    /// The value of Tau (τ), a mathematical constant equal to 2π, approximately equal to 6.28319.
+    /// The value of Pi (π).
     /// </summary>
-    public const float Tau = 2f * PI;
+    public const float Pi = 3.1415926535897932f;
 
     /// <summary>
-    /// The base of the natural logarithm, approximately equal to 2.71828.
+    /// The value of Tau (τ), mathematical constant equal to 2π.
+    /// </summary>
+    public const float Tau = 2f * Pi;
+
+    /// <summary>
+    /// The base of the natural logarithm.
     /// </summary>
     public const float E = 2.718281828459045f;
 
     /// <summary>
     /// The conversion factor from radians to degrees.
     /// </summary>
-    public const float RadianToDegree = 180f / PI;
+    public const float RadianToDegree = 180f / Pi;
 
     /// <summary>
     /// The conversion factor from degrees to radians.
     /// </summary>
-    public const float DegreeToRadian = PI / 180f;
+    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.
@@ -37,6 +96,20 @@ public static class Math
     /// <returns>The absolute value of <paramref name="x"/>.</returns>
     public static T Abs<T>(T x) where T : INumber<T> => x > T.Zero ? x : -x;
 
+    /// <summary>
+    /// Returns the cosine of a number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The cosine of <paramref name="x"/>.</returns>
+    public static float Cos(float x) => MathF.Cos(x);
+
+    /// <summary>
+    /// Returns the sine of a number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The sine of <paramref name="x"/>.</returns>
+    public static float Sin(float x) => MathF.Sin(x);
+
     /// <summary>
     /// Returns the arccosine of a number.
     /// </summary>
@@ -74,7 +147,7 @@ public static class Math
     /// <param name="min">The minimum value.</param>
     /// <param name="max">The maximum value.</param>
     /// <returns>The clamped value.</returns>
-    public static T Clamp<T>(this T x, T min, T max) where T : INumber<T> => (x < min) ? min : (x > max) ? max : x;
+    public static T Clamp<T>(T x, T min, T max) where T : INumber<T> => (x < min) ? min : (x > max) ? max : x;
 
     /// <summary>
     /// Returns the smallest integral value that is greater than or equal to the specified number.
@@ -156,6 +229,16 @@ public static class Math
     /// <returns>The number <paramref name="x"/> raised to the power <paramref name="y"/>.</returns>
     public static float Pow(float x, float y) => MathF.Pow(x, y);
 
+    /// <summary>
+    /// Performs linear interpolation between two specified values.
+    /// </summary>
+    /// <typeparam name="T">The type of the values, which must implement <see cref="IFloatingPoint{T}"/>.</typeparam>
+    /// <param name="x">The starting value of the interpolation.</param>
+    /// <param name="y">The ending value of the interpolation.</param>
+    /// <param name="t">The interpolation factor, typically in the range [0, 1].</param>
+    /// <returns>A value that represents the linear interpolation between <paramref name="x"/> and <paramref name="y"/>.</returns>
+    public static T Lerp<T>(T x, T y, T t) where T : IFloatingPoint<T> => x + (y - x) * t;
+
     /// <summary>
     /// Rounds a number to a specified number of fractional digits.
     /// </summary>
@@ -165,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>
@@ -186,5 +278,4 @@ public static class Math
     /// <param name="x">The number.</param>
     /// <returns>The integral part of <paramref name="x"/>.</returns>
     public static float Truncate(float x) => MathF.Truncate(x);
-
 }

Engine.Core/MathExtensions.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Numerics;
+
+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);
+
+    /// <inheritdoc cref="Math.Cos(float)" />
+    public static float Cos(this float x) => Math.Cos(x);
+
+    /// <inheritdoc cref="Math.Sin(float)" />
+    public static float Sin(this float x) => Math.Sin(x);
+
+    /// <inheritdoc cref="Math.Acos(float)" />
+    public static float Acos(this float x) => Math.Acos(x);
+
+    /// <inheritdoc cref="Math.Asin(float)" />
+    public static float Asin(this float x) => Math.Asin(x);
+
+    /// <inheritdoc cref="Math.Atan2(float, float)" />
+    public static float Atan2(this float y, float x) => Math.Atan2(y, x);
+
+    /// <inheritdoc cref="Math.Atanh(float)" />
+    public static float Atanh(this float x) => Math.Atanh(x);
+
+    /// <inheritdoc cref="Math.Clamp{T}(T, T, T)" />
+    public static T Clamp<T>(this T x, T min, T max) where T : INumber<T> => Math.Clamp(x, min, max);
+
+    /// <inheritdoc cref="Math.Ceiling(float)" />
+    public static float Ceiling(this float x) => Math.Ceiling(x);
+
+    /// <inheritdoc cref="Math.CopySign(float, float)" />
+    public static float CopySign(this float x, float y) => Math.CopySign(x, y);
+
+    /// <inheritdoc cref="Math.Floor(float)" />
+    public static float Floor(this float x) => Math.Floor(x);
+
+    /// <inheritdoc cref="Math.IEEERemainder(float, float)" />
+    public static float IEEERemainder(this float x, float y) => Math.IEEERemainder(x, y);
+
+    /// <inheritdoc cref="Math.Log(float, float)" />
+    public static float Log(this float x, float y) => Math.Log(x, y);
+
+    /// <inheritdoc cref="Math.Max{T}(T, T)" />
+    public static T Max<T>(this T x, T y) where T : INumber<T> => Math.Max(x, y);
+
+    /// <inheritdoc cref="Math.AbsMax{T}(T, T)" />
+    public static T AbsMax<T>(this T x, T y) where T : INumber<T> => Math.AbsMax(x, y);
+
+    /// <inheritdoc cref="Math.Min{T}(T, T)" />
+    public static T Min<T>(this T x, T y) where T : INumber<T> => Math.Min(x, y);
+
+    /// <inheritdoc cref="Math.AbsMin{T}(T, T)" />
+    public static T AbsMin<T>(this T x, T y) where T : INumber<T> => Math.AbsMin(x, y);
+
+    /// <inheritdoc cref="Math.Pow(float, float)" />
+    public static float Pow(this float x, float y) => Math.Pow(x, y);
+
+    /// <inheritdoc cref="Math.Lerp{T}(T, T, T)" />
+    public static T Lerp<T>(this T x, T y, T t) where T : IFloatingPoint<T> => Math.Lerp(x, y, t);
+
+    /// <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);
+
+    /// <inheritdoc cref="Math.Sqrt(float)" />
+    public static float Sqrt(this float x) => Math.Sqrt(x);
+
+    /// <inheritdoc cref="Math.Truncate(float)" />
+    public static float Truncate(this float x) => Math.Truncate(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/AABB.cs

@@ -1,8 +1,6 @@
 using System.Collections.Generic;
 
-using Syntriax.Engine.Core;
-
-namespace Syntriax.Engine.Physics2D.Primitives;
+namespace Syntriax.Engine.Core;
 
 /// <summary>
 /// Represents an Axis-Aligned Bounding Box (AABB) in 2D space.
@@ -40,6 +38,9 @@ public readonly struct AABB(Vector2D lowerBoundary, Vector2D upperBoundary)
     /// </summary>
     public readonly Vector2D SizeHalf => Size * .5f;
 
+    public static bool operator ==(AABB left, AABB right) => left.UpperBoundary == right.UpperBoundary && left.LowerBoundary == right.LowerBoundary;
+    public static bool operator !=(AABB left, AABB right) => left.UpperBoundary != right.UpperBoundary || left.LowerBoundary != right.LowerBoundary;
+
     /// <summary>
     /// Creates an <see cref="AABB"/> from a collection of <see cref="Vector2D"/>s.
     /// </summary>
@@ -70,9 +71,29 @@ public readonly struct AABB(Vector2D lowerBoundary, Vector2D upperBoundary)
     /// </summary>
     /// <param name="left">The first <see cref="AABB"/>.</param>
     /// <param name="right">The second <see cref="AABB"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
     /// <returns><see cref="true"/> if the <see cref="AABB"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
-    public static bool ApproximatelyEquals(AABB left, AABB right)
-        => left.LowerBoundary.ApproximatelyEquals(right.LowerBoundary) && left.UpperBoundary.ApproximatelyEquals(right.UpperBoundary);
+    public static bool ApproximatelyEquals(AABB left, AABB right, float epsilon = float.Epsilon)
+        => left.LowerBoundary.ApproximatelyEquals(right.LowerBoundary, epsilon) && left.UpperBoundary.ApproximatelyEquals(right.UpperBoundary, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="AABB"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="AABB"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="AABB"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is AABB aabb && this == aabb;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="AABB"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="AABB"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(LowerBoundary, UpperBoundary);
+
+    /// <summary>
+    /// Converts the <see cref="AABB"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="AABB"/>.</returns>
+    public override string ToString() => $"{nameof(AABB)}({LowerBoundary}, {UpperBoundary})";
 }
 
 /// <summary>
@@ -80,18 +101,9 @@ public readonly struct AABB(Vector2D lowerBoundary, Vector2D upperBoundary)
 /// </summary>
 public static class AABBExtensions
 {
-    /// <summary>
-    /// Converts a collection of <see cref="Vector2D"/>s to an <see cref="AABB"/>.
-    /// </summary>
-    /// <param name="vectors">The collection of <see cref="Vector2D"/>s.</param>
-    /// <returns>An <see cref="AABB"/> that bounds all the <see cref="Vector2D"/>s.</returns>
+    /// <inheritdoc cref="AABB.ToAABB" />
     public static AABB ToAABB(this IEnumerable<Vector2D> vectors) => AABB.FromVectors(vectors);
 
-    /// <summary>
-    /// Checks if two <see cref="AABB"/>s are approximately equal.
-    /// </summary>
-    /// <param name="left">The first <see cref="AABB"/>.</param>
-    /// <param name="right">The second <see cref="AABB"/>.</param>
-    /// <returns><see cref="true"/> if the <see cref="AABB"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
-    public static bool ApproximatelyEquals(this AABB left, AABB right) => AABB.ApproximatelyEquals(left, right);
+    /// <inheritdoc cref="AABB.ApproximatelyEquals" />
+    public static bool ApproximatelyEquals(this AABB left, AABB right, float epsilon = float.Epsilon) => AABB.ApproximatelyEquals(left, right, epsilon);
 }

Engine.Core/Primitives/Circle.cs

@@ -0,0 +1,129 @@
+using System.Diagnostics;
+
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a 2D circle.
+/// </summary>
+/// <param name="center">The center of the circle.</param>
+/// <param name="radius">The radius of the circle.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="Circle"/> struct with the specified center and radius.
+/// </remarks>
+[DebuggerDisplay("Center: {Center.ToString(),nq}, Radius: {Radius}")]
+public readonly struct Circle(Vector2D center, float radius)
+{
+    /// <summary>
+    /// The center of the circle.
+    /// </summary>
+    public readonly Vector2D Center = center;
+
+    /// <summary>
+    /// The radius of the <see cref="Circle"/>.
+    /// </summary>
+    public readonly float Radius = radius;
+
+    /// <summary>
+    /// Gets the squared radius of the <see cref="Circle"/>.
+    /// </summary>
+    public readonly float RadiusSquared => Radius * Radius;
+
+    /// <summary>
+    /// Gets the diameter of the <see cref="Circle"/>.
+    /// </summary>
+    public readonly float Diameter => 2f * Radius;
+
+    /// <summary>
+    /// A predefined unit <see cref="Circle"/> with a center at the origin and a radius of 1.
+    /// </summary>
+    public static readonly Circle UnitCircle = new(Vector2D.Zero, 1f);
+
+    public static bool operator ==(Circle left, Circle right) => left.Center == right.Center && left.Radius == right.Radius;
+    public static bool operator !=(Circle left, Circle right) => left.Center != right.Center || left.Radius != right.Radius;
+
+    /// <summary>
+    /// Sets the center of the <see cref="Circle"/>.
+    /// </summary>
+    public static Circle SetCenter(Circle circle, Vector2D center) => new(center, circle.Radius);
+
+    /// <summary>
+    /// Sets the radius of the <see cref="Circle"/>.
+    /// </summary>
+    public static Circle SetRadius(Circle circle, float radius) => new(circle.Center, radius);
+
+    /// <summary>
+    /// Displaces the <see cref="Circle"/> by the specified <see cref="Vector2D"/>.
+    /// </summary>
+    public static Circle Displace(Circle circle, Vector2D displaceVector) => new(circle.Center + displaceVector, circle.Radius);
+
+    /// <summary>
+    /// Projects the <see cref="Circle"/> onto the specified <see cref="Vector2D"/>.
+    /// </summary>
+    public static Projection1D Project(Circle circle, Vector2D projectionVector)
+    {
+        float projectedCenter = circle.Center.Dot(projectionVector);
+        return new(projectedCenter - circle.Radius, projectedCenter + circle.Radius);
+    }
+
+    /// <summary>
+    /// Transforms the <see cref="Circle"/> by the specified <see cref="ITransform2D"/>.
+    /// </summary>
+    public static Circle Transform(ITransform2D transform, Circle circle)
+        => new(transform.Transform(circle.Center), circle.Radius * (transform.Scale.Magnitude / Vector2D.One.Magnitude));
+
+    /// <summary>
+    /// Checks if two <see cref="Circle"/>s are approximately equal.
+    /// </summary>
+    /// <param name="left">The first <see cref="Circle"/>.</param>
+    /// <param name="right">The second <see cref="Circle"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns><see cref="true"/> if the <see cref="Circle"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
+    public static bool ApproximatelyEquals(Circle left, Circle right, float epsilon = float.Epsilon)
+        => left.Center.ApproximatelyEquals(right.Center, epsilon) && left.Radius.ApproximatelyEquals(right.Radius, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="Circle"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="Circle"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Circle"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is Circle circle && this == circle;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="Circle"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="Circle"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(Center, Radius);
+
+    /// <summary>
+    /// Converts the <see cref="Circle"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="Circle"/>.</returns>
+    public override string ToString() => $"{nameof(Circle)}({Center}, {Radius})";
+}
+
+/// <summary>
+/// Provides extension methods for the <see cref="Circle"/> struct.
+/// </summary>
+public static class CircleExtensions
+{
+    /// <inheritdoc cref="Circle.SetCenter(Circle, Vector2D)" />
+    public static Circle SetCenter(this Circle circle, Vector2D center) => Circle.SetCenter(circle, center);
+
+    /// <inheritdoc cref="Circle.SetRadius(Circle, float)" />
+    public static Circle SetRadius(this Circle circle, float radius) => Circle.SetRadius(circle, radius);
+
+    /// <inheritdoc cref="Circle.Displace(Circle, Vector2D)" />
+    public static Circle Displace(this Circle circle, Vector2D displaceVector) => Circle.Displace(circle, displaceVector);
+
+    /// <inheritdoc cref="Circle.Project(Circle, Vector2D)" />
+    public static Projection1D ToProjection(this Circle circle, Vector2D projectionVector) => Circle.Project(circle, projectionVector);
+
+    /// <inheritdoc cref="Circle.Transform(ITransform2D, Circle)" />
+    public static Circle Transform(this ITransform2D transform, Circle circle) => Circle.Transform(transform, circle);
+
+    /// <inheritdoc cref="Circle.Transform(ITransform2D, Circle)" />
+    public static Circle Transform(this Circle circle, ITransform2D transform) => Circle.Transform(transform, circle);
+
+    /// <inheritdoc cref="Circle.ApproximatelyEquals(Circle, Circle, float)" />
+    public static bool ApproximatelyEquals(this Circle left, Circle right, float epsilon = float.Epsilon) => Circle.ApproximatelyEquals(left, right, epsilon);
+}

Engine.Core/Primitives/ColorHSV.cs

@@ -0,0 +1,151 @@
+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(), color.Saturation.OneMinus(), color.Value.OneMinus());
+    public static ColorHSV operator +(ColorHSV left, ColorHSV right) => new(left.Hue + right.Hue, left.Saturation + right.Saturation, left.Value + right.Value);
+    public static ColorHSV operator -(ColorHSV left, ColorHSV right) => new(left.Hue - right.Hue, left.Saturation - right.Saturation, left.Value - right.Value);
+    public static ColorHSV operator *(ColorHSV left, ColorHSV right) => new(left.Hue * right.Hue, left.Saturation * right.Saturation, left.Value * right.Value);
+    public static ColorHSV operator *(ColorHSV color, float value) => new(color.Hue * value, color.Saturation * value, color.Value * value);
+    public static ColorHSV operator *(float value, ColorHSV color) => new(color.Hue * value, color.Saturation * value, color.Value * value);
+    public static ColorHSV operator /(ColorHSV color, float value) => new(color.Hue / value, color.Saturation / value, color.Value / value);
+    public static bool operator ==(ColorHSV left, ColorHSV right) => left.Hue == right.Hue && left.Saturation == right.Saturation && left.Value == right.Value;
+    public static bool operator !=(ColorHSV left, ColorHSV right) => left.Hue != right.Hue || left.Saturation != right.Saturation || left.Value != right.Value;
+
+    public static implicit operator ColorHSV(ColorHSVA hsva) => new(hsva.Hue, hsva.Saturation, hsva.Value);
+    public static implicit operator ColorHSV(ColorRGBA rgba) => (ColorHSVA)rgba;
+    public static implicit operator ColorHSV(ColorRGB rgb) => (ColorHSVA)rgb;
+
+    /// <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>
+    /// 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)
+    {
+        float hueDiff = to.Hue - from.Hue;
+        float saturationDiff = to.Saturation - from.Saturation;
+        float valueDiff = to.Value - from.Value;
+
+        return from + new ColorHSV(hueDiff * t, saturationDiff * t, valueDiff * t);
+    }
+
+    /// <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 colorHSV && this == colorHSV;
+
+    /// <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>
+    /// 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>
+/// 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.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/ColorHSVA.cs

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

Engine.Core/Primitives/ColorRGB.cs

@@ -0,0 +1,138 @@
+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(ColorHSVA hsva) => (ColorRGBA)hsva;
+    public static implicit operator ColorRGB(ColorHSV hsv) => (ColorRGBA)hsv;
+
+    /// <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>
+    /// 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)
+    {
+        int redDiff = to.R - from.R;
+        int greenDiff = to.G - from.G;
+        int blueDiff = to.B - from.B;
+
+        return from + new ColorRGB((byte)(redDiff * t), (byte)(greenDiff * t), (byte)(blueDiff * t));
+    }
+
+    /// <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 colorRGB && this == colorRGB;
+
+    /// <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>
+    /// 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>
+/// 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.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,168 @@
+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) => (ColorHSVA)hsv;
+    public static implicit operator ColorRGBA(ColorHSVA hsva)
+    {
+        float hue = hsva.Hue * 360f;
+        float chroma = hsva.Value * hsva.Saturation;
+        float x = chroma * (1f - Math.Abs(hue / 60f % 2f - 1f));
+        float m = hsva.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, (byte)(hsva.Alpha * 255));
+    }
+
+    /// <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>
+    /// 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)
+    {
+        int redDiff = to.R - from.R;
+        int greenDiff = to.G - from.G;
+        int blueDiff = to.B - from.B;
+        int alphaDiff = to.A - from.A;
+
+        return from + new ColorRGBA((byte)(redDiff * t), (byte)(greenDiff * t), (byte)(blueDiff * t), (byte)(alphaDiff * t));
+    }
+
+    /// <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 colorRGBA && this == colorRGBA;
+
+    /// <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>
+    /// 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>
+/// 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.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

@@ -0,0 +1,244 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a 2D line segment defined by two endpoints.
+/// </summary>
+/// <param name="from">The starting point of the <see cref="Line2D"/> segment.</param>
+/// <param name="to">The ending point of the <see cref="Line2D"/> segment.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="Line2D"/> struct with the specified endpoints.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("From: {From.ToString(),nq}, To: {To.ToString(),nq}, Direction: {Direction.ToString(),nq}, Length: {Length}")]
+public readonly struct Line2D(Vector2D from, Vector2D to)
+{
+    /// <summary>
+    /// The starting point of the <see cref="Line2D"/> segment.
+    /// </summary>
+    public readonly Vector2D From = from;
+
+    /// <summary>
+    /// The ending point of the <see cref="Line2D"/> segment.
+    /// </summary>
+    public readonly Vector2D To = to;
+
+    /// <summary>
+    /// The reversed <see cref="Line2D"/> segment.
+    /// </summary>
+    public readonly Line2D Reversed => new(To, From);
+
+    /// <summary>
+    /// The normalized direction <see cref="Vector2D"/> of the <see cref="Line2D"/> segment.
+    /// </summary>
+    public readonly Vector2D Direction => From.FromTo(To).Normalize();
+
+    /// <summary>
+    /// The length of the <see cref="Line2D"/> segment.
+    /// </summary>
+    public readonly float Length => From.FromTo(To).Length();
+
+    /// <summary>
+    /// The squared length of the <see cref="Line2D"/> segment.
+    /// </summary>
+    public readonly float LengthSquared => From.FromTo(To).LengthSquared();
+
+    public static bool operator ==(Line2D left, Line2D right) => left.From == right.From && left.To == right.To;
+    public static bool operator !=(Line2D left, Line2D right) => left.From != right.From || left.To != right.To;
+
+    /// <summary>
+    /// The equation of the <see cref="Line2D"/> defined by this <see cref="Line2D"/> segment.
+    /// </summary>
+    public static Line2DEquation GetLineEquation(Line2D line)
+    {
+        Vector2D slopeVector = line.From.FromTo(line.To);
+        float slope = slopeVector.Y / slopeVector.X;
+
+        float yOffset = line.From.Y - (slope * line.From.X);
+
+        return new Line2DEquation(slope, yOffset);
+    }
+
+    /// <summary>
+    /// Determines whether the specified <see cref="Vector2D"/> lies on the <see cref="Line2D"/>.
+    /// </summary>
+    public static bool Intersects(Line2D line, Vector2D point)
+        => Line2DEquation.Resolve(GetLineEquation(line), point.X).ApproximatelyEquals(point.Y);
+
+    /// <summary>
+    /// Calculates the parameter 't' representing the point's position on the <see cref="Line2D"/> segment.
+    /// </summary>
+    public static float GetT(Line2D line, Vector2D point)
+    {
+        float fromX = Math.Abs(line.From.X);
+        float toX = Math.Abs(line.To.X);
+        float pointX = Math.Abs(point.X);
+
+        float min = Math.Min(fromX, toX);
+        float max = Math.Max(fromX, toX) - min;
+
+        pointX -= min;
+
+        float t = pointX / max;
+
+        // FIXME
+        // I don't even know, apparently whatever I wrote up there doesn't take into account of the direction of the line
+        // Which... I can see how, but I am also not sure how I can make it take into account. Or actually I'm for some reason
+        // too unmotivated to find a solution. Future me, find a better way if possible, please.
+        if (!Lerp(line, t).ApproximatelyEquals(point))
+            return 1f - t;
+        return t;
+    }
+
+    /// <summary>
+    /// Checks if the <see cref="Line2D"/> segment intersects with another <see cref="Line2D"/> segment.
+    /// </summary>
+    public static bool Intersects(Line2D left, Line2D right)
+    {
+        int o1 = Vector2D.Orientation(left.From, left.To, right.From);
+        int o2 = Vector2D.Orientation(left.From, left.To, right.To);
+        int o3 = Vector2D.Orientation(right.From, right.To, left.From);
+        int o4 = Vector2D.Orientation(right.From, right.To, left.To);
+
+        if (o1 != o2 && o3 != o4)
+            return true;
+
+        if (o1 == 0 && OnSegment(left, right.From)) return true;
+        if (o2 == 0 && OnSegment(left, right.To)) return true;
+        if (o3 == 0 && OnSegment(right, left.From)) return true;
+        if (o4 == 0 && OnSegment(right, left.To)) return true;
+
+        return false;
+    }
+
+    /// <summary>
+    /// Checks if the point lies within the <see cref="Line2D"/> segment.
+    /// </summary>
+    public static bool OnSegment(Line2D line, Vector2D point)
+    {
+        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;
+    }
+
+    /// <summary>
+    /// Determines whether two <see cref="Line2D"/> segments intersect.
+    /// </summary>
+    public static bool Intersects(Line2D left, Line2D right, [NotNullWhen(returnValue: true)] out Vector2D? point)
+    {
+        point = null;
+
+        bool result = Intersects(left, right);
+
+        if (result)
+            point = IntersectionPoint(left, right);
+
+        return result;
+    }
+
+    /// <summary>
+    /// Finds the point of intersection between two <see cref="Line2D"/> segments.
+    /// </summary>
+    public static Vector2D IntersectionPoint(Line2D left, Line2D right)
+        => Vector2D.Lerp(left.From, left.To, IntersectionParameterT(left, right));
+
+    /// <summary>
+    /// Calculates the parameter 't' representing the intersection point's position on the <see cref="Line2D"/> segment.
+    /// </summary>
+    public static float IntersectionParameterT(Line2D left, Line2D right)
+    {
+        float numerator = (left.From.X - right.From.X) * (right.From.Y - right.To.Y) - (left.From.Y - right.From.Y) * (right.From.X - right.To.X);
+        float denominator = (left.From.X - left.To.X) * (right.From.Y - right.To.Y) - (left.From.Y - left.To.Y) * (right.From.X - right.To.X);
+
+        // Lines are parallel
+        if (denominator == 0)
+            return float.NaN;
+
+        return numerator / denominator;
+    }
+
+    /// <summary>
+    /// Linearly interpolates between the two endpoints of the <see cref="Line2D"/> segment using parameter 't'.
+    /// </summary>
+    public static Vector2D Lerp(Line2D line, float t)
+        => Vector2D.Lerp(line.From, line.To, t);
+
+    /// <summary>
+    /// Calculates the closest point on the <see cref="Line2D"/> segment to the specified point.
+    /// </summary>
+    public static Vector2D ClosestPointTo(Line2D line, Vector2D point)
+    {
+        Vector2D lineRelativeVector = line.From.FromTo(line.To);
+
+        Vector2D lineDirection = lineRelativeVector.Normalized;
+        Vector2D pointVector = line.From.FromTo(point);
+
+        float dot = lineDirection.Dot(pointVector).Clamp(0f, lineRelativeVector.Magnitude);
+
+        return lineDirection * dot;
+    }
+
+    /// <summary>
+    /// Checks if two <see cref="Line2D"/> segments are approximately equal.
+    /// </summary>
+    /// <param name="left">The first <see cref="Line2D"/>.</param>
+    /// <param name="right">The second <see cref="Line2D"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns><see cref="true"/> if the <see cref="Line2D"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
+    public static bool ApproximatelyEquals(Line2D left, Line2D right, float epsilon = float.Epsilon)
+        => left.From.ApproximatelyEquals(right.From, epsilon) && left.To.ApproximatelyEquals(right.To, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="Line2D"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="Line2D"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Line2D"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is Line2D line2D && this == line2D;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="Line2D"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="Line2D"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(From, To);
+
+    /// <summary>
+    /// Converts the <see cref="Line2D"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="Line2D"/>.</returns>
+    public override string ToString() => $"{nameof(Line2D)}({From}, {To})";
+}
+
+/// <summary>
+/// Provides extension methods for the <see cref="Line2D"/> struct.
+/// </summary>
+public static class Line2DExtensions
+{
+    /// <inheritdoc cref="Line2D.Lerp(Line2D, float)" />
+    public static Vector2D Lerp(this Line2D line, float t) => Line2D.Lerp(line, t);
+
+    /// <inheritdoc cref="Line2D.GetLineEquation(Line2D)" />
+    public static Line2DEquation ToLineEquation(this Line2D line) => Line2D.GetLineEquation(line);
+
+    /// <inheritdoc cref="Line2D.Intersects(Line2D, Vector2D)" />
+    public static bool Intersects(this Line2D line, Vector2D point) => Line2D.Intersects(line, point);
+
+    /// <inheritdoc cref="Line2D.IntersectionPoint(Line2D, Line2D)" />
+    public static Vector2D IntersectionPoint(this Line2D left, Line2D right) => Line2D.IntersectionPoint(left, right);
+
+    /// <inheritdoc cref="Line2D.GetT(Line2D, Vector2D)" />
+    public static float GetT(this Line2D line, Vector2D point) => Line2D.GetT(line, point);
+
+    /// <inheritdoc cref="Line2D.Intersects(Line2D, Line2D)" />
+    public static bool Intersects(this Line2D left, Line2D right) => Line2D.Intersects(left, right);
+
+    /// <inheritdoc cref="Line2D.Intersects(Line2D, Line2D, out Vector2D?)" />
+    public static bool Intersects(this Line2D left, Line2D right, [NotNullWhen(returnValue: true)] out Vector2D? point) => Line2D.Intersects(left, right, out point);
+
+    /// <inheritdoc cref="Line2D.ClosestPointTo(Line2D, Vector2D)" />
+    public static Vector2D ClosestPointTo(this Line2D line, Vector2D point) => Line2D.ClosestPointTo(line, point);
+
+    /// <inheritdoc cref="Line2D.ApproximatelyEquals(Line2D, Line2D, float)" />
+    public static bool ApproximatelyEquals(this Line2D left, Line2D right, float epsilon = float.Epsilon) => Line2D.ApproximatelyEquals(left, right, epsilon);
+}

Engine.Core/Primitives/Line2DEquation.cs

@@ -0,0 +1,75 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a <see cref="Line2DEquation"/> in the form y = mx + b.
+/// </summary>
+/// <param name="slope">The slope of the line.</param>
+/// <param name="offsetY">The Y intercept of the line.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="Line2DEquation"/> struct with the specified slope and Y intercept.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("y = {Slope}x + {OffsetY}")]
+public readonly struct Line2DEquation(float slope, float offsetY)
+{
+    /// <summary>
+    /// The slope of the <see cref="Line2DEquation"/>.
+    /// </summary>
+    public readonly float Slope = slope;
+
+    /// <summary>
+    /// The Y intercept of the <see cref="Line2DEquation"/>.
+    /// </summary>
+    public readonly float OffsetY = offsetY;
+
+    public static bool operator ==(Line2DEquation left, Line2DEquation right) => left.Slope == right.Slope && left.OffsetY == right.OffsetY;
+    public static bool operator !=(Line2DEquation left, Line2DEquation right) => left.Slope != right.Slope || left.OffsetY != right.OffsetY;
+
+    /// <summary>
+    /// Resolves the Y coordinate for a given X coordinate using the <see cref="Line2DEquation"/>.
+    /// </summary>
+    /// <param name="lineEquation">The <see cref="Line2DEquation"/> to resolve.</param>
+    /// <param name="x">The X coordinate for which to resolve the Y coordinate.</param>
+    /// <returns>The Y coordinate resolved using the <see cref="Line2DEquation"/>.</returns>
+    public static float Resolve(Line2DEquation lineEquation, float x) => lineEquation.Slope * x + lineEquation.OffsetY; // y = mx + b
+
+    /// <summary>
+    /// Checks if two <see cref="Line2DEquation"/> are approximately equal.
+    /// </summary>
+    /// <param name="left">The first <see cref="Line2DEquation"/> to compare.</param>
+    /// <param name="right">The second <see cref="Line2DEquation"/> to compare.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns>True if the <see cref="Line2DEquation"/> are approximately equal; otherwise, false.</returns>
+    public static bool ApproximatelyEquals(Line2DEquation left, Line2DEquation right, float epsilon = float.Epsilon)
+        => left.Slope.ApproximatelyEquals(right.Slope, epsilon) && left.OffsetY.ApproximatelyEquals(right.OffsetY, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="Line2DEquation"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="Line2DEquation"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Line2DEquation"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is Line2DEquation lineEquation && this == lineEquation;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="Line2DEquation"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="Line2DEquation"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(Slope, OffsetY);
+
+    /// <summary>
+    /// Converts the <see cref="Line2DEquation"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="Line2DEquation"/>.</returns>
+    public override string ToString() => $"{nameof(Line2DEquation)}({Slope}, {OffsetY})";
+}
+
+/// <summary>
+/// Provides extension methods for the <see cref="Line2DEquation"/> struct.
+/// </summary>
+public static class Line2DEquationExtensions
+{
+    /// <inheritdoc cref="Line2DEquation.Resolve(Line2DEquation, float)" />
+    public static float Resolve(this Line2DEquation lineEquation, float x) => Line2DEquation.Resolve(lineEquation, x);
+
+    /// <inheritdoc cref="Line2DEquation.ApproximatelyEquals(Line2DEquation, Line2DEquation, float)" />
+    public static bool ApproximatelyEquals(this Line2DEquation left, Line2DEquation right, float epsilon = float.Epsilon) => Line2DEquation.ApproximatelyEquals(left, right, epsilon);
+}

Engine.Core/Primitives/Projection1D.cs

@@ -0,0 +1,120 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a range of values along a single axis.
+/// </summary>
+/// <param name="min">The minimum value of the projection.</param>
+/// <param name="max">The maximum value of the projection.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="Projection1D"/> struct with the specified minimum and maximum values.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("Min: {Min}, Max: {Max}")]
+public readonly struct Projection1D(float min, float max)
+{
+    /// <summary>
+    /// Gets the minimum value of the projection.
+    /// </summary>
+    public readonly float Min = min;
+
+    /// <summary>
+    /// Gets the maximum value of the projection.
+    /// </summary>
+    public readonly float Max = max;
+
+    public static bool operator ==(Projection1D left, Projection1D right) => left.Min == right.Min && left.Max == right.Max;
+    public static bool operator !=(Projection1D left, Projection1D right) => left.Min != right.Min || left.Max != right.Max;
+
+    /// <summary>
+    /// Checks if two projections overlap.
+    /// </summary>
+    /// <param name="left">The first projection to check.</param>
+    /// <param name="right">The second projection to check.</param>
+    /// <returns><see cref="true"/> if the projections overlap; otherwise, <see cref="false"/>.</returns>
+    public static bool Overlaps(Projection1D left, Projection1D right) => Overlaps(left, right, out float _);
+
+    /// <summary>
+    /// Checks if two projections overlap and calculates the depth of the overlap.
+    /// </summary>
+    /// <param name="left">The first projection to check.</param>
+    /// <param name="right">The second projection to check.</param>
+    /// <param name="depth">The depth of the overlap, if any.</param>
+    /// <returns><see cref="true"/> if the projections overlap; otherwise, <see cref="false"/>.</returns>
+    public static bool Overlaps(Projection1D left, Projection1D right, out float depth)
+    {
+        // TODO Try to improve this
+        bool rightMinInLeft = right.Min > left.Min && right.Min < left.Max;
+        if (rightMinInLeft)
+        {
+            depth = left.Max - right.Min;
+            return true;
+        }
+
+        bool rightMaxInLeft = right.Max < left.Max && right.Max > left.Min;
+        if (rightMaxInLeft)
+        {
+            depth = left.Min - right.Max;
+            return true;
+        }
+
+        bool leftMinInRight = left.Min > right.Min && left.Min < right.Max;
+        if (leftMinInRight)
+        {
+            depth = right.Max - left.Min;
+            return true;
+        }
+
+        bool leftMaxInRight = left.Max < right.Max && left.Max > right.Min;
+        if (leftMaxInRight)
+        {
+            depth = right.Min - left.Max;
+            return true;
+        }
+
+        depth = 0f;
+        return false;
+    }
+
+    /// <summary>
+    /// Checks if two <see cref="Projection1D"/>s are approximately equal within a specified epsilon range.
+    /// </summary>
+    /// <param name="left">The first <see cref="Projection1D"/>.</param>
+    /// <param name="right">The second <see cref="Projection1D"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns><see cref="true"/> if the <see cref="Projection1D"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
+    public static bool ApproximatelyEquals(Projection1D left, Projection1D right, float epsilon = float.Epsilon)
+        => left.Min.ApproximatelyEquals(right.Min, epsilon) && left.Max.ApproximatelyEquals(right.Max, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="Projection1D"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="Projection1D"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Projection1D"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is Projection1D projection1D && this == projection1D;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="Projection1D"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="Projection1D"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(Min, Max);
+
+    /// <summary>
+    /// Converts the <see cref="Projection1D"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="Projection1D"/>.</returns>
+    public override string ToString() => $"{nameof(Projection1D)}({Min}, {Max})";
+}
+
+/// <summary>
+/// Provides extension methods for the <see cref="Projection1D"/> struct.
+/// </summary>
+public static class Projection1DExtensions
+{
+    /// <inheritdoc cref="Projection1D.Overlaps(Projection1D, Projection1D)" />
+    public static bool Overlaps(this Projection1D left, Projection1D right) => Projection1D.Overlaps(left, right);
+
+    /// <inheritdoc cref="Projection1D.Overlaps(Projection1D, Projection1D, out float)" />
+    public static bool Overlaps(this Projection1D left, Projection1D right, out float depth) => Projection1D.Overlaps(left, right, out depth);
+
+    /// <inheritdoc cref="Projection1D.ApproximatelyEquals(Projection1D, Projection1D, float)" />
+    public static bool ApproximatelyEquals(this Projection1D left, Projection1D right, float epsilon = float.Epsilon) => Projection1D.ApproximatelyEquals(left, right, epsilon);
+}

Engine.Core/Primitives/Quaternion.cs

@@ -0,0 +1,357 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents a 3D space rotation.
+/// </summary>
+/// <param name="x">X(i) position of the <see cref="Quaternion"/>.</param>
+/// <param name="y">Y(j) position of the <see cref="Quaternion"/>.</param>
+/// <param name="z">Z(k) position of the <see cref="Quaternion"/>.</param>
+/// <param name="w">W(a) position of the <see cref="Quaternion"/>.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="Quaternion"/> struct with the specified positions.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("{ToString(),nq}, Length: {Magnitude}, LengthSquared: {MagnitudeSquared}, Normalized: {Normalized.ToString(),nq}")]
+public readonly struct Quaternion(float x, float y, float z, float w)
+{
+    /// <summary>
+    /// The X(i) imaginary of the <see cref="Quaternion"/>.
+    /// </summary>
+    public readonly float X = x;
+
+    /// <summary>
+    /// The Y(j) imaginary of the <see cref="Quaternion"/>.
+    /// </summary>
+    public readonly float Y = y;
+
+    /// <summary>
+    /// The Z(k) imaginary of the <see cref="Quaternion"/>.
+    /// </summary>
+    public readonly float Z = z;
+
+    /// <summary>
+    /// The W(a) scalar of the <see cref="Quaternion"/>.
+    /// </summary>
+    public readonly float W = w;
+
+    /// <summary>
+    /// The magnitude (length) of the <see cref="Quaternion"/>.
+    /// </summary>
+    public float Magnitude => Length(this);
+
+    /// <summary>
+    /// The squared magnitude (length) of the <see cref="Quaternion"/>.
+    /// </summary>
+    public float MagnitudeSquared => LengthSquared(this);
+
+    /// <summary>
+    /// The normalized form of the <see cref="Quaternion"/> (a <see cref="Quaternion"/> with the same direction and a magnitude of 1).
+    /// </summary>
+    public Quaternion Normalized => Normalize(this);
+
+    /// <summary>
+    /// Represents the <see cref="Quaternion"/> with no rotation.
+    /// </summary>
+    public readonly static Quaternion Zero = new(0f, 0f, 0f, 0f);
+
+    /// <summary>
+    /// Represents the identity <see cref="Quaternion"/>.
+    /// </summary>
+    public readonly static Quaternion Identity = new(0f, 0f, 0f, 1f);
+
+    public static Quaternion operator -(Quaternion quaternion) => new(-quaternion.X, -quaternion.Y, -quaternion.Z, quaternion.W);
+    public static Quaternion operator +(Quaternion left, Quaternion right) => new(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+    public static Quaternion operator -(Quaternion left, Quaternion right) => new(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+    public static Quaternion operator *(Quaternion quaternion, float value) => new(quaternion.X * value, quaternion.Y * value, quaternion.Z * value, quaternion.W * value);
+    public static Quaternion operator *(float value, Quaternion quaternion) => new(quaternion.X * value, quaternion.Y * value, quaternion.Z * value, quaternion.W * value);
+    public static Quaternion operator *(Quaternion left, Quaternion right)
+        => new(
+            left.W * right.X + left.X * right.W + left.Y * right.Z - left.Z * right.Y,
+            left.W * right.Y + left.Y * right.W + left.Z * right.X - left.X * right.Z,
+            left.W * right.Z + left.Z * right.W + left.X * right.Y - left.Y * right.X,
+            left.W * right.W - left.X * right.X - left.Y * right.Y - left.Z * right.Z
+        );
+    public static Quaternion operator /(Quaternion quaternion, float value) => new(quaternion.X / value, quaternion.Y / value, quaternion.Z / value, quaternion.W / value);
+    public static bool operator ==(Quaternion left, Quaternion right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
+    public static bool operator !=(Quaternion left, Quaternion right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z || left.W != right.W;
+
+    public static implicit operator Quaternion(System.Numerics.Quaternion quaternion) => new(quaternion.X, quaternion.Y, quaternion.Z, quaternion.W);
+    public static implicit operator System.Numerics.Quaternion(Quaternion quaternion) => new(quaternion.X, quaternion.Y, quaternion.Z, quaternion.W);
+
+    /// <summary>
+    /// Calculates the length of the <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/>.</param>
+    /// <returns>The length of the <see cref="Quaternion"/>.</returns>
+    public static float Length(Quaternion quaternion) => Math.Sqrt(LengthSquared(quaternion));
+
+    /// <summary>
+    /// Calculates the squared length of the <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/>.</param>
+    /// <returns>The squared length of the <see cref="Quaternion"/>.</returns>
+    public static float LengthSquared(Quaternion quaternion) => quaternion.X * quaternion.X + quaternion.Y * quaternion.Y + quaternion.Z * quaternion.Z + quaternion.Z * quaternion.Z + quaternion.W * quaternion.W;
+
+    /// <summary>
+    /// Adds two <see cref="Quaternion"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="Quaternion"/>.</param>
+    /// <param name="right">The second <see cref="Quaternion"/>.</param>
+    /// <returns>The sum of the two <see cref="Quaternion"/>s.</returns>
+    public static Quaternion Add(Quaternion left, Quaternion right) => left + right;
+
+    /// <summary>
+    /// Subtracts one <see cref="Quaternion"/> from another.
+    /// </summary>
+    /// <param name="left">The <see cref="Quaternion"/> to subtract from.</param>
+    /// <param name="right">The <see cref="Quaternion"/> to subtract.</param>
+    /// <returns>The result of subtracting the second <see cref="Quaternion"/> from the first.</returns>
+    public static Quaternion Subtract(Quaternion left, Quaternion right) => left - right;
+
+    /// <summary>
+    /// Multiplies a <see cref="Quaternion"/> by a scalar value.
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of multiplying the <see cref="Quaternion"/> by the scalar value.</returns>
+    public static Quaternion Multiply(Quaternion quaternion, float value) => quaternion * value;
+
+    /// <summary>
+    /// Divides a <see cref="Quaternion"/> by a scalar value.
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/>.</param>
+    /// <param name="value">The scalar value.</param>
+    /// <returns>The result of dividing the <see cref="Quaternion"/> by the scalar value.</returns>
+    public static Quaternion Divide(Quaternion quaternion, float value) => quaternion / value;
+
+    /// <summary>
+    /// Normalizes the <see cref="Quaternion"/> (creates a unit <see cref="Quaternion"/> with the same direction).
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/> to normalize.</param>
+    /// <returns>The normalized <see cref="Quaternion"/>.</returns>
+    public static Quaternion Normalize(Quaternion quaternion) => quaternion / Length(quaternion);
+
+    /// <summary>
+    /// Inverts the direction of the <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/>.</param>
+    /// <returns>The inverted <see cref="Quaternion"/>.</returns>
+    public static Quaternion Invert(Quaternion quaternion) => Conjugate(quaternion) / LengthSquared(quaternion);
+
+    /// <summary>
+    /// Conjugate of the <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="quaternion">The <see cref="Quaternion"/>.</param>
+    /// <returns>The inverted <see cref="Quaternion"/>.</returns>
+    public static Quaternion Conjugate(Quaternion quaternion) => -quaternion;
+
+    /// <summary>
+    /// Rotates a <see cref="Vector3D"/> by applying the provided <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="vector">The <see cref="Vector3D"/> to be rotated.</param>
+    /// <param name="quaternion">The <see cref="Quaternion"/> to used for applying rotation.</param>
+    /// <returns>The rotated <see cref="Vector3D"/>.</returns>
+    public static Vector3D RotateVector(Vector3D vector, Quaternion quaternion)
+    {
+        Quaternion rotation = quaternion * new Quaternion(vector.X, vector.Y, vector.Z, 0) * Invert(quaternion);
+        return new(rotation.X, rotation.Y, rotation.Z);
+    }
+
+    /// <summary>
+    /// Performs spherical linear interpolation between two <see cref="Quaternion"/>s.
+    /// </summary>
+    /// <param name="from">The starting <see cref="Quaternion"/> (t = 0).</param>
+    /// <param name="to">The target <see cref="Quaternion"/> (t = 1).</param>
+    /// <param name="t">The interpolation parameter.</param>
+    /// <returns>The interpolated <see cref="Quaternion"/>.</returns>
+    public static Quaternion SLerp(Quaternion from, Quaternion to, float t)
+    {
+        float dot = Dot(from, to);
+
+        if (dot < 0.0f)
+        {
+            from = new Quaternion(-from.X, -from.Y, -from.Z, -from.W);
+            dot = -dot;
+        }
+
+        if (dot > 0.9995f)
+            return Lerp(from, to, t);
+
+        float angle = Math.Acos(dot);
+        float sinAngle = Math.Sin(angle);
+
+        float fromWeight = Math.Sin((1f - t) * angle) / sinAngle;
+        float toWeight = Math.Sin(t * angle) / sinAngle;
+
+        return from * fromWeight + to * toWeight;
+    }
+
+    /// <summary>
+    /// Performs linear interpolation between two <see cref="Quaternion"/>s.
+    /// </summary>
+    /// <param name="from">The starting <see cref="Quaternion"/> (t = 0).</param>
+    /// <param name="to">The target <see cref="Quaternion"/> (t = 1).</param>
+    /// <param name="t">The interpolation parameter.</param>
+    /// <returns>The interpolated <see cref="Quaternion"/>.</returns>
+    public static Quaternion Lerp(Quaternion from, Quaternion to, float t) => Normalize(new(from.X.Lerp(to.X, t), from.W.Lerp(to.W, t), from.Z.Lerp(to.Z, t), from.W.Lerp(to.W, t)));
+
+    /// <summary>
+    /// Calculates the dot product of two <see cref="Quaternion"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="Quaternion"/>.</param>
+    /// <param name="right">The second <see cref="Quaternion"/>.</param>
+    /// <returns>The dot product of the two <see cref="Quaternion"/>s.</returns>
+    public static float Dot(Quaternion left, Quaternion right) => left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
+
+    /// <summary>
+    /// Calculates the <see cref="Quaternion"/> from given axis and angle.
+    /// </summary>
+    /// <param name="axis">The axis of the rotation in <see cref="Vector3D"/>.</param>
+    /// <param name="angle">The angle in radians.</param>
+    /// <returns>The rotation <see cref="Quaternion"/> calculated by the given parameters.</returns>
+    public static Quaternion FromAxisAngle(Vector3D axis, float angle)
+    {
+        float halfAngle = angle * .5f;
+        float sinHalf = Math.Sin(halfAngle);
+        return new Quaternion(axis.X * sinHalf, axis.Y * sinHalf, axis.Z * sinHalf, Math.Cos(halfAngle));
+    }
+
+    /// <summary>
+    /// Calculates the <see cref="Quaternion"/> from given yaw, pitch and roll values.
+    /// </summary>
+    /// <returns>The rotation <see cref="Quaternion"/> calculated by the given parameters.</returns>
+    public static Quaternion FromAngles(float x, float y, float z)
+    {
+        float cosX = Math.Cos(x * .5f);
+        float sinX = Math.Sin(x * .5f);
+        float cosY = Math.Cos(y * .5f);
+        float sinY = Math.Sin(y * .5f);
+        float cozZ = Math.Cos(z * .5f);
+        float sinZ = Math.Sin(z * .5f);
+
+        return new Quaternion(
+            x: sinX * cosY * cozZ - cosX * sinY * sinZ,
+            y: cosX * sinY * cozZ + sinX * cosY * sinZ,
+            z: cosX * cosY * sinZ - sinX * sinY * cozZ,
+            w: cosX * cosY * cozZ + sinX * sinY * sinZ
+        );
+    }
+
+    /// <summary>
+    /// Calculates the <see cref="System.Numerics.Matrix4x4"/> from given <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="axis">The axis of the rotation in <see cref="Vector3D"/>.</param>
+    /// <param name="angle">The angle in radians.</param>
+    /// <returns>The rotation <see cref="System.Numerics.Matrix4x4"/> calculated by the given <see cref="Quaternion"/>.</returns>
+    public static System.Numerics.Matrix4x4 ToRotationMatrix4x4(Quaternion quaternion)
+    {
+        float m00 = 1 - 2 * (quaternion.Y * quaternion.Y + quaternion.Z * quaternion.Z);
+        float m01 = 2 * (quaternion.X * quaternion.Y - quaternion.W * quaternion.Z);
+        float m02 = 2 * (quaternion.X * quaternion.Z + quaternion.W * quaternion.Y);
+        float m03 = 0;
+
+        float m10 = 2 * (quaternion.X * quaternion.Y + quaternion.W * quaternion.Z);
+        float m11 = 1 - 2 * (quaternion.X * quaternion.X + quaternion.Z * quaternion.Z);
+        float m12 = 2 * (quaternion.Y * quaternion.Z - quaternion.W * quaternion.X);
+        float m13 = 0;
+
+        float m20 = 2 * (quaternion.X * quaternion.Z - quaternion.W * quaternion.Y);
+        float m21 = 2 * (quaternion.Y * quaternion.Z + quaternion.W * quaternion.X);
+        float m22 = 1 - 2 * (quaternion.X * quaternion.X + quaternion.Y * quaternion.Y);
+        float m23 = 0;
+
+        float m30 = 0;
+        float m31 = 0;
+        float m32 = 0;
+        float m33 = 1;
+
+        return new(
+            m00, m01, m02, m03,
+            m10, m11, m12, m13,
+            m20, m21, m22, m23,
+            m30, m31, m32, m33
+        );
+    }
+
+    /// <summary>
+    /// Checks if two <see cref="Quaternion"/>s are approximately equal within a specified epsilon range.
+    /// </summary>
+    /// <param name="left">The first <see cref="Quaternion"/>.</param>
+    /// <param name="right">The second <see cref="Quaternion"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns><see cref="true"/> if the <see cref="Quaternion"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
+    public static bool ApproximatelyEquals(Quaternion left, Quaternion right, float epsilon = float.Epsilon)
+        => left.X.ApproximatelyEquals(right.X, epsilon) && left.Y.ApproximatelyEquals(right.Y, epsilon) && left.Z.ApproximatelyEquals(right.Z, epsilon) && left.W.ApproximatelyEquals(right.W, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="Quaternion"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="Quaternion"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Quaternion"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is Quaternion quaternion && this == quaternion;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="Quaternion"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="Quaternion"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(W, X, Y, Z);
+
+    /// <summary>
+    /// Converts the <see cref="Quaternion"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="Quaternion"/>.</returns>
+    public override string ToString() => $"{nameof(Quaternion)}({W}, {X}, {Y}, {Z})";
+}
+
+/// <summary>
+/// Provides extension methods for <see cref="Quaternion"/> type.
+/// </summary>
+public static class QuaternionExtensions
+{
+    /// <inheritdoc cref="Quaternion.Length(Quaternion)" />
+    public static float Length(this Quaternion quaternion) => Quaternion.Length(quaternion);
+
+    /// <inheritdoc cref="Quaternion.LengthSquared(Quaternion)" />
+    public static float LengthSquared(this Quaternion quaternion) => Quaternion.LengthSquared(quaternion);
+
+    /// <inheritdoc cref="Quaternion.Add(Quaternion, Quaternion)" />
+    public static Quaternion Add(this Quaternion left, Quaternion right) => Quaternion.Add(left, right);
+
+    /// <inheritdoc cref="Quaternion.Subtract(Quaternion, Quaternion)" />
+    public static Quaternion Subtract(this Quaternion left, Quaternion right) => Quaternion.Subtract(left, right);
+
+    /// <inheritdoc cref="Quaternion.Multiply(Quaternion, float)" />
+    public static Quaternion Multiply(this Quaternion quaternion, float value) => Quaternion.Multiply(quaternion, value);
+
+    /// <inheritdoc cref="Quaternion.Divide(Quaternion, float)" />
+    public static Quaternion Divide(this Quaternion quaternion, float value) => Quaternion.Divide(quaternion, value);
+
+    /// <inheritdoc cref="Quaternion.Normalize(Quaternion)" />
+    public static Quaternion Normalize(this Quaternion quaternion) => Quaternion.Normalize(quaternion);
+
+    /// <inheritdoc cref="Quaternion.Invert(Quaternion)" />
+    public static Quaternion Invert(this Quaternion quaternion) => Quaternion.Invert(quaternion);
+
+    /// <inheritdoc cref="Quaternion.Conjugate(Quaternion)" />
+    public static Quaternion Conjugate(this Quaternion quaternion) => Quaternion.Conjugate(quaternion);
+
+    /// <inheritdoc cref="Quaternion.RotateVector(Vector3D, Quaternion)" />
+    public static Vector3D RotateVector(this Vector3D vector, Quaternion quaternion) => Quaternion.RotateVector(vector, quaternion);
+
+    /// <inheritdoc cref="Quaternion.SLerp(Quaternion, Quaternion, float)" />
+    public static Quaternion SLerp(this Quaternion from, Quaternion to, float t) => Quaternion.SLerp(from, to, t);
+
+    /// <inheritdoc cref="Quaternion.Lerp(Quaternion, Quaternion, float)" />
+    public static Quaternion Lerp(this Quaternion from, Quaternion to, float t) => Quaternion.Lerp(from, to, t);
+
+    /// <inheritdoc cref="Quaternion.Dot(Quaternion, Quaternion)" />
+    public static float Dot(this Quaternion left, Quaternion right) => Quaternion.Dot(left, right);
+
+    /// <inheritdoc cref="Quaternion.ToRotationMatrix4x4(Quaternion, Quaternion)" />
+    public static System.Numerics.Matrix4x4 ToRotationMatrix4x4(this Quaternion quaternion) => Quaternion.ToRotationMatrix4x4(quaternion);
+
+    /// <inheritdoc cref="Quaternion.FromAxisAngle(Vector3D, float)" />
+    public static Quaternion CreateRotation(this Vector3D axis, float angle) => Quaternion.FromAxisAngle(axis, angle);
+
+    /// <inheritdoc cref="Quaternion.ApproximatelyEquals(Quaternion, Quaternion, float)" />
+    public static bool ApproximatelyEquals(this Quaternion left, Quaternion right, float epsilon = float.Epsilon) => Quaternion.ApproximatelyEquals(left, right, epsilon);
+}

Engine.Core/Primitives/Ray2D.cs

@@ -0,0 +1,105 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an infinite ray in 2D space.
+/// </summary>
+/// <param name="Origin">The <see cref="Vector2D"/> in 2D space where the ray starts from.</param>
+/// <param name="Direction">Normalized <see cref="Vector2D"/> indicating the ray's is direction.</param> 
+public readonly struct Ray2D(Vector2D Origin, Vector2D Direction)
+{
+    /// <summary>
+    /// The starting point of the <see cref="Ray2D"/>.
+    /// </summary>
+    public readonly Vector2D Origin = Origin;
+
+    /// <summary>
+    /// The direction in which the <see cref="Ray2D"/> points. Should be a normalized vector.
+    /// </summary>
+    public readonly Vector2D Direction = Direction;
+
+    /// <summary>
+    /// Gets a <see cref="Ray2D"/> with the same origin but with the direction reversed.
+    /// </summary>
+    public readonly Ray2D Reversed => new(Origin, -Direction);
+
+    public static bool operator ==(Ray2D left, Ray2D right) => left.Origin == right.Origin && left.Direction == right.Direction;
+    public static bool operator !=(Ray2D left, Ray2D right) => left.Origin != right.Origin || left.Direction != right.Direction;
+    public static implicit operator Ray2D(Line2D line) => new(line.From, line.From.FromTo(line.To).Normalized);
+
+    /// <summary>
+    /// Constructs a <see cref="Line2D"/> from a <see cref="Ray2D"/>, extending from its origin in the <see cref="Ray2D"/>'s direction for a given distance.
+    /// </summary>
+    /// <param name="ray">The source <see cref="Ray2D"/>.</param>
+    /// <param name="distance">The length of the line segment to create from the <see cref="Ray2D"/>.</param>
+    /// <returns>A <see cref="Line2D"/> representing the segment of the <see cref="Ray2D"/>.</returns>
+    public static Line2D GetLine(Ray2D ray, float distance)
+        => new(ray.Origin, ray.Origin + ray.Direction * distance);
+
+    /// <summary>
+    /// Evaluates the point on the <see cref="Ray2D"/> at a specified distance from its origin.
+    /// </summary>
+    /// <param name="ray">The <see cref="Ray2D"/> to evaluate.</param>
+    /// <param name="distanceFromOrigin">The distance from the origin along the <see cref="Ray2D"/>'s direction.</param>
+    /// <returns>A <see cref="Vector2D"/> representing the point at the given distance on the <see cref="Ray2D"/>.</returns>
+    public static Vector2D Evaluate(Ray2D ray, float distanceFromOrigin)
+        => ray.Origin + ray.Direction * distanceFromOrigin;
+
+    /// <summary>
+    /// Calculates the closest point on the <see cref="Ray2D"/> to the specified point.
+    /// </summary>
+    public static Vector2D ClosestPointTo(Ray2D ray, Vector2D point)
+    {
+        Vector2D originToPoint = ray.Origin.FromTo(point);
+
+        float dot = ray.Direction.Dot(originToPoint);
+
+        return ray.Origin + ray.Direction * dot;
+    }
+
+    /// <summary>
+    /// Checks if two <see cref="Ray2D"/>s are approximately equal within a specified epsilon range.
+    /// </summary>
+    /// <param name="left">The first <see cref="Ray2D"/>.</param>
+    /// <param name="right">The second <see cref="Ray2D"/>.</param>
+    /// <param name="epsilon">The epsilon range.</param>
+    /// <returns><see cref="true"/> if the <see cref="Ray2D"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
+    public static bool ApproximatelyEquals(Ray2D left, Ray2D right, float epsilon = float.Epsilon)
+        => left.Origin.ApproximatelyEquals(right.Origin, epsilon) && left.Direction.ApproximatelyEquals(right.Direction, epsilon);
+
+    /// <summary>
+    /// Determines whether the specified object is equal to the current <see cref="Ray2D"/>.
+    /// </summary>
+    /// <param name="obj">The object to compare with the current <see cref="Ray2D"/>.</param>
+    /// <returns><see cref="true"/> if the specified object is equal to the current <see cref="Ray2D"/>; otherwise, <see cref="false"/>.</returns>
+    public override bool Equals(object? obj) => obj is Ray2D ray2D && this == ray2D;
+
+    /// <summary>
+    /// Generates a hash code for the <see cref="Ray2D"/>.
+    /// </summary>
+    /// <returns>A hash code for the <see cref="Ray2D"/>.</returns>
+    public override int GetHashCode() => System.HashCode.Combine(Origin, Direction);
+
+    /// <summary>
+    /// Converts the <see cref="Ray2D"/> to its string representation.
+    /// </summary>
+    /// <returns>A string representation of the <see cref="Ray2D"/>.</returns>
+    public override string ToString() => $"{nameof(Ray2D)}({Origin}, {Direction})";
+}
+
+/// <summary>
+/// Provides extension methods for the <see cref="Ray2D"/> struct.
+/// </summary>
+public static class Ray2DExtensions
+{
+    /// <inheritdoc cref="Ray2D.GetLine(Ray2D, float) />
+    public static Line2D ToLine(this Ray2D ray, float distance) => Ray2D.GetLine(ray, distance);
+
+    /// <inheritdoc cref="Ray2D.Evaluate(Ray2D, float) />
+    public static Vector2D Evaluate(this Ray2D ray, float distanceFromOrigin) => Ray2D.Evaluate(ray, distanceFromOrigin);
+
+    /// <inheritdoc cref="Ray2D.ClosestPointTo(Ray2D, Vector2D) />
+    public static Vector2D ClosestPointTo(this Ray2D ray, Vector2D point) => Ray2D.ClosestPointTo(ray, point);
+
+    /// <inheritdoc cref="Ray2D.ApproximatelyEquals(Ray2D, Ray2D, float)" />
+    public static bool ApproximatelyEquals(this Ray2D left, Ray2D right, float epsilon = float.Epsilon) => Ray2D.ApproximatelyEquals(left, right, epsilon);
+}