diff --git a/Shared/Behaviours/PaddleBehaviour.cs b/Shared/Behaviours/PaddleBehaviour.cs index 8c759f9..6c3a581 100644 --- a/Shared/Behaviours/PaddleBehaviour.cs +++ b/Shared/Behaviours/PaddleBehaviour.cs @@ -3,11 +3,12 @@ using System; using Microsoft.Xna.Framework.Input; using Syntriax.Engine.Core; +using Syntriax.Engine.Network; using Syntriax.Engine.Systems.Input; namespace Pong.Behaviours; -public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Speed) : Behaviour2D +public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Speed) : Behaviour2D, INetworkEntity { private Keys Up { get; } = Up; private Keys Down { get; } = Down; @@ -19,6 +20,8 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp private bool isDownPressed = false; private IButtonInputs inputs = null!; + private INetworkCommunicatorClient networkClient = null!; + private INetworkCommunicatorServer? networkServer = null; protected override void OnUpdate() { @@ -26,9 +29,15 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp return; if (isUpPressed) + { Transform.Position = Transform.Position + Vector2D.Up * Universe.Time.DeltaTime * Speed; + networkClient.SendToServer(new EntityPaddlePositionPacket(this)); + } 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)); } @@ -36,7 +45,10 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp protected override void OnFirstActiveFrame() { inputs = Universe.FindRequiredBehaviour>(); - + networkClient = Universe.GetRequiredUniverseObject(); + networkServer = Universe.GetRequiredUniverseObject(); + networkClient.SubscribeToPackets(ReceiveDataClient); + networkServer.SubscribeToPackets(ReceiveDataServer); inputs.RegisterOnPress(Up, OnUpPressed); inputs.RegisterOnRelease(Up, OnUpReleased); @@ -57,4 +69,44 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp private void OnUpReleased(IButtonInputs inputs, Keys keys) => isUpPressed = false; private void OnDownPressed(IButtonInputs inputs, Keys keys) => isDownPressed = true; private void OnDownReleased(IButtonInputs inputs, Keys keys) => isDownPressed = false; + + public void ReceiveDataClient(T data, string _) + { + if (data is not EntityPaddlePositionPacket position) + return; + + Transform.Position = position.Position; + } + + public void ReceiveDataServer(T data, string fromClientId) + { + if (data is not EntityPaddlePositionPacket position) + return; + + Transform.Position = position.Position; + networkServer?.SendToClient("*", position); + } + + public void ReceiveDataClient(T data) + { + if (data is not EntityPaddlePositionPacket position) + return; + + Transform.Position = position.Position; + } + + public class EntityPaddlePositionPacket : IEntityNetworkPacket + { + public string EntityId = default!; + public Vector2D Position = default!; + + string IEntityNetworkPacket.EntityId => EntityId; + + public EntityPaddlePositionPacket() { } + public EntityPaddlePositionPacket(PaddleBehaviour paddleBehaviour) + { + EntityId = paddleBehaviour.Id; + Position = paddleBehaviour.Transform.Position; + } + } } diff --git a/Shared/GamePong.cs b/Shared/GamePong.cs index 2e55304..69355dd 100644 --- a/Shared/GamePong.cs +++ b/Shared/GamePong.cs @@ -8,9 +8,24 @@ using Apos.Shapes; using Syntriax.Engine.Core; using Syntriax.Engine.Physics2D; +using System.Linq; +using Syntriax.Engine.Network; +using Syntriax.Engine.Core.Factory; namespace Pong; +[System.Serializable] +public class TestMessagePacket : INetworkPacket, LiteNetLib.Utils.INetSerializable +{ + public string Message { get; set; } + + public void Deserialize(LiteNetLib.Utils.NetDataReader reader) => Message = reader.GetString(); + public void Serialize(LiteNetLib.Utils.NetDataWriter writer) => writer.Put(Message); + + public TestMessagePacket() => Message = "Default Message"; + public TestMessagePacket(string Message) => this.Message = Message; +} + public class GamePong : Game { private readonly IUniverseObject platformSpecificUniverseObject = null!; @@ -24,6 +39,8 @@ public class GamePong : Game private MonoGameCamera2DBehaviour cameraBehaviour = null!; private PongManagerBehaviour pongManager = null!; + private TextScoreBehaviour leftText; + private TextScoreBehaviour rightText; public GamePong(IUniverseObject platformSpecificUniverseObject) { @@ -58,6 +75,14 @@ public class GamePong : Game SpriteFont spriteFont = Content.Load("UbuntuMono"); universe.Register(platformSpecificUniverseObject); + + NetworkManager networkManager = universe.InstantiateUniverseObject().SetUniverseObject("Network Manager"); + networkManager.NetworkCommunicator = universe.InstantiateUniverseObject().SetUniverseObject("Client").Connect("localhost", 8888).SendToServer(new TestMessagePacket("Hola")).SubscribeToPackets(OnClientPacketReceived); + if (Environment.GetCommandLineArgs().FirstOrDefault(x => x.CompareTo("-server") == 0) is not null) + { + universe.InstantiateUniverseObject().SetUniverseObject("Server").Start(8888, 2).SubscribeToPackets(OnServerPacketReceived); + Window.Title = $"{Window.Title} - Server"; + } universe.InstantiateUniverseObject().SetUniverseObject("Physics Engine 2D"); //////////////////////////////////////////////////////////////////////////////////// @@ -82,17 +107,21 @@ public class GamePong : Game //////////////////////////////////////////////////////////////////////////////////// - universe.InstantiateUniverseObject().SetUniverseObject("Left Paddle") - .BehaviourController.AddBehaviour().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f)) + IUniverseObject leftPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Left Paddle"); + leftPaddle.Id = "lp"; + leftPaddle.BehaviourController.AddBehaviour().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f)) .BehaviourController.AddBehaviour(Keys.W, Keys.S, 228f, -228f, 400f) .BehaviourController.AddBehaviour(Shape2D.Square) .BehaviourController.AddBehaviour().IsStatic = true; + universe.Register(leftPaddle); - universe.InstantiateUniverseObject().SetUniverseObject("Right Paddle") - .BehaviourController.AddBehaviour().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f)) + IUniverseObject rightPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Right Paddle"); + rightPaddle.Id = "rp"; + rightPaddle.BehaviourController.AddBehaviour().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f)) .BehaviourController.AddBehaviour(Keys.Up, Keys.Down, 228f, -228f, 400f) .BehaviourController.AddBehaviour(Shape2D.Square) .BehaviourController.AddBehaviour().IsStatic = true; + universe.Register(rightPaddle); //////////////////////////////////////////////////////////////////////////////////// @@ -120,15 +149,29 @@ public class GamePong : Game //////////////////////////////////////////////////////////////////////////////////// - universe.InstantiateUniverseObject().SetUniverseObject("Score Left") + leftText = universe.InstantiateUniverseObject().SetUniverseObject("Score Left") .BehaviourController.AddBehaviour().SetTransform(position: new Vector2D(-250f, 250f), scale: Vector2D.One * .25f) .BehaviourController.AddBehaviour(true, spriteFont); - universe.InstantiateUniverseObject().SetUniverseObject("Score Right") + rightText = universe.InstantiateUniverseObject().SetUniverseObject("Score Right") .BehaviourController.AddBehaviour().SetTransform(position: new Vector2D(250f, 250f), scale: Vector2D.One * .25f) .BehaviourController.AddBehaviour(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().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)) @@ -136,6 +179,9 @@ public class GamePong : Game universe.Update(gameTime.ToUniverseTime()); + if (Keyboard.GetState().IsKeyDown(Keys.S)) + universe.GetRequiredUniverseObject().SendToServer(new TestMessagePacket($"Hola ({gameTime.TotalGameTime.TotalSeconds})")); + base.Update(gameTime); } diff --git a/Shared/Network/Abstract/IEntityNetworkPacket.cs b/Shared/Network/Abstract/IEntityNetworkPacket.cs new file mode 100644 index 0000000..70f0696 --- /dev/null +++ b/Shared/Network/Abstract/IEntityNetworkPacket.cs @@ -0,0 +1,6 @@ +namespace Syntriax.Engine.Network; + +public interface IEntityNetworkPacket : INetworkPacket +{ + string EntityId { get; } +} diff --git a/Shared/Network/Abstract/INetworkCommunicator.cs b/Shared/Network/Abstract/INetworkCommunicator.cs index b6e6618..93e2945 100644 --- a/Shared/Network/Abstract/INetworkCommunicator.cs +++ b/Shared/Network/Abstract/INetworkCommunicator.cs @@ -6,8 +6,8 @@ public interface INetworkCommunicator { INetworkCommunicator Stop(); - void SubscribeToPackets(Action callback); - void UnsubscribeFromPackets(Action callback); + INetworkCommunicator SubscribeToPackets(Action callback); + INetworkCommunicator UnsubscribeFromPackets(Action callback); } public interface INetworkCommunicatorClient : INetworkCommunicator diff --git a/Shared/Network/Abstract/INetworkEntity.cs b/Shared/Network/Abstract/INetworkEntity.cs index bc68596..ad458b2 100644 --- a/Shared/Network/Abstract/INetworkEntity.cs +++ b/Shared/Network/Abstract/INetworkEntity.cs @@ -4,5 +4,5 @@ namespace Syntriax.Engine.Network; public interface INetworkEntity : IEntity { - void ReceiveData(object data); + void ReceiveDataClient(T data); } diff --git a/Shared/Network/Abstract/INetworkManager.cs b/Shared/Network/Abstract/INetworkManager.cs index 3f9e4db..91c1b4f 100644 --- a/Shared/Network/Abstract/INetworkManager.cs +++ b/Shared/Network/Abstract/INetworkManager.cs @@ -6,8 +6,6 @@ namespace Syntriax.Engine.Network; public interface INetworkManager { - INetworkCommunicator NetworkCommunicator { get; } - IReadOnlyDictionary NetworkEntities { get; } IBehaviourCollector NetworkEntityCollector { get; } } diff --git a/Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs b/Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs index dfc41a8..ca7fdfc 100644 --- a/Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs +++ b/Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs @@ -44,7 +44,7 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu return; foreach (Delegate @delegate in delegates) - @delegate.InvokeSafe(packet); + @delegate.InvokeSafe(packet, peer.Id.ToString()); } private void NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod) @@ -57,7 +57,7 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu { // Find network packets implementing INetworkPacket IEnumerable packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()) - .Where(t => typeof(INetworkPacket).IsAssignableFrom(t) && !t.IsInterface); + .Where(t => typeof(INetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType); MethodInfo subscribeReusableMethod = typeof(NetPacketProcessor) .GetMethods() @@ -66,17 +66,33 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu 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 method bellow where T is our found network packet type + // Register all network packets by calling the methods bellow where T is our found network packet type // NetPacketProcessor.SubscribeReusable(Action onReceive) - foreach (var packetType in packetTypes) + // NetPacketProcessor.RegisterNestedType() + foreach (Type packetType in packetTypes) { - var genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType); + if (!packetType.IsClass) + { + Console.WriteLine($"Registering Nested: {packetType.FullName}"); + MethodInfo genericRegisterNestedTypeMethod = registerNestedTypeMethod.MakeGenericMethod(packetType); + genericRegisterNestedTypeMethod.Invoke(netPacketProcessor, []); + continue; + } - var delegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(NetPeer)); - var delegateHandler = Delegate.CreateDelegate(delegateType, this, genericOnPacketArrivedMethod); + Console.WriteLine($"Registering Reusable: {packetType.FullName}"); + MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType); + + Type delegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(NetPeer)); + Delegate delegateHandler = Delegate.CreateDelegate(delegateType, this, genericOnPacketArrivedMethod); var genericSubscribeReusableMethod = subscribeReusableMethod.MakeGenericMethod(packetType, typeof(NetPeer)); genericSubscribeReusableMethod.Invoke(netPacketProcessor, [delegateHandler]); @@ -112,22 +128,28 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu netPacketProcessor.RegisterNestedType(Vector3DNetPacker.Write, Vector3DNetPacker.Read); } - public void SubscribeToPackets(Action callback) + public INetworkCommunicator SubscribeToPackets(Action callback) { - if (!listeners.TryGetValue(typeof(T), out List? delegates)) + Type type = typeof(T); + Console.WriteLine($"Subscribing to: {type.FullName} on {GetType().Name}"); + if (!listeners.TryGetValue(type, out List? delegates)) { delegates = []; - listeners.Add(typeof(T), delegates); + listeners.Add(type, delegates); } delegates.Add(callback); + return this; } - public void UnsubscribeFromPackets(Action callback) + public INetworkCommunicator UnsubscribeFromPackets(Action callback) { - if (!listeners.TryGetValue(typeof(T), out List? delegates)) - return; + Type type = typeof(T); + Console.WriteLine($"Unsubscribing from: {type.FullName} on {GetType().Name}"); + if (!listeners.TryGetValue(type, out List? delegates)) + return this; delegates.Remove(callback); + return this; } } diff --git a/Shared/Network/NetworkManager.cs b/Shared/Network/NetworkManager.cs index 7ceeb1f..a7ed7f2 100644 --- a/Shared/Network/NetworkManager.cs +++ b/Shared/Network/NetworkManager.cs @@ -1,5 +1,7 @@ +using System; using System.Collections.Generic; - +using System.Linq; +using System.Reflection; using Syntriax.Engine.Core; namespace Syntriax.Engine.Network; @@ -7,6 +9,8 @@ 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; @@ -18,8 +22,8 @@ public class NetworkManager : UniverseObject, INetworkManager var previousCommunicator = networkCommunicator; networkCommunicator = value; - if (previousCommunicator is not null) previousCommunicator.OnPacketReceived -= OnPacketReceived; - if (networkCommunicator is not null) networkCommunicator.OnPacketReceived += OnPacketReceived; + if (previousCommunicator is not null) UnsubscribeDelegates(networkCommunicator); + if (networkCommunicator is not null) SubscribeDelegates(networkCommunicator); } } @@ -31,16 +35,62 @@ public class NetworkManager : UniverseObject, INetworkManager public NetworkManager() { + CacheDelegates(); + _networkEntityCollector.OnCollected += OnCollected; _networkEntityCollector.OnRemoved += OnRemoved; } - private void OnPacketReceived(INetworkCommunicator sender, object packet, string from) + private void CacheDelegates() { - // if (packet is not EntityDataPacket entityDataPacket) - // return; + // Find network packets implementing EntityDataPacket<> + IEnumerable packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()) + .Where(t => typeof(IEntityNetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType); - // _networkEntities[entityDataPacket.Entity].ReceiveData(entityDataPacket.Data); + 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 entityDataPacket, string fromClientId) + { + if (entityDataPacket is IEntityNetworkPacket entityNetworkPacket) + _networkEntities[entityNetworkPacket.EntityId].ReceiveDataClient(entityDataPacket); } private void OnCollected(IBehaviourCollector sender, INetworkEntity behaviourCollected)