feat: client & server packet listener interfaces added

Engine

@@ -1 +1 @@
-Subproject commit 0bf38234c6dbef8824045c81c4bd79c440a70abc
+Subproject commit 3b6a93d37a7453376ad97d52709af750304fe89a

Shared/Behaviours/PaddleBehaviour.cs

@@ -8,7 +8,8 @@ using Syntriax.Engine.Systems.Input;
 
 namespace Pong.Behaviours;
 
-public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Speed) : Behaviour2D, INetworkEntity
+public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Speed) : Behaviour2D,
+    IPacketListenerServer<PaddleBehaviour.EntityPaddlePositionPacket>, IPacketListenerClient<PaddleBehaviour.EntityPaddlePositionPacket>
 {
     private Keys Up { get; } = Up;
     private Keys Down { get; } = Down;
@@ -42,10 +43,8 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
     protected override void OnFirstActiveFrame()
     {
         inputs = Universe.FindRequiredBehaviour<IButtonInputs<Keys>>();
-        networkClient = Universe.GetRequiredUniverseObject<INetworkCommunicatorClient>();
+        networkClient = Universe.FindRequiredBehaviour<INetworkCommunicatorClient>();
-        networkServer = Universe.GetUniverseObject<INetworkCommunicatorServer>();
+        networkServer = Universe.FindBehaviour<INetworkCommunicatorServer>();
-        networkClient.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataClient);
-        networkServer?.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataServer);
 
         inputs.RegisterOnPress(Up, OnUpPressed);
         inputs.RegisterOnRelease(Up, OnUpReleased);
@@ -68,9 +67,20 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
     private void OnDownPressed(IButtonInputs<Keys> inputs, Keys keys) { isDownPressed = true; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
     private void OnDownReleased(IButtonInputs<Keys> inputs, Keys keys) { isDownPressed = false; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
 
-    public void ReceiveDataClient<T>(T data, string _)
+    public void OnServerPacketArrived(EntityPaddlePositionPacket packet, string from)
     {
-        if (data is not EntityPaddlePositionPacket position)
+        if (packet is not EntityPaddlePositionPacket position)
+            return;
+
+        if (position.EntityId.CompareTo(Id) != 0)
+            return;
+
+        networkServer?.SendToClient("*", position);
+    }
+
+    public void OnClientPacketArrived(EntityPaddlePositionPacket packet)
+    {
+        if (packet is not EntityPaddlePositionPacket position)
             return;
 
         if (position.EntityId.CompareTo(Id) != 0)
@@ -80,17 +90,6 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
         isMovingDown = position.IsDownPressed;
     }
 
-    public void ReceiveDataServer<T>(T data, string fromClientId)
-    {
-        if (data is not EntityPaddlePositionPacket position)
-            return;
-
-        if (position.EntityId.CompareTo(Id) != 0)
-            return;
-
-        networkServer?.SendToClient("*", position);
-    }
-
     public class EntityPaddlePositionPacket : IEntityNetworkPacket
     {
         public string EntityId { get; set; } = default!;

Shared/GamePong.cs

@@ -80,10 +80,15 @@ public class GamePong : Game
 
         if (Environment.GetCommandLineArgs().FirstOrDefault(x => x.CompareTo("-server") == 0) is not null)
         {
-            universe.InstantiateUniverseObject<LiteNetLibServer>().SetUniverseObject("Server").Start(8888, 2);
+            LiteNetLibServer server = universe.InstantiateUniverseObject().SetUniverseObject("Server").BehaviourController.AddBehaviour<LiteNetLibServer>();
+            UniverseObjectFactory.Instantiate<NetworkManager>().SetUniverseObject("NetworkManager", server.BehaviourController.UniverseObject);
+            server.Start(8888, 2);
             Window.Title = $"{Window.Title} - Server";
         }
-        universe.InstantiateUniverseObject<LiteNetLibClient>().SetUniverseObject("Client").Connect("localhost", 8888);
+        LiteNetLibClient client = universe.InstantiateUniverseObject().SetUniverseObject("Client").BehaviourController.AddBehaviour<LiteNetLibClient>();
+        UniverseObjectFactory.Instantiate<NetworkManager>().SetUniverseObject("NetworkManager", client.BehaviourController.UniverseObject);
+        client.Connect("localhost", 8888);
+
         universe.InstantiateUniverseObject<PhysicsEngine2D>().SetUniverseObject("Physics Engine 2D");
 
         ////////////////////////////////////////////////////////////////////////////////////
@@ -169,7 +174,7 @@ public class GamePong : Game
         universe.Update(gameTime.ToUniverseTime());
 
         if (Keyboard.GetState().IsKeyDown(Keys.S))
-            universe.GetRequiredUniverseObject<INetworkCommunicatorClient>().SendToServer<TestMessagePacket>(new TestMessagePacket($"Hola ({gameTime.TotalGameTime.TotalSeconds})"));
+            universe.FindRequiredBehaviour<INetworkCommunicatorClient>().SendToServer<TestMessagePacket>(new TestMessagePacket($"Hola ({gameTime.TotalGameTime.TotalSeconds})"));
 
         base.Update(gameTime);
     }

Shared/Network/Abstract/IPacketListenerClient.cs

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

Shared/Network/Abstract/IPacketListenerServer.cs

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

Shared/Network/LiteNetLib/LiteNetLibClient.cs

@@ -8,7 +8,7 @@ public class LiteNetLibClient : LiteNetLibCommunicatorBase, INetworkCommunicator
 
     public INetworkCommunicatorClient Connect(string address, int port, string? password = null)
     {
-        if (!IsInUniverse)
+        if (!UniverseObject.IsInUniverse)
             throw new($"{nameof(LiteNetLibClient)} must be in an universe to connect");
 
         Manager.Start();

Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs

@@ -10,7 +10,7 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Network;
 
-public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommunicator
+public abstract class LiteNetLibCommunicatorBase : Behaviour, INetworkCommunicator
 {
     protected readonly NetPacketProcessor netPacketProcessor = new();
 
@@ -25,12 +25,12 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
         return this;
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
         universe.OnPreUpdate += PollEvents;
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         universe.OnPreUpdate -= PollEvents;
 
@@ -82,13 +82,11 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
         {
             if (!packetType.IsClass)
             {
-                Console.WriteLine($"Registering Nested: {packetType.FullName}");
                 MethodInfo genericRegisterNestedTypeMethod = registerNestedTypeMethod.MakeGenericMethod(packetType);
                 genericRegisterNestedTypeMethod.Invoke(netPacketProcessor, []);
                 continue;
             }
 
-            Console.WriteLine($"Registering Reusable: {packetType.FullName}");
             MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType);
 
             Type delegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(NetPeer));
@@ -131,7 +129,6 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
     public INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback)
     {
         Type type = typeof(T);
-        Console.WriteLine($"Subscribing to: {type.FullName} on {GetType().Name}");
         if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
         {
             delegates = [];
@@ -145,7 +142,6 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
     public INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback)
     {
         Type type = typeof(T);
-        Console.WriteLine($"Unsubscribing from: {type.FullName} on {GetType().Name}");
         if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
             return this;
 

Shared/Network/LiteNetLib/LiteNetLibServer.cs

@@ -30,7 +30,7 @@ public class LiteNetLibServer : LiteNetLibCommunicatorBase, INetworkCommunicator
 
     public INetworkCommunicatorServer Start(int port, int maxConnectionCount, string? password = null)
     {
-        if (!IsInUniverse)
+        if (!UniverseObject.IsInUniverse)
             throw new($"{nameof(LiteNetLibServer)} must be in an universe to start");
 
         Password = password ?? string.Empty;

Shared/Network/NetworkManager.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Network;
+
+public class NetworkManager : UniverseObject, INetworkManager
+{
+    private INetworkCommunicator networkCommunicator = null!;
+    private readonly List<(Type packetType, Delegate callback)> delegates = [];
+
+    public INetworkCommunicator NetworkCommunicator
+    {
+        get => networkCommunicator;
+        set
+        {
+            if (networkCommunicator == value)
+                return;
+
+            var previousCommunicator = networkCommunicator;
+            networkCommunicator = value;
+
+            if (previousCommunicator is not null) UnsubscribeDelegates(networkCommunicator);
+            if (networkCommunicator is not null) SubscribeDelegates(networkCommunicator);
+        }
+    }
+
+    private readonly Dictionary<Type, List<object>> clientPacketListeners = [];
+    private readonly Dictionary<Type, List<object>> serverPacketListeners = [];
+
+    private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
+    public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
+
+    private readonly BehaviourCollector<INetworkEntity> _networkEntityCollector = new();
+    public IBehaviourCollector<INetworkEntity> NetworkEntityCollector => _networkEntityCollector;
+
+    public NetworkManager()
+    {
+        CacheDelegates();
+
+        _networkEntityCollector.OnCollected += OnCollected;
+        _networkEntityCollector.OnRemoved += OnRemoved;
+    }
+
+    private void CacheDelegates()
+    {
+        // Find network packets implementing EntityDataPacket<>
+        IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
+            .Where(t => typeof(IEntityNetworkPacket).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(Action<,>).MakeGenericType(packetType, typeof(string));
+            Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
+
+            delegates.Add((packetType, genericPacketReceivedDelegate));
+        }
+    }
+
+    private void SubscribeDelegates(INetworkCommunicator networkCommunicator)
+    {
+        MethodInfo subscribeToPacketsMethod = typeof(INetworkCommunicator)
+            .GetMethod(nameof(INetworkCommunicator.SubscribeToPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+
+        foreach ((Type packetType, Delegate callback) in delegates)
+        {
+            MethodInfo genericSubscribeMethod = subscribeToPacketsMethod.MakeGenericMethod(packetType);
+
+            genericSubscribeMethod.Invoke(networkCommunicator, [callback]);
+        }
+    }
+
+    private void UnsubscribeDelegates(INetworkCommunicator networkCommunicator)
+    {
+        MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
+            .GetMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+
+        foreach ((Type packetType, Delegate callback) in delegates)
+        {
+            MethodInfo genericUnsubscribeMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);
+
+            genericUnsubscribeMethod.Invoke(networkCommunicator, [callback]);
+        }
+    }
+
+    private void OnPacketReceived<T>(T entityDataPacket, string fromClientId)
+    {
+        Type packetType = typeof(T);
+
+        if (networkCommunicator is INetworkCommunicatorClient)
+            if (clientPacketListeners.TryGetValue(packetType, out List<object>? clientListeners))
+                foreach (object clientListener in clientListeners)
+                {
+                    MethodInfo clientListenerReceiveMethod = typeof(IPacketListenerClient<>).MakeGenericType(packetType).GetMethods().First(m => m.Name == nameof(IPacketListenerClient<T>.OnClientPacketArrived));
+                    clientListenerReceiveMethod.Invoke(clientListener, [entityDataPacket]);
+                }
+        if (networkCommunicator is INetworkCommunicatorServer)
+            if (serverPacketListeners.TryGetValue(packetType, out List<object>? serverListeners))
+                foreach (object serverListener in serverListeners)
+                {
+                    MethodInfo serverListenerReceiveMethod = typeof(IPacketListenerServer<>).MakeGenericType(packetType).GetMethods().First(m => m.Name == nameof(IPacketListenerServer<T>.OnServerPacketArrived));
+                    serverListenerReceiveMethod.Invoke(serverListener, [entityDataPacket, fromClientId]);
+                }
+    }
+
+    private void OnCollected(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourCollected)
+    {
+        if (!_networkEntities.TryAdd(behaviourCollected.Id, behaviourCollected))
+            throw new($"Unable to add {behaviourCollected.Id} to {nameof(NetworkManager)}");
+
+        foreach (Type clientListenerType in behaviourCollected.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketListenerClient<>)))
+        {
+            Type clientListenerParameterType = clientListenerType.GetGenericArguments().First();
+
+            if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out List<object>? clientListeners))
+            {
+                clientListeners = [];
+                clientPacketListeners.Add(clientListenerParameterType, clientListeners);
+            }
+
+            clientListeners.Add(behaviourCollected);
+        }
+
+        foreach (Type serverListenerType in behaviourCollected.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketListenerServer<>)))
+        {
+            Type serverListenerParameterType = serverListenerType.GetGenericArguments().First();
+
+            if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out List<object>? serverListeners))
+            {
+                serverListeners = [];
+                serverPacketListeners.Add(serverListenerParameterType, serverListeners);
+            }
+
+            serverListeners.Add(behaviourCollected);
+        }
+    }
+
+    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourRemoved)
+    {
+        _networkEntities.Remove(behaviourRemoved.Id);
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
+    protected override void OnEnteringUniverse(IUniverse universe)
+    {
+        _networkEntityCollector.Assign(universe);
+        NetworkCommunicator = BehaviourController.GetRequiredBehaviourInParent<INetworkCommunicator>();
+    }
+}