chore: updated engine to use MonoGame integrations

refactor: renamed delegate type to be less confusing
perf: network manager registration memory allocation reduced further by removing boxing on some methods
2025-06-01 18:38:07 +03:00 · 2025-06-01 11:28:14 +03:00 · 2025-06-01 11:19:33 +03:00 · 2025-06-01 10:20:06 +03:00 · 2025-06-01 02:21:24 +03:00 · 2025-05-31 23:22:43 +03:00
49 changed files with 1743 additions and 394 deletions
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -0,0 +1,52 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": ".NET Launch (Client) 1",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      "program": "${workspaceFolder}/Platforms/Desktop/bin/Debug/net9.0/Desktop.exe",
+      "args": [],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "console": "internalConsole"
+    },
+    {
+      "name": ".NET Launch (Client) 2",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      "program": "${workspaceFolder}/Platforms/Desktop/bin/Debug/net9.0/Desktop.exe",
+      "args": [],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "console": "internalConsole"
+    },
+    {
+      "name": ".NET Launch (Server)",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      "program": "${workspaceFolder}/Platforms/Desktop/bin/Debug/net9.0/Desktop.exe",
+      "args": ["-server"],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "console": "internalConsole"
+    }
+  ],
+  "compounds": [
+    {
+      "name": ".NET Launch 1 Client & 1 Server",
+      "configurations": [".NET Launch (Server)", ".NET Launch (Client) 1"]
+    },
+    {
+      "name": ".NET Launch 2 Client & 1 Server",
+      "configurations": [
+        ".NET Launch (Server)",
+        ".NET Launch (Client) 1",
+        ".NET Launch (Client) 2"
+      ]
+    }
+  ]
+}
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@ -0,0 +1,14 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "command": "dotnet",
+      "args": [
+        "build"
+      ],
+      "group": "build",
+      "problemMatcher": [],
+      "label": "build"
+    }
+  ]
+}
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 6e5b805803ce60f9ad904180406e57de9e9f9c4e
+Subproject commit 8d49fb467cda79187a1a5677f7d594af4dbaef6e
--- a/Platforms/Desktop/Desktop.csproj
+++ b/Platforms/Desktop/Desktop.csproj
@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
    <RollForward>Major</RollForward>
    <PublishReadyToRun>false</PublishReadyToRun>
    <TieredCompilation>false</TieredCompilation>
--- a/Platforms/Desktop/KeyboardInputsBehaviour.cs
+++ b/Platforms/Desktop/KeyboardInputsBehaviour.cs
@ -1,112 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-using Microsoft.Xna.Framework.Input;
-
-using Syntriax.Engine.Core;
-using Syntriax.Engine.Systems.Input;
-
-namespace Pong.Platforms.Desktop;
-
-public class KeyboardInputsBehaviour : Behaviour, IButtonInputs<Keys>
-{
-    private readonly Dictionary<Keys, IButtonInputs<Keys>.ButtonCallbackEventHandler> OnPressed = new(256);
-    private readonly Dictionary<Keys, IButtonInputs<Keys>.ButtonCallbackEventHandler> OnReleased = new(256);
-
-    private int cachePressedCurrentlyCount = 0;
-    private readonly Keys[] cachePressedCurrently = new Keys[256];
-
-    private int cachePressedPreviouslyCount = 0;
-    private readonly Keys[] cachePressedPreviously = new Keys[256];
-
-    public event IButtonInputs<Keys>.ButtonCallbackEventHandler? OnAnyButtonPressed = null;
-    public event IButtonInputs<Keys>.ButtonCallbackEventHandler? OnAnyButtonReleased = null;
-
-    public void RegisterOnPress(Keys key, IButtonInputs<Keys>.ButtonCallbackEventHandler callback)
-    {
-        if (OnPressed.TryGetValue(key, out var action))
-        {
-            action += callback;
-            return;
-        }
-
-        OnPressed.Add(key, callback);
-    }
-
-    public void UnregisterOnPress(Keys key, IButtonInputs<Keys>.ButtonCallbackEventHandler callback)
-    {
-        if (OnPressed.TryGetValue(key, out var action))
-            action -= callback;
-    }
-
-    public void RegisterOnRelease(Keys key, IButtonInputs<Keys>.ButtonCallbackEventHandler callback)
-    {
-        if (OnReleased.TryGetValue(key, out var action))
-        {
-            action += callback;
-            return;
-        }
-
-        OnReleased.Add(key, callback);
-    }
-
-    public void UnregisterOnRelease(Keys key, IButtonInputs<Keys>.ButtonCallbackEventHandler callback)
-    {
-        if (OnReleased.TryGetValue(key, out var action))
-            action -= callback;
-    }
-
-    protected override void OnUpdate()
-    {
-        KeyboardState keyboardState = Keyboard.GetState();
-        keyboardState.GetPressedKeys(cachePressedCurrently);
-        cachePressedCurrentlyCount = keyboardState.GetPressedKeyCount();
-
-        for (int i = 0; i < cachePressedCurrentlyCount; i++)
-        {
-            Keys currentlyPressedKey = cachePressedCurrently[i];
-
-            if (!OnPressed.TryGetValue(currentlyPressedKey, out var action))
-                continue;
-
-            if (WasPressed(currentlyPressedKey))
-                continue;
-
-            action.InvokeSafe(this, currentlyPressedKey);
-            OnAnyButtonPressed?.InvokeSafe(this, currentlyPressedKey);
-        }
-
-        for (int i = 0; i < cachePressedPreviouslyCount; i++)
-        {
-            Keys previouslyPressedKey = cachePressedPreviously[i];
-
-            if (!OnReleased.TryGetValue(previouslyPressedKey, out var action))
-                continue;
-
-            if (IsPressed(previouslyPressedKey))
-                continue;
-
-            action.InvokeSafe(this, previouslyPressedKey);
-            OnAnyButtonReleased?.InvokeSafe(this, previouslyPressedKey);
-        }
-
-        Array.Copy(cachePressedCurrently, cachePressedPreviously, cachePressedCurrentlyCount);
-        cachePressedPreviouslyCount = cachePressedCurrentlyCount;
-    }
-
-    public bool IsPressed(Keys key)
-    {
-        for (int i = 0; i < cachePressedCurrentlyCount; i++)
-            if (cachePressedCurrently[i] == key)
-                return true;
-        return false;
-    }
-
-    public bool WasPressed(Keys key)
-    {
-        for (int i = 0; i < cachePressedPreviouslyCount; i++)
-            if (cachePressedPreviously[i] == key)
-                return true;
-        return false;
-    }
-}
--- a/Platforms/Desktop/Program.cs
+++ b/Platforms/Desktop/Program.cs
@ -1,7 +1,7 @@
-using Pong.Platforms.Desktop;
-using Syntriax.Engine.Core;
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Integration.MonoGame;

-Syntriax.Engine.Core.IUniverseObject universeObject = Syntriax.Engine.Core.Factory.UniverseObjectFactory.Instantiate().SetUniverseObject("Desktop HO");
+IUniverseObject universeObject = Syntriax.Engine.Core.Factory.UniverseObjectFactory.Instantiate().SetUniverseObject("Desktop HO");
 universeObject.BehaviourController.AddBehaviour<KeyboardInputsBehaviour>();
 using var game = new Pong.GamePong(universeObject);
 game.Run();
--- a/Pong.sln
+++ b/Pong.sln
@ -19,36 +19,104 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Desktop", "Platforms\Deskto
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Systems", "Engine\Engine.Systems\Engine.Systems.csproj", "{8863A1BA-2E83-419F-BACB-D4A4156EC71C}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Engine.Integration", "Engine.Integration", "{9059393F-4073-9273-0EEC-2B1BA61B620B}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Integration.MonoGame", "Engine\Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
 		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Debug|x64.Build.0 = Debug|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Debug|x86.Build.0 = Debug|Any CPU
 		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Release|x64.ActiveCfg = Release|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Release|x64.Build.0 = Release|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Release|x86.ActiveCfg = Release|Any CPU
+		{990CA10C-1EBB-4395-A43A-456B7029D8C9}.Release|x86.Build.0 = Release|Any CPU
 		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Debug|x64.Build.0 = Debug|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Debug|x86.Build.0 = Debug|Any CPU
 		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Release|x64.ActiveCfg = Release|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Release|x64.Build.0 = Release|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Release|x86.ActiveCfg = Release|Any CPU
+		{0D97F83C-B043-48B1-B155-7354C4E84FC0}.Release|x86.Build.0 = Release|Any CPU
 		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Debug|x64.Build.0 = Debug|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Debug|x86.Build.0 = Debug|Any CPU
 		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Release|x64.ActiveCfg = Release|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Release|x64.Build.0 = Release|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Release|x86.ActiveCfg = Release|Any CPU
+		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969}.Release|x86.Build.0 = Release|Any CPU
 		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Debug|x64.Build.0 = Debug|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Debug|x86.Build.0 = Debug|Any CPU
 		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Release|x64.ActiveCfg = Release|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Release|x64.Build.0 = Release|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Release|x86.ActiveCfg = Release|Any CPU
+		{590E392E-9FB3-49FA-B4DA-6C8F7126FFE5}.Release|x86.Build.0 = Release|Any CPU
 		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Debug|x64.Build.0 = Debug|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Debug|x86.Build.0 = Debug|Any CPU
 		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Release|x64.ActiveCfg = Release|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Release|x64.Build.0 = Release|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Release|x86.ActiveCfg = Release|Any CPU
+		{2B627F66-5A61-4F69-B479-62EEAB603D01}.Release|x86.Build.0 = Release|Any CPU
 		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Debug|x64.Build.0 = Debug|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Debug|x86.Build.0 = Debug|Any CPU
 		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Release|x64.ActiveCfg = Release|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Release|x64.Build.0 = Release|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Release|x86.ActiveCfg = Release|Any CPU
+		{8863A1BA-2E83-419F-BACB-D4A4156EC71C}.Release|x86.Build.0 = Release|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Debug|x64.Build.0 = Debug|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Debug|x86.Build.0 = Debug|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Release|x64.ActiveCfg = Release|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Release|x64.Build.0 = Release|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Release|x86.ActiveCfg = Release|Any CPU
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@ -59,5 +127,7 @@ Global
 		{2F6B1E26-1217-4EFD-874C-05ADEE4C7969} = {F7F62670-237A-4C93-A30E-CE661C6FC401}
 		{2B627F66-5A61-4F69-B479-62EEAB603D01} = {FECFFD54-338F-4060-9161-1E5770D1DC33}
 		{8863A1BA-2E83-419F-BACB-D4A4156EC71C} = {F7F62670-237A-4C93-A30E-CE661C6FC401}
+		{9059393F-4073-9273-0EEC-2B1BA61B620B} = {F7F62670-237A-4C93-A30E-CE661C6FC401}
+		{7CC31BC4-38EE-40F4-BBBA-9FC2F4CF6283} = {9059393F-4073-9273-0EEC-2B1BA61B620B}
 	EndGlobalSection
 EndGlobal
--- a/Shared/Abstract/IDisplayableSprite.cs
+++ b/Shared/Abstract/IDisplayableSprite.cs
@ -1,8 +0,0 @@
-using Microsoft.Xna.Framework.Graphics;
-
-namespace Syntriax.Engine.Core;
-
-public interface IDisplayableSprite
-{
-    public void Draw(SpriteBatch spriteBatch);
-}
--- a/Shared/Abstract/IDisplayableShape.cs
+++ b/Shared/Abstract/IDisplayableShape.cs
@ -2,7 +2,7 @@ using Apos.Shapes;

 namespace Syntriax.Engine.Core;

-public interface IDisplayableShape
+public interface IDrawableShape : IBehaviour
 {
    void Draw(ShapeBatch shapeBatch);
 }
--- a/Shared/Behaviours/BallBehaviour.cs
+++ b/Shared/Behaviours/BallBehaviour.cs
@ -1,74 +1,84 @@
-using System;
-
 using Syntriax.Engine.Core;
+using Syntriax.Engine.Network;
 using Syntriax.Engine.Physics2D;
+using Syntriax.Engine.Systems.Tween;

 namespace Pong.Behaviours;

-public class BallBehaviour : Behaviour2D
+public class BallBehaviour : Behaviour2D, IFirstFrameUpdate, IPhysicsUpdate, INetworkEntity,
+    IPacketListenerClient<BallBehaviour.BallUpdatePacket>
 {
-    public Vector2D StartDirection { get; private set; } = Vector2D.Zero;
    public float Speed { get; set; } = 500f;
    public float SpeedUpMultiplier { get; set; } = .0125f;

-    private readonly Random random = new();
-    private IRigidBody2D rigidBody = null!;
+    public IRigidBody2D RigidBody { get; private set; } = null!;

-    protected override void OnFirstActiveFrame()
+    private IPhysicsEngine2D physicsEngine2D = null!;
+    private ITweenManager tweenManager = null!;
+    private INetworkCommunicatorServer? networkServer = null;
+
+    public void FirstActiveFrame()
    {
-        BehaviourController.GetRequiredBehaviour<ICollider2D>().OnCollisionDetected += OnCollisionDetected;
-        rigidBody = BehaviourController.GetRequiredBehaviour<IRigidBody2D>();
-
-        if (UniverseObject.Universe.TryFindBehaviour(out PongManagerBehaviour? pongManager))
-        {
-            pongManager.OnReset += ResetBall;
-            pongManager.OnScored += ResetBall;
-            pongManager.OnFinished += DisableBall;
-        }
+        BehaviourController.GetRequiredBehaviour<ICollider2D>().OnCollisionDetected.AddListener(OnCollisionDetected);
+        physicsEngine2D = Universe.GetRequiredUniverseObject<IPhysicsEngine2D>();
+        tweenManager = Universe.GetRequiredUniverseObject<ITweenManager>();
+        RigidBody = BehaviourController.GetRequiredBehaviour<IRigidBody2D>();
+        networkServer = Universe.Find<INetworkCommunicatorServer>();
    }

-    private void DisableBall(PongManagerBehaviour pongManager)
+    public void LaunchBall(Vector2D launchDirection)
+    {
+        ResetBall();
+        RigidBody.Velocity = launchDirection * Speed;
+        networkServer?.SendToClient("*", new BallUpdatePacket(this));
+    }
+
+    public void ResetBall()
    {
        Transform.Position = Vector2D.Zero;
-        rigidBody.Velocity = Vector2D.Zero;
+        RigidBody.Velocity = Vector2D.Zero;
    }

-    private void ResetBall(PongManagerBehaviour pongManager)
+    public void PhysicsUpdate(float delta)
    {
-        StateEnable.Enabled = true;
-        Transform.Position = Vector2D.Zero;
-        rigidBody.Velocity = GetRandomDirection() * Speed;
-    }
-
-    private Vector2D GetRandomDirection()
-    {
-        const float AllowedRadians = 45f * Syntriax.Engine.Core.Math.DegreeToRadian;
-        float rotation = (float)random.NextDouble() * 2f * AllowedRadians - AllowedRadians;
-        bool isBackwards = (random.Next() % 2) == 1;
-        return Vector2D.Right.Rotate(isBackwards ? rotation + Syntriax.Engine.Core.Math.PI : rotation);
-    }
-
-    protected override void OnUpdate()
-    {
-        if (rigidBody.Velocity.MagnitudeSquared <= 0.01f)
+        if (RigidBody.Velocity.MagnitudeSquared <= 0.01f)
            return;

-        Vector2D speedUp = rigidBody.Velocity.Normalized * Universe.Time.DeltaTime;
-        rigidBody.Velocity += speedUp * SpeedUpMultiplier;
+        Vector2D direction = RigidBody.Velocity.Normalized;
+        RigidBody.Velocity += direction * delta * SpeedUpMultiplier;
    }

    private void OnCollisionDetected(ICollider2D collider2D, CollisionDetectionInformation information)
    {
-        if (Syntriax.Engine.Core.Math.Abs(information.Normal.Dot(Vector2D.Right)) > .25)
-            rigidBody.Velocity = information.Detected.Transform.Position.FromTo(information.Detector.Transform.Position).Normalized * rigidBody.Velocity.Magnitude;
+        if (Math.Abs(information.Normal.Dot(Vector2D.Right)) > .25)
+            RigidBody.Velocity = information.Detected.Transform.Position.FromTo(information.Detector.Transform.Position).Normalized * RigidBody.Velocity.Magnitude;
        else
-            rigidBody.Velocity = rigidBody.Velocity.Reflect(information.Normal);
+            RigidBody.Velocity = RigidBody.Velocity.Reflect(information.Normal);
+        networkServer?.SendToClient("*", new BallUpdatePacket(this));
    }

    public BallBehaviour() { }
-    public BallBehaviour(Vector2D startDirection, float speed)
+    public BallBehaviour(float speed) => Speed = speed;
+
+    void IPacketListenerClient<BallUpdatePacket>.OnClientPacketArrived(BallUpdatePacket packet)
    {
-        StartDirection = Vector2D.Normalize(startDirection);
-        Speed = speed;
+        Transform.TweenPositionAdditive(tweenManager, .25f, Transform.Position.FromTo(packet.Position));
+        RigidBody.Velocity = packet.Velocity;
+        physicsEngine2D.StepIndividual(RigidBody, new System.DateTime(System.DateTime.UtcNow.Ticks - packet.Timestamp).Second);
+    }
+
+    private class BallUpdatePacket : INetworkPacket
+    {
+        public Vector2D Position { get; set; } = Vector2D.Zero;
+        public Vector2D Velocity { get; set; } = Vector2D.Zero;
+        public long Timestamp { get; set; } = 0;
+
+        public BallUpdatePacket() { }
+        public BallUpdatePacket(BallBehaviour ballBehaviour)
+        {
+            Position = ballBehaviour.Transform.Position;
+            Velocity = ballBehaviour.RigidBody.Velocity;
+            Timestamp = System.DateTime.UtcNow.Ticks;
+        }
    }
 }
--- a/Shared/Behaviours/CameraController.cs
+++ b/Shared/Behaviours/CameraController.cs
@ -1,27 +1,28 @@
 using Microsoft.Xna.Framework.Input;

 using Syntriax.Engine.Core;
+using Syntriax.Engine.Integration.MonoGame;
 using Syntriax.Engine.Systems.Input;

 namespace Pong.Behaviours;

-public class CameraController : Behaviour
+public class CameraController : Behaviour, IFirstFrameUpdate, IUpdate
 {
    private MonoGameCamera2DBehaviour cameraBehaviour = null!;
    private IButtonInputs<Keys> buttonInputs = null!;

    private float defaultZoomLevel = 1f;

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
-        cameraBehaviour ??= BehaviourController.GetRequiredBehaviour<MonoGameCamera2DBehaviour>();
+        cameraBehaviour = BehaviourController.GetRequiredBehaviour<MonoGameCamera2DBehaviour>();
        buttonInputs = Universe.FindRequiredBehaviour<IButtonInputs<Keys>>();

        buttonInputs.RegisterOnPress(Keys.F, SwitchToFullScreen);
        buttonInputs.RegisterOnPress(Keys.R, ResetCamera);
    }

-    protected override void OnUpdate()
+    public void Update()
    {
        if (buttonInputs.IsPressed(Keys.U))
            cameraBehaviour.Zoom += Universe.Time.DeltaTime * 5f;
@ -41,7 +42,7 @@ public class CameraController : Behaviour
            cameraBehaviour.Transform.Rotation -= Universe.Time.DeltaTime * 45f;
    }

-    private void SwitchToFullScreen(IButtonInputs<Keys> inputs, Keys keys)
+    private void SwitchToFullScreen(IButtonInputs<Keys> sender, IButtonInputs<Keys>.ButtonCallbackArguments args)
    {
        if (cameraBehaviour.Graphics.IsFullScreen)
            return;
@ -59,7 +60,7 @@ public class CameraController : Behaviour
        cameraBehaviour.Viewport = cameraBehaviour.Graphics.GraphicsDevice.Viewport;
    }

-    private void ResetCamera(IButtonInputs<Keys> inputs, Keys keys)
+    private void ResetCamera(IButtonInputs<Keys> sender, IButtonInputs<Keys>.ButtonCallbackArguments args)
    {
        cameraBehaviour.Zoom = defaultZoomLevel;
        cameraBehaviour.Transform.LocalPosition = Vector2D.Zero;
--- a/Shared/Behaviours/CircleBehaviour.cs
+++ b/Shared/Behaviours/CircleBehaviour.cs
@ -6,7 +6,7 @@ using Syntriax.Engine.Core;

 namespace Pong.Behaviours;

-public class CircleBehaviour : Syntriax.Engine.Physics2D.Collider2DCircleBehaviour, IDisplayableShape
+public class CircleBehaviour : Syntriax.Engine.Physics2D.Collider2DCircleBehaviour, IDrawableShape
 {
    public Color Color { get; set; } = Color.White;
    public float Thickness { get; set; } = .5f;
--- a/Shared/Behaviours/MonoGameCamera2DBehaviour.cs
+++ b/Shared/Behaviours/MonoGameCamera2DBehaviour.cs
@ -1,101 +0,0 @@
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-
-using Syntriax.Engine.Core;
-
-namespace Pong.Behaviours;
-
-public class MonoGameCamera2DBehaviour(GraphicsDeviceManager Graphics) : Behaviour2D, ICamera2D
-{
-    public event OnMatrixTransformChangedDelegate? OnMatrixTransformChanged = null;
-    public event OnViewportChangedDelegate? OnViewportChanged = null;
-    public event OnZoomChangedDelegate? OnZoomChanged = null;
-
-    private Matrix _matrixTransform = Matrix.Identity;
-
-    private Viewport _viewport = default;
-    private float _zoom = 1f;
-
-    public GraphicsDeviceManager Graphics { get; } = Graphics;
-
-    public Matrix MatrixTransform
-    {
-        get => _matrixTransform;
-        set
-        {
-            if (_matrixTransform == value)
-                return;
-
-            _matrixTransform = value;
-            OnMatrixTransformChanged?.InvokeSafe(this);
-        }
-    }
-
-    public Vector2D Position
-    {
-        get => Transform.Position;
-        set => Transform.Position = value;
-    }
-
-    public Viewport Viewport
-    {
-        get => _viewport;
-        set
-        {
-            if (_viewport.Equals(value))
-                return;
-
-            _viewport = value;
-            OnViewportChanged?.InvokeSafe(this);
-        }
-    }
-
-    public float Zoom
-    {
-        get => _zoom;
-        set
-        {
-            float newValue = Math.Max(0.1f, value);
-
-            if (_zoom == newValue)
-                return;
-
-            _zoom = newValue;
-            OnZoomChanged?.InvokeSafe(this);
-        }
-    }
-
-    public float Rotation
-    {
-        get => Transform.Rotation;
-        set => Transform.Rotation = value;
-    }
-
-    // TODO This causes delay since OnPreDraw calls assuming this is called in in Update 
-    public Vector2D ScreenToWorldPosition(Vector2D screenPosition)
-    {
-        Vector2D worldPosition = Vector2.Transform(screenPosition.ToVector2(), Matrix.Invert(MatrixTransform)).ToVector2D();
-        return worldPosition.Scale(EngineConverter.screenScale);
-    }
-    public Vector2D WorldToScreenPosition(Vector2D worldPosition)
-    {
-        Vector2D screenPosition = Vector2.Transform(worldPosition.ToVector2(), MatrixTransform).ToVector2D();
-        return screenPosition.Scale(EngineConverter.screenScale);
-    }
-
-    protected override void OnFirstActiveFrame()
-        => Viewport = Graphics.GraphicsDevice.Viewport;
-
-    protected override void OnPreDraw()
-    {
-        MatrixTransform =
-            Matrix.CreateTranslation(new Vector3(-Position.X, Position.Y, 0f)) *
-            Matrix.CreateRotationZ(Rotation * Math.DegreeToRadian) *
-            Matrix.CreateScale(Zoom) *
-            Matrix.CreateTranslation(new Vector3(_viewport.Width * .5f, _viewport.Height * .5f, 0f));
-    }
-
-    public delegate void OnMatrixTransformChangedDelegate(MonoGameCamera2DBehaviour sender);
-    public delegate void OnViewportChangedDelegate(MonoGameCamera2DBehaviour sender);
-    public delegate void OnZoomChangedDelegate(MonoGameCamera2DBehaviour sender);
-}
--- a/Shared/Behaviours/MovementBallBehaviour.cs
+++ b/Shared/Behaviours/MovementBallBehaviour.cs
@ -3,7 +3,7 @@ using Syntriax.Engine.Physics2D;

 namespace Pong.Behaviours;

-public class MovementBallBehaviour : Behaviour2D
+public class MovementBallBehaviour : Behaviour2D, IFirstFrameUpdate, IUpdate
 {
    public Vector2D StartDirection { get; private set; } = Vector2D.Zero;
    public float Speed { get; set; } = 500f;
@ -11,15 +11,15 @@ public class MovementBallBehaviour : Behaviour2D

    private IRigidBody2D rigidBody = null!;

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
        rigidBody = BehaviourController.GetRequiredBehaviour<IRigidBody2D>();

        rigidBody.Velocity = StartDirection * Speed;
-        BehaviourController.GetRequiredBehaviour<ICollider2D>().OnCollisionDetected += OnCollisionDetected;
+        BehaviourController.GetRequiredBehaviour<ICollider2D>().OnCollisionDetected.AddListener(OnCollisionDetected);
    }

-    protected override void OnUpdate()
+    public void Update()
    {
        if (rigidBody.Velocity.MagnitudeSquared <= 0.01f)
            return;
--- a/Shared/Behaviours/PaddleBehaviour.cs
+++ b/Shared/Behaviours/PaddleBehaviour.cs
@ -3,11 +3,14 @@ using System;
 using Microsoft.Xna.Framework.Input;

 using Syntriax.Engine.Core;
+using Syntriax.Engine.Network;
+using Syntriax.Engine.Physics2D;
 using Syntriax.Engine.Systems.Input;

 namespace Pong.Behaviours;

-public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Speed) : Behaviour2D
+public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Speed) : Behaviour2D, IFirstFrameUpdate, IPostPhysicsUpdate,
+    IPacketListenerServer<PaddleBehaviour.PaddleKeyStatePacket>, IPacketListenerClient<PaddleBehaviour.PaddleKeyStatePacket>
 {
    private Keys Up { get; } = Up;
    private Keys Down { get; } = Down;
@ -19,23 +22,23 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
    private bool isDownPressed = false;

    private IButtonInputs<Keys> inputs = null!;
+    private INetworkCommunicatorClient? networkClient = null!;
+    private INetworkCommunicatorServer? networkServer = null;
+    private IRigidBody2D rigidBody = null!;
+    private IPhysicsEngine2D physicsEngine2D = null!;

-    protected override void OnUpdate()
+    public void PostPhysicsUpdate(float delta)
    {
-        if (isUpPressed && isDownPressed)
-            return;
-
-        if (isUpPressed)
-            Transform.Position = Transform.Position + Vector2D.Up * Universe.Time.DeltaTime * Speed;
-        else if (isDownPressed)
-            Transform.Position = Transform.Position + -Vector2D.Up * Universe.Time.DeltaTime * Speed;
-
        Transform.Position = new Vector2D(Transform.Position.X, MathF.Max(MathF.Min(Transform.Position.Y, High), Low));
    }

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
-        inputs = Universe.FindRequiredBehaviour<IButtonInputs<Keys>>();
+        physicsEngine2D = Universe.GetRequiredUniverseObject<IPhysicsEngine2D>();
+        inputs = Universe.FindRequired<IButtonInputs<Keys>>();
+        networkClient = Universe.Find<INetworkCommunicatorClient>();
+        networkServer = Universe.Find<INetworkCommunicatorServer>();
+        rigidBody = BehaviourController.GetRequiredBehaviour<IRigidBody2D>();

        inputs.RegisterOnPress(Up, OnUpPressed);
        inputs.RegisterOnRelease(Up, OnUpReleased);
@ -53,8 +56,61 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
        inputs.UnregisterOnRelease(Down, OnDownReleased);
    }

-    private void OnUpPressed(IButtonInputs<Keys> inputs, Keys keys) => isUpPressed = true;
-    private void OnUpReleased(IButtonInputs<Keys> inputs, Keys keys) => isUpPressed = false;
-    private void OnDownPressed(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = true;
-    private void OnDownReleased(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = false;
+    private void OnUpPressed(IButtonInputs<Keys> sender, IButtonInputs<Keys>.ButtonCallbackArguments args) { isUpPressed = true; UpdateVelocity(); networkClient?.SendToServer(new PaddleKeyStatePacket(this)); }
+    private void OnUpReleased(IButtonInputs<Keys> sender, IButtonInputs<Keys>.ButtonCallbackArguments args) { isUpPressed = false; UpdateVelocity(); networkClient?.SendToServer(new PaddleKeyStatePacket(this)); }
+    private void OnDownPressed(IButtonInputs<Keys> sender, IButtonInputs<Keys>.ButtonCallbackArguments args) { isDownPressed = true; UpdateVelocity(); networkClient?.SendToServer(new PaddleKeyStatePacket(this)); }
+    private void OnDownReleased(IButtonInputs<Keys> sender, IButtonInputs<Keys>.ButtonCallbackArguments args) { isDownPressed = false; UpdateVelocity(); networkClient?.SendToServer(new PaddleKeyStatePacket(this)); }
+
+    private void UpdateVelocity()
+    {
+        if (isUpPressed)
+            rigidBody.Velocity = Vector2D.Up * Speed;
+        else if (isDownPressed)
+            rigidBody.Velocity = -Vector2D.Up * Speed;
+        else
+            rigidBody.Velocity = Vector2D.Zero;
+    }
+
+    public void OnServerPacketArrived(string sender, PaddleKeyStatePacket packet)
+    {
+        isUpPressed = packet.IsUpPressed;
+        isDownPressed = packet.IsDownPressed;
+        UpdateVelocity();
+
+        networkServer?.SendToClient("*", new PaddleKeyStatePacket(this));
+    }
+
+    public void OnClientPacketArrived(PaddleKeyStatePacket packet)
+    {
+        isUpPressed = packet.IsUpPressed;
+        isDownPressed = packet.IsDownPressed;
+        Transform.Position = packet.Position;
+
+        UpdateVelocity();
+
+        physicsEngine2D.StepIndividual(rigidBody, new DateTime(DateTime.UtcNow.Ticks - packet.Timestamp).Second);
+    }
+
+    public class PaddleKeyStatePacket : IEntityNetworkPacket
+    {
+        public string EntityId { get; set; } = default!;
+        public Vector2D Position { get; set; } = default!;
+        public bool IsUpPressed { get; set; } = default!;
+        public bool IsDownPressed { get; set; } = default!;
+        public long Timestamp { get; set; } = 0;
+
+        public PaddleKeyStatePacket Set(PaddleBehaviour paddleBehaviour)
+        {
+            EntityId = paddleBehaviour.Id;
+            Position = paddleBehaviour.Transform.Position;
+            IsUpPressed = paddleBehaviour.isUpPressed;
+            IsDownPressed = paddleBehaviour.isDownPressed;
+            Timestamp = DateTime.UtcNow.Ticks;
+
+            return this;
+        }
+
+        public PaddleKeyStatePacket() { }
+        public PaddleKeyStatePacket(PaddleBehaviour paddleBehaviour) => Set(paddleBehaviour);
+    }
 }
--- a/Shared/Behaviours/PongManagerBehaviour.cs
+++ b/Shared/Behaviours/PongManagerBehaviour.cs
@ -3,16 +3,24 @@ using System;
 using Microsoft.Xna.Framework.Input;

 using Syntriax.Engine.Core;
+using Syntriax.Engine.Network;
 using Syntriax.Engine.Systems.Input;

 namespace Pong.Behaviours;

-public class PongManagerBehaviour : Behaviour
+public class PongManagerBehaviour : Behaviour, INetworkEntity, IFirstFrameUpdate,
+    IPacketListenerServer<PongManagerBehaviour.RequestStartPacket>
 {
    public Action<PongManagerBehaviour>? OnReset { get; set; } = null;
    public Action<PongManagerBehaviour>? OnFinished { get; set; } = null;
    public Action<PongManagerBehaviour>? OnScored { get; set; } = null;

+    private Random random = new();
+    private BallBehaviour ball = null!;
+
+    private INetworkCommunicatorClient? networkClient = null!;
+    private INetworkCommunicatorServer? networkServer = null;
+
    public int ScoreLeft { get; private set; } = 0;
    public int ScoreRight { get; private set; } = 0;
    public int ScoreSum => ScoreLeft + ScoreRight;
@ -22,17 +30,20 @@ public class PongManagerBehaviour : Behaviour
    public PongManagerBehaviour() => WinScore = 5;
    public PongManagerBehaviour(int winScore) => WinScore = winScore;

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
-        var buttonInputs = Universe.FindRequiredBehaviour<IButtonInputs<Keys>>();
-        buttonInputs.RegisterOnRelease(Keys.Space, (_, _1) => Reset());
-    }
+        IButtonInputs<Keys> buttonInputs = Universe.FindRequired<IButtonInputs<Keys>>();
+        buttonInputs.RegisterOnRelease(Keys.Space, (_, _1) => networkClient?.SendToServer(new RequestStartPacket()));

+        ball = Universe.FindRequiredBehaviour<BallBehaviour>();
+        networkClient = Universe.Find<INetworkCommunicatorClient>();
+        networkServer = Universe.Find<INetworkCommunicatorServer>();
+    }

    public void ScoreToLeft()
    {
        ScoreLeft++;
-        OnScored?.InvokeSafe(this);
+        OnScored?.Invoke(this);

        CheckFinish();
    }
@ -40,7 +51,7 @@ public class PongManagerBehaviour : Behaviour
    public void ScoreToRight()
    {
        ScoreRight++;
-        OnScored?.InvokeSafe(this);
+        OnScored?.Invoke(this);

        CheckFinish();
    }
@ -48,14 +59,43 @@ public class PongManagerBehaviour : Behaviour
    public void Reset()
    {
        ScoreLeft = ScoreRight = 0;
-        OnReset?.InvokeSafe(this);
+
+        ball.ResetBall();
+        ball.LaunchBall(GetBallLaunchDirection());
+
+        OnReset?.Invoke(this);
    }

    private void CheckFinish()
    {
        int halfwayScore = (int)(WinScore * .5f);
+        ball.ResetBall();

        if (ScoreLeft > halfwayScore || ScoreRight > halfwayScore)
-            OnFinished?.InvokeSafe(this);
+        {
+            OnFinished?.Invoke(this);
+            return;
+        }
+
+        ball.ResetBall();
+        ball.LaunchBall(GetBallLaunchDirection());
    }
+
+    private Vector2D GetBallLaunchDirection()
+    {
+        const float AllowedRadians = 45f * Syntriax.Engine.Core.Math.DegreeToRadian;
+        float rotation = (float)random.NextDouble() * 2f * AllowedRadians - AllowedRadians;
+        bool isBackwards = (random.Next() % 2) == 1;
+        return Vector2D.Right.Rotate(isBackwards ? rotation + Syntriax.Engine.Core.Math.PI : rotation);
+    }
+
+    void IPacketListenerServer<RequestStartPacket>.OnServerPacketArrived(string sender, RequestStartPacket packet)
+    {
+        if (ball.RigidBody.Velocity.MagnitudeSquared > 0.01f)
+            return;
+
+        ball.LaunchBall(GetBallLaunchDirection());
+    }
+
+    private class RequestStartPacket : INetworkPacket;
 }
--- a/Shared/Behaviours/ShapeAABBBehaviour.cs
+++ b/Shared/Behaviours/ShapeAABBBehaviour.cs
@ -8,7 +8,7 @@ using Syntriax.Engine.Systems.Input;

 namespace Pong.Behaviours;

-public class ShapeAABBBehaviour : Behaviour2D, IDisplayableShape
+public class ShapeAABBBehaviour : Behaviour2D, IDrawableShape, IFirstFrameUpdate
 {
    private IShapeCollider2D? shapeCollider = null;

@ -16,7 +16,7 @@ public class ShapeAABBBehaviour : Behaviour2D, IDisplayableShape
    public float Thickness { get; set; } = .5f;
    public bool display = true;

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
        BehaviourController.TryGetBehaviour(out shapeCollider);

--- a/Shared/Behaviours/ShapeBatcher.cs
+++ b/Shared/Behaviours/ShapeBatcher.cs
@ -0,0 +1,35 @@
+using System.Collections.Generic;
+
+using Apos.Shapes;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Integration.MonoGame;
+
+namespace Pong.Behaviours;
+
+public class ShapeBatcher : BehaviourBase, IFirstFrameUpdate, IDraw
+{
+    private static Comparer<IBehaviour> SortByPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
+    private ShapeBatch shapeBatch = null!;
+    private MonoGameCamera2DBehaviour camera2D = null!;
+    private readonly ActiveBehaviourCollectorSorted<IDrawableShape> drawableShapes = new() { SortBy = SortByPriority() };
+
+    public void FirstActiveFrame()
+    {
+        MonoGameWindowContainer windowContainer = BehaviourController.UniverseObject.Universe.FindRequiredBehaviour<MonoGameWindowContainer>();
+        camera2D = BehaviourController.UniverseObject.Universe.FindRequiredBehaviour<MonoGameCamera2DBehaviour>();
+
+        shapeBatch = new(windowContainer.Window.GraphicsDevice, windowContainer.Window.Content);
+
+        drawableShapes.Unassign();
+        drawableShapes.Assign(Universe);
+    }
+
+    public void Draw()
+    {
+        shapeBatch.Begin(camera2D.MatrixTransform);
+        for (int i = drawableShapes.Count - 1; i >= 0; i--)
+            drawableShapes[i].Draw(shapeBatch);
+        shapeBatch.End();
+    }
+}
--- a/Shared/Behaviours/ShapeBehaviour.cs
+++ b/Shared/Behaviours/ShapeBehaviour.cs
@ -6,7 +6,7 @@ using Syntriax.Engine.Core;

 namespace Pong.Behaviours;

-public class ShapeBehaviour : Syntriax.Engine.Physics2D.Collider2DShapeBehaviour, IDisplayableShape
+public class ShapeBehaviour : Syntriax.Engine.Physics2D.Collider2DShapeBehaviour, IDrawableShape
 {
    public Color Color { get; set; } = Color.White;
    public float Thickness { get; set; } = .5f;
--- a/Shared/Behaviours/TextBehaviour.cs
+++ b/Shared/Behaviours/TextBehaviour.cs
@ -2,10 +2,11 @@ using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;

 using Syntriax.Engine.Core;
+using Syntriax.Engine.Integration.MonoGame;

 namespace Pong.Behaviours;

-public class TextBehaviour : Behaviour2D, IDisplayableSprite
+public class TextBehaviour : Behaviour2D, IDrawableSprite
 {
    public SpriteFont? Font { get; set; } = null;
    public int Size { get; set; } = 16;
@ -13,7 +14,7 @@ public class TextBehaviour : Behaviour2D, IDisplayableSprite

    public void Draw(SpriteBatch spriteBatch)
    {
-        if (!IsActive || Font is null)
+        if (Font is null)
            return;

        spriteBatch.DrawString(Font, Text, Transform.Position.ToDisplayVector2(), Color.White, Transform.Rotation, Vector2.One * .5f, Transform.Scale.Magnitude, SpriteEffects.None, 0f);
--- a/Shared/Behaviours/TextScoreBehaviour.cs
+++ b/Shared/Behaviours/TextScoreBehaviour.cs
@ -3,13 +3,13 @@ using Syntriax.Engine.Core;

 namespace Pong.Behaviours;

-public class TextScoreBehaviour : TextBehaviour
+public class TextScoreBehaviour : TextBehaviour, IFirstFrameUpdate
 {
    public bool IsLeft { get; }

    private PongManagerBehaviour? pongManager = null;

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
        if (!UniverseObject.Universe.TryFindBehaviour(out pongManager))
            return;
--- a/Shared/Behaviours/WallScoreBehaviour.cs
+++ b/Shared/Behaviours/WallScoreBehaviour.cs
@ -5,15 +5,15 @@ using Syntriax.Engine.Physics2D;

 namespace Pong.Behaviours;

-public class WallScoreBehaviour(Action OnCollision) : Behaviour2D
+public class WallScoreBehaviour(Action OnCollision) : Behaviour2D, IFirstFrameUpdate
 {
    private Action OnCollision { get; } = OnCollision;

-    protected override void OnFirstActiveFrame()
+    public void FirstActiveFrame()
    {
        if (!BehaviourController.TryGetBehaviour(out ICollider2D? collider2D))
            return;

-        collider2D.OnCollisionDetected += (_, _1) => OnCollision?.InvokeSafe();
+        collider2D.OnCollisionDetected.AddListener((_, _1) => OnCollision?.Invoke());
    }
 }
--- a/Shared/GamePong.cs
+++ b/Shared/GamePong.cs
@ -1,75 +1,73 @@
 using System;
+using System.Linq;
+
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using Microsoft.Xna.Framework.Input;

 using Pong.Behaviours;
-using Apos.Shapes;

 using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Factory;
+using Syntriax.Engine.Network;
 using Syntriax.Engine.Physics2D;
+using Syntriax.Engine.Systems.Tween;
+using Syntriax.Engine.Integration.MonoGame;

 namespace Pong;

-public class GamePong : Game
+public class GamePong : MonoGameWindow
 {
    private readonly IUniverseObject platformSpecificUniverseObject = null!;
-    private readonly GraphicsDeviceManager graphics = null!;
-    private SpriteBatch spriteBatch = null!;
-    private ShapeBatch shapeBatch = null!;
-
-    private Universe universe = null!;
-    private BehaviourCollector<IDisplayableSprite> displayableCollector = null!;
-    private BehaviourCollector<IDisplayableShape> displayableShapeCollector = null!;
-    private MonoGameCamera2DBehaviour cameraBehaviour = null!;
-
-    private PongManagerBehaviour pongManager = null!;

    public GamePong(IUniverseObject platformSpecificUniverseObject)
    {
        this.platformSpecificUniverseObject = platformSpecificUniverseObject;
-        graphics = new GraphicsDeviceManager(this)
-        {
-            PreferredBackBufferWidth = 1024,
-            PreferredBackBufferHeight = 576,
-            GraphicsProfile = GraphicsProfile.HiDef
-        };
-
-        Content.RootDirectory = "Content";
-        IsMouseVisible = true;
+        Graphics.PreferredBackBufferWidth = 1024;
+        Graphics.PreferredBackBufferHeight = 576;
+        Graphics.GraphicsProfile = GraphicsProfile.HiDef;
    }

-    protected override void Initialize()
+    protected override void PopulateUniverse(IUniverse universe)
    {
-        // TODO: Add your initialization logic here
-        universe = new();
-        displayableCollector = new(universe);
-        displayableShapeCollector = new(universe);
-
-        universe.Initialize();
-
-        base.Initialize();
-    }
-
-    protected override void LoadContent()
-    {
-        spriteBatch = new SpriteBatch(GraphicsDevice);
-        shapeBatch = new ShapeBatch(GraphicsDevice, Content);
        SpriteFont spriteFont = Content.Load<SpriteFont>("UbuntuMono");

        universe.Register(platformSpecificUniverseObject);
+
+        if (Environment.GetCommandLineArgs().FirstOrDefault(x => x.CompareTo("-server") == 0) is not null)
+        {
+            LiteNetLibServer server = universe.InstantiateUniverseObject<LiteNetLibServer>().SetUniverseObject("Server");
+            UniverseObjectFactory.Instantiate<NetworkManager>().SetUniverseObject("NetworkManager", server.BehaviourController.UniverseObject);
+            server.Start(8888, 2);
+            Window.Title = $"Server";
+        }
+        else
+        {
+            LiteNetLibClient client = universe.InstantiateUniverseObject<LiteNetLibClient>().SetUniverseObject("Client");
+            UniverseObjectFactory.Instantiate<NetworkManager>().SetUniverseObject("NetworkManager", client.BehaviourController.UniverseObject);
+            client.Connect("localhost", 8888);
+            Window.Title = $"Client";
+
+            DrawManager drawManager = universe.InstantiateUniverseObject<DrawManager>().SetUniverseObject("Draw Manager");
+            universe.InstantiateUniverseObject().SetUniverseObject("Shape Batcher", drawManager).BehaviourController.AddBehaviour<ShapeBatcher>();
+            universe.InstantiateUniverseObject().SetUniverseObject("Sprite Batcher", drawManager).BehaviourController.AddBehaviour<SpriteBatcher>();
+        }
+
+        universe.InstantiateUniverseObject<UpdateManager>().SetUniverseObject("Update Manager");
+        universe.InstantiateUniverseObject<CoroutineManager>().SetUniverseObject("Coroutine Manager");
+        universe.InstantiateUniverseObject<TweenManager>().SetUniverseObject("Tween Manager");
        universe.InstantiateUniverseObject<PhysicsEngine2D>().SetUniverseObject("Physics Engine 2D");

        ////////////////////////////////////////////////////////////////////////////////////

-        cameraBehaviour = universe.InstantiateUniverseObject().SetUniverseObject("Camera")
+        universe.InstantiateUniverseObject().SetUniverseObject("Camera")
            .BehaviourController.AddBehaviour<Transform2D>()
            .BehaviourController.AddBehaviour<CameraController>()
-            .BehaviourController.AddBehaviour<MonoGameCamera2DBehaviour>(graphics);
+            .BehaviourController.AddBehaviour<MonoGameCamera2DBehaviour>();

        ////////////////////////////////////////////////////////////////////////////////////

-        pongManager = universe.InstantiateUniverseObject().SetUniverseObject("Pong Game Manager")
+        PongManagerBehaviour pongManager = universe.InstantiateUniverseObject().SetUniverseObject("Pong Game Manager")
            .BehaviourController.AddBehaviour<PongManagerBehaviour>(5);

        ////////////////////////////////////////////////////////////////////////////////////
@ -82,17 +80,23 @@ public class GamePong : Game

        ////////////////////////////////////////////////////////////////////////////////////

-        universe.InstantiateUniverseObject().SetUniverseObject("Left Paddle")
-            .BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f))
-            .BehaviourController.AddBehaviour<PaddleBehaviour>(Keys.W, Keys.S, 228f, -228f, 400f)
+        IUniverseObject leftPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Left Paddle");
+        leftPaddle.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f))
            .BehaviourController.AddBehaviour<ShapeBehaviour>(Shape2D.Square)
-            .BehaviourController.AddBehaviour<RigidBody2D>().IsStatic = true;
+            .BehaviourController.AddBehaviour<RigidBody2D>();
+        PaddleBehaviour leftPaddleBehaviour = BehaviourFactory.Instantiate<PaddleBehaviour>(Keys.W, Keys.S, 228f, -228f, 400f);
+        leftPaddleBehaviour.Id = "lp";
+        leftPaddle.BehaviourController.AddBehaviour(leftPaddleBehaviour);
+        universe.Register(leftPaddle);

-        universe.InstantiateUniverseObject().SetUniverseObject("Right Paddle")
-            .BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f))
-            .BehaviourController.AddBehaviour<PaddleBehaviour>(Keys.Up, Keys.Down, 228f, -228f, 400f)
+        IUniverseObject rightPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Right Paddle");
+        rightPaddle.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f))
            .BehaviourController.AddBehaviour<ShapeBehaviour>(Shape2D.Square)
-            .BehaviourController.AddBehaviour<RigidBody2D>().IsStatic = true;
+            .BehaviourController.AddBehaviour<RigidBody2D>();
+        PaddleBehaviour rightPaddleBehaviour = BehaviourFactory.Instantiate<PaddleBehaviour>(Keys.Up, Keys.Down, 228f, -228f, 400f);
+        rightPaddleBehaviour.Id = "rp";
+        rightPaddle.BehaviourController.AddBehaviour(rightPaddleBehaviour);
+        universe.Register(rightPaddle);

        ////////////////////////////////////////////////////////////////////////////////////

@ -128,34 +132,4 @@ public class GamePong : Game
            .BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(250f, 250f), scale: Vector2D.One * .25f)
            .BehaviourController.AddBehaviour<TextScoreBehaviour>(false, spriteFont);
    }
-
-    protected override void Update(GameTime gameTime)
-    {
-        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
-            Exit();
-
-        universe.Update(gameTime.ToUniverseTime());
-
-        base.Update(gameTime);
-    }
-
-    protected override void Draw(GameTime gameTime)
-    {
-        GraphicsDevice.Clear(new Color() { R = 32, G = 32, B = 32 });
-
-        // TODO: Add your drawing code here
-        universe.PreDraw();
-
-        spriteBatch.Begin(SpriteSortMode.Deferred, transformMatrix: cameraBehaviour.MatrixTransform);
-        foreach (var displayable in displayableCollector)
-            displayable.Draw(spriteBatch);
-        spriteBatch.End();
-
-        shapeBatch.Begin(cameraBehaviour.MatrixTransform);
-        foreach (var displayableShape in displayableShapeCollector)
-            displayableShape.Draw(shapeBatch);
-        shapeBatch.End();
-
-        base.Draw(gameTime);
-    }
 }
--- a/Shared/Network/Abstract/IEntityNetworkPacket.cs
+++ b/Shared/Network/Abstract/IEntityNetworkPacket.cs
@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Network;
+
+public interface IEntityNetworkPacket : INetworkPacket
+{
+    string EntityId { get; }
+}
--- a/Shared/Network/Abstract/INetworkCommunicator.cs
+++ b/Shared/Network/Abstract/INetworkCommunicator.cs
@ -0,0 +1,29 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public interface INetworkCommunicator
+{
+    INetworkCommunicator Stop();
+
+    INetworkCommunicator SubscribeToPackets<T>(Event<string, T>.EventHandler callback);
+    INetworkCommunicator UnsubscribeFromPackets<T>(Event<string, T>.EventHandler callback);
+}
+
+public interface INetworkCommunicatorClient : INetworkCommunicator
+{
+    INetworkCommunicatorClient Connect(string address, int port, string? password = null);
+
+    INetworkCommunicatorClient SendToServer<T>(T packet) where T : class, new();
+}
+
+public interface INetworkCommunicatorServer : INetworkCommunicator
+{
+    string Password { get; }
+    int MaxConnectionCount { get; }
+    int Port { get; }
+
+    INetworkCommunicatorServer Start(int port, int maxConnectionCount, string? password = null);
+
+    INetworkCommunicatorServer SendToClient<T>(string to, T packet) where T : class, new();
+}
--- a/Shared/Network/Abstract/INetworkEntity.cs
+++ b/Shared/Network/Abstract/INetworkEntity.cs
@ -0,0 +1,5 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public interface INetworkEntity : IEntity;
--- a/Shared/Network/Abstract/INetworkManager.cs
+++ b/Shared/Network/Abstract/INetworkManager.cs
@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public interface INetworkManager
+{
+    IReadOnlyDictionary<string, INetworkEntity> NetworkEntities { get; }
+    IBehaviourCollector<INetworkEntity> NetworkEntityCollector { get; }
+}
--- a/Shared/Network/Abstract/INetworkPacket.cs
+++ b/Shared/Network/Abstract/INetworkPacket.cs
@ -0,0 +1,3 @@
+namespace Syntriax.Engine.Network;
+
+public interface INetworkPacket;
--- a/Shared/Network/Abstract/IPacketListenerClient.cs
+++ b/Shared/Network/Abstract/IPacketListenerClient.cs
@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Network;
+
+public interface IPacketListenerClient<T> : INetworkEntity
+{
+    void OnClientPacketArrived(T packet);
+}
--- a/Shared/Network/Abstract/IPacketListenerServer.cs
+++ b/Shared/Network/Abstract/IPacketListenerServer.cs
@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Network;
+
+public interface IPacketListenerServer<T> : INetworkEntity
+{
+    void OnServerPacketArrived(string sender, T packet);
+}
--- a/Shared/Network/LiteNetLib/LiteNetLibClient.cs
+++ b/Shared/Network/LiteNetLib/LiteNetLibClient.cs
@ -0,0 +1,62 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public class LiteNetLibClient : LiteNetLibCommunicatorBase, INetworkCommunicatorClient
+{
+    private readonly NetDataWriter netDataWriter = new();
+
+    private CancellationTokenSource? cancellationTokenSource = null;
+
+    public INetworkCommunicatorClient Connect(string address, int port, string? password = null)
+    {
+        if (!IsInUniverse)
+            throw new($"{nameof(LiteNetLibClient)} must be in an universe to connect");
+
+        Manager.Start();
+        Manager.Connect(address, port, password ?? string.Empty);
+
+        return this;
+    }
+
+    public INetworkCommunicatorClient SendToServer<T>(T packet) where T : class, new()
+    {
+        netDataWriter.Reset();
+        netPacketProcessor.Write(netDataWriter, packet);
+        Manager.FirstPeer.Send(netDataWriter, LiteNetLib.DeliveryMethod.ReliableOrdered);
+
+        return this;
+    }
+
+    protected override void OnEnteringUniverse(IUniverse universe)
+    {
+        base.OnEnteringUniverse(universe);
+
+        cancellationTokenSource = new CancellationTokenSource();
+        PollEvents(cancellationTokenSource.Token);
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe)
+    {
+        base.OnExitingUniverse(universe);
+        cancellationTokenSource?.Cancel();
+    }
+
+    /// <summary>
+    /// Client needs to send everything as soon as possible so 
+    /// the events are polled a separate thread running constantly 
+    /// </summary>
+    private async void PollEvents(CancellationToken cancellationToken) => await Task.Run(() =>
+    {
+        while (true)
+        {
+            Manager.PollEvents();
+            Thread.Sleep(1);
+        }
+    }, cancellationToken);
+}
--- a/Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs
+++ b/Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs
@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using LiteNetLib;
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommunicator
+{
+    protected readonly NetPacketProcessor netPacketProcessor = new();
+
+    private readonly Dictionary<Type, Event<string, object>> listeners = [];
+
+    public EventBasedNetListener Listener { get; private set; } = null!;
+    public NetManager Manager { get; private set; } = null!;
+
+    public INetworkCommunicator Stop()
+    {
+        Manager.Stop();
+        return this;
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe)
+    {
+        base.OnExitingUniverse(universe);
+        Stop();
+    }
+
+    protected virtual void OnPacketArrived<T>(T packet, NetPeer peer) where T : INetworkPacket
+    {
+        if (!listeners.TryGetValue(typeof(T), out Event<string, object>? @event))
+            return;
+
+        @event.Invoke(peer.Id.ToString(), packet);
+    }
+
+    private void NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod)
+    {
+        try { netPacketProcessor.ReadAllPackets(reader, peer); }
+        catch { }
+    }
+
+    private void SetupPackets()
+    {
+        // Find network packets implementing INetworkPacket
+        IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
+            .Where(t => typeof(INetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType);
+
+        MethodInfo subscribeReusableMethod = typeof(NetPacketProcessor)
+            .GetMethods()
+            .FirstOrDefault(m => m.Name == nameof(NetPacketProcessor.SubscribeReusable) &&
+                m.GetParameters().Length == 1 &&
+                m.GetParameters()[0].ParameterType.GetGenericTypeDefinition() == typeof(Action<,>)
+            )!;
+
+        MethodInfo registerNestedTypeMethod = typeof(NetPacketProcessor)
+            .GetMethods()
+            .FirstOrDefault(m => m.Name == nameof(NetPacketProcessor.RegisterNestedType) &&
+                m.GetParameters().Length == 0
+            )!;
+
+        MethodInfo onPacketArrivedMethod = typeof(LiteNetLibCommunicatorBase)
+            .GetMethod(nameof(OnPacketArrived), BindingFlags.NonPublic | BindingFlags.Instance)!;
+
+        // Register all network packets by calling the methods bellow where T is our found network packet type
+        // NetPacketProcessor.SubscribeReusable<T, NetPeer>(Action<T, NetPeer> onReceive)
+        // NetPacketProcessor.RegisterNestedType<T>()
+        foreach (Type packetType in packetTypes)
+        {
+            if (!packetType.IsClass)
+            {
+                MethodInfo genericRegisterNestedTypeMethod = registerNestedTypeMethod.MakeGenericMethod(packetType);
+                genericRegisterNestedTypeMethod.Invoke(netPacketProcessor, []);
+                continue;
+            }
+
+            MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType);
+
+            Type delegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(NetPeer));
+            Delegate delegateHandler = Delegate.CreateDelegate(delegateType, this, genericOnPacketArrivedMethod);
+
+            var genericSubscribeReusableMethod = subscribeReusableMethod.MakeGenericMethod(packetType, typeof(NetPeer));
+            genericSubscribeReusableMethod.Invoke(netPacketProcessor, [delegateHandler]);
+        }
+    }
+
+    public LiteNetLibCommunicatorBase()
+    {
+        Listener = new EventBasedNetListener();
+        Manager = new NetManager(Listener);
+
+        Listener.NetworkReceiveEvent += NetworkReceiveEvent;
+
+        SetupEnginePackets();
+        SetupPackets();
+    }
+
+    private void SetupEnginePackets()
+    {
+        // I know, ugly af. I need to find a better way
+        netPacketProcessor.RegisterNestedType(AABBNetPacker.Write, AABBNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(CircleNetPacker.Write, CircleNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(ColorHSVNetPacker.Write, ColorHSVNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(ColorRGBANetPacker.Write, ColorRGBANetPacker.Read);
+        netPacketProcessor.RegisterNestedType(ColorRGBNetPacker.Write, ColorRGBNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(Line2DEquationNetPacker.Write, Line2DEquationNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(Line2DNetPacker.Write, Line2DNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(Projection1DNetPacker.Write, Projection1DNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(QuaternionNetPacker.Write, QuaternionNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(Shape2DNetPacker.Write, Shape2DNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(TriangleNetPacker.Write, TriangleNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(Vector2DNetPacker.Write, Vector2DNetPacker.Read);
+        netPacketProcessor.RegisterNestedType(Vector3DNetPacker.Write, Vector3DNetPacker.Read);
+    }
+
+    public INetworkCommunicator SubscribeToPackets<T>(Event<string, T>.EventHandler callback)
+    {
+        Type type = typeof(T);
+        if (!listeners.TryGetValue(type, out Event<string, object>? @event))
+        {
+            @event = new();
+            listeners.Add(type, @event);
+        }
+
+        @event.AddListener(EventDelegateWrapper(callback));
+        return this;
+    }
+
+    public INetworkCommunicator UnsubscribeFromPackets<T>(Event<string, T>.EventHandler callback)
+    {
+        Type type = typeof(T);
+        if (!listeners.TryGetValue(type, out Event<string, object>? @event))
+            return this;
+
+        @event.RemoveListener(EventDelegateWrapper(callback));
+        return this;
+    }
+
+    private static Event<string, object>.EventHandler EventDelegateWrapper<T>(Event<string, T>.EventHandler callback) => (sender, @object) => callback.Invoke(sender, (T)@object);
+}
--- a/Shared/Network/LiteNetLib/LiteNetLibServer.cs
+++ b/Shared/Network/LiteNetLib/LiteNetLibServer.cs
@ -0,0 +1,76 @@
+using System.Linq;
+
+using LiteNetLib;
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public class LiteNetLibServer : LiteNetLibCommunicatorBase, INetworkCommunicatorServer
+{
+    public string Password { get; private set; } = string.Empty;
+    public int MaxConnectionCount { get; private set; } = 2;
+    public int Port { get; private set; } = 8888;
+
+    private readonly NetDataWriter netDataWriter = new();
+
+    public LiteNetLibServer() : this(8888, 2) { }
+    public LiteNetLibServer(int port, int maxConnectionCount) : base()
+    {
+        MaxConnectionCount = maxConnectionCount;
+        Port = port;
+
+        Listener.ConnectionRequestEvent += request =>
+        {
+            if (Manager.ConnectedPeersCount < maxConnectionCount)
+                request.AcceptIfKey(Password);
+            else
+                request.Reject();
+        };
+    }
+
+    public INetworkCommunicatorServer Start(int port, int maxConnectionCount, string? password = null)
+    {
+        if (!IsInUniverse)
+            throw new($"{nameof(LiteNetLibServer)} must be in an universe to start");
+
+        Password = password ?? string.Empty;
+        MaxConnectionCount = maxConnectionCount;
+        Port = port;
+
+        Manager.Start(port);
+
+        return this;
+    }
+
+    public INetworkCommunicatorServer SendToClient<T>(string to, T packet) where T : class, new()
+    {
+        bool isBroadcastToAll = to.CompareTo("*") == 0;
+
+        netDataWriter.Reset();
+        netPacketProcessor.Write(netDataWriter, packet);
+        if (isBroadcastToAll)
+            Manager.SendToAll(netDataWriter, DeliveryMethod.ReliableOrdered);
+        else if (Manager.ConnectedPeerList.FirstOrDefault(p => p.Id.ToString().CompareTo(to) == 0) is NetPeer netPeer)
+            netPeer.Send(netDataWriter, DeliveryMethod.ReliableOrdered);
+        else
+            throw new($"Peer {to} couldn't be found.");
+
+        return this;
+    }
+
+    private void PollEvents(IUniverse sender, IUniverse.UpdateArguments args) => Manager.PollEvents();
+
+    protected override void OnEnteringUniverse(IUniverse universe)
+    {
+        base.OnEnteringUniverse(universe);
+        universe.OnPostUpdate.AddListener(PollEvents);
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe)
+    {
+        base.OnExitingUniverse(universe);
+        universe.OnPostUpdate.RemoveListener(PollEvents);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/AABBNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/AABBNetPacker.cs
@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class AABBNetPacker
+{
+    internal static void Write(NetDataWriter writer, AABB data)
+    {
+        Vector2DNetPacker.Write(writer, data.LowerBoundary);
+        Vector2DNetPacker.Write(writer, data.UpperBoundary);
+    }
+
+    internal static AABB Read(NetDataReader reader)
+    {
+        Vector2D lowerBoundary = Vector2DNetPacker.Read(reader);
+        Vector2D upperBoundary = Vector2DNetPacker.Read(reader);
+
+        return new AABB(lowerBoundary, upperBoundary);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/CircleNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/CircleNetPacker.cs
@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class CircleNetPacker
+{
+    internal static void Write(NetDataWriter writer, Circle data)
+    {
+        Vector2DNetPacker.Write(writer, data.Center);
+        writer.Put(data.Radius);
+    }
+
+    internal static Circle Read(NetDataReader reader)
+    {
+        Vector2D center = Vector2DNetPacker.Read(reader);
+        float radius = reader.GetFloat();
+
+        return new Circle(center, radius);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/ColorHSVNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/ColorHSVNetPacker.cs
@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class ColorHSVNetPacker
+{
+    internal static void Write(NetDataWriter writer, ColorHSV data)
+    {
+        writer.Put(data.Hue);
+        writer.Put(data.Saturation);
+        writer.Put(data.Value);
+    }
+
+    internal static ColorHSV Read(NetDataReader reader)
+    {
+        float hue = reader.GetFloat();
+        float saturation = reader.GetFloat();
+        float value = reader.GetFloat();
+
+        return new ColorHSV(hue, saturation, value);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/ColorRGBANetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/ColorRGBANetPacker.cs
@ -0,0 +1,26 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class ColorRGBANetPacker
+{
+    internal static void Write(NetDataWriter writer, ColorRGBA data)
+    {
+        writer.Put(data.R);
+        writer.Put(data.G);
+        writer.Put(data.B);
+        writer.Put(data.A);
+    }
+
+    internal static ColorRGBA Read(NetDataReader reader)
+    {
+        byte red = reader.GetByte();
+        byte green = reader.GetByte();
+        byte blue = reader.GetByte();
+        byte alpha = reader.GetByte();
+
+        return new ColorRGBA(red, green, blue, alpha);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/ColorRGBNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/ColorRGBNetPacker.cs
@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class ColorRGBNetPacker
+{
+    internal static void Write(NetDataWriter writer, ColorRGB data)
+    {
+        writer.Put(data.R);
+        writer.Put(data.G);
+        writer.Put(data.B);
+    }
+
+    internal static ColorRGB Read(NetDataReader reader)
+    {
+        byte red = reader.GetByte();
+        byte green = reader.GetByte();
+        byte blue = reader.GetByte();
+
+        return new ColorRGB(red, green, blue);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/Line2DEquationNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/Line2DEquationNetPacker.cs
@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class Line2DEquationNetPacker
+{
+    internal static void Write(NetDataWriter writer, Line2DEquation data)
+    {
+        writer.Put(data.Slope);
+        writer.Put(data.OffsetY);
+    }
+
+    internal static Line2DEquation Read(NetDataReader reader)
+    {
+        float slope = reader.GetFloat();
+        float offsetY = reader.GetFloat();
+
+        return new Line2DEquation(slope, offsetY);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/Line2DNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/Line2DNetPacker.cs
@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class Line2DNetPacker
+{
+    internal static void Write(NetDataWriter writer, Line2D data)
+    {
+        Vector2DNetPacker.Write(writer, data.From);
+        Vector2DNetPacker.Write(writer, data.To);
+    }
+
+    internal static Line2D Read(NetDataReader reader)
+    {
+        Vector2D from = Vector2DNetPacker.Read(reader);
+        Vector2D to = Vector2DNetPacker.Read(reader);
+
+        return new Line2D(from, to);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/Projection1DNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/Projection1DNetPacker.cs
@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class Projection1DNetPacker
+{
+    internal static void Write(NetDataWriter writer, Projection1D data)
+    {
+        writer.Put(data.Min);
+        writer.Put(data.Max);
+    }
+
+    internal static Projection1D Read(NetDataReader reader)
+    {
+        float min = reader.GetFloat();
+        float max = reader.GetFloat();
+
+        return new Projection1D(min, max);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/QuaternionNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/QuaternionNetPacker.cs
@ -0,0 +1,26 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class QuaternionNetPacker
+{
+    internal static void Write(NetDataWriter writer, Quaternion data)
+    {
+        writer.Put(data.X);
+        writer.Put(data.Y);
+        writer.Put(data.Z);
+        writer.Put(data.W);
+    }
+
+    internal static Quaternion Read(NetDataReader reader)
+    {
+        float x = reader.GetFloat();
+        float y = reader.GetFloat();
+        float z = reader.GetFloat();
+        float w = reader.GetFloat();
+
+        return new Quaternion(x, y, z, w);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/Shape2DNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/Shape2DNetPacker.cs
@ -0,0 +1,28 @@
+using System.Collections.Generic;
+
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class Shape2DNetPacker
+{
+    internal static void Write(NetDataWriter writer, Shape2D data)
+    {
+        writer.Put(data.Vertices.Count);
+        foreach (Vector2D vertex in data.Vertices)
+            Vector2DNetPacker.Write(writer, vertex);
+    }
+
+    internal static Shape2D Read(NetDataReader reader)
+    {
+        int verticesCount = reader.GetInt();
+        List<Vector2D> vertices = new(verticesCount);
+
+        for (int i = 0; i < verticesCount; i++)
+            vertices.Add(Vector2DNetPacker.Read(reader));
+
+        return new Shape2D(vertices);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/TriangleNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/TriangleNetPacker.cs
@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class TriangleNetPacker
+{
+    internal static void Write(NetDataWriter writer, Triangle data)
+    {
+        Vector2DNetPacker.Write(writer, data.A);
+        Vector2DNetPacker.Write(writer, data.B);
+        Vector2DNetPacker.Write(writer, data.C);
+    }
+
+    internal static Triangle Read(NetDataReader reader)
+    {
+        Vector2D a = Vector2DNetPacker.Read(reader);
+        Vector2D b = Vector2DNetPacker.Read(reader);
+        Vector2D c = Vector2DNetPacker.Read(reader);
+
+        return new Triangle(a, b, c);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/Vector2DNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/Vector2DNetPacker.cs
@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class Vector2DNetPacker
+{
+    internal static void Write(NetDataWriter writer, Vector2D data)
+    {
+        writer.Put(data.X);
+        writer.Put(data.Y);
+    }
+
+    internal static Vector2D Read(NetDataReader reader)
+    {
+        float x = reader.GetFloat();
+        float y = reader.GetFloat();
+
+        return new Vector2D(x, y);
+    }
+}
--- a/Shared/Network/LiteNetLib/Packers/Vector3DNetPacker.cs
+++ b/Shared/Network/LiteNetLib/Packers/Vector3DNetPacker.cs
@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+internal static class Vector3DNetPacker
+{
+    internal static void Write(NetDataWriter writer, Vector3D data)
+    {
+        writer.Put(data.X);
+        writer.Put(data.Y);
+        writer.Put(data.Z);
+    }
+
+    internal static Vector3D Read(NetDataReader reader)
+    {
+        float x = reader.GetFloat();
+        float y = reader.GetFloat();
+        float z = reader.GetFloat();
+
+        return new Vector3D(x, y, z);
+    }
+}
--- a/Shared/Network/NetworkManager.cs
+++ b/Shared/Network/NetworkManager.cs
@ -0,0 +1,333 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+/// <summary>
+/// Intermediary manager that looks up in it's hierarchy for a <see cref="INetworkCommunicator"/> to route/broadcast it's received packets to their destinations.
+/// </summary>
+public class NetworkManager : UniverseObject, INetworkManager
+{
+    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> clientPacketArrivalMethods = [];
+    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> serverPacketArrivalMethods = [];
+
+    private readonly Dictionary<Type, Dictionary<string, object>> clientPacketRouters = [];
+    private readonly Dictionary<Type, Dictionary<string, object>> serverPacketRouters = [];
+
+    private readonly List<(Type packetType, Delegate @delegate)> packetRetrievalDelegates = [];
+
+    private readonly Dictionary<Type, MethodInfo> clearRoutesMethods = [];
+    private readonly Dictionary<Type, MethodInfo> registerPacketListenersMethods = [];
+
+    private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
+    public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
+
+    private readonly BehaviourCollector<INetworkEntity> _networkEntityCollector = new();
+    public IBehaviourCollector<INetworkEntity> NetworkEntityCollector => _networkEntityCollector;
+
+    private INetworkCommunicator _networkCommunicator = null!;
+    public INetworkCommunicator NetworkCommunicator
+    {
+        get => _networkCommunicator;
+        set
+        {
+            if (_networkCommunicator == value)
+                return;
+
+            var previousCommunicator = _networkCommunicator;
+            _networkCommunicator = value;
+
+            if (previousCommunicator is not null) UnsubscribeCommunicatorMethods(previousCommunicator);
+            if (_networkCommunicator is not null) SubscribeCommunicatorMethods(_networkCommunicator);
+        }
+    }
+
+    #region Communicator Subscriptions
+    private void SubscribeCommunicatorMethods(INetworkCommunicator networkCommunicator)
+    {
+        MethodInfo subscribeToPacketsMethod = typeof(INetworkCommunicator)
+            .GetMethod(nameof(INetworkCommunicator.SubscribeToPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+
+        foreach ((Type packetType, Delegate @delegate) in packetRetrievalDelegates)
+        {
+            MethodInfo genericSubscribeMethod = subscribeToPacketsMethod.MakeGenericMethod(packetType);
+            genericSubscribeMethod.Invoke(networkCommunicator, [@delegate]);
+        }
+    }
+
+    private void UnsubscribeCommunicatorMethods(INetworkCommunicator networkCommunicator)
+    {
+        MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
+            .GetMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+
+        foreach ((Type packetType, Delegate @delegate) in packetRetrievalDelegates)
+        {
+            MethodInfo genericUnsubscribeMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);
+            genericUnsubscribeMethod.Invoke(networkCommunicator, [@delegate]);
+        }
+    }
+    #endregion
+
+    #region Packet Routing
+    private void OnPacketReceived<T>(string senderClientId, T entityDataPacket)
+    {
+        if (entityDataPacket is IEntityNetworkPacket entityPacket)
+            RoutePacket(senderClientId, entityDataPacket, entityPacket);
+        else
+            BroadcastPacket(senderClientId, entityDataPacket);
+    }
+
+    private void RoutePacket<T>(string senderClientId, T entityDataPacket, IEntityNetworkPacket entityPacket)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            RoutePacket(clientPacketRouters, entityPacket.EntityId, senderClientId, entityDataPacket);
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            RoutePacket(serverPacketRouters, entityPacket.EntityId, senderClientId, entityDataPacket);
+    }
+
+    private void BroadcastPacket<T>(string senderClientId, T entityDataPacket)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            BroadcastPacket(clientPacketRouters, senderClientId, entityDataPacket);
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            BroadcastPacket(serverPacketRouters, senderClientId, entityDataPacket);
+    }
+
+
+    private static void BroadcastPacket<T>(
+        Dictionary<Type, Dictionary<string, object>> packetRouters,
+        string senderClientId,
+        T entityDataPacket)
+    {
+        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, object>? routers))
+            return;
+
+        foreach ((string id, object routerEventReference) in routers)
+        {
+            Event<string, T> routerEvent = (Event<string, T>)routerEventReference;
+            routerEvent.Invoke(senderClientId, entityDataPacket!);
+        }
+    }
+
+    private static void RoutePacket<T>(
+        Dictionary<Type, Dictionary<string, object>> packetRouters,
+        string entityId,
+        string senderClientId,
+        T entityDataPacket)
+    {
+        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, object>? routers))
+            return;
+
+        if (!routers.TryGetValue(entityId, out object? routerEventReference))
+            return;
+
+        Event<string, T> routerEvent = (Event<string, T>)routerEventReference;
+        routerEvent.Invoke(senderClientId, entityDataPacket!);
+    }
+    #endregion
+
+    #region Packet Routers
+    private void RegisterPacketRoutersFor(
+        INetworkEntity behaviour,
+        Dictionary<Type, Dictionary<string, object>> packetRouters,
+        Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods,
+        NetworkType networkType)
+    {
+        if (!packetArrivalMethods.TryGetValue(behaviour.GetType(), out Dictionary<Type, List<MethodInfo>>? arrivalMethods))
+            return;
+
+        foreach ((Type packetType, List<MethodInfo> methods) in arrivalMethods)
+            foreach (MethodInfo receiveMethod in methods)
+            {
+                if (!packetRouters.TryGetValue(packetType, out Dictionary<string, object>? routers))
+                {
+                    routers = [];
+                    packetRouters.Add(packetType, routers);
+                }
+
+                object packetListenerEvent = CreateEventAndRegister(packetType, behaviour, networkType);
+                routers.Add(behaviour.Id, packetListenerEvent);
+            }
+    }
+
+    private object CreateEventAndRegister(Type packetType, INetworkEntity behaviour, NetworkType networkType)
+    {
+        Type genericEventType = typeof(Event<,>).MakeGenericType(typeof(string), packetType);
+        object packetListenerEvent = Activator.CreateInstance(genericEventType)!;
+
+        if (!registerPacketListenersMethods.TryGetValue(packetType, out MethodInfo? registerPacketListenerMethod))
+            throw new($"{nameof(RegisterPacketListenerEvent)} for {packetType.Name} has not been cached.");
+
+        registerPacketListenerMethod.Invoke(this, [behaviour, packetListenerEvent, networkType]);
+        return packetListenerEvent;
+    }
+
+    private static void RegisterPacketListenerEvent<T>(
+        INetworkEntity behaviour,
+        Event<string, T> packetListenerEvent,
+        NetworkType networkType)
+    {
+        switch (networkType)
+        {
+            case NetworkType.Client: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerClient<T>)behaviour).OnClientPacketArrived(packet)); break;
+            case NetworkType.Server: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerServer<T>)behaviour).OnServerPacketArrived(sender, packet)); break;
+        }
+    }
+
+    private void UnregisterPacketRoutersFor(
+        INetworkEntity behaviour,
+        Dictionary<Type, Dictionary<string, object>> packetRouters,
+        Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods)
+    {
+        if (!packetArrivalMethods.TryGetValue(behaviour.GetType(), out Dictionary<Type, List<MethodInfo>>? arrivalMethods))
+            return;
+
+        foreach ((Type packetType, List<MethodInfo> methods) in arrivalMethods)
+        {
+            if (!packetRouters.TryGetValue(packetType, out Dictionary<string, object>? routers))
+                continue;
+
+            if (!routers.TryGetValue(behaviour.Id, out object? routerEventReference))
+                continue;
+
+            if (!clearRoutesMethods.TryGetValue(packetType, out MethodInfo? clearRouterMethod))
+                continue;
+
+            clearRouterMethod.Invoke(this, [routerEventReference]);
+        }
+    }
+
+    private static void ClearRouter<T>(object routerEventReference)
+    {
+        Event<string, T> routerEvent = (Event<string, T>)routerEventReference;
+        routerEvent.Clear();
+    }
+
+    #endregion
+
+    #region Engine Callbacks
+    private void OnCollected(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourCollectedArguments args)
+    {
+        INetworkEntity collectedBehaviour = args.BehaviourCollected;
+
+        if (!_networkEntities.TryAdd(collectedBehaviour.Id, collectedBehaviour))
+            throw new($"Unable to add {collectedBehaviour.Id} to {nameof(NetworkManager)}");
+
+        RegisterPacketRoutersFor(collectedBehaviour, clientPacketRouters, clientPacketArrivalMethods, NetworkType.Client);
+        RegisterPacketRoutersFor(collectedBehaviour, serverPacketRouters, serverPacketArrivalMethods, NetworkType.Server);
+    }
+
+    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourRemovedArguments args)
+    {
+        INetworkEntity removedBehaviour = args.BehaviourRemoved;
+        if (!_networkEntities.Remove(args.BehaviourRemoved.Id))
+            return;
+
+        UnregisterPacketRoutersFor(removedBehaviour, clientPacketRouters, clientPacketArrivalMethods);
+        UnregisterPacketRoutersFor(removedBehaviour, serverPacketRouters, serverPacketArrivalMethods);
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
+    protected override void OnEnteringUniverse(IUniverse universe)
+    {
+        _networkEntityCollector.Assign(universe);
+        NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
+    }
+    #endregion
+
+    #region Initialization
+    public NetworkManager()
+    {
+        CachePacketRetrievalDelegates();
+        CacheRegistrationMethods();
+        CachePacketArrivalMethods();
+
+        _networkEntityCollector.OnCollected.AddListener(OnCollected);
+        _networkEntityCollector.OnRemoved.AddListener(OnRemoved);
+    }
+
+    private void CachePacketRetrievalDelegates()
+    {
+        IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
+            .Where(t => typeof(INetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType);
+
+        MethodInfo onPacketArrivedMethod = GetType()
+            .GetMethod(nameof(OnPacketReceived), BindingFlags.NonPublic | BindingFlags.Instance)!;
+
+        foreach (Type packetType in packetTypes)
+        {
+            MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType);
+
+            Type genericDelegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(string), packetType);
+            Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
+
+            packetRetrievalDelegates.Add((packetType, genericPacketReceivedDelegate));
+        }
+    }
+
+    private void CacheRegistrationMethods()
+    {
+        CacheRegistrationMethods(registerPacketListenersMethods, nameof(RegisterPacketListenerEvent));
+        CacheRegistrationMethods(clearRoutesMethods, nameof(ClearRouter));
+    }
+
+    private void CacheRegistrationMethods(Dictionary<Type, MethodInfo> registrationMethods, string methodName)
+    {
+        MethodInfo registerPacketMethod = typeof(NetworkManager).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static)!;
+        foreach ((Type packetType, Delegate @delegate) in packetRetrievalDelegates)
+        {
+            MethodInfo genericMethod = registerPacketMethod.MakeGenericMethod(packetType);
+            registrationMethods.Add(packetType, genericMethod);
+        }
+    }
+
+    private void CachePacketArrivalMethods()
+    {
+        CachePacketArrivalMethods(clientPacketArrivalMethods, typeof(IPacketListenerClient<>), nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived));
+        CachePacketArrivalMethods(serverPacketArrivalMethods, typeof(IPacketListenerServer<>), nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived));
+    }
+
+    private static void CachePacketArrivalMethods(Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods, Type listenerType, string packetArrivalMethodName)
+    {
+        foreach (Type listenerClass in GetGenericsWith(listenerType))
+        {
+            Dictionary<Type, List<MethodInfo>> packetRouters = [];
+            packetArrivalMethods.Add(listenerClass, packetRouters);
+
+            foreach (Type packetListener in GetGenericInterfacesWith(listenerType, listenerClass))
+            {
+                Type packetType = packetListener.GetGenericArguments().First();
+
+                List<MethodInfo> arrivalMethods = packetListener
+                    .GetMethods()
+                    .Where(m => m.Name == packetArrivalMethodName)
+                    .ToList();
+
+                packetRouters.Add(packetType, arrivalMethods);
+            }
+        }
+    }
+
+    private static IEnumerable<Type> GetGenericsWith(Type type)
+        => AppDomain.CurrentDomain
+            .GetAssemblies()
+            .SelectMany(a =>
+                a.GetTypes().Where(
+                    t => t.GetInterfaces().Any(
+                        i => i.IsGenericType && i.GetGenericTypeDefinition() == type
+                    )
+                )
+            );
+
+    private static IEnumerable<Type> GetGenericInterfacesWith(Type interfaceType, Type type)
+        => type.GetInterfaces().Where(
+            i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceType
+        );
+    #endregion
+
+    private enum NetworkType { Client, Server }
+}
--- a/Shared/Network/NetworkManagerSlo.cs
+++ b/Shared/Network/NetworkManagerSlo.cs
@ -0,0 +1,325 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public class NetworkManagerSlo : UniverseObject, INetworkManager
+{
+    private readonly List<(Type packetType, Delegate callback)> packetDelegates = [];
+
+    private readonly Dictionary<Type, Dictionary<Type, List<DelegateData>>> clientListenerDelegates = [];
+    private readonly Dictionary<Type, Dictionary<Type, List<DelegateData>>> serverListenerDelegates = [];
+
+    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> clientPacketListeners = [];
+    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> serverPacketListeners = [];
+
+    private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
+    private readonly BehaviourCollector<INetworkEntity> _networkEntityCollector = new();
+
+    public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
+    public IBehaviourCollector<INetworkEntity> NetworkEntityCollector => _networkEntityCollector;
+
+    private INetworkCommunicator _networkCommunicator = null!;
+    public INetworkCommunicator NetworkCommunicator
+    {
+        get => _networkCommunicator;
+        set
+        {
+            if (_networkCommunicator == value)
+                return;
+
+            INetworkCommunicator previousCommunicator = _networkCommunicator;
+            _networkCommunicator = value;
+
+            if (previousCommunicator is not null)
+                UnsubscribeDelegates(previousCommunicator);
+
+            if (_networkCommunicator is not null)
+                SubscribeDelegates(_networkCommunicator);
+        }
+    }
+
+    #region Network Communicator Subscriptions
+    private static MethodInfo? GetCommunicatorMethod(string methodName)
+        => typeof(INetworkCommunicator).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
+
+    private void SubscribeDelegates(INetworkCommunicator communicator)
+    {
+        MethodInfo subscribeMethod = GetCommunicatorMethod(nameof(INetworkCommunicator.SubscribeToPackets))!;
+
+        foreach ((Type packetType, Delegate callback) in packetDelegates)
+        {
+            MethodInfo genericMethod = subscribeMethod.MakeGenericMethod(packetType);
+            genericMethod.Invoke(communicator, [callback]);
+        }
+    }
+
+    private void UnsubscribeDelegates(INetworkCommunicator communicator)
+    {
+        MethodInfo unsubscribeMethod = GetCommunicatorMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets))!;
+
+        foreach ((Type packetType, Delegate callback) in packetDelegates)
+        {
+            MethodInfo genericMethod = unsubscribeMethod.MakeGenericMethod(packetType);
+            genericMethod.Invoke(communicator, [callback]);
+        }
+    }
+    #endregion
+
+    #region Engine Callbacks
+    private void OnEntityCollected(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourCollectedArguments args)
+    {
+        INetworkEntity entity = args.BehaviourCollected;
+
+        if (!_networkEntities.TryAdd(entity.Id, entity))
+            throw new Exception($"Unable to add {entity.Id} to {nameof(NetworkManager)}");
+
+        RegisterEntityListeners(entity);
+    }
+
+    private void OnEntityRemoved(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourRemovedArguments args)
+    {
+        INetworkEntity removedBehaviour = args.BehaviourRemoved;
+        if (!_networkEntities.Remove(args.BehaviourRemoved.Id))
+            return;
+
+        UnRegisterEntityListeners(removedBehaviour);
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe)
+    {
+        _networkEntityCollector.Unassign();
+    }
+
+    protected override void OnEnteringUniverse(IUniverse universe)
+    {
+        _networkEntityCollector.Assign(universe);
+        NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
+    }
+    #endregion
+
+    #region Packet Retrieval
+    private void OnPacketReceived<T>(string senderClientId, T packet)
+    {
+        if (packet is IEntityNetworkPacket entityPacket)
+            RouteEntityPacket(senderClientId, entityPacket.EntityId, packet);
+        else
+            RouteBroadcastPacket(senderClientId, packet!);
+    }
+
+    private void RouteEntityPacket<T>(string senderClientId, string entityId, T packet)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            InvokeListenerIfExists(clientPacketListeners, entityId, senderClientId, packet!);
+
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            InvokeListenerIfExists(serverPacketListeners, entityId, senderClientId, packet!);
+    }
+
+    private void RouteBroadcastPacket<T>(string senderClientId, T packet)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            InvokeAllListeners(clientPacketListeners, senderClientId, packet!);
+
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            InvokeAllListeners(serverPacketListeners, senderClientId, packet!);
+    }
+
+    private static void InvokeListenerIfExists<T>(
+        Dictionary<Type, Dictionary<string, Event<string, object>>> listeners,
+        string entityId,
+        string senderClientId,
+        T packet)
+    {
+        if (!listeners.TryGetValue(packet!.GetType(), out Dictionary<string, Event<string, object>>? entityListeners))
+            return;
+
+        if (entityListeners.TryGetValue(entityId, out Event<string, object>? listenerEvent))
+            listenerEvent.Invoke(senderClientId, packet);
+    }
+
+    private static void InvokeAllListeners<T>(
+        Dictionary<Type, Dictionary<string, Event<string, object>>> listeners,
+        string senderClientId,
+        T packet)
+    {
+        if (!listeners.TryGetValue(packet!.GetType(), out Dictionary<string, Event<string, object>>? entityListeners))
+            return;
+
+        foreach ((string _, Event<string, object> listenerEvent) in entityListeners)
+            listenerEvent.Invoke(senderClientId, packet);
+    }
+    #endregion
+
+    #region Listener Setups
+    private void RegisterEntityListeners(INetworkEntity entity)
+    {
+        RegisterEntityListenersForSide(entity, clientListenerDelegates, clientPacketListeners, isServer: false);
+        RegisterEntityListenersForSide(entity, serverListenerDelegates, serverPacketListeners, isServer: true);
+    }
+
+    private static void RegisterEntityListenersForSide(
+        INetworkEntity entity,
+        Dictionary<Type, Dictionary<Type, List<DelegateData>>> listenerDelegates,
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetListeners,
+        bool isServer)
+    {
+        if (!listenerDelegates.TryGetValue(entity.GetType(), out Dictionary<Type, List<DelegateData>>? interfaceDelegates))
+            return;
+
+        foreach ((Type interfaceType, List<DelegateData> delegateDataList) in interfaceDelegates)
+            foreach ((Type parameterType, MethodInfo receiveMethod) in delegateDataList)
+            {
+                Dictionary<string, Event<string, object>> listeners = GetOrCreateListenersForPacketType(packetListeners, parameterType);
+                Event<string, object> listenerEvent = CreateListenerEvent(entity, receiveMethod, isServer);
+                listeners.Add(entity.Id, listenerEvent);
+            }
+    }
+
+    private void UnRegisterEntityListeners(INetworkEntity entity)
+    {
+        UnregisterEntityListenersForSide(entity, clientListenerDelegates, clientPacketListeners);
+        UnregisterEntityListenersForSide(entity, serverListenerDelegates, serverPacketListeners);
+    }
+
+    private static void UnregisterEntityListenersForSide(
+        INetworkEntity entity,
+        Dictionary<Type, Dictionary<Type, List<DelegateData>>> listenerDelegates,
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetListeners)
+    {
+        if (!listenerDelegates.TryGetValue(entity.GetType(), out Dictionary<Type, List<DelegateData>>? interfaceDelegates))
+            return;
+
+        foreach ((Type interfaceType, List<DelegateData> delegateDataList) in interfaceDelegates)
+            foreach ((Type parameterType, MethodInfo receiveMethod) in delegateDataList)
+            {
+                Dictionary<string, Event<string, object>> listeners = GetOrCreateListenersForPacketType(packetListeners, parameterType);
+
+                if (!listeners.TryGetValue(entity.Id, out Event<string, object>? listenerEvent))
+                    continue;
+
+                listeners.Remove(entity.Id);
+                listenerDelegates.Clear();
+            }
+    }
+
+    private static Dictionary<string, Event<string, object>> GetOrCreateListenersForPacketType(
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetListeners,
+        Type packetType)
+    {
+        if (!packetListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? listeners))
+        {
+            listeners = [];
+            packetListeners.Add(packetType, listeners);
+        }
+        return listeners;
+    }
+
+    private static Event<string, object> CreateListenerEvent(INetworkEntity entity, MethodInfo receiveMethod, bool isServer)
+    {
+        Event<string, object> listenerEvent = new();
+
+        if (isServer)
+            listenerEvent.AddListener((sender, packet) => receiveMethod.Invoke(entity, [sender, packet]));
+        else
+            listenerEvent.AddListener((sender, packet) => receiveMethod.Invoke(entity, [packet]));
+
+        return listenerEvent;
+    }
+    #endregion
+
+    #region Initialization
+    private static IEnumerable<Type> DiscoverPacketTypes()
+        => AppDomain.CurrentDomain.GetAssemblies()
+            .SelectMany(a => a.GetTypes())
+            .Where(
+                t => typeof(INetworkPacket).IsAssignableFrom(t)
+                    && !t.IsInterface
+                    && !t.IsAbstract
+                    && !t.IsGenericType
+            );
+
+    private static IEnumerable<Type> DiscoverClassesImplementing(Type interfaceType)
+        => AppDomain.CurrentDomain.GetAssemblies()
+            .SelectMany(a => a.GetTypes())
+            .Where(
+                t => t.GetInterfaces().Any(
+                    i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceType
+                )
+            );
+
+    private static IEnumerable<Type> GetInterfacesOfType(Type type, Type interfaceType)
+        => type.GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceType);
+
+    private static void CacheListenerDelegatesForSide(Dictionary<Type, Dictionary<Type, List<DelegateData>>> targetCache, Type listenerInterfaceType, string methodName)
+    {
+        IEnumerable<Type> listenerClasses = DiscoverClassesImplementing(listenerInterfaceType);
+
+        foreach (Type listenerClass in listenerClasses)
+        {
+            Dictionary<Type, List<DelegateData>> interfaceListeners = [];
+            targetCache.Add(listenerClass, interfaceListeners);
+
+            IEnumerable<Type> interfaces = GetInterfacesOfType(listenerClass, listenerInterfaceType);
+
+            foreach (Type listenerInterface in interfaces)
+            {
+                Type packetType = listenerInterface.GetGenericArguments().First();
+
+                List<DelegateData> methods = listenerInterface.GetMethods()
+                    .Where(m => m.Name == methodName)
+                    .Select(m => new DelegateData(packetType, m))
+                    .ToList();
+
+                interfaceListeners.Add(packetType, methods);
+            }
+        }
+    }
+
+    private void CacheListenerDelegates()
+    {
+        CacheListenerDelegatesForSide(clientListenerDelegates, typeof(IPacketListenerClient<>), nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived));
+        CacheListenerDelegatesForSide(serverListenerDelegates, typeof(IPacketListenerServer<>), nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived));
+    }
+
+    private void CachePacketDelegates()
+    {
+        IEnumerable<Type> packetTypes = DiscoverPacketTypes();
+        MethodInfo onPacketReceivedMethod = GetType().GetMethod(
+            nameof(OnPacketReceived),
+            BindingFlags.NonPublic | BindingFlags.Instance
+        )!;
+
+        foreach (Type packetType in packetTypes)
+        {
+            MethodInfo genericMethod = onPacketReceivedMethod.MakeGenericMethod(packetType);
+            Type delegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(string), packetType);
+            Delegate packetDelegate = Delegate.CreateDelegate(delegateType, this, genericMethod);
+
+            packetDelegates.Add((packetType, packetDelegate));
+        }
+    }
+
+    public NetworkManagerSlo()
+    {
+        CachePacketDelegates();
+        CacheListenerDelegates();
+
+        _networkEntityCollector.OnCollected.AddListener(OnEntityCollected);
+        _networkEntityCollector.OnRemoved.AddListener(OnEntityRemoved);
+    }
+    #endregion
+
+    private readonly record struct DelegateData(Type ParameterType, MethodInfo ReceiveMethod)
+    {
+        public static implicit operator (Type ParameterType, MethodInfo ReceiveMethod)(DelegateData value)
+            => (value.ParameterType, value.ReceiveMethod);
+
+        public static implicit operator DelegateData((Type ParameterType, MethodInfo ReceiveMethod) value)
+            => new(value.ParameterType, value.ReceiveMethod);
+    }
+}
--- a/Shared/Shared.csproj
+++ b/Shared/Shared.csproj
@ -1,10 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Apos.Shapes" Version="0.2.3" />
+    <PackageReference Include="LiteNetLib" Version="1.3.1" />
    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.1.303" />
    <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.2.1105">
      <PrivateAssets>All</PrivateAssets>
@ -12,5 +13,6 @@
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="../Engine/Engine/Engine.csproj" />
+    <ProjectReference Include="../Engine/Engine.Integration/Engine.Integration.MonoGame/Engine.Integration.MonoGame.csproj" />
  </ItemGroup>
 </Project>
Author	SHA1	Message	Date
Syntriax	dcee3a0ff0	chore: updated engine to use MonoGame integrations	2025-06-01 18:38:07 +03:00
Syntriax	1ff26f5be4	refactor: renamed delegate type to be less confusing	2025-06-01 11:28:14 +03:00
Syntriax	e27b825990	perf: network manager registration memory allocation reduced further by removing boxing on some methods	2025-06-01 11:19:33 +03:00
Syntriax	4824496f1a	fix: network manager not subscribing to communicator properly	2025-06-01 10:20:06 +03:00
Syntriax	f3b7ccaf70	refactor: network manager refactored for readability	2025-06-01 02:21:24 +03:00
Syntriax	475d82ba02	chore: added one client one server compound for launch.json	2025-05-31 23:22:43 +03:00
Syntriax	b3dd0f72a4	fix: network manager not unmonitoring removed universe objects	2025-05-31 23:22:12 +03:00
Syntriax	f3ff1b74d2	perf: reduced network manager memory allocations	2025-05-31 22:53:53 +03:00
Syntriax	8901a5469f	perf: improved networking code to use the new events	2025-05-31 20:25:30 +03:00
Syntriax	52682d42b6	chore: updated engine to use the new events	2025-05-31 00:34:27 +03:00
Syntriax	0acd119099	refactor: implemented new IBehaviourCollector	2025-05-29 23:17:44 +03:00
Syntriax	3c38cb4159	perf: removed obsolete method calls and switched to for in draw calls	2025-05-29 22:49:51 +03:00
Syntriax	59059fa09d	feat: paddle networking	2025-05-28 22:09:49 +03:00
Syntriax	cbda44c2d5	feat: ball networking	2025-05-28 17:18:15 +03:00
Syntriax	f20aabcacf	chore: unused types removed	2025-05-28 16:56:07 +03:00
Syntriax	da284eda95	fix: build task	2025-05-27 11:36:37 +03:00
Syntriax	d0ef2ef224	chore: de-networked pong manager	2025-05-26 23:07:37 +03:00
Syntriax	bddf00ce7a	perf: packet listener methods are now cached for performance	2025-05-26 22:09:40 +03:00
Syntriax	29829bbaa6	refactor: entity packets now directly go into the target entity	2025-05-26 21:58:09 +03:00
Syntriax	12f4950ffb	refactor: network implementations switched to universe objects	2025-05-25 13:34:45 +03:00
Syntriax	0da5ac6f57	chore: updated engine to the version that fixes first frame calls	2025-05-24 20:06:09 +03:00
Syntriax	79922fadbe	chore: improved paddle synchronization	2025-05-24 17:09:13 +03:00
Syntriax	0f0180d435	refactor: client is now running on a different thread	2025-05-24 17:08:58 +03:00
Syntriax	ed6f783180	chore: engine update	2025-05-22 23:52:13 +03:00
Syntriax	2853a6130b	feat: basic pong manager networking added	2025-05-21 22:45:21 +03:00
Syntriax	8f9c9f77f0	chore: formatted usings in network packers	2025-05-21 22:43:26 +03:00
Syntriax	2b29636b4f	fix: network manager looking up wrong type of interface to register listeners	2025-05-19 23:59:41 +03:00
Syntriax	4f3a2b4a4e	refactor: paddle packets renamed and cleaned up	2025-05-19 22:39:55 +03:00
Syntriax	57868ce178	feat: client & server packet listener interfaces added	2025-05-19 22:24:06 +03:00
Syntriax	214c37e63f	feat: working networked paddles	2025-05-18 00:49:14 +03:00
Syntriax	54bdcd93b2	fix: vector 2d & 3d's x values being read as int fixed	2025-05-18 00:48:11 +03:00
Syntriax	721d63cf66	refactor: network entity packets	2025-05-17 22:17:25 +03:00
Syntriax	03082ab43b	feat: engine data type packers	2025-05-16 21:55:20 +03:00
Syntriax	6591326b70	feat: network manager listens to all received packets	2025-05-12 19:18:02 +03:00
Syntriax	0153d4cf69	chore: added vscode launch configurations for server and client	2025-05-11 11:51:57 +03:00
Syntriax	94f7d4acfd	fix: renamed old classes and fixed packet registration issues	2025-05-11 11:51:25 +03:00
Syntriax	23a0c8e893	feat: added revised version of the old networking system	2025-05-11 00:02:53 +03:00