feat: added LiteNetLib networking integration

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.Tests/Core/BehaviourController_Tests.cs

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

Engine.Tests/Core/Behaviour_Tests.cs

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

Engine.Tests/Core/UniverseObject_Tests.cs

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

Engine.Tests/Engine.Tests.csproj

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

Engine.sln

@@ -21,7 +21,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Integration", "Integration"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Integration.MonoGame", "Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{C3438D33-0879-44E4-9DF0-D29F5621C44C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Tests", "Engine.Tests\Engine.Tests.csproj", "{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}"
+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
@@ -117,18 +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
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x64.Build.0 = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x64.Build.0 = Debug|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Debug|x86.Build.0 = Debug|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Debug|x86.Build.0 = Debug|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|Any CPU.Build.0 = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x64.ActiveCfg = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x64.ActiveCfg = Release|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x64.Build.0 = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x64.Build.0 = Release|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x86.ActiveCfg = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x86.ActiveCfg = Release|Any CPU
-		{5FAE9C0F-39B9-4470-9E6B-08F764A03A08}.Release|x86.Build.0 = Release|Any CPU
+		{121A7C66-1691-4DA5-B070-A681A83779AC}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -137,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