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

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)