feat: added LiteNetLib networking integration

Use IUniverseObject.Children to access children

Engine.Core/Abstract/IUniverseObject.cs

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

Engine.Core/BehaviourBase.cs

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

Engine.Core/BehaviourController.cs

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

Engine.Core/Debug/AssertHelpers.cs

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

Engine.Core/Extensions/BehaviourControllerExtensions.cs

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

Engine.Core/Extensions/UniverseObjectExtensions.cs

@@ -12,7 +12,7 @@ public static class UniverseObjectExtensions
         if (!string.IsNullOrWhiteSpace(name))
             universeObject.Name = name;
         if (parent is not null)
-            universeObject.SetParent(parent);
+            universeObject.Parent = parent;
         return universeObject;
     }
 
@@ -81,7 +81,7 @@ public static class UniverseObjectExtensions
     /// <returns>The <see cref="IUniverseObject"/> of the specified type if found; otherwise, null.</returns>
     public static T? GetUniverseObjectInParent<T>(this IUniverseObject universeObject) where T : class
     {
-        if (universeObject.GetUniverseObject<T>() is T localUniverseObject)
+        if (universeObject.Children.GetUniverseObject<T>() is T localUniverseObject)
             return localUniverseObject;
 
         IUniverseObject? parent = universeObject;
@@ -129,10 +129,10 @@ public static class UniverseObjectExtensions
     /// <returns>The <see cref="IUniverseObject"/> of the specified type if found; otherwise, null.</returns>
     public static T? GetUniverseObjectInChildren<T>(this IUniverseObject universeObject) where T : class
     {
-        if (universeObject.GetUniverseObject<T>() is T localUniverseObject)
+        if (universeObject.Children.GetUniverseObject<T>() is T localUniverseObject)
             return localUniverseObject;
 
-        foreach (IUniverseObject child in universeObject)
+        foreach (IUniverseObject child in universeObject.Children)
             if (GetUniverseObjectInChildren<T>(child) is T behaviour)
                 return behaviour;
 
@@ -246,7 +246,7 @@ public static class UniverseObjectExtensions
 
         foreach (IUniverseObject universeObject in universeObjects)
         {
-            universeObject.Find(cache);
+            universeObject.Children.Find(cache);
             foreach (T behaviour in cache)
                 instances.Add(behaviour);
         }

Engine.Core/Factory/BehaviourControllerFactory.cs

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

Engine.Core/Factory/BehaviourFactory.cs

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

Engine.Core/Factory/UniverseObjectFactory.cs

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

Engine.Core/Universe.cs

@@ -83,7 +83,7 @@ public class Universe : BaseEntity, IUniverse
 
     public void Remove(IUniverseObject universeObject)
     {
-        universeObject.SetParent(null);
+        universeObject.Parent = null;
         RemoveIncursive(universeObject);
     }
 

Engine.Core/UniverseObject.cs

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

Engine.Integration/Engine.Integration.LiteNetLib/Engine.Integration.LiteNetLib.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <RootNamespace>Syntriax.Engine.Systems.Network</RootNamespace>
+    <AssemblyName>Syntriax.Engine.Integration.LiteNetLib</AssemblyName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="LiteNetLib" Version="1.3.1" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="../../Engine/Engine.csproj" />
+  </ItemGroup>
+
+</Project>

Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibClient.cs

@@ -0,0 +1,85 @@
+using System.Net.Sockets;
+
+using LiteNetLib;
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Debug;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public class LiteNetLibClient : LiteNetLibCommunicatorBase, INetworkCommunicatorClient
+{
+    private readonly NetDataWriter netDataWriter = new();
+
+    private CancellationTokenSource? cancellationTokenSource = null;
+
+    protected override IConnection GetConnection(NetPeer peer) => new LiteNetLibServerConnection(peer);
+
+    public INetworkCommunicatorClient Connect(string address, int port, string? password = null)
+    {
+        if (!UniverseObject.IsInUniverse)
+            throw new($"{nameof(LiteNetLibClient)} must be in an universe to connect");
+
+        password ??= string.Empty;
+
+        // Okay, for some reason sometimes LiteNetLib goes dumb when the server hostname has IPv6 address as well as IPv4
+        // but the client doesn't support IPv6, it still tries to use the v6 unless we explicitly tell the ip to connect to,
+        // which fails to connect... So for the time being I am preferring IPv4 below over IPv6 for clients.
+        // TODO: I think this is something that happens on Linux only? I need to check on Windows as well just to be sure.
+        System.Net.IPAddress[] addresses = System.Net.Dns.GetHostAddresses(address);
+        string connectionAddress = addresses.FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork, addresses[0]).ToString();
+
+        logger?.Log(this, $"Connecting to server at '{address}:{port}' with password '{password}'");
+        logger?.Log(this, $"Resolved address for {address}: {connectionAddress}");
+
+        Manager.Start();
+        Manager.Connect(connectionAddress, port, password);
+
+        return this;
+    }
+
+    public INetworkCommunicatorClient SendToServer<T>(T packet, PacketDelivery packetDelivery) where T : class, new()
+    {
+        netDataWriter.Reset();
+        netPacketProcessor.Write(netDataWriter, packet);
+
+        switch (packetDelivery)
+        {
+            case PacketDelivery.ReliableInOrder: Manager.FirstPeer.Send(netDataWriter, DeliveryMethod.ReliableOrdered); break;
+            case PacketDelivery.UnreliableInOrder: Manager.FirstPeer.Send(netDataWriter, DeliveryMethod.Sequenced); break;
+            case PacketDelivery.ReliableOutOfOrder: Manager.FirstPeer.Send(netDataWriter, DeliveryMethod.ReliableUnordered); break;
+            case PacketDelivery.UnreliableOutOfOrder: Manager.FirstPeer.Send(netDataWriter, DeliveryMethod.Unreliable); break;
+            default: Manager.FirstPeer.Send(netDataWriter, DeliveryMethod.ReliableOrdered); break;
+        }
+
+        return this;
+    }
+
+    protected override void OnEnteredUniverse(IUniverse universe)
+    {
+        base.OnEnteredUniverse(universe);
+
+        cancellationTokenSource = new CancellationTokenSource();
+        PollEvents(cancellationTokenSource.Token);
+    }
+
+    protected override void OnExitedUniverse(IUniverse universe)
+    {
+        base.OnExitedUniverse(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);
+}

Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibClientConnection.cs

@@ -0,0 +1,16 @@
+using LiteNetLib;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public record class LiteNetLibClientConnection(NetPeer NetPeer) : IConnection
+{
+    public string Id { get; } = NetPeer.Id.ToString();
+
+    public float Ping => NetPeer.Ping * .001f;
+    public float RoundTrip => NetPeer.RoundTripTime * .001f;
+
+    public int PingMs => NetPeer.Ping;
+    public int RoundTripMs => NetPeer.RoundTripTime;
+
+    public override string ToString() => $"Connection({Id})";
+}

Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibCommunicatorBase.cs

@@ -0,0 +1,185 @@
+using System.Reflection;
+
+using LiteNetLib;
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Debug;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public abstract class LiteNetLibCommunicatorBase : Behaviour, INetworkCommunicator
+{
+    protected readonly NetPacketProcessor netPacketProcessor = new();
+
+    private readonly Dictionary<Type, Event<IConnection, object>> listeners = [];
+    private readonly Dictionary<string, IConnection> _connections = [];
+
+    private readonly Dictionary<int, IConnection> localPeerIdToConnectionDictionary = [];
+
+    protected ILogger? logger = null;
+
+    public IReadOnlyDictionary<string, IConnection> Connections => _connections;
+    public EventBasedNetListener Listener { get; private set; } = null!;
+    public NetManager Manager { get; private set; } = null!;
+
+    public Event<INetworkCommunicator, IConnection> OnConnectionEstablished { get; } = new();
+    public Event<INetworkCommunicator, IConnection> OnConnectionAbolished { get; } = new();
+
+    public INetworkCommunicator Stop()
+    {
+        Manager.Stop();
+        return this;
+    }
+
+    protected override void OnEnteredUniverse(IUniverse universe)
+    {
+        base.OnEnteredUniverse(universe);
+        logger = universe.FindBehaviour<ILogger>();
+    }
+
+    protected override void OnExitedUniverse(IUniverse universe)
+    {
+        base.OnExitedUniverse(universe);
+        logger = null;
+        Stop();
+    }
+
+    protected virtual void OnPacketArrived<T>(T packet, NetPeer peer) where T : INetworkPacket
+    {
+        if (!listeners.TryGetValue(typeof(T), out Event<IConnection, object>? @event))
+            return;
+
+        @event.Invoke(localPeerIdToConnectionDictionary[peer.Id], packet);
+    }
+
+    private void NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod)
+    {
+        try { netPacketProcessor.ReadAllPackets(reader, peer); }
+        catch (Exception exception) { logger?.LogException(this, exception, force: true); }
+    }
+
+    protected abstract IConnection GetConnection(NetPeer peer);
+    private void ConnectionEstablished(NetPeer peer)
+    {
+        IConnection connection = GetConnection(peer);
+
+        localPeerIdToConnectionDictionary.Add(peer.Id, connection);
+        _connections.Add(connection.Id, connection);
+
+        logger?.Log(this, $"Connection established with ip '{peer.Address}' and id '{connection.Id}'");
+        OnConnectionEstablished.Invoke(this, connection);
+    }
+
+    private void ConnectionAbolished(NetPeer peer, DisconnectInfo disconnectInfo)
+    {
+        if (!localPeerIdToConnectionDictionary.TryGetValue(peer.Id, out IConnection? connection))
+            return;
+
+        localPeerIdToConnectionDictionary.Remove(peer.Id);
+        _connections.Remove(connection.Id);
+
+        logger?.Log(this, $"Connection abolished with ip '{peer.Address}' and id '{connection.Id}'");
+        OnConnectionAbolished.Invoke(this, connection);
+    }
+
+    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);
+
+            MethodInfo genericSubscribeReusableMethod = subscribeReusableMethod.MakeGenericMethod(packetType, typeof(NetPeer));
+            genericSubscribeReusableMethod.Invoke(netPacketProcessor, [delegateHandler]);
+        }
+    }
+
+    public LiteNetLibCommunicatorBase()
+    {
+        Listener = new EventBasedNetListener();
+        Manager = new NetManager(Listener);
+
+        Listener.NetworkReceiveEvent += NetworkReceiveEvent;
+        Listener.PeerConnectedEvent += ConnectionEstablished;
+        Listener.PeerDisconnectedEvent += ConnectionAbolished;
+
+        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<IConnection, T>.EventHandler callback)
+    {
+        Type type = typeof(T);
+        if (!listeners.TryGetValue(type, out Event<IConnection, object>? @event))
+        {
+            @event = new();
+            listeners.Add(type, @event);
+        }
+
+        @event.AddListener(EventDelegateWrapper(callback));
+        return this;
+    }
+
+    public INetworkCommunicator UnsubscribeFromPackets<T>(Event<IConnection, T>.EventHandler callback)
+    {
+        Type type = typeof(T);
+        if (!listeners.TryGetValue(type, out Event<IConnection, object>? @event))
+            return this;
+
+        @event.RemoveListener(EventDelegateWrapper(callback));
+        return this;
+    }
+
+    private static Event<IConnection, object>.EventHandler EventDelegateWrapper<T>(Event<IConnection, T>.EventHandler callback) => (sender, @object) => callback.Invoke(sender, (T)@object);
+}

Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibServer.cs

@@ -0,0 +1,102 @@
+using LiteNetLib;
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Debug;
+
+namespace Syntriax.Engine.Systems.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 += OnConnectionRequest;
+    }
+
+    protected override IConnection GetConnection(NetPeer peer) => new LiteNetLibClientConnection(peer);
+
+    private void OnConnectionRequest(ConnectionRequest request)
+    {
+        logger?.Log(this, $"Connection request from ip {request.RemoteEndPoint}");
+        logger?.Log(this, $"Current connection count: {Connections.Count}");
+        if (Manager.ConnectedPeersCount < MaxConnectionCount)
+            request.AcceptIfKey(Password);
+        else
+            request.Reject();
+    }
+
+    public INetworkCommunicatorServer Start(int port, int maxConnectionCount, string? password = null)
+    {
+        if (!UniverseObject.IsInUniverse)
+            throw new($"{nameof(LiteNetLibServer)} must be in an universe to start");
+
+        Password = password ?? string.Empty;
+        MaxConnectionCount = maxConnectionCount;
+        Port = port;
+
+        logger?.Log(this, $"Starting server on port '{port}' with password '{Password}' and max connection count '{maxConnectionCount}'");
+        logger?.Log(this, $"Server status: {(Manager.Start(port) ? "Active" : "Failed")}");
+
+        return this;
+    }
+
+    public INetworkCommunicatorServer SendToClient<T>(IConnection connection, T packet, PacketDelivery packetDelivery) where T : class, new()
+    {
+        netDataWriter.Reset();
+        netPacketProcessor.Write(netDataWriter, packet);
+
+        if (Manager.ConnectedPeerList.FirstOrDefault(p => p.Id.CompareTo(connection.Id) == 0) is not NetPeer netPeer)
+            throw new($"Peer {connection} couldn't be found.");
+
+        switch (packetDelivery)
+        {
+            case PacketDelivery.ReliableInOrder: netPeer.Send(netDataWriter, DeliveryMethod.ReliableOrdered); break;
+            case PacketDelivery.UnreliableInOrder: netPeer.Send(netDataWriter, DeliveryMethod.Sequenced); break;
+            case PacketDelivery.ReliableOutOfOrder: netPeer.Send(netDataWriter, DeliveryMethod.ReliableUnordered); break;
+            case PacketDelivery.UnreliableOutOfOrder: netPeer.Send(netDataWriter, DeliveryMethod.Unreliable); break;
+            default: netPeer.Send(netDataWriter, DeliveryMethod.ReliableOrdered); break;
+        }
+
+        return this;
+    }
+
+    public INetworkCommunicatorServer SendToAll<T>(T packet, PacketDelivery packetDelivery) where T : class, new()
+    {
+        netDataWriter.Reset();
+        netPacketProcessor.Write(netDataWriter, packet);
+
+        switch (packetDelivery)
+        {
+            case PacketDelivery.ReliableInOrder: Manager.SendToAll(netDataWriter, DeliveryMethod.ReliableOrdered); break;
+            case PacketDelivery.UnreliableInOrder: Manager.SendToAll(netDataWriter, DeliveryMethod.Sequenced); break;
+            case PacketDelivery.ReliableOutOfOrder: Manager.SendToAll(netDataWriter, DeliveryMethod.ReliableUnordered); break;
+            case PacketDelivery.UnreliableOutOfOrder: Manager.SendToAll(netDataWriter, DeliveryMethod.Unreliable); break;
+            default: Manager.SendToAll(netDataWriter, DeliveryMethod.ReliableOrdered); break;
+        }
+        return this;
+    }
+
+    private void PollEvents(IUniverse sender, IUniverse.UpdateArguments args) => Manager.PollEvents();
+
+    protected override void OnEnteredUniverse(IUniverse universe)
+    {
+        base.OnEnteredUniverse(universe);
+        universe.OnPostUpdate.AddListener(PollEvents);
+    }
+
+    protected override void OnExitedUniverse(IUniverse universe)
+    {
+        base.OnExitedUniverse(universe);
+        universe.OnPostUpdate.RemoveListener(PollEvents);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibServerConnection.cs

@@ -0,0 +1,16 @@
+using LiteNetLib;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public record class LiteNetLibServerConnection(NetPeer NetPeer) : IConnection
+{
+    public string Id => NetPeer.RemoteId.ToString();
+
+    public float Ping => NetPeer.Ping * .001f;
+    public float RoundTrip => NetPeer.RoundTripTime * .001f;
+
+    public int PingMs => NetPeer.Ping;
+    public int RoundTripMs => NetPeer.RoundTripTime;
+
+    public override string ToString() => $"Connection({Id})";
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/AABBNetPacker.cs

@@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/CircleNetPacker.cs

@@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorHSVNetPacker.cs

@@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorRGBANetPacker.cs

@@ -0,0 +1,26 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorRGBNetPacker.cs

@@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/Line2DEquationNetPacker.cs

@@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/Line2DNetPacker.cs

@@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/Projection1DNetPacker.cs

@@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/QuaternionNetPacker.cs

@@ -0,0 +1,26 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/Shape2DNetPacker.cs

@@ -0,0 +1,26 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/TriangleNetPacker.cs

@@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector2DNetPacker.cs

@@ -0,0 +1,22 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector3DNetPacker.cs

@@ -0,0 +1,24 @@
+using LiteNetLib.Utils;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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);
+    }
+}

Engine.Systems/Network/Abstract/IConnection.cs

@@ -0,0 +1,12 @@
+namespace Syntriax.Engine.Systems.Network;
+
+public interface IConnection
+{
+    string Id { get; }
+
+    float Ping { get; }
+    float RoundTrip { get; }
+
+    int PingMs { get; }
+    int RoundTripMs { get; }
+}

Engine.Systems/Network/Abstract/IEntityNetworkPacket.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Systems.Network;
+
+public interface IEntityNetworkPacket : INetworkPacket
+{
+    string EntityId { get; }
+}

Engine.Systems/Network/Abstract/INetworkCommunicator.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public interface INetworkCommunicator
+{
+    Event<INetworkCommunicator, IConnection> OnConnectionEstablished { get; }
+    Event<INetworkCommunicator, IConnection> OnConnectionAbolished { get; }
+
+    IReadOnlyDictionary<string, IConnection> Connections { get; }
+
+    INetworkCommunicator Stop();
+
+    INetworkCommunicator SubscribeToPackets<T>(Event<IConnection, T>.EventHandler callback);
+    INetworkCommunicator UnsubscribeFromPackets<T>(Event<IConnection, T>.EventHandler callback);
+}
+
+public interface INetworkCommunicatorClient : INetworkCommunicator
+{
+    INetworkCommunicatorClient Connect(string address, int port, string? password = null);
+
+    INetworkCommunicatorClient SendToServer<T>(T packet, PacketDelivery packetDelivery = PacketDelivery.ReliableInOrder) 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>(IConnection connection, T packet, PacketDelivery packetDelivery = PacketDelivery.ReliableInOrder) where T : class, new();
+    INetworkCommunicatorServer SendToAll<T>(T packet, PacketDelivery packetDelivery = PacketDelivery.ReliableInOrder) where T : class, new();
+}

Engine.Systems/Network/Abstract/INetworkEntity.cs

@@ -0,0 +1,5 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public interface INetworkEntity : IEntity;

Engine.Systems/Network/Abstract/INetworkManager.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.Network;
+
+public interface INetworkManager
+{
+    IReadOnlyDictionary<string, INetworkEntity> NetworkEntities { get; }
+    IBehaviourCollector<INetworkEntity> NetworkEntityCollector { get; }
+}

Engine.Systems/Network/Abstract/INetworkPacket.cs

@@ -0,0 +1,3 @@
+namespace Syntriax.Engine.Systems.Network;
+
+public interface INetworkPacket;

Engine.Systems/Network/Abstract/IPacketListenerClient.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Systems.Network;
+
+public interface IPacketListenerClient<T> : INetworkEntity
+{
+    void OnClientPacketArrived(IConnection sender, T packet);
+}

Engine.Systems/Network/Abstract/IPacketListenerServer.cs

@@ -0,0 +1,6 @@
+namespace Syntriax.Engine.Systems.Network;
+
+public interface IPacketListenerServer<T> : INetworkEntity
+{
+    void OnServerPacketArrived(IConnection sender, T packet);
+}

Engine.Systems/Network/Abstract/PacketDelivery.cs

@@ -0,0 +1,9 @@
+namespace Syntriax.Engine.Systems.Network;
+
+public enum PacketDelivery
+{
+    ReliableInOrder,
+    ReliableOutOfOrder,
+    UnreliableInOrder,
+    UnreliableOutOfOrder,
+};

Engine.Systems/Network/NetworkManager.cs

@@ -0,0 +1,332 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Systems.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 : Behaviour, 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;
+
+            INetworkCommunicator? 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>(IConnection sender, T entityDataPacket)
+    {
+        if (entityDataPacket is IEntityNetworkPacket entityPacket)
+            RoutePacket(sender, entityDataPacket, entityPacket);
+        else
+            BroadcastPacket(sender, entityDataPacket);
+    }
+
+    private void RoutePacket<T>(IConnection sender, T entityDataPacket, IEntityNetworkPacket entityPacket)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            RoutePacket(clientPacketRouters, entityPacket.EntityId, sender, entityDataPacket);
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            RoutePacket(serverPacketRouters, entityPacket.EntityId, sender, entityDataPacket);
+    }
+
+    private void BroadcastPacket<T>(IConnection sender, T entityDataPacket)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            BroadcastPacket(clientPacketRouters, sender, entityDataPacket);
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            BroadcastPacket(serverPacketRouters, sender, entityDataPacket);
+    }
+
+    private static void BroadcastPacket<T>(
+        Dictionary<Type, Dictionary<string, object>> packetRouters,
+        IConnection sender,
+        T entityDataPacket)
+    {
+        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, object>? routers))
+            return;
+
+        foreach ((string behaviourId, object routerEventReference) in routers)
+        {
+            Event<IConnection, T> routerEvent = (Event<IConnection, T>)routerEventReference;
+            routerEvent.Invoke(sender, entityDataPacket!);
+        }
+    }
+
+    private static void RoutePacket<T>(
+        Dictionary<Type, Dictionary<string, object>> packetRouters,
+        string entityId,
+        IConnection sender,
+        T entityDataPacket)
+    {
+        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, object>? routers))
+            return;
+
+        if (!routers.TryGetValue(entityId, out object? routerEventReference))
+            return;
+
+        Event<IConnection, T> routerEvent = (Event<IConnection, T>)routerEventReference;
+        routerEvent.Invoke(sender, 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(IConnection), 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<IConnection, T> packetListenerEvent,
+        NetworkType networkType)
+    {
+        switch (networkType)
+        {
+            case NetworkType.Client: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerClient<T>)behaviour).OnClientPacketArrived(sender, 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<IConnection, T> routerEvent = (Event<IConnection, 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 OnExitedUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
+    protected override void OnEnteredUniverse(IUniverse universe)
+    {
+        _networkEntityCollector.Assign(universe);
+        NetworkCommunicator = BehaviourController.GetRequiredBehaviourInParent<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(IConnection), 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 }
+}

Engine.sln

@@ -19,7 +19,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "YamlDotNet", "Engine.Serial
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Integration", "Integration", "{823D4020-332D-2C13-F261-6F510F11A57E}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonoGame", "Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{C3438D33-0879-44E4-9DF0-D29F5621C44C}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Integration.MonoGame", "Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{C3438D33-0879-44E4-9DF0-D29F5621C44C}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Engine.Integration", "Engine.Integration", "{3122C4BF-14AF-E0C0-27A2-43B3E062692D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Integration.LiteNetLib", "Engine.Integration\Engine.Integration.LiteNetLib\Engine.Integration.LiteNetLib.csproj", "{121A7C66-1691-4DA5-B070-A681A83779AC}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -115,6 +119,18 @@ Global
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x64.Build.0 = Release|Any CPU
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x86.ActiveCfg = Release|Any CPU
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x86.Build.0 = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x64.Build.0 = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x86.Build.0 = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x64.ActiveCfg = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x64.Build.0 = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x86.ActiveCfg = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -123,5 +139,6 @@ Global
 		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176} = {F88E129A-9A47-4D27-96EE-6EC02F79594B}
 		{3D852C92-BC14-4893-AEF2-50612DAFCD8F} = {F88E129A-9A47-4D27-96EE-6EC02F79594B}
 		{C3438D33-0879-44E4-9DF0-D29F5621C44C} = {823D4020-332D-2C13-F261-6F510F11A57E}
+		{121A7C66-1691-4DA5-B070-A681A83779AC} = {3122C4BF-14AF-E0C0-27A2-43B3E062692D}
 	EndGlobalSection
 EndGlobal