feat: working networked paddles

Shared/Behaviours/PaddleBehaviour.cs

@@ -19,25 +19,22 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
     private bool isUpPressed = false;
     private bool isDownPressed = false;
 
+    private bool isMovingUp = false;
+    private bool isMovingDown = false;
+
     private IButtonInputs<Keys> inputs = null!;
     private INetworkCommunicatorClient networkClient = null!;
     private INetworkCommunicatorServer? networkServer = null;
 
     protected override void OnUpdate()
     {
-        if (isUpPressed && isDownPressed)
+        if (isMovingUp && isMovingDown)
             return;
 
-        if (isUpPressed)
+        if (isMovingUp)
-        {
             Transform.Position = Transform.Position + Vector2D.Up * Universe.Time.DeltaTime * Speed;
-            networkClient.SendToServer(new EntityPaddlePositionPacket(this));
+        else if (isMovingDown)
-        }
-        else if (isDownPressed)
-        {
             Transform.Position = Transform.Position + -Vector2D.Up * Universe.Time.DeltaTime * Speed;
-            networkClient.SendToServer(new EntityPaddlePositionPacket(this));
-        }
 
         Transform.Position = new Vector2D(Transform.Position.X, MathF.Max(MathF.Min(Transform.Position.Y, High), Low));
     }
@@ -46,9 +43,10 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
     {
         inputs = Universe.FindRequiredBehaviour<IButtonInputs<Keys>>();
         networkClient = Universe.GetRequiredUniverseObject<INetworkCommunicatorClient>();
-        networkServer = Universe.GetRequiredUniverseObject<INetworkCommunicatorServer>();
+        networkServer = Universe.GetUniverseObject<INetworkCommunicatorServer>();
         networkClient.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataClient);
-        networkServer.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataServer);
+        networkServer?.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataServer);
+
         inputs.RegisterOnPress(Up, OnUpPressed);
         inputs.RegisterOnRelease(Up, OnUpReleased);
 
@@ -65,17 +63,21 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
         inputs.UnregisterOnRelease(Down, OnDownReleased);
     }
 
-    private void OnUpPressed(IButtonInputs<Keys> inputs, Keys keys) => isUpPressed = true;
+    private void OnUpPressed(IButtonInputs<Keys> inputs, Keys keys) { isUpPressed = true; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
-    private void OnUpReleased(IButtonInputs<Keys> inputs, Keys keys) => isUpPressed = false;
+    private void OnUpReleased(IButtonInputs<Keys> inputs, Keys keys) { isUpPressed = false; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
-    private void OnDownPressed(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = true;
+    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;
+    private void OnDownReleased(IButtonInputs<Keys> inputs, Keys keys) { isDownPressed = false; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
 
     public void ReceiveDataClient<T>(T data, string _)
     {
         if (data is not EntityPaddlePositionPacket position)
             return;
 
-        Transform.Position = position.Position;
+        if (position.EntityId.CompareTo(Id) != 0)
+            return;
+
+        isMovingUp = position.IsUpPressed;
+        isMovingDown = position.IsDownPressed;
     }
 
     public void ReceiveDataServer<T>(T data, string fromClientId)
@@ -83,22 +85,17 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
         if (data is not EntityPaddlePositionPacket position)
             return;
 
-        Transform.Position = position.Position;
+        if (position.EntityId.CompareTo(Id) != 0)
-        networkServer?.SendToClient("*", position);
-    }
-
-    public void ReceiveDataClient<T>(T data)
-    {
-        if (data is not EntityPaddlePositionPacket position)
             return;
 
-        Transform.Position = position.Position;
+        networkServer?.SendToClient("*", position);
     }
 
     public class EntityPaddlePositionPacket : IEntityNetworkPacket
     {
-        public string EntityId = default!;
+        public string EntityId { get; set; } = default!;
-        public Vector2D Position = default!;
+        public bool IsUpPressed { get; set; } = default!;
+        public bool IsDownPressed { get; set; } = default!;
 
         string IEntityNetworkPacket.EntityId => EntityId;
 
@@ -106,7 +103,8 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
         public EntityPaddlePositionPacket(PaddleBehaviour paddleBehaviour)
         {
             EntityId = paddleBehaviour.Id;
-            Position = paddleBehaviour.Transform.Position;
+            IsUpPressed = paddleBehaviour.isUpPressed;
+            IsDownPressed = paddleBehaviour.isDownPressed;
         }
     }
 }

Shared/GamePong.cs

@@ -1,16 +1,18 @@
 using System;
+using System.Linq;
+
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using Microsoft.Xna.Framework.Input;
 
-using Pong.Behaviours;
 using Apos.Shapes;
 
+using Pong.Behaviours;
+
 using Syntriax.Engine.Core;
-using Syntriax.Engine.Physics2D;
-using System.Linq;
-using Syntriax.Engine.Network;
 using Syntriax.Engine.Core.Factory;
+using Syntriax.Engine.Network;
+using Syntriax.Engine.Physics2D;
 
 namespace Pong;
 
@@ -76,13 +78,12 @@ public class GamePong : Game
 
         universe.Register(platformSpecificUniverseObject);
 
-        NetworkManager networkManager = universe.InstantiateUniverseObject<NetworkManager>().SetUniverseObject("Network Manager");
-        networkManager.NetworkCommunicator = universe.InstantiateUniverseObject<LiteNetLibClient>().SetUniverseObject("Client").Connect("localhost", 8888).SendToServer(new TestMessagePacket("Hola")).SubscribeToPackets<TestMessagePacket>(OnClientPacketReceived);
         if (Environment.GetCommandLineArgs().FirstOrDefault(x => x.CompareTo("-server") == 0) is not null)
         {
-            universe.InstantiateUniverseObject<LiteNetLibServer>().SetUniverseObject("Server").Start(8888, 2).SubscribeToPackets<TestMessagePacket>(OnServerPacketReceived);
+            universe.InstantiateUniverseObject<LiteNetLibServer>().SetUniverseObject("Server").Start(8888, 2);
             Window.Title = $"{Window.Title} - Server";
         }
+        universe.InstantiateUniverseObject<LiteNetLibClient>().SetUniverseObject("Client").Connect("localhost", 8888);
         universe.InstantiateUniverseObject<PhysicsEngine2D>().SetUniverseObject("Physics Engine 2D");
 
         ////////////////////////////////////////////////////////////////////////////////////
@@ -108,19 +109,21 @@ public class GamePong : Game
         ////////////////////////////////////////////////////////////////////////////////////
 
         IUniverseObject leftPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Left Paddle");
-        leftPaddle.Id = "lp";
         leftPaddle.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f))
-            .BehaviourController.AddBehaviour<PaddleBehaviour>(Keys.W, Keys.S, 228f, -228f, 400f)
             .BehaviourController.AddBehaviour<ShapeBehaviour>(Shape2D.Square)
             .BehaviourController.AddBehaviour<RigidBody2D>().IsStatic = true;
+        PaddleBehaviour leftPaddleBehaviour = BehaviourFactory.Instantiate<PaddleBehaviour>(Keys.W, Keys.S, 228f, -228f, 400f);
+        leftPaddleBehaviour.Id = "lp";
+        leftPaddle.BehaviourController.AddBehaviour(leftPaddleBehaviour);
         universe.Register(leftPaddle);
 
         IUniverseObject rightPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Right Paddle");
-        rightPaddle.Id = "rp";
         rightPaddle.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f))
-            .BehaviourController.AddBehaviour<PaddleBehaviour>(Keys.Up, Keys.Down, 228f, -228f, 400f)
             .BehaviourController.AddBehaviour<ShapeBehaviour>(Shape2D.Square)
             .BehaviourController.AddBehaviour<RigidBody2D>().IsStatic = true;
+        PaddleBehaviour rightPaddleBehaviour = BehaviourFactory.Instantiate<PaddleBehaviour>(Keys.Up, Keys.Down, 228f, -228f, 400f);
+        rightPaddleBehaviour.Id = "rp";
+        rightPaddle.BehaviourController.AddBehaviour(rightPaddleBehaviour);
         universe.Register(rightPaddle);
 
         ////////////////////////////////////////////////////////////////////////////////////
@@ -158,20 +161,6 @@ public class GamePong : Game
             .BehaviourController.AddBehaviour<TextScoreBehaviour>(false, spriteFont);
     }
 
-    private void OnClientPacketReceived(TestMessagePacket packet, string from)
-    {
-        Console.WriteLine($"Message received from server: {packet.Message}");
-        leftText.Text = packet.Message;
-    }
-
-    private void OnServerPacketReceived(TestMessagePacket packet, string from)
-    {
-        Console.WriteLine($"Message received from client: {packet.Message}");
-        rightText.Text = packet.Message;
-
-        universe.GetRequiredUniverseObject<INetworkCommunicatorServer>().SendToClient(from, new TestMessagePacket("Reply!"));
-    }
-
     protected override void Update(GameTime gameTime)
     {
         if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))

Shared/Network/Abstract/INetworkEntity.cs

@@ -2,7 +2,4 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Network;
 
-public interface INetworkEntity : IEntity
+public interface INetworkEntity : IEntity;
-{
-    void ReceiveDataClient<T>(T data);
-}

Shared/Network/NetworkManager.cs

@@ -1,109 +0,0 @@
-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<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)
-    {
-        if (entityDataPacket is IEntityNetworkPacket entityNetworkPacket)
-            _networkEntities[entityNetworkPacket.EntityId].ReceiveDataClient(entityDataPacket);
-    }
-
-    private void OnCollected(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourCollected)
-    {
-        if (!_networkEntities.TryAdd(behaviourCollected.Id, behaviourCollected))
-            throw new($"Unable to add {behaviourCollected.Id} to {nameof(NetworkManager)}");
-    }
-
-    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourRemoved)
-    {
-        _networkEntities.Remove(behaviourRemoved.Id);
-    }
-
-    protected override void OnEnteringUniverse(IUniverse universe) => _networkEntityCollector.Assign(universe);
-    protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
-}