Syntriax/Engine-Pong
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: network entity packets

Browse Source
This commit is contained in:
Syntriax
2025-05-17 22:17:25 +03:00
parent 03082ab43b
commit 721d63cf66
8 changed files with 207 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
Shared/Behaviours/PaddleBehaviour.cs
View File

@@ -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<Keys> 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<IButtonInputs<Keys>>();
networkClient = Universe.GetRequiredUniverseObject<INetworkCommunicatorClient>();
networkServer = Universe.GetRequiredUniverseObject<INetworkCommunicatorServer>();
networkClient.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataClient);
networkServer.SubscribeToPackets<EntityPaddlePositionPacket>(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<Keys> inputs, Keys keys) => isUpPressed = false;
private void OnDownPressed(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = true;
private void OnDownReleased(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = false;
public void ReceiveDataClient<T>(T data, string _)
{
if (data is not EntityPaddlePositionPacket position)
return;
Transform.Position = position.Position;
}
public void ReceiveDataServer<T>(T data, string fromClientId)
{
if (data is not EntityPaddlePositionPacket position)
return;
Transform.Position = position.Position;
networkServer?.SendToClient("*", position);
}
public void ReceiveDataClient<T>(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;
}
}
}

58
Shared/GamePong.cs
View File

@@ -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<SpriteFont>("UbuntuMono");
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);
Window.Title = $"{Window.Title} - Server";
}
universe.InstantiateUniverseObject<PhysicsEngine2D>().SetUniverseObject("Physics Engine 2D");
////////////////////////////////////////////////////////////////////////////////////
@@ -82,17 +107,21 @@ public class GamePong : Game
////////////////////////////////////////////////////////////////////////////////////
universe.InstantiateUniverseObject().SetUniverseObject("Left Paddle")
.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f))
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;
universe.Register(leftPaddle);
universe.InstantiateUniverseObject().SetUniverseObject("Right Paddle")
.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f))
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;
universe.Register(rightPaddle);
////////////////////////////////////////////////////////////////////////////////////
@@ -120,15 +149,29 @@ public class GamePong : Game
////////////////////////////////////////////////////////////////////////////////////
universe.InstantiateUniverseObject().SetUniverseObject("Score Left")
leftText = universe.InstantiateUniverseObject().SetUniverseObject("Score Left")
.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(-250f, 250f), scale: Vector2D.One * .25f)
.BehaviourController.AddBehaviour<TextScoreBehaviour>(true, spriteFont);
universe.InstantiateUniverseObject().SetUniverseObject("Score Right")
rightText = universe.InstantiateUniverseObject().SetUniverseObject("Score Right")
.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(250f, 250f), scale: Vector2D.One * .25f)
.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))
@@ -136,6 +179,9 @@ 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})"));
base.Update(gameTime);
}

6
Shared/Network/Abstract/IEntityNetworkPacket.cs Normal file
View File

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

4
Shared/Network/Abstract/INetworkCommunicator.cs
View File

@@ -6,8 +6,8 @@ public interface INetworkCommunicator
{
INetworkCommunicator Stop();
void SubscribeToPackets<T>(Action<T> callback);
void UnsubscribeFromPackets<T>(Action<T> callback);
INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback);
INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback);
}
public interface INetworkCommunicatorClient : INetworkCommunicator

2
Shared/Network/Abstract/INetworkEntity.cs
View File

@@ -4,5 +4,5 @@ namespace Syntriax.Engine.Network;
public interface INetworkEntity : IEntity
{
void ReceiveData(object data);
void ReceiveDataClient<T>(T data);
}

2
Shared/Network/Abstract/INetworkManager.cs
View File

@@ -6,8 +6,6 @@ namespace Syntriax.Engine.Network;
public interface INetworkManager
{
INetworkCommunicator NetworkCommunicator { get; }
IReadOnlyDictionary<string, INetworkEntity> NetworkEntities { get; }
IBehaviourCollector<INetworkEntity> NetworkEntityCollector { get; }
}

48
Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs
View File

@@ -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<Type> 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<T, NetPeer>(Action<T, NetPeer> onReceive)
foreach (var packetType in packetTypes)
// NetPacketProcessor.RegisterNestedType<T>()
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<T>(Action<T> callback)
public INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback)
{
if (!listeners.TryGetValue(typeof(T), out List<Delegate>? delegates))
Type type = typeof(T);
Console.WriteLine($"Subscribing to: {type.FullName} on {GetType().Name}");
if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
{
delegates = [];
listeners.Add(typeof(T), delegates);
listeners.Add(type, delegates);
}
delegates.Add(callback);
return this;
}
public void UnsubscribeFromPackets<T>(Action<T> callback)
public INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback)
{
if (!listeners.TryGetValue(typeof(T), out List<Delegate>? delegates))
return;
Type type = typeof(T);
Console.WriteLine($"Unsubscribing from: {type.FullName} on {GetType().Name}");
if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
return this;
delegates.Remove(callback);
return this;
}
}

64
Shared/Network/NetworkManager.cs
View File

@@ -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<Type> 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>(T entityDataPacket, string fromClientId)
{
if (entityDataPacket is IEntityNetworkPacket entityNetworkPacket)
_networkEntities[entityNetworkPacket.EntityId].ReceiveDataClient(entityDataPacket);
}
private void OnCollected(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourCollected)