refactor: universe and objects now use fast list

They still do generate a lot of garbage but with boxed value pools I made the boxes reusable, it still does generate garbage through the delegate creation, gotta find a solution for them later

.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

.gitignore

@@ -1,484 +1,484 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from `dotnet new gitignore`
-
-# dotenv files
-.env
-
-# User-specific files
-*.rsuser
-*.suo
-*.user
-*.userosscache
-*.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
-
-# Mono auto generated files
-mono_crash.*
-
-# Build results
-[Dd]ebug/
-[Dd]ebugPublic/
-[Rr]elease/
-[Rr]eleases/
-x64/
-x86/
-[Ww][Ii][Nn]32/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-bld/
-[Bb]in/
-[Oo]bj/
-[Ll]og/
-[Ll]ogs/
-
-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUnit
-*.VisualState.xml
-TestResult.xml
-nunit-*.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# Tye
-.tye/
-
-# ASP.NET Scaffolding
-ScaffoldingReadMe.txt
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.tlog
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Coverlet is a free, cross platform Code Coverage Tool
-coverage*.json
-coverage*.xml
-coverage*.info
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# NuGet Symbol Packages
-*.snupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-*.appxbundle
-*.appxupload
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- [Bb]ackup.rdl
-*- [Bb]ackup ([0-9]).rdl
-*- [Bb]ackup ([0-9][0-9]).rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio 6 auto-generated project file (contains which files were open etc.)
-*.vbp
-
-# Visual Studio 6 workspace and project file (working project files containing files to include in project)
-*.dsw
-*.dsp
-
-# Visual Studio 6 technical files
-*.ncb
-*.aps
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# Visual Studio History (VSHistory) files
-.vshistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
-
-# Backup folder for Package Reference Convert tool in Visual Studio 2017
-MigrationBackup/
-
-# Ionide (cross platform F# VS Code tools) working folder
-.ionide/
-
-# Fody - auto-generated XML schema
-FodyWeavers.xsd
-
-# VS Code files for those working on multiple tools
-.vscode/*
-!.vscode/settings.json
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json
-*.code-workspace
-
-# Local History for Visual Studio Code
-.history/
-
-# Windows Installer files from build outputs
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# JetBrains Rider
-*.sln.iml
-.idea
-
-##
-## Visual studio for Mac
-##
-
-
-# globs
-Makefile.in
-*.userprefs
-*.usertasks
-config.make
-config.status
-aclocal.m4
-install-sh
-autom4te.cache/
-*.tar.gz
-tarballs/
-test-results/
-
-# Mac bundle stuff
-*.dmg
-*.app
-
-# content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore
-# General
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Icon must end with two \r
-Icon
-
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-.com.apple.timemachine.donotpresent
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-# content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore
-# Windows thumbnail cache files
-Thumbs.db
-ehthumbs.db
-ehthumbs_vista.db
-
-# Dump file
-*.stackdump
-
-# Folder config file
-[Dd]esktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
-
-# Vim temporary swap files
-*.swp
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from `dotnet new gitignore`
+
+# dotenv files
+.env
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# Tye
+.tye/
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.tlog
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio 6 auto-generated project file (contains which files were open etc.)
+*.vbp
+
+# Visual Studio 6 workspace and project file (working project files containing files to include in project)
+*.dsw
+*.dsp
+
+# Visual Studio 6 technical files
+*.ncb
+*.aps
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# Visual Studio History (VSHistory) files
+.vshistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+# VS Code files for those working on multiple tools
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+# Windows Installer files from build outputs
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# JetBrains Rider
+*.sln.iml
+.idea
+
+##
+## Visual studio for Mac
+##
+
+
+# globs
+Makefile.in
+*.userprefs
+*.usertasks
+config.make
+config.status
+aclocal.m4
+install-sh
+autom4te.cache/
+*.tar.gz
+tarballs/
+test-results/
+
+# Mac bundle stuff
+*.dmg
+*.app
+
+# content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore
+# Windows thumbnail cache files
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# Vim temporary swap files
+*.swp

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Engine.Integration/YamlDotNet"]
+	path = Engine.Integration/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,6 +1,4 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace Engine.Core;
 
 /// <summary>
 /// Indicates the class implementing it has Assignable fields that are necessary for the engine to work properly.
@@ -8,9 +6,9 @@ namespace Syntriax.Engine.Core.Abstract;
 public interface IAssignable
 {
     /// <summary>
-    /// Callback triggered when the <see cref="IAssignable"/>'s fields are unassigned and completely ready to recycle.
+    /// Event triggered when the <see cref="IAssignable"/>'s fields are unassigned and completely ready to recycle.
     /// </summary> 
-    Action<IAssignable>? OnUnassigned { get; set; }
+    Event<IAssignable>? OnUnassigned { get; }
 
     /// <summary>
     /// Unassign <see cref="IAssignable"/>'s all fields and make it ready to recycle.

Engine.Core/Abstract/Assignable/IAssignableGameObject.cs

@@ -1,26 +0,0 @@
-using System;
-
-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>
-    /// Callback triggered when the <see cref="IGameObject"/> value has has been assigned a new value.
-    /// </summary>
-    Action<IAssignableGameObject>? OnGameObjectAssigned { get; set; }
-
-    /// <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);
-}

Engine.Core/Abstract/Assignable/IAssignableSprite.cs

@@ -1,26 +0,0 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-/// <summary>
-/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="ISprite"/> field.
-/// </summary>
-public interface IAssignableSprite : IAssignable
-{
-    /// <summary>
-    /// Callback triggered when the <see cref="ISprite"/> value has has been assigned a new value.
-    /// </summary>
-    Action<IAssignableSprite>? OnSpriteAssigned { get; set; }
-
-    /// <inheritdoc cref="ISprite" />
-    ISprite Sprite { get; }
-
-    /// <summary>
-    /// Assign a value to the <see cref="ISprite"/> field of this object
-    /// </summary>
-    /// <param name="sprite">New <see cref="ISprite"/> to assign.</param>
-    /// <returns> 
-    /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
-    /// </returns>
-    bool Assign(ISprite sprite);
-}

Engine.Core/Abstract/Assignable/IAssignableTransform.cs

@@ -1,26 +0,0 @@
-using System;
-
-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>
-    /// Callback triggered when the <see cref="ITransform"/> value has has been assigned a new value.
-    /// </summary>
-    Action<IAssignableTransform>? OnTransformAssigned { get; set; }
-
-    /// <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);
-}

Engine.Core/Abstract/Assignable/IHasBehaviourController.cs

@@ -1,22 +1,20 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace 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>
-    /// Callback triggered when the <see cref="IBehaviourController"/> value has has been assigned a new value.
+    /// Event triggered when the <see cref="IBehaviourController"/> value has has been assigned a new value.
     /// </summary>
-    Action<IAssignableBehaviourController>? OnBehaviourControllerAssigned { get; set; }
+    Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; }
 
     /// <inheritdoc cref="IBehaviourController" />
     IBehaviourController BehaviourController { get; }
 
     /// <summary>
-    /// Assign a value to the <see cref="IBehaviourController"/> field of this object
+    /// Assign a value to the <see cref="IBehaviourController"/> field of this object.
     /// </summary>
     /// <param name="behaviourController">New <see cref="IBehaviourController"/> to assign.</param>
     /// <returns> 

Engine.Core/Abstract/Assignable/IHasEntity.cs

@@ -1,22 +1,20 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace 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>
-    /// Callback triggered when the <see cref="IEntity"/> value has has been assigned a new value.
+    /// Event triggered when the <see cref="IEntity"/> value has has been assigned a new value.
     /// </summary>
-    Action<IAssignableEntity>? OnEntityAssigned { get; set; }
+    Event<IHasEntity> OnEntityAssigned { get; }
 
     /// <inheritdoc cref="IEntity" />
     IEntity Entity { get; }
 
     /// <summary>
-    /// Assign a value to the <see cref="IEntity"/> field of this object
+    /// Assign a value to the <see cref="IEntity"/> field of this object.
     /// </summary>
     /// <param name="entity">New <see cref="IEntity"/> to assign.</param>
     /// <returns> 

Engine.Core/Abstract/Assignable/IHasStateEnable.cs

@@ -1,22 +1,20 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace 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>
-    /// Callback triggered when the <see cref="IStateEnable"/> value has has been assigned a new value.
+    /// Event triggered when the <see cref="IStateEnable"/> value has has been assigned a new value.
     /// </summary>
-    Action<IAssignableStateEnable>? OnStateEnableAssigned { get; set; }
+    Event<IHasStateEnable> OnStateEnableAssigned { get; }
 
     /// <inheritdoc cref="IStateEnable" />
     IStateEnable StateEnable { get; }
 
     /// <summary>
-    /// Assign a value to the <see cref="IStateEnable"/> field of this object
+    /// Assign a value to the <see cref="IStateEnable"/> field of this object.
     /// </summary>
     /// <param name="stateEnable">New <see cref="IStateEnable"/> to assign.</param>
     /// <returns> 

Engine.Core/Abstract/Assignable/IHasUniverse.cs

@@ -0,0 +1,24 @@
+namespace 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 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 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,19 +1,19 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace Engine.Core;
 
 /// <summary>
-/// Responsible for every behaviour an object in the game might have, controlled by <see cref="IBehaviourController"/>.
+/// 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>
-    /// Callback triggered when the <see cref="Priority"/> has changed.
+    /// Event triggered when the priority of the <see cref="IBehaviour"/> changes.
     /// </summary>
-    Action<IBehaviour>? OnPriorityChanged { get; set; }
+    Event<IBehaviour, PriorityChangedArguments> OnPriorityChanged { get; }
 
     /// <summary>
-    /// Call priority of the <see cref="IBehaviour"/>.
+    /// The priority of the <see cref="IBehaviour"/>.
     /// </summary>
     int Priority { get; set; }
+
+    readonly record struct PriorityChangedArguments(int PreviousPriority);
 }

Engine.Core/Abstract/IBehaviour2D.cs

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

Engine.Core/Abstract/IBehaviourCollector.cs

@@ -0,0 +1,42 @@
+namespace 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,85 +1,83 @@
-using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 
-using Microsoft.Xna.Framework;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace Engine.Core;
 
 /// <summary>
-/// Responsible for controlling <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
+public interface IBehaviourController : IEntity, IHasUniverseObject
 {
     /// <summary>
-    /// Callback triggered when the <see cref="Update(GameTime)"/> is called.
+    /// Event triggered when a <see cref="IBehaviour"/> is added to the <see cref="IBehaviourController"/>.
     /// </summary>
-    Action<IBehaviourController, GameTime>? OnUpdate { get; set; }
+    Event<IBehaviourController, BehaviourAddedArguments> OnBehaviourAdded { get; }
 
     /// <summary>
-    /// Callback triggered when the <see cref="OnPreDraw(GameTime)"/> is called.
+    /// Event triggered when a <see cref="IBehaviour"/> is removed from the <see cref="IBehaviourController"/>.
     /// </summary>
-    Action<IBehaviourController, GameTime>? OnPreDraw { get; set; }
-
+    Event<IBehaviourController, BehaviourRemovedArguments> OnBehaviourRemoved { get; }
 
     /// <summary>
-    /// Callback triggered when the <see cref="IBehaviourController"/> has been registered a new <see cref="IBehaviour"/>.
+    /// Amount of <see cref="IBehaviour"/> collected.
     /// </summary>
-    Action<IBehaviourController, IBehaviour>? OnBehaviourAdded { get; set; }
+    int Count { get; }
 
     /// <summary>
-    /// Callback triggered when the <see cref="IBehaviourController"/> has been removed an existing <see cref="IBehaviour"/>.
+    /// Get a <see cref="IBehaviour"/> collected by it's index.
     /// </summary>
-    Action<IBehaviourController, IBehaviour>? OnBehaviourRemoved { get; set; }
-
+    IBehaviour this[System.Index index] { get; }
 
     /// <summary>
-    /// Registers the provided <see cref="IBehaviour"/> to be controlled by the <see cref="IBehaviourController"/>. 
+    /// Adds a <see cref="IBehaviour"/> to the <see cref="IBehaviourController"/>.
     /// </summary>
-    /// <param name="behaviour">Uninitialized <see cref="IBehaviour"/> to be registered.</param>
-    /// <typeparam name="T">An implemented class of <see cref="IBehaviour"/></typeparam>
-    /// <returns>The provided <see cref="IBehaviour"/> class after initialization.</returns>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to add.</typeparam>
+    /// <param name="behaviour">The <see cref="IBehaviour"/> to add.</param>
+    /// <returns>The added <see cref="IBehaviour"/>.</returns>
     T AddBehaviour<T>(T behaviour) where T : class, IBehaviour;
 
     /// <summary>
-    /// Instantiates the provided <see cref="IBehaviour"/> type and registers it to the <see cref="IBehaviourController"/>. 
+    /// Adds a <see cref="IBehaviour"/> of the specified type to the <see cref="IBehaviourController"/>.
     /// </summary>
-    /// <param name="args">Constructor parameters for the given <see cref="IBehaviour"/> class.</param>
-    /// <typeparam name="T">An implemented class of <see cref="IBehaviour"/></typeparam>
-    /// <returns>The instantiated <see cref="IBehaviour"/> class after initialization.</returns>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to add.</typeparam>
+    /// <param name="args">Construction parameters for the <see cref="IBehaviour"/>.</param>
+    /// <returns>The added <see cref="IBehaviour"/>.</returns>
     T AddBehaviour<T>(params object?[]? args) where T : class, IBehaviour;
 
     /// <summary>
-    /// Looks up and tries to get the <see cref="IBehaviour"/> that is controlled by the <see cref="IBehaviourController"/>. 
+    /// Gets a <see cref="IBehaviour"/> of the specified type.
     /// </summary>
-    /// <param name="behaviour">If return value is <see cref="true"/> outputs the class found in the <see cref="IBehaviourController"/>. If the return value is falls, this parameter is <see cref="null"/></param>
-    /// <typeparam name="T">An implemented class or <see cref="interface"/></typeparam>
-    /// <returns> 
-    /// <see cref="true"/>, if the type of <see cref="IBehaviour"/> is present in the <see cref="IBehaviourController"/>, <see cref="false"/> if not.
-    /// </returns>
-    bool TryGetBehaviour<T>([NotNullWhen(returnValue: true)] out T? behaviour);
-
-    /// <typeparam name="T">An implemented class or <see cref="interface"/> of <see cref="IBehaviour"/></typeparam>
-    /// <returns>Returns a list of all the matching <see cref="IBehaviour"/>s found in the <see cref="IBehaviourController"/>.</returns>
-    IList<T> GetBehaviours<T>() where T : IBehaviour;
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
+    /// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, <see cref="null"/>.</returns>
+    T? GetBehaviour<T>();
 
     /// <summary>
-    /// Removes the <see cref="IBehaviour"/> found in the <see cref="IBehaviourController"/>.
+    /// Gets all <see cref="IBehaviour"/>s of the specified type.
     /// </summary>
-    /// <param name="removeAll">If all of the instances of the given Type is to be removed or not.</param>
-    /// <typeparam name="T">An implemented class or <see cref="interface"/> of <see cref="IBehaviour"/></typeparam>
-    void RemoveBehaviour<T>(bool removeAll = false) where T : IBehaviour;
-
+    /// <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>
+    IReadOnlyList<T> GetBehaviours<T>();
 
     /// <summary>
-    /// To be called in every frame of the engine. Responsible for notifying <see cref="IBehaviour"/>'s under the <see cref="IBehaviourController"/>'s control that a new frame is happening.
+    /// Gets all <see cref="IBehaviour"/>s of the specified type and stores them in the provided list.
     /// </summary>
-    /// <param name="gameTime"><see cref="GameTime"/> information from the game.</param>
-    void Update(GameTime gameTime);
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/>s to get.</typeparam>
+    /// <param name="results">The list to store the <see cref="IBehaviour"/>s.</param>
+    void GetBehaviours<T>(IList<T> results);
 
     /// <summary>
-    /// To be called before every draw call from the engine. Responsible for notifying <see cref="IBehaviour"/>'s under the <see cref="IBehaviourController"/>'s control that the engine is about to start drawing into the screen.
+    /// Removes <see cref="IBehaviour"/>s of the specified type from the <see cref="IBehaviourController"/>.
     /// </summary>
-    /// <param name="gameTime"><see cref="GameTime"/> information from the game.</param>
-    void UpdatePreDraw(GameTime gameTime);
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/>s to remove.</typeparam>
+    /// <param name="removeAll">A flag indicating whether to remove all <see cref="IBehaviour"/>s of the specified type.</param>
+    void RemoveBehaviour<T>(bool removeAll = false) where T : class, IBehaviour;
+
+    /// <summary>
+    /// Removes the specified <see cref="IBehaviour"/> from the <see cref="IBehaviourController"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="IBehaviour"/> to remove.</typeparam>
+    /// <param name="behaviour">The <see cref="IBehaviour"/> to remove.</param>
+    void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour;
+
+    readonly record struct BehaviourAddedArguments(IBehaviour BehaviourAdded);
+    readonly record struct BehaviourRemovedArguments(IBehaviour BehaviourRemoved);
 }

Engine.Core/Abstract/ICamera.cs

@@ -1,24 +0,0 @@
-using System;
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-public interface ICamera
-{
-    Action<ICamera>? OnMatrixTransformChanged { get; set; }
-    Action<ICamera>? OnViewportChanged { get; set; }
-    Action<ICamera>? OnPositionChanged { get; set; }
-    Action<ICamera>? OnRotationChanged { get; set; }
-    Action<ICamera>? OnZoomChanged { get; set; }
-
-    Matrix MatrixTransform { get; }
-    Viewport Viewport { get; set; }
-
-    Vector2 Position { get; set; }
-
-    float Rotation { get; set; }
-    float Zoom { get; set; }
-
-    void Update();
-}

Engine.Core/Abstract/ICamera2D.cs

@@ -0,0 +1,26 @@
+namespace Engine.Core;
+
+/// <summary>
+/// Represents a 2D camera in the engine.
+/// </summary>
+public interface ICamera2D : IBehaviour2D
+{
+    /// <summary>
+    /// The zoom level of the camera.
+    /// </summary>
+    float Zoom { get; set; }
+
+    /// <summary>
+    /// Converts a position from screen coordinates to world coordinates.
+    /// </summary>
+    /// <param name="screenPosition">The position in screen coordinates.</param>
+    /// <returns>The position in world coordinates.</returns>
+    Vector2D ScreenToWorldPosition(Vector2D screenPosition);
+
+    /// <summary>
+    /// Converts a position from world coordinates to screen coordinates.
+    /// </summary>
+    /// <param name="worldPosition">The position in world coordinates.</param>
+    /// <returns>The position in screen coordinates.</returns>
+    Vector2D WorldToScreenPosition(Vector2D worldPosition);
+}

Engine.Core/Abstract/ICoroutineYield.cs

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

Engine.Core/Abstract/IDisplayable.cs

@@ -1,8 +0,0 @@
-using Microsoft.Xna.Framework.Graphics;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-public interface IDisplayable
-{
-    public void Draw(SpriteBatch spriteBatch);
-}

Engine.Core/Abstract/IEntity.cs

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

Engine.Core/Abstract/IGameObject.cs

@@ -1,12 +0,0 @@
-using System;
-
-using Microsoft.Xna.Framework;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-public interface IGameObject : IEntity, IAssignableTransform, IAssignableBehaviourController, INameable, IInitialize
-{
-    Action<IGameObject, GameTime>? OnUpdated { get; set; }
-
-    void Update(GameTime time);
-}

Engine.Core/Abstract/IInitializable.cs

@@ -0,0 +1,34 @@
+namespace 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 IInitializable
+{
+    /// <summary>
+    /// Event triggered when the <see cref="Initialize"/> method is called successfully.
+    /// </summary>
+    Event<IInitializable> OnInitialized { get; }
+
+    /// <summary>
+    /// Event triggered when the <see cref="IInitializable"/> method is called successfully.
+    /// </summary>
+    Event<IInitializable> OnFinalized { get; }
+
+    /// <summary>
+    /// The value indicating whether the entity has been initialized.
+    /// </summary>
+    bool IsInitialized { get; }
+
+    /// <summary>
+    /// Initializes the entity.
+    /// </summary>
+    /// <returns><see cref="true"/> if initialization is successful, otherwise <see cref="false"/>.</returns>
+    bool Initialize();
+
+    /// <summary>
+    /// Finalizes the entity so it can either be recycled or garbage collected.
+    /// </summary>
+    /// <returns><see cref="true"/> if finalization is successful, otherwise <see cref="false"/>.</returns>
+    bool Finalize();
+}

Engine.Core/Abstract/IInitialize.cs

@@ -1,13 +0,0 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-public interface IInitialize
-{
-    Action<IInitialize>? OnInitialized { get; set; }
-    Action<IInitialize>? OnFinalized { get; set; }
-    bool Initialized { get; }
-
-    bool Initialize();
-    bool Finalize();
-}

Engine.Core/Abstract/INameable.cs

@@ -1,9 +1,19 @@
-using System;
-
-namespace Syntriax.Engine.Core.Abstract;
+namespace Engine.Core;
 
+/// <summary>
+/// Represents an entity with a name.
+/// </summary>
 public interface INameable
 {
-    Action<IEntity>? OnNameChanged { get; set; }
+    /// <summary>
+    /// Event triggered when the name of the entity changes.
+    /// </summary>
+    Event<INameable, NameChangedArguments> OnNameChanged { get; }
+
+    /// <summary>
+    /// The name of the entity.
+    /// </summary>
     string Name { get; set; }
+
+    readonly record struct NameChangedArguments(string PreviousName);
 }

Engine.Core/Abstract/ISprite.cs

@@ -1,13 +0,0 @@
-using System;
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-// TODO Probably gonna have to rethink this
-public interface ISprite
-{
-    Action<ISprite>? OnTextureChanged { get; set; }
-
-    Texture2D Texture2D { get; set; }
-}

Engine.Core/Abstract/IStateEnable.cs

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

Engine.Core/Abstract/ITransform.cs

@@ -1,17 +0,0 @@
-using System;
-
-using Microsoft.Xna.Framework;
-
-namespace Syntriax.Engine.Core.Abstract;
-
-public interface ITransform
-{
-    Action<ITransform>? OnPositionChanged { get; set; }
-    Action<ITransform>? OnScaleChanged { get; set; }
-    Action<ITransform>? OnRotationChanged { get; set; }
-
-    Vector2 Position { get; set; }
-    Vector2 Scale { get; set; }
-
-    float Rotation { get; set; }
-}

Engine.Core/Abstract/ITransform2D.cs

@@ -0,0 +1,90 @@
+namespace 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 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 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/BaseEntity.cs

@@ -0,0 +1,109 @@
+using System;
+
+namespace Engine.Core;
+
+public abstract class BaseEntity : IEntity
+{
+    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!;
+
+    private bool _initialized = false;
+    private string _id = string.Empty;
+
+    public virtual IStateEnable StateEnable => _stateEnable;
+
+    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, new(previousId));
+        }
+    }
+
+    public bool IsInitialized
+    {
+        get => _initialized;
+        private set
+        {
+            if (value == _initialized)
+                return;
+
+            _initialized = value;
+            if (value)
+                OnInitialized?.Invoke(this);
+            else
+                OnFinalized?.Invoke(this);
+        }
+    }
+
+    protected virtual void OnAssign(IStateEnable stateEnable) { }
+    public bool Assign(IStateEnable stateEnable)
+    {
+        if (IsInitialized)
+            return false;
+
+        _stateEnable = stateEnable;
+        _stateEnable.Assign(this);
+        OnAssign(stateEnable);
+        OnStateEnableAssigned?.Invoke(this);
+        return true;
+    }
+
+    protected virtual void UnassignInternal() { }
+    public bool Unassign()
+    {
+        if (IsInitialized)
+            return false;
+
+        UnassignInternal();
+
+        _stateEnable = null!;
+        _stateEnable.Unassign();
+        OnUnassigned?.Invoke(this);
+        return true;
+    }
+
+    protected virtual void InitializeInternal() { }
+    public bool Initialize()
+    {
+        if (IsInitialized)
+            return false;
+
+        _stateEnable ??= Factory.StateEnableFactory.Instantiate(this);
+
+        InitializeInternal();
+
+        IsInitialized = true;
+        return true;
+    }
+
+    protected virtual void FinalizeInternal() { }
+    public bool Finalize()
+    {
+        if (!IsInitialized)
+            return false;
+
+        FinalizeInternal();
+
+        IsInitialized = false;
+        return true;
+    }
+
+    protected BaseEntity() => _id = Guid.NewGuid().ToString("D");
+    protected BaseEntity(string id) => _id = id;
+}

Engine.Core/Behaviour.cs

@@ -1,110 +1,50 @@
-using System;
+namespace Engine.Core;
 
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-
-namespace Syntriax.Engine.Core;
-
-public abstract class Behaviour : IBehaviour
+public abstract class Behaviour : BehaviourBase
 {
-    public Action<IAssignable>? OnUnassigned { get; set; } = null;
-    public Action<IAssignableStateEnable>? OnStateEnableAssigned { get; set; } = null;
-    public Action<IAssignableBehaviourController>? OnBehaviourControllerAssigned { get; set; } = null;
+    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler delegateEnteredUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateExitedUniverse = null!;
 
-    public Action<IInitialize>? OnInitialized { get; set; } = null;
-    public Action<IInitialize>? OnFinalized { get; set; } = null;
-    public Action<IBehaviour>? OnPriorityChanged { get; set; } = null;
-
-
-    private IBehaviourController _behaviourController = null!;
-    private IStateEnable _stateEnable = null!;
-
-    private bool _initialized = false;
-    private int _priority = 0;
-
-    public IStateEnable StateEnable => _stateEnable;
-    public IBehaviourController BehaviourController => _behaviourController;
-
-    public bool Initialized
+    public Behaviour()
     {
-        get => _initialized;
-        private set
-        {
-            if (value == _initialized)
-                return;
+        OnInitialized.AddListener(OnInitialize);
+        OnFinalized.AddListener(OnFinalize);
+        OnUnassigned.AddListener(OnUnassign);
 
-            _initialized = value;
-            if (value)
-                OnInitialized?.Invoke(this);
-            else
-                OnFinalized?.Invoke(this);
-        }
+        delegateEnteredUniverse = EnteredUniverse;
+        delegateExitedUniverse = ExitedUniverse;
     }
 
-    public int Priority
-    {
-        get => _priority;
-        set
-        {
-            if (value == _priority)
-                return;
+    protected virtual void OnUnassign() { }
+    protected void OnUnassign(IAssignable assignable) => OnUnassign();
 
-            _priority = value;
-            OnPriorityChanged?.Invoke(this);
-        }
+    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));
     }
 
-    public bool Assign(IStateEnable stateEnable)
+    protected virtual void OnFinalize() { }
+    protected void OnFinalize(IInitializable _)
     {
-        if (Initialized)
-            return false;
+        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(delegateEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(delegateExitedUniverse);
 
-        _stateEnable = stateEnable;
-        _stateEnable.Assign(this);
-        OnStateEnableAssigned?.Invoke(this);
-        return true;
+        OnFinalize();
+
+        if (UniverseObject.IsInUniverse)
+            ExitedUniverse(UniverseObject, new(Universe));
     }
 
-    public bool Assign(IBehaviourController behaviourController)
-    {
-        if (Initialized)
-            return false;
+    protected virtual void OnEnteredUniverse(IUniverse universe) { }
+    protected void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => OnEnteredUniverse(args.Universe);
 
-        _behaviourController = behaviourController;
-        OnBehaviourControllerAssigned?.Invoke(this);
-        return true;
-    }
-
-    public bool Unassign()
-    {
-        if (Initialized)
-            return false;
-
-        _stateEnable = null!;
-        _behaviourController = null!;
-
-        OnUnassigned?.Invoke(this);
-        return true;
-    }
-
-    public bool Initialize()
-    {
-        if (Initialized)
-            return false;
-
-        NotAssignedException.Check(this, _behaviourController);
-        NotAssignedException.Check(this, _stateEnable);
-
-        Initialized = true;
-        return true;
-    }
-
-    public bool Finalize()
-    {
-        if (!Initialized)
-            return false;
-
-        Initialized = false;
-        return true;
-    }
+    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 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 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/BehaviourController.cs

@@ -1,128 +1,128 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 
-using Microsoft.Xna.Framework;
+namespace Engine.Core;
 
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core;
-
-public class BehaviourController : IBehaviourController
+[System.Diagnostics.DebuggerDisplay("Behaviour Count: {behaviours.Count}")]
+public class BehaviourController : BaseEntity, IBehaviourController
 {
-    public Action<IBehaviourController, GameTime>? OnUpdate { get; set; } = null;
-    public Action<IBehaviourController, GameTime>? OnPreDraw { get; set; } = null;
+    public Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments> OnBehaviourAdded { get; } = new();
+    public Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments> OnBehaviourRemoved { get; } = new();
+    public Event<IHasUniverseObject> OnUniverseObjectAssigned { get; } = new();
 
-    public Action<IBehaviourController, IBehaviour>? OnBehaviourAdded { get; set; } = null;
-    public Action<IBehaviourController, IBehaviour>? OnBehaviourRemoved { get; set; } = null;
-    public Action<IAssignable>? OnUnassigned { get; set; } = null;
-    public Action<IAssignableGameObject>? OnGameObjectAssigned { get; set; } = null;
+    private readonly FastList<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));
-
-    public bool TryGetBehaviour<T>([NotNullWhen(returnValue: true)] out T? behaviour)
     {
-        foreach (var behaviourItem in behaviours)
-        {
-            if (behaviourItem is not T result)
-                continue;
-
-            behaviour = result;
-            return true;
-        }
-
-        behaviour = default;
-        return false;
+        T behaviour = Factory.BehaviourFactory.Instantiate<T>(args);
+        return AddBehaviour(behaviour);
     }
 
-    public IList<T> GetBehaviours<T>() where T : IBehaviour
+    public T? GetBehaviour<T>()
     {
-        IList<T> behaviours = new List<T>();
-        foreach (var behaviourItem in this.behaviours)
-        {
-            if (behaviourItem is not T behaviour)
-                continue;
+        foreach (IBehaviour behaviourItem in behaviours)
+            if (behaviourItem is T result)
+                return result;
 
-            behaviours ??= new List<T>();
-            behaviours.Add(behaviour);
-        }
+        return default;
+    }
+
+    public IReadOnlyList<T> GetBehaviours<T>()
+    {
+        List<T> behaviours = [];
+
+        foreach (IBehaviour behaviourItem in this.behaviours)
+            if (behaviourItem is T behaviour)
+                behaviours.Add(behaviour);
 
         return behaviours;
     }
 
-    public void RemoveBehaviour<T>(bool removeAll = false) where T : IBehaviour
+    public void GetBehaviours<T>(IList<T> results)
     {
-        for (int i = behaviours.Count; i >= 0; i--)
+        results.Clear();
+        foreach (IBehaviour behaviourItem in behaviours)
+        {
+            if (behaviourItem is not T behaviour)
+                continue;
+
+            results.Add(behaviour);
+        }
+    }
+
+    public void RemoveBehaviour<T>(bool removeAll = false) where T : class, IBehaviour
+    {
+        for (int i = behaviours.Count - 1; i >= 0; i--)
         {
             if (behaviours[i] is not T behaviour)
                 continue;
 
-            behaviour.OnPriorityChanged -= OnPriorityChange;
-            behaviour.Finalize();
-            behaviours.RemoveAt(i);
-            OnBehaviourRemoved?.Invoke(this, behaviour);
+            RemoveBehaviour(behaviour);
 
             if (!removeAll)
                 return;
         }
     }
 
-    public bool Assign(IGameObject gameObject)
+    public void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour
     {
-        if (GameObject is not null && GameObject.Initialized)
+        if (!behaviours.Contains(behaviour))
+            throw new Exception($"{behaviour.GetType().Name} does not exist in {UniverseObject.Name}'s {nameof(IBehaviourController)}.");
+
+        behaviour.OnPriorityChanged.RemoveListener(OnPriorityChange);
+        behaviour.Finalize();
+        behaviours.Remove(behaviour);
+        OnBehaviourRemoved?.Invoke(this, new(behaviour));
+    }
+
+    protected virtual void OnAssign(IUniverseObject universeObject) { }
+    public bool Assign(IUniverseObject universeObject)
+    {
+        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(GameTime gameTime)
+    protected override void FinalizeInternal()
     {
-        if (!GameObject.StateEnable.Enabled)
-            return;
-
-        OnUpdate?.Invoke(this, gameTime);
-    }
-    public void UpdatePreDraw(GameTime gameTime)
-    {
-        if (!GameObject.StateEnable.Enabled)
-            return;
-
-        OnPreDraw?.Invoke(this, gameTime);
+        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
     {
@@ -141,9 +141,9 @@ public class BehaviourController : IBehaviourController
             behaviours.Add(behaviour);
     }
 
-    private void OnPriorityChange(IBehaviour behaviour)
+    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
     {
-        behaviours.Remove(behaviour);
-        InsertBehaviourByPriority(behaviour);
+        behaviours.Remove(sender);
+        InsertBehaviourByPriority(sender);
     }
 }

Engine.Core/BehaviourOverride.cs

@@ -1,62 +0,0 @@
-using System;
-using Microsoft.Xna.Framework;
-
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core;
-
-public abstract class BehaviourOverride : Behaviour
-{
-    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 _)
-    {
-        BehaviourController.OnPreDraw += PreDraw;
-        BehaviourController.OnUpdate += Update;
-        OnInitialize();
-    }
-
-    protected virtual void OnFinalize() { }
-    private void OnFinalize(IInitialize _)
-    {
-        BehaviourController.OnPreDraw -= PreDraw;
-        BehaviourController.OnUpdate -= Update;
-        OnFinalize();
-    }
-
-    protected virtual void OnUpdatePreEnabledCheck(GameTime time) { }
-    protected virtual void OnUpdate(GameTime time) { }
-    private void Update(IBehaviourController _, GameTime time)
-    {
-        OnUpdatePreEnabledCheck(time);
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnUpdate(time);
-    }
-
-    protected virtual void OnPreDrawPreEnabledCheck(GameTime time) { }
-    protected virtual void OnPreDraw(GameTime time) { }
-    private void PreDraw(IBehaviourController _, GameTime time)
-    {
-        OnPreDrawPreEnabledCheck(time);
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPreDraw(time);
-    }
-}

Engine.Core/CameraBehaviour.cs

@@ -1,98 +0,0 @@
-using System;
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-using Syntriax.Engine.Core.Abstract;
-
-namespace Syntriax.Engine.Core;
-
-public class CameraBehaviour : BehaviourOverride, ICamera
-{
-    public Action<ICamera>? OnPositionChanged { get; set; } = null;
-    public Action<ICamera>? OnMatrixTransformChanged { get; set; } = null;
-    public Action<ICamera>? OnViewportChanged { get; set; } = null;
-    public Action<ICamera>? OnRotationChanged { get; set; } = null;
-    public Action<ICamera>? OnZoomChanged { get; set; } = null;
-
-    private Matrix _matrixTransform = Matrix.Identity;
-
-    private Viewport _viewport = default;
-
-    private float _zoom = 1f;
-
-    public Matrix MatrixTransform
-    {
-        get => _matrixTransform;
-        set
-        {
-            if (_matrixTransform == value)
-                return;
-
-            _matrixTransform = value;
-            OnMatrixTransformChanged?.Invoke(this);
-        }
-    }
-
-    public Vector2 Position
-    {
-        get => Transform.Position;
-        set => Transform.Position = value;
-    }
-
-    public Viewport Viewport
-    {
-        get => _viewport;
-        set
-        {
-            if (_viewport.Equals(value))
-                return;
-
-            _viewport = value;
-            OnViewportChanged?.Invoke(this);
-        }
-    }
-
-    public float Zoom
-    {
-        get => _zoom;
-        set
-        {
-            float newValue = value >= .1f ? value : .1f;
-
-            if (_zoom == newValue)
-                return;
-
-            _zoom = newValue;
-            OnZoomChanged?.Invoke(this);
-        }
-    }
-
-    public float Rotation
-    {
-        get => Transform.Rotation;
-        set => Transform.Rotation = value;
-    }
-
-    public void Update()
-    {
-        MatrixTransform =
-            Matrix.CreateTranslation(new Vector3(-Position.X, Position.Y, 0f)) *
-            Matrix.CreateRotationZ(Rotation) *
-            Matrix.CreateScale(Zoom) *
-            Matrix.CreateTranslation(new Vector3(_viewport.Width * .5f, _viewport.Height * .5f, 0f));
-    }
-
-    protected override void OnInitialize()
-    {
-        Transform.OnRotationChanged += OnTransformRotationChanged;
-        Transform.OnPositionChanged += OnTransformPositionChanged;
-    }
-
-    protected override void OnFinalize()
-    {
-        Transform.OnRotationChanged -= OnTransformRotationChanged;
-        Transform.OnPositionChanged -= OnTransformPositionChanged;
-    }
-
-    private void OnTransformRotationChanged(ITransform _) => OnRotationChanged?.Invoke(this);
-    private void OnTransformPositionChanged(ITransform _) => OnPositionChanged?.Invoke(this);
-}

Engine.Core/Collectors/ActiveBehaviourCollector.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace Engine.Core;
+
+public class ActiveBehaviourCollector<T> : ActiveBehaviourCollectorBase<T> where T : class, IBehaviour
+{
+    protected readonly FastList<T> activeBehaviours = new(32);
+    public override T this[Index index] => activeBehaviours[index];
+    public override int Count => activeBehaviours.Count;
+
+    public ActiveBehaviourCollector() { }
+    public ActiveBehaviourCollector(IUniverse universe) : base(universe) { }
+
+    protected override void AddBehaviour(T behaviour) => activeBehaviours.Add(behaviour);
+    protected override bool RemoveBehaviour(T tBehaviour) => activeBehaviours.Remove(tBehaviour);
+}

Engine.Core/Collectors/ActiveBehaviourCollectorBase.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+
+namespace Engine.Core;
+
+public abstract class ActiveBehaviourCollectorBase<T> : IBehaviourCollector<T> where T : class, IBehaviour
+{
+    protected readonly Dictionary<IActive, T> monitoringActiveToBehaviour = new(32);
+    protected readonly FastList<T> monitoringBehaviours = new(32);
+
+    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!;
+
+    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 abstract int Count { get; }
+
+    public abstract T this[Index index] { get; }
+    public IUniverse Universe { get; private set; } = null!;
+
+    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;
+    }
+
+    protected abstract void AddBehaviour(T behaviour);
+    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 abstract bool RemoveBehaviour(T 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 (!RemoveBehaviour(tBehaviour))
+            return;
+
+        OnBehaviourRemove(tBehaviour);
+        OnRemoved?.Invoke(this, new(tBehaviour));
+    }
+    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 (RemoveBehaviour(behaviour))
+        {
+            OnBehaviourRemove(behaviour);
+            OnRemoved?.Invoke(this, new(behaviour));
+        }
+    }
+
+    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]));
+    }
+
+    public ActiveBehaviourCollectorBase()
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
+
+    public ActiveBehaviourCollectorBase(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
+    }
+}

Engine.Core/Collectors/ActiveBehaviourCollectorOrdered.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+
+namespace Engine.Core;
+
+public class ActiveBehaviourCollectorOrdered<TIndex, TItem> : ActiveBehaviourCollector<TItem> where TItem : class, IBehaviour where TIndex : IComparable
+{
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
+
+    private readonly SortedDictionary<TIndex, FastList<TItem>> behaviours = null!;
+
+    private readonly Func<TItem, TIndex> getIndexFunc = null!;
+    private readonly IComparer<TIndex> sortBy = null!;
+
+    private int count = 0;
+    public override int Count => count;
+
+    public override TItem this[Index index]
+    {
+        get
+        {
+            int actualIndex = index.IsFromEnd
+                ? count - index.Value
+                : index.Value;
+
+            if (actualIndex < 0 || actualIndex >= count)
+                throw new IndexOutOfRangeException();
+
+            int leftIndex = actualIndex;
+            foreach ((TIndex i, FastList<TItem> list) in behaviours)
+            {
+                if (leftIndex < list.Count)
+                    return list[leftIndex];
+                leftIndex -= list.Count;
+            }
+            throw new IndexOutOfRangeException();
+        }
+    }
+
+    protected override bool RemoveBehaviour(TItem tBehaviour)
+    {
+        TIndex index = getIndexFunc(tBehaviour);
+        if (!behaviours.TryGetValue(index, out FastList<TItem>? list))
+            throw new Exceptions.NotFoundException($"Index of '{index}' is not found in the collector");
+
+        if (!list.Remove(tBehaviour))
+            return false;
+
+        count--;
+        return true;
+    }
+
+    protected override void AddBehaviour(TItem behaviour)
+    {
+        TIndex key = getIndexFunc(behaviour);
+        if (!behaviours.TryGetValue(key, out FastList<TItem>? list))
+            behaviours[key] = list = [];
+
+        count++;
+        list.Add(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)
+    {
+        TItem behaviour = (TItem)sender;
+        RemoveBehaviour(behaviour);
+        AddBehaviour(behaviour);
+    }
+
+    public ActiveBehaviourCollectorOrdered(Func<TItem, TIndex> getIndexFunc, Comparison<TIndex> sortBy)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.getIndexFunc = getIndexFunc;
+        this.sortBy = Comparer<TIndex>.Create(sortBy);
+        behaviours = new(this.sortBy);
+    }
+
+    public ActiveBehaviourCollectorOrdered(IUniverse universe, Func<TItem, TIndex> getIndexFunc, Comparison<TIndex> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.getIndexFunc = getIndexFunc;
+        this.sortBy = Comparer<TIndex>.Create(sortBy);
+        behaviours = new(this.sortBy);
+    }
+
+    public ActiveBehaviourCollectorOrdered(Func<TItem, TIndex> getIndexFunc, IComparer<TIndex> sortBy)
+    {
+        this.getIndexFunc = getIndexFunc;
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.sortBy = sortBy;
+        behaviours = new(sortBy);
+    }
+
+    public ActiveBehaviourCollectorOrdered(IUniverse universe, Func<TItem, TIndex> getIndexFunc, IComparer<TIndex> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.getIndexFunc = getIndexFunc;
+        this.sortBy = sortBy;
+        behaviours = new(sortBy);
+    }
+}

Engine.Core/Collectors/BehaviourCollector.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Engine.Core;
+
+public class BehaviourCollector<T> : BehaviourCollectorBase<T> where T : class
+{
+    protected readonly FastList<T> behaviours = new(32);
+
+    public override T this[Index index] => behaviours[index];
+    public override int Count => behaviours.Count;
+
+    protected override void AddBehaviour(T behaviour) => behaviours.Add(behaviour);
+    protected override bool RemoveBehaviour(T tBehaviour) => behaviours.Remove(tBehaviour);
+
+    public BehaviourCollector() { }
+    public BehaviourCollector(IUniverse universe) : base(universe) { }
+}

Engine.Core/Collectors/BehaviourCollectorBase.cs

@@ -0,0 +1,124 @@
+using System;
+
+namespace Engine.Core;
+
+public abstract class BehaviourCollectorBase<T> : IBehaviourCollector<T> where T : class
+{
+    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!;
+
+    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 IUniverse Universe { get; private set; } = null!;
+
+    public abstract int Count { get; }
+
+    public abstract T this[Index index] { get; }
+
+    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.OnPreUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
+
+        Universe = universe;
+        OnAssign(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.OnPreUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
+
+        Universe = null!;
+        OnUnassigned?.Invoke(this);
+        return true;
+    }
+
+    protected virtual void OnAssign(IUniverse universe) { }
+
+    protected abstract void AddBehaviour(T behaviour);
+    protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
+    {
+        if (args.BehaviourAdded is not T tBehaviour)
+            return;
+
+        AddBehaviour(tBehaviour);
+        OnBehaviourAdd(args.BehaviourAdded);
+        OnCollected?.Invoke(this, new(tBehaviour));
+    }
+
+    protected abstract bool RemoveBehaviour(T tBehaviour);
+    protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
+    {
+        if (args.BehaviourRemoved is not T tBehaviour)
+            return;
+
+        if (!RemoveBehaviour(tBehaviour))
+            return;
+
+        OnBehaviourRemove(args.BehaviourRemoved);
+        OnRemoved?.Invoke(this, new(tBehaviour));
+    }
+
+    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]));
+    }
+
+    public BehaviourCollectorBase()
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
+
+    public BehaviourCollectorBase(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
+    }
+}

Engine.Core/Collectors/BehaviourCollectorOrdered.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+
+namespace Engine.Core;
+
+public class BehaviourCollectorOrdered<TIndex, TItem> : BehaviourCollectorBase<TItem> where TItem : class where TIndex : IComparable
+{
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
+
+    private readonly SortedDictionary<TIndex, FastList<TItem>> behaviours = null!;
+
+    private readonly Func<TItem, TIndex> getIndexFunc = null!;
+    private readonly IComparer<TIndex> sortBy = null!;
+
+    private int count = 0;
+    public override int Count => count;
+
+    public override TItem this[Index index]
+    {
+        get
+        {
+            int actualIndex = index.IsFromEnd
+                ? count - index.Value
+                : index.Value;
+
+            if (actualIndex < 0 || actualIndex >= count)
+                throw new IndexOutOfRangeException();
+
+            int leftIndex = actualIndex;
+            foreach ((TIndex i, FastList<TItem> list) in behaviours)
+            {
+                if (leftIndex < list.Count)
+                    return list[leftIndex];
+                leftIndex -= list.Count;
+            }
+            throw new IndexOutOfRangeException();
+        }
+    }
+
+    protected override bool RemoveBehaviour(TItem tBehaviour)
+    {
+        TIndex index = getIndexFunc(tBehaviour);
+        if (!behaviours.TryGetValue(index, out FastList<TItem>? list))
+            throw new Exceptions.NotFoundException($"Index of '{index}' is not found in the collector");
+
+        if (!list.Remove(tBehaviour))
+            return false;
+
+        count--;
+        return true;
+    }
+
+    protected override void AddBehaviour(TItem behaviour)
+    {
+        TIndex key = getIndexFunc(behaviour);
+        if (!behaviours.TryGetValue(key, out FastList<TItem>? list))
+            behaviours[key] = list = [];
+
+        count++;
+        list.Add(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)
+    {
+        TItem behaviour = (TItem)sender;
+        RemoveBehaviour(behaviour);
+        AddBehaviour(behaviour);
+    }
+
+    public BehaviourCollectorOrdered(Func<TItem, TIndex> getIndexFunc, Comparison<TIndex> sortBy)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.getIndexFunc = getIndexFunc;
+        this.sortBy = Comparer<TIndex>.Create(sortBy);
+        behaviours = new(this.sortBy);
+    }
+
+    public BehaviourCollectorOrdered(IUniverse universe, Func<TItem, TIndex> getIndexFunc, Comparison<TIndex> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.getIndexFunc = getIndexFunc;
+        this.sortBy = Comparer<TIndex>.Create(sortBy);
+        behaviours = new(this.sortBy);
+    }
+
+    public BehaviourCollectorOrdered(Func<TItem, TIndex> getIndexFunc, IComparer<TIndex> sortBy)
+    {
+        this.getIndexFunc = getIndexFunc;
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.sortBy = sortBy;
+        behaviours = new(sortBy);
+    }
+
+    public BehaviourCollectorOrdered(IUniverse universe, Func<TItem, TIndex> getIndexFunc, IComparer<TIndex> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+        this.getIndexFunc = getIndexFunc;
+        this.sortBy = sortBy;
+        behaviours = new(sortBy);
+    }
+}

Engine.Core/CoroutineManager.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace 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 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 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 Engine.Core.Debug;
+
+public class ConsoleLogger : LoggerBase
+{
+    protected override void Write(string message) => Console.WriteLine(message);
+}

Engine.Core/Debug/FileLogger.cs

@@ -0,0 +1,32 @@
+using System;
+using System.IO;
+
+namespace 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)
+    {
+        if (!filePath.EndsWith(".log"))
+            filePath += ".log";
+
+        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 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 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 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 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 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 Engine.Core.Debug;
+
+public static class LoggerWrapperExtensions
+{
+    public static ILogger WrapWith(this ILogger thisLogger, ILogger logger) => new LoggerWrapper(thisLogger, logger);
+}

Engine.Core/Debug/RotatingFileLogger.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace Engine.Core.Debug;
+
+public class RotatingFileLogger : ILogger
+{
+    public readonly FileLogger FileLogger = null!;
+    public readonly string Directory = string.Empty;
+    public readonly int RotateLength = 3;
+
+    public RotatingFileLogger(string directory, string namePrefix, string nameSuffix = "", int rotateLength = 3)
+    {
+        RotateLength = rotateLength;
+
+        string fileName = Path.Combine(directory, namePrefix);
+        if (!string.IsNullOrWhiteSpace(nameSuffix))
+            fileName += $"_{nameSuffix}";
+
+        bool isRelativePath = Path.GetFullPath(fileName).CompareTo(fileName) != 0;
+
+        if (isRelativePath)
+            fileName = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName));
+
+        if (File.Exists($"{fileName}.log"))
+            RenameExistingLogs(fileName, RotateLength);
+
+        FileLogger = new(fileName);
+
+        Directory = Path.GetDirectoryName(fileName) ?? throw new("Unexpected error on getting directory of logger path");
+        RotateLastLogs(Directory, namePrefix, RotateLength);
+    }
+
+    private static void RenameExistingLogs(string filePath, int rotateLength)
+    {
+        for (int i = rotateLength - 1; i >= 0; i--)
+        {
+            string source = i == 0
+                ? $"{filePath}.log"
+                : $"{filePath}_{i}.log";
+
+            string dest = $"{filePath}_{i + 1}.log";
+
+            if (!File.Exists(source))
+                continue;
+
+            if (File.Exists(dest))
+                File.Delete(dest);
+
+            File.Move(source, dest);
+        }
+    }
+
+    private static void RotateLastLogs(string directory, string prefix, int rotateLength)
+    {
+        IOrderedEnumerable<string> logs = System.IO.Directory.GetFiles(directory, $"{prefix}*.log")
+            .OrderBy(File.GetCreationTime);
+
+        foreach (string file in logs.Skip(rotateLength))
+            try
+            {
+                ILogger.Shared.Log($"Removing log file located at \"{file}\" during rotation.");
+                File.Delete(file);
+            }
+            catch (Exception e) { ILogger.Shared.LogException($"Failed to rotate log file at \"{file}\"", e); }
+    }
+
+    public ILogger.Level FilterLevel { get => FileLogger.FilterLevel; set => FileLogger.FilterLevel = value; }
+    public void Log(string message, ILogger.Level level = ILogger.Level.Info, bool force = false) => FileLogger.Log(message, level, force);
+}

Engine.Core/Engine.Core.csproj

@@ -1,12 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>false</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <RootNamespace>Engine.Core</RootNamespace>
+    <AssemblyName>Engine.Core</AssemblyName>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.1.303" />
-  </ItemGroup>
 </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/Engine.Core.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.5.002.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Engine.Core", "Engine.Core.csproj", "{6C1AF4B1-60B0-4225-9A96-F597BC04E9D0}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{6C1AF4B1-60B0-4225-9A96-F597BC04E9D0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6C1AF4B1-60B0-4225-9A96-F597BC04E9D0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6C1AF4B1-60B0-4225-9A96-F597BC04E9D0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6C1AF4B1-60B0-4225-9A96-F597BC04E9D0}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {CC449885-B99C-4C71-842D-3C19A35E786F}
-	EndGlobalSection
-EndGlobal

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 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 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;
+namespace 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 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 Engine.Core.Exceptions;
+
+public class UniverseObjectNotFoundException(string? message) : NotFoundException(message);

Engine.Core/Extensions/BehaviourControllerExtensions.cs

@@ -0,0 +1,182 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+using Engine.Core.Exceptions;
+
+namespace 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 (controller.GetBehaviour<T>() is T behaviour)
+                return behaviour;
+
+            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 (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/EnumExtensions.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace 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/FloatExtensions.cs

@@ -0,0 +1,22 @@
+namespace Engine.Core;
+
+public static class FloatExtensions
+{
+    public static bool ApproximatelyEquals(this float a, float b)
+        => ApproximatelyEquals(a, b, float.Epsilon);
+    public static bool ApproximatelyEquals(this float a, float b, float epsilon)
+    {
+        if (a == b)
+            return true;
+
+        const float floatNormal = (1 << 23) * float.Epsilon;
+        float absA = Math.Abs(a);
+        float absB = Math.Abs(b);
+        float diff = Math.Abs(a - b);
+
+        if (a == 0.0f || b == 0.0f || diff < floatNormal)
+            return diff < (epsilon * floatNormal);
+
+        return diff / Math.Min(absA + absB, float.MaxValue) < epsilon;
+    }
+}

Engine.Core/Extensions/TransformExtensions.cs

@@ -0,0 +1,17 @@
+namespace Engine.Core;
+
+public static class TransformExtensions
+{
+    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)
+    {
+        if (position.HasValue) transform.Position = position.Value;
+        if (rotation.HasValue) transform.Rotation = rotation.Value;
+        if (scale.HasValue) transform.Scale = scale.Value;
+        if (localPosition.HasValue) transform.LocalPosition = localPosition.Value;
+        if (localRotation.HasValue) transform.LocalRotation = localRotation.Value;
+        if (localScale.HasValue) transform.LocalScale = localScale.Value;
+        return transform;
+    }
+}

Engine.Core/Extensions/UniverseExtensions.cs

@@ -0,0 +1,36 @@
+using Engine.Core.Exceptions;
+
+namespace 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 Engine.Core.Exceptions;
+
+namespace 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/Factory/Abstract/IFactory.cs

@@ -1,4 +1,4 @@
-namespace Syntriax.Engine.Core.Factory.Abstract;
+namespace Engine.Core.Factory.Abstract;
 
 public interface IFactory<TInterface> where TInterface : class
 {

Engine.Core/Factory/BehaviourControllerFactory.cs

@@ -1,20 +1,33 @@
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
+using Engine.Core.Exceptions;
 
-namespace Syntriax.Engine.Core.Factory;
+namespace 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;
+using Engine.Core.Exceptions;
 
-namespace Syntriax.Engine.Core.Factory;
+namespace 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/FactoryBase.cs

@@ -1,7 +1,7 @@
 using System;
-using Syntriax.Engine.Core.Factory.Abstract;
+using Engine.Core.Factory.Abstract;
 
-namespace Syntriax.Engine.Core.Factory;
+namespace Engine.Core.Factory;
 
 public abstract class FactoryBase<TInterface> : IFactory<TInterface>
     where TInterface : class

Engine.Core/Factory/GameObjectFactory.cs

@@ -1,39 +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 (!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;
+using Engine.Core.Exceptions;
 
-namespace Syntriax.Engine.Core.Factory;
+namespace 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;
+namespace 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;
+namespace 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 Engine.Core.Exceptions;
+
+namespace 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,205 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-using Syntriax.Engine.Core.Factory;
-
-namespace Syntriax.Engine.Core;
-
-public class GameManager : IEntity
-{
-    public Action<GameManager>? OnCameraChanged { get; set; } = null;
-    public Action<IInitialize>? OnInitialized { get; set; } = null;
-    public Action<IInitialize>? OnFinalized { get; set; } = null;
-    public Action<IAssignable>? OnUnassigned { get; set; } = null;
-    public Action<IAssignableStateEnable>? OnStateEnableAssigned { get; set; } = null;
-
-
-    private IList<IGameObject> _gameObjects = new List<IGameObject>(Constants.GAME_OBJECTS_SIZE_INITIAL);
-    private IList<IDisplayable> _drawables = new List<IDisplayable>(Constants.DRAWABLE_OBJECTS_SIZE_INITIAL);
-
-    private IStateEnable _stateEnable = null!;
-    private GameObjectFactory _gameObjectFactory = null!;
-    private bool _initialized = false;
-    private ICamera _camera = null!;
-
-    private GameObjectFactory GameObjectFactory
-    {
-        get
-        {
-            if (_gameObjectFactory is null)
-                _gameObjectFactory = new GameObjectFactory();
-            return _gameObjectFactory;
-        }
-    }
-
-    public bool Initialized => _initialized;
-    public IList<IGameObject> GameObjects => _gameObjects;
-    public IStateEnable StateEnable
-    {
-        get
-        {
-            if (_stateEnable is null)
-            {
-                Assign(new StateEnableFactory().Instantiate(this));
-                if (_stateEnable is null)
-                    throw NotAssignedException.From(this, _stateEnable);
-            }
-
-            return _stateEnable;
-        }
-    }
-
-    public ICamera Camera
-    {
-        get => _camera;
-        set
-        {
-            if (_camera == value)
-                return;
-
-            _camera = value;
-            OnCameraChanged?.Invoke(this);
-        }
-    }
-
-    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;
-    }
-
-    public bool Initialize()
-    {
-        if (Initialized)
-            return false;
-
-        NotAssignedException.Check(this, StateEnable);
-
-        foreach (var gameObject in GameObjects)
-            gameObject.Initialize();
-
-        OnInitialized?.Invoke(this);
-        return true;
-    }
-
-    public bool Finalize()
-    {
-        if (!Initialized)
-            return false;
-
-        for (int i = GameObjects.Count; i >= 0; i--)
-            GameObjects[i].Finalize();
-
-        OnFinalized?.Invoke(this);
-        return true;
-    }
-
-    public bool Assign(IStateEnable stateEnable)
-    {
-        if (Initialized)
-            return false;
-
-        _stateEnable = stateEnable;
-        OnStateEnableAssigned?.Invoke(this);
-        return true;
-    }
-
-    public bool Unassign()
-    {
-        if (Initialized)
-            return false;
-
-        _stateEnable = null!;
-        OnUnassigned?.Invoke(this);
-        return true;
-    }
-
-    public void Update(GameTime time)
-    {
-        foreach (var gameObject in GameObjects)
-            gameObject.BehaviourController.Update(time);
-    }
-
-    public void PreDraw(GameTime time)
-    {
-        foreach (var gameObject in GameObjects)
-            gameObject.BehaviourController.UpdatePreDraw(time);
-    }
-
-    public void Draw(SpriteBatch spriteBatch)
-    {
-        spriteBatch.Begin(SpriteSortMode.Deferred, transformMatrix: Camera.MatrixTransform);
-
-        foreach (var drawable in _drawables)
-            drawable.Draw(spriteBatch);
-
-        spriteBatch.End();
-    }
-
-    /////////////////////////////////////////////////////////////////
-
-    private void Unregister(IGameObject gameObject)
-    {
-        gameObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdd;
-        gameObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemove;
-        gameObject.OnFinalized -= OnGameObjectFinalize;
-
-        if (gameObject.BehaviourController.TryGetBehaviour<IDisplayable>(out var drawable))
-            _drawables.Remove(drawable);
-
-        _gameObjects.Remove(gameObject);
-    }
-
-    private void Register(IGameObject gameObject)
-    {
-        gameObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdd;
-        gameObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemove;
-        gameObject.OnFinalized += OnGameObjectFinalize;
-
-        if (gameObject.BehaviourController.TryGetBehaviour<IDisplayable>(out var drawable))
-            _drawables.Add(drawable);
-
-        _gameObjects.Add(gameObject);
-    }
-
-    private void OnGameObjectFinalize(IInitialize initialize)
-    {
-        if (initialize is IGameObject gameObject)
-            Unregister(gameObject);
-    }
-
-    private void OnBehaviourAdd(IBehaviourController controller, IBehaviour behaviour)
-    {
-        if (behaviour is IDisplayable drawable)
-            _drawables.Add(drawable);
-    }
-
-    private void OnBehaviourRemove(IBehaviourController controller, IBehaviour behaviour)
-    {
-        if (behaviour is IDisplayable drawable)
-            _drawables.Remove(drawable);
-    }
-}

Engine.Core/GameObject.cs

@@ -1,151 +0,0 @@
-using System;
-
-using Microsoft.Xna.Framework;
-
-using Syntriax.Engine.Core.Abstract;
-using Syntriax.Engine.Core.Exceptions;
-
-namespace Syntriax.Engine.Core;
-
-public class GameObject : IGameObject
-{
-    public Action<IAssignableStateEnable>? OnStateEnableAssigned { get; set; } = null;
-    public Action<IAssignableTransform>? OnTransformAssigned { get; set; } = null;
-    public Action<IAssignable>? OnUnassigned { get; set; } = null;
-    public Action<IAssignableBehaviourController>? OnBehaviourControllerAssigned { get; set; } = null;
-
-    public Action<IEntity>? OnNameChanged { get; set; } = null;
-
-    public Action<IInitialize>? OnInitialized { get; set; } = null;
-    public Action<IInitialize>? OnFinalized { get; set; } = null;
-
-    public Action<IGameObject, GameTime>? OnUpdated { get; set; } = null;
-
-
-    private ITransform _transform = null!;
-    private IBehaviourController _behaviourController = null!;
-    private IStateEnable _stateEnable = null!;
-
-    private string _name = nameof(GameObject);
-    private bool _initialized = false;
-
-    public ITransform Transform => _transform;
-    public IBehaviourController BehaviourController => _behaviourController;
-    public IStateEnable StateEnable => _stateEnable;
-
-    public bool Initialized
-    {
-        get => _initialized;
-        private set
-        {
-            if (value == _initialized)
-                return;
-
-            _initialized = value;
-            if (value)
-                OnInitialized?.Invoke(this);
-            else
-                OnFinalized?.Invoke(this);
-        }
-    }
-
-    public string Name
-    {
-        get => _name;
-        set
-        {
-            if (value == _name) return;
-
-            _name = value;
-            OnNameChanged?.Invoke(this);
-        }
-    }
-
-    public bool Initialize()
-    {
-        if (Initialized)
-            return false;
-
-        NotAssignedException.Check(this, _transform);
-        NotAssignedException.Check(this, _behaviourController);
-        NotAssignedException.Check(this, _stateEnable);
-
-        Initialized = true;
-        return true;
-    }
-
-    public void Update(GameTime time)
-    {
-        if (!_stateEnable.Enabled)
-            return;
-
-        OnUpdated?.Invoke(this, time);
-    }
-
-    public bool Finalize()
-    {
-        if (!Initialized)
-            return false;
-
-
-        System.Threading.Tasks.Parallel.ForEach(
-            _behaviourController.GetBehaviours<IBehaviour>(),
-            behaviour => behaviour.Finalize()
-        );
-
-        Initialized = false;
-        return true;
-    }
-
-    public bool Assign(IStateEnable stateEnable)
-    {
-        if (Initialized)
-            return false;
-
-        _stateEnable = stateEnable;
-        OnStateEnableAssigned?.Invoke(this);
-        return true;
-    }
-
-    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 Unassign()
-    {
-        if (Initialized)
-            return false;
-
-        _stateEnable = null!;
-        _transform = null!;
-        _behaviourController = null!;
-
-        OnUnassigned?.Invoke(this);
-        return true;
-    }
-
-    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,506 @@
+using System;
+using System.Collections.Generic;
+
+using Engine.Core.Debug;
+
+namespace Engine.Core;
+
+// TODO!: every reverse loop has a chance to have more than 1 unsubscription,
+// for (int i = listeners.Count - 1; i >= 0; i--) 
+// can be replaced with 
+// for (int i = listeners.Count - 1; i >= 0; i = Math.Min(i - 1, listeners.Count - 1))
+// but this would causes possible double calls on already called callbacks, find a better method.
+
+/// <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/FastList.cs

@@ -0,0 +1,78 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Engine.Core;
+
+public class FastList<T> : IList<T>, IReadOnlyList<T>, IEnumerable<T> where T : notnull
+{
+    private readonly List<T> items = [];
+    private readonly Dictionary<T, int> indexMap = [];
+
+    public int Count => items.Count;
+
+    public bool IsReadOnly { get; set; } = false;
+    public T this[int index] { get => items[index]; set => items[index] = value; }
+
+    public void Add(T item)
+    {
+        indexMap[item] = items.Count;
+        items.Add(item);
+    }
+
+    public void RemoveAt(int i) => Remove(items[i], i);
+    public bool Remove(T item)
+    {
+        if (!indexMap.TryGetValue(item, out int index))
+            return false;
+
+        Remove(item, index);
+
+        return true;
+    }
+
+    private void Remove(T item, int index)
+    {
+        int lastIndex = items.Count - 1;
+        T lastItem = items[lastIndex];
+
+        items[index] = lastItem;
+        indexMap[lastItem] = index;
+
+        items.RemoveAt(lastIndex);
+        indexMap.Remove(item);
+    }
+
+    public void Insert(int index, T item)
+    {
+        items.Insert(index, item);
+
+        for (int i = index; i < items.Count; i++)
+            indexMap[items[i]] = i;
+    }
+
+    public void Clear()
+    {
+        items.Clear();
+        indexMap.Clear();
+    }
+
+    public bool Contains(T item) => indexMap.ContainsKey(item);
+
+    public int BinarySearch(T item, IComparer<T>? comparer = null) => items.BinarySearch(item, comparer);
+    public void Sort(IComparer<T> comparer)
+    {
+        items.Sort(comparer);
+
+        for (int i = 0; i < items.Count; i++)
+            indexMap[items[i]] = i;
+    }
+
+    public int IndexOf(T item) => items.IndexOf(item);
+    public void CopyTo(T[] array, int arrayIndex) => items.CopyTo(array, arrayIndex);
+
+    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public FastList() { }
+    public FastList(int count) { items.Capacity = count; }
+}

Engine.Core/Helpers/IPool.cs

@@ -0,0 +1,10 @@
+namespace 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 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,41 @@
+using System;
+using System.Collections.Generic;
+
+namespace 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();
+    private readonly HashSet<T> queuedHashes = [];
+
+    public T Get()
+    {
+        if (!queue.TryDequeue(out T? result))
+            result = generator();
+
+        queuedHashes.Remove(result);
+        OnRemoved?.Invoke(this, result);
+        return result;
+    }
+
+    public void Return(T item)
+    {
+        if (queuedHashes.Contains(item))
+            return;
+
+        queue.Enqueue(item);
+        queuedHashes.Add(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 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 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 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 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

@@ -0,0 +1,281 @@
+using System;
+using System.Numerics;
+
+namespace Engine.Core;
+
+public static class Math
+{
+    /// <summary>
+    /// The value of Pi (π).
+    /// </summary>
+    public const float Pi = 3.1415926535897932f;
+
+    /// <summary>
+    /// 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;
+
+    /// <summary>
+    /// The conversion factor from degrees to radians.
+    /// </summary>
+    public const float DegreeToRadian = Pi / 180f;
+
+    /// <summary>
+    /// Gets one minus of given <see cref="T"/>.
+    /// </summary>
+    /// <param name="value">The value <see cref="T"/>.</param>
+    /// <returns>One minus of given <see cref="T"/>.</returns>
+    public static T OneMinus<T>(T value) where T : INumber<T> => T.One - value;
+
+    /// <summary>
+    /// Adds two <see cref="T"/>s.
+    /// </summary>
+    /// <param name="left">The first <see cref="T"/>.</param>
+    /// <param name="value">The second <see cref="T"/>.</param>
+    /// <returns>The sum of the two <see cref="T"/>s.</returns>
+    public static T Add<T>(T left, T value) where T : INumber<T> => left + value;
+
+    /// <summary>
+    /// Subtracts one <see cref="T"/> from another.
+    /// </summary>
+    /// <param name="left">The <see cref="T"/> to subtract from.</param>
+    /// <param name="value">The <see cref="T"/> to subtract.</param>
+    /// <returns>The result of subtracting the second <see cref="T"/> from the first.</returns>
+    public static T Subtract<T>(T left, T value) where T : INumber<T> => left - value;
+
+    /// <summary>
+    /// Multiplies a <see cref="T"/> by a scalar value.
+    /// </summary>
+    /// <param name="left">The <see cref="T"/>.</param>
+    /// <param name="multiplier">The scalar value.</param>
+    /// <returns>The result of multiplying the <see cref="T"/> by the scalar value.</returns>
+    public static T Multiply<T>(T left, T multiplier) where T : INumber<T> => left * multiplier;
+
+    /// <summary>
+    /// Divides a <see cref="T"/> by a scalar value.
+    /// </summary>
+    /// <param name="left">The <see cref="T"/>.</param>
+    /// <param name="divider">The scalar value.</param>
+    /// <returns>The result of dividing the <see cref="T"/> by the scalar value.</returns>
+    public static T Divide<T>(T left, T divider) where T : INumber<T> => left / divider;
+
+    /// <summary>
+    /// Returns the true mathematical modulus of a <see cref="T"/> value. 
+    /// Unlike the remainder operator (%), this result is always non-negative,
+    /// even when the <paramref name="value"/> operand is negative.
+    /// </summary>
+    /// <typeparam name="T">A numeric type that implements <see cref="INumber{T}"/>.</typeparam>
+    /// <param name="value">The dividend <see cref="T"/> value.</param>
+    /// <param name="modulus">The modulus <see cref="T"/> value (must be non-zero).</param>
+    /// <returns>
+    /// The non-negative remainder of <paramref name="value"/> divided by <paramref name="modulus"/>.
+    /// </returns>
+    public static T Mod<T>(T value, T modulus) where T : INumber<T>
+    {
+        T result = value % modulus;
+        if (result < T.Zero)
+            result += modulus;
+        return result;
+    }
+
+    /// <summary>
+    /// Returns the absolute value of a number.
+    /// </summary>
+    /// <typeparam name="T">The type of the number.</typeparam>
+    /// <param name="x">The number.</param>
+    /// <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>
+    /// <param name="x">The number.</param>
+    /// <returns>The arccosine of <paramref name="x"/>.</returns>
+    public static float Acos(float x) => MathF.Acos(x);
+
+    /// <summary>
+    /// Returns the arcsine of a number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The arcsine of <paramref name="x"/>.</returns>
+    public static float Asin(float x) => MathF.Asin(x);
+
+    /// <summary>
+    /// Returns the angle whose tangent is the quotient of two specified numbers.
+    /// </summary>
+    /// <param name="y">The y-coordinate of a point.</param>
+    /// <param name="x">The x-coordinate of a point.</param>
+    /// <returns>The angle, measured in radians.</returns>
+    public static float Atan2(float y, float x) => MathF.Atan2(y, x);
+
+    /// <summary>
+    /// Returns the hyperbolic arctangent of a number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The hyperbolic arctangent of <paramref name="x"/>.</returns>
+    public static float Atanh(float x) => MathF.Atanh(x);
+
+    /// <summary>
+    /// Clamps a number between a minimum and maximum value.
+    /// </summary>
+    /// <typeparam name="T">The type of the number.</typeparam>
+    /// <param name="x">The number to clamp.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <returns>The clamped value.</returns>
+    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.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The smallest integral value that is greater than or equal to <paramref name="x"/>.</returns>
+    public static float Ceiling(float x) => MathF.Ceiling(x);
+
+    /// <summary>
+    /// Returns a value with the magnitude of <paramref name="x"/> and the sign of <paramref name="y"/>.
+    /// </summary>
+    /// <param name="x">The magnitude value.</param>
+    /// <param name="y">The sign value.</param>
+    /// <returns>A value with the magnitude of <paramref name="x"/> and the sign of <paramref name="y"/>.</returns>
+    public static float CopySign(float x, float y) => MathF.CopySign(x, y);
+
+    /// <summary>
+    /// Returns the largest integral value that is less than or equal to the specified number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The largest integral value that is less than or equal to <paramref name="x"/>.</returns>
+    public static float Floor(float x) => MathF.Floor(x);
+
+    /// <summary>
+    /// Returns the remainder of the division of two specified numbers.
+    /// </summary>
+    /// <param name="x">The dividend.</param>
+    /// <param name="y">The divisor.</param>
+    /// <returns>The remainder of the division of <paramref name="x"/> by <paramref name="y"/>.</returns>
+    public static float IEEERemainder(float x, float y) => MathF.IEEERemainder(x, y);
+
+    /// <summary>
+    /// Returns the natural (base e) logarithm of a specified number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <param name="y">The base.</param>
+    /// <returns>The natural logarithm of <paramref name="x"/> with base <paramref name="y"/>.</returns>
+    public static float Log(float x, float y) => MathF.Log(x, y);
+
+    /// <summary>
+    /// Returns the larger of two numbers.
+    /// </summary>
+    /// <typeparam name="T">The type of the numbers.</typeparam>
+    /// <param name="x">The first number.</param>
+    /// <param name="y">The second number.</param>
+    /// <returns>The larger of <paramref name="x"/> and <paramref name="y"/>.</returns>
+    public static T Max<T>(T x, T y) where T : INumber<T> => (x > y) ? x : y;
+
+    /// <summary>
+    /// Returns the number whose absolute value is larger.
+    /// </summary>
+    /// <param name="x">The first number.</param>
+    /// <param name="y">The second number.</param>
+    /// <returns>The number whose absolute value is larger.</returns>
+    public static T AbsMax<T>(T x, T y) where T : INumber<T> => (Abs(x) > Abs(y)) ? x : y;
+
+    /// <summary>
+    /// Returns the smaller of two numbers.
+    /// </summary>
+    /// <typeparam name="T">The type of the numbers.</typeparam>
+    /// <param name="x">The first number.</param>
+    /// <param name="y">The second number.</param>
+    /// <returns>The smaller of <paramref name="x"/> and <paramref name="y"/>.</returns>
+    public static T Min<T>(T x, T y) where T : INumber<T> => (x < y) ? x : y;
+
+    /// <summary>
+    /// Returns the number whose absolute value is smaller.
+    /// </summary>
+    /// <param name="x">The first number.</param>
+    /// <param name="y">The second number.</param>
+    /// <returns>The number whose absolute value is smaller.</returns>
+    public static T AbsMin<T>(T x, T y) where T : INumber<T> => (Abs(x) < Abs(y)) ? x : y;
+
+    /// <summary>
+    /// Returns a specified number raised to the specified power.
+    /// </summary>
+    /// <param name="x">The number to raise to a power.</param>
+    /// <param name="y">The power to raise <paramref name="x"/> to.</param>
+    /// <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>
+    /// <param name="x">The number to round.</param>
+    /// <param name="digits">The number of fractional digits in the return value.</param>
+    /// <param name="mode">Specification for how to round <paramref name="x"/> if it is midway between two other numbers.</param>
+    /// <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>
+    /// <typeparam name="T">The type of the number.</typeparam>
+    /// <param name="x">The number to square.</param>
+    /// <returns>The square of <paramref name="x"/>.</returns>
+    public static T Sqr<T>(T x) where T : INumber<T> => x * x;
+
+    /// <summary>
+    /// Returns the square root of a specified number.
+    /// </summary>
+    /// <param name="x">The number.</param>
+    /// <returns>The square root of <paramref name="x"/>.</returns>
+    public static float Sqrt(float x) => MathF.Sqrt(x);
+
+    /// <summary>
+    /// Calculates the integral part of a number.
+    /// </summary>
+    /// <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 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 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

@@ -0,0 +1,109 @@
+using System.Collections.Generic;
+
+namespace Engine.Core;
+
+/// <summary>
+/// Represents an Axis-Aligned Bounding Box (AABB) in 2D space.
+/// </summary>
+/// <param name="lowerBoundary">The lower boundary of the <see cref="AABB"/>.</param>
+/// <param name="upperBoundary">The upper boundary of the <see cref="AABB"/>.</param>
+/// <remarks>
+/// Initializes a new instance of the <see cref="AABB"/> struct with the specified lower and upper boundaries.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("LowerBoundary: {LowerBoundary.ToString(), nq}, UpperBoundary: {UpperBoundary.ToString(), nq}")]
+public readonly struct AABB(Vector2D lowerBoundary, Vector2D upperBoundary)
+{
+    /// <summary>
+    /// The lower boundary of the <see cref="AABB"/>.
+    /// </summary>
+    public readonly Vector2D LowerBoundary = lowerBoundary;
+
+    /// <summary>
+    /// The upper boundary of the <see cref="AABB"/>.
+    /// </summary>
+    public readonly Vector2D UpperBoundary = upperBoundary;
+
+    /// <summary>
+    /// Gets the center point of the <see cref="AABB"/>.
+    /// </summary>
+    public readonly Vector2D Center => (LowerBoundary + UpperBoundary) * .5f;
+
+    /// <summary>
+    /// Gets the size of the <see cref="AABB"/>.
+    /// </summary>
+    public readonly Vector2D Size => LowerBoundary.FromTo(UpperBoundary).Abs();
+
+    /// <summary>
+    /// Gets half the size of the <see cref="AABB"/>.
+    /// </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>
+    /// <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>
+    public static AABB FromVectors(IEnumerable<Vector2D> vectors)
+    {
+        int counter = 0;
+
+        Vector2D lowerBoundary = new(float.MaxValue, float.MaxValue);
+        Vector2D upperBoundary = new(float.MinValue, float.MinValue);
+
+        foreach (Vector2D vector in vectors)
+        {
+            lowerBoundary = Vector2D.Min(lowerBoundary, vector);
+            upperBoundary = Vector2D.Max(upperBoundary, vector);
+            counter++;
+        }
+
+        if (counter < 2)
+            throw new System.ArgumentException($"Parameter {nameof(vectors)} must have at least 2 items.");
+
+        return new(lowerBoundary, upperBoundary);
+    }
+
+    /// <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>
+    /// <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, 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>
+/// Provides extension methods for the <see cref="AABB"/> struct.
+/// </summary>
+public static class AABBExtensions
+{
+    /// <inheritdoc cref="AABB.ToAABB" />
+    public static AABB ToAABB(this IEnumerable<Vector2D> vectors) => AABB.FromVectors(vectors);
+
+    /// <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 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 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 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);
+}