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

perf: improved networking code to use the new events

Browse Source
This commit is contained in:
Syntriax 2025-05-31 20:25:30 +03:00
parent 52682d42b6
commit 8901a5469f
7 changed files with 45 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Engine

@ -1 +1 @@
Subproject commit 61e276158001cac85dc5758546fa839e091c0299
Subproject commit 86c9ed2ba98e05f21a952b58c49af5954207e006

2
Shared/Behaviours/PaddleBehaviour.cs
View File

@ -71,7 +71,7 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
rigidBody.Velocity = Vector2D.Zero;
}
public void OnServerPacketArrived(PaddleKeyStatePacket packet, string from)
public void OnServerPacketArrived(string sender, PaddleKeyStatePacket packet)
{
isUpPressed = packet.IsUpPressed;
isDownPressed = packet.IsDownPressed;

2
Shared/Behaviours/PongManagerBehaviour.cs
View File

@ -89,7 +89,7 @@ public class PongManagerBehaviour : Behaviour, INetworkEntity,
return Vector2D.Right.Rotate(isBackwards ? rotation + Syntriax.Engine.Core.Math.PI : rotation);
}
void IPacketListenerServer<RequestStartPacket>.OnServerPacketArrived(RequestStartPacket packet, string from)
void IPacketListenerServer<RequestStartPacket>.OnServerPacketArrived(string sender, RequestStartPacket packet)
{
if (ball.RigidBody.Velocity.MagnitudeSquared > 0.01f)
return;

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

@ -1,4 +1,4 @@
using System;
using Syntriax.Engine.Core;
namespace Syntriax.Engine.Network;
@ -6,8 +6,8 @@ public interface INetworkCommunicator
{
INetworkCommunicator Stop();
INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback);
INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback);
INetworkCommunicator SubscribeToPackets<T>(Event<string, T>.EventHandler callback);
INetworkCommunicator UnsubscribeFromPackets<T>(Event<string, T>.EventHandler callback);
}
public interface INetworkCommunicatorClient : INetworkCommunicator

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

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

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

@ -14,7 +14,7 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
{
protected readonly NetPacketProcessor netPacketProcessor = new();
private readonly Dictionary<Type, List<Delegate>> listeners = [];
private readonly Dictionary<Type, Event<string, object>> listeners = [];
public EventBasedNetListener Listener { get; private set; } = null!;
public NetManager Manager { get; private set; } = null!;
@ -33,11 +33,10 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
protected virtual void OnPacketArrived<T>(T packet, NetPeer peer) where T : INetworkPacket
{
if (!listeners.TryGetValue(typeof(T), out List<Delegate>? delegates))
if (!listeners.TryGetValue(typeof(T), out Event<string, object>? @event))
return;
foreach (Delegate @delegate in delegates)
@delegate.DynamicInvoke(packet, peer.Id.ToString());
@event.Invoke(peer.Id.ToString(), packet);
}
private void NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod)
@ -119,26 +118,28 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
netPacketProcessor.RegisterNestedType(Vector3DNetPacker.Write, Vector3DNetPacker.Read);
}
public INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback)
public INetworkCommunicator SubscribeToPackets<T>(Event<string, T>.EventHandler callback)
{
Type type = typeof(T);
if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
if (!listeners.TryGetValue(type, out Event<string, object>? @event))
{
delegates = [];
listeners.Add(type, delegates);
@event = new();
listeners.Add(type, @event);
}
delegates.Add(callback);
@event.AddListener(EventDelegateWrapper(callback));
return this;
}
public INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback)
public INetworkCommunicator UnsubscribeFromPackets<T>(Event<string, T>.EventHandler callback)
{
Type type = typeof(T);
if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
if (!listeners.TryGetValue(type, out Event<string, object>? @event))
return this;
delegates.Remove(callback);
@event.RemoveListener(EventDelegateWrapper(callback));
return this;
}
private static Event<string, object>.EventHandler EventDelegateWrapper<T>(Event<string, T>.EventHandler callback) => (sender, @object) => callback.Invoke(sender, (T)@object);
}

51
Shared/Network/NetworkManager.cs
View File

@ -28,8 +28,8 @@ public class NetworkManager : UniverseObject, INetworkManager
}
}
private readonly Dictionary<Type, Dictionary<string, PacketListenerData>> clientPacketListeners = [];
private readonly Dictionary<Type, Dictionary<string, PacketListenerData>> serverPacketListeners = [];
private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> clientPacketListeners = [];
private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> serverPacketListeners = [];
private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
@ -44,6 +44,7 @@ public class NetworkManager : UniverseObject, INetworkManager
_networkEntityCollector.OnCollected.AddListener(OnCollected);
_networkEntityCollector.OnRemoved.AddListener(OnRemoved);
}
private void CacheDelegates()
{
// Find network packets implementing INetworkPacket
@ -57,7 +58,7 @@ public class NetworkManager : UniverseObject, INetworkManager
{
MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType);
Type genericDelegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(string));
Type genericDelegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(string), packetType);
Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
delegates.Add((packetType, genericPacketReceivedDelegate));
@ -90,34 +91,34 @@ public class NetworkManager : UniverseObject, INetworkManager
}
}
private void OnPacketReceived<T>(T entityDataPacket, string fromClientId)
private void OnPacketReceived<T>(string senderClientId, T entityDataPacket)
{
Type packetType = typeof(T);
if (entityDataPacket is IEntityNetworkPacket entityPacket)
{
if (networkCommunicator is INetworkCommunicatorClient)
if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? clientListeners))
if (clientListeners.TryGetValue(entityPacket.EntityId, out PacketListenerData clientListenerData))
clientListenerData.ListenerMethod.Invoke(clientListenerData.Object, [entityDataPacket]);
if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? clientListeners))
if (clientListeners.TryGetValue(entityPacket.EntityId, out Event<string, object>? clientListenerData))
clientListenerData.Invoke(senderClientId, entityDataPacket!);
if (networkCommunicator is INetworkCommunicatorServer)
if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? serverListeners))
if (serverListeners.TryGetValue(entityPacket.EntityId, out PacketListenerData serverListenerData))
serverListenerData.ListenerMethod.Invoke(serverListenerData.Object, [entityDataPacket, fromClientId]);
if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? serverListeners))
if (serverListeners.TryGetValue(entityPacket.EntityId, out Event<string, object>? serverListenerData))
serverListenerData.Invoke(senderClientId, entityDataPacket!);
return;
}
if (networkCommunicator is INetworkCommunicatorClient)
if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? clientListeners))
foreach ((string id, PacketListenerData clientListenerData) in clientListeners)
clientListenerData.ListenerMethod.Invoke(clientListenerData.Object, [entityDataPacket]);
if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? clientListeners))
foreach ((string id, Event<string, object> clientListenerData) in clientListeners)
clientListenerData.Invoke(senderClientId, entityDataPacket!);
if (networkCommunicator is INetworkCommunicatorServer)
if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? serverListeners))
foreach ((string id, PacketListenerData serverListenerData) in serverListeners)
serverListenerData.ListenerMethod.Invoke(serverListenerData.Object, [entityDataPacket, fromClientId]);
if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? serverListeners))
foreach ((string id, Event<string, object> serverListenerData) in serverListeners)
serverListenerData.Invoke(senderClientId, entityDataPacket!);
}
private void OnCollected(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourCollectedArguments args)
@ -132,13 +133,15 @@ public class NetworkManager : UniverseObject, INetworkManager
Type clientListenerParameterType = clientListenerType.GetGenericArguments().First();
MethodInfo clientListenerReceiveMethod = clientListenerType.GetMethods().First(m => m.Name == nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived));
if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out Dictionary<string, PacketListenerData>? clientListeners))
if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out Dictionary<string, Event<string, object>>? clientListeners))
{
clientListeners = [];
clientPacketListeners.Add(clientListenerParameterType, clientListeners);
}
clientListeners.Add(collectedBehaviour.Id, new(collectedBehaviour, clientListenerReceiveMethod));
Event<string, object> clientListenerEvent = new();
clientListenerEvent.AddListener((sender, @object) => clientListenerReceiveMethod.Invoke(collectedBehaviour, [@object]));
clientListeners.Add(collectedBehaviour.Id, clientListenerEvent);
}
foreach (Type serverListenerType in collectedBehaviour.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketListenerServer<>)))
@ -146,13 +149,15 @@ public class NetworkManager : UniverseObject, INetworkManager
Type serverListenerParameterType = serverListenerType.GetGenericArguments().First();
MethodInfo serverListenerReceiveMethod = serverListenerType.GetMethods().First(m => m.Name == nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived));
if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out Dictionary<string, PacketListenerData>? serverListeners))
if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out Dictionary<string, Event<string, object>>? serverListeners))
{
serverListeners = [];
serverPacketListeners.Add(serverListenerParameterType, serverListeners);
}
serverListeners.Add(collectedBehaviour.Id, new(collectedBehaviour, serverListenerReceiveMethod));
Event<string, object> serverListenerEvent = new();
serverListenerEvent.AddListener((sender, @object) => serverListenerReceiveMethod.Invoke(collectedBehaviour, [sender, @object]));
serverListeners.Add(collectedBehaviour.Id, serverListenerEvent);
}
}
@ -167,10 +172,4 @@ public class NetworkManager : UniverseObject, INetworkManager
_networkEntityCollector.Assign(universe);
NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
}
private record struct PacketListenerData(object Object, MethodInfo ListenerMethod)
{
public static implicit operator (object @object, MethodInfo listenerMethod)(PacketListenerData value) => (value.Object, value.ListenerMethod);
public static implicit operator PacketListenerData((object @object, MethodInfo listenerMethod) value) => new(value.@object, value.listenerMethod);
}
}