refactor: network manager refactored for readability

Shared/Network/NetworkManager.cs

@@ -7,32 +7,18 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Network;
 
+/// <summary>
+/// Intermediary manager that looks up in it's hierarchy for a <see cref="INetworkCommunicator"/> to route/broadcast it's received packets to their destinations.
+/// </summary>
 public class NetworkManager : UniverseObject, INetworkManager
 {
-    private INetworkCommunicator networkCommunicator = null!;
+    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> clientPacketArrivalMethods = [];
+    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> serverPacketArrivalMethods = [];
 
-    private readonly Dictionary<Type, Dictionary<Type, List<DelegateData>>> clientListenerDelegates = [];
+    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> clientPacketRouters = [];
-    private readonly Dictionary<Type, Dictionary<Type, List<DelegateData>>> serverListenerDelegates = [];
+    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> serverPacketRouters = [];
 
-    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> clientPacketListeners = [];
+    private readonly List<(Type packetType, Delegate callback)> packetRetrievalDelegates = [];
-    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> serverPacketListeners = [];
-    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;
@@ -40,45 +26,205 @@ public class NetworkManager : UniverseObject, INetworkManager
     private readonly BehaviourCollector<INetworkEntity> _networkEntityCollector = new();
     public IBehaviourCollector<INetworkEntity> NetworkEntityCollector => _networkEntityCollector;
 
+    private INetworkCommunicator _networkCommunicator = null!;
+    public INetworkCommunicator NetworkCommunicator
+    {
+        get => _networkCommunicator;
+        set
+        {
+            if (_networkCommunicator == value)
+                return;
+
+            var previousCommunicator = _networkCommunicator;
+            _networkCommunicator = value;
+
+            if (previousCommunicator is not null) SubscribeCommunicatorMethods(previousCommunicator);
+            if (_networkCommunicator is not null) UnsubscribeCommunicatorMethods(_networkCommunicator);
+        }
+    }
+
+    #region Communicator Subscriptions
+    private void SubscribeCommunicatorMethods(INetworkCommunicator networkCommunicator)
+    {
+        MethodInfo subscribeToPacketsMethod = typeof(INetworkCommunicator)
+            .GetMethod(nameof(INetworkCommunicator.SubscribeToPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+
+        foreach ((Type packetType, Delegate callback) in packetRetrievalDelegates)
+        {
+            MethodInfo genericSubscribeMethod = subscribeToPacketsMethod.MakeGenericMethod(packetType);
+            genericSubscribeMethod.Invoke(networkCommunicator, [callback]);
+        }
+    }
+
+    private void UnsubscribeCommunicatorMethods(INetworkCommunicator networkCommunicator)
+    {
+        MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
+            .GetMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+
+        foreach ((Type packetType, Delegate callback) in packetRetrievalDelegates)
+        {
+            MethodInfo genericUnsubscribeMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);
+            genericUnsubscribeMethod.Invoke(networkCommunicator, [callback]);
+        }
+    }
+    #endregion
+
+    #region Packet Routing
+    private void OnPacketReceived<T>(string senderClientId, T entityDataPacket)
+    {
+        if (entityDataPacket is IEntityNetworkPacket entityPacket)
+            RoutePacket(senderClientId, entityDataPacket, entityPacket);
+        else
+            BroadcastPacket(senderClientId, entityDataPacket);
+    }
+
+    private void RoutePacket<T>(string senderClientId, T entityDataPacket, IEntityNetworkPacket entityPacket)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            RoutePacket(clientPacketRouters, entityPacket.EntityId, senderClientId, entityDataPacket);
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            RoutePacket(serverPacketRouters, entityPacket.EntityId, senderClientId, entityDataPacket);
+    }
+
+    private void BroadcastPacket<T>(string senderClientId, T entityDataPacket)
+    {
+        if (NetworkCommunicator is INetworkCommunicatorClient)
+            BroadcastPacket(clientPacketRouters, senderClientId, entityDataPacket);
+        if (NetworkCommunicator is INetworkCommunicatorServer)
+            BroadcastPacket(serverPacketRouters, senderClientId, entityDataPacket);
+    }
+
+
+    private static void BroadcastPacket<T>(
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetRouters,
+        string senderClientId,
+        T entityDataPacket)
+    {
+        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, Event<string, object>>? routers))
+            return;
+
+        foreach ((string id, Event<string, object> routerEvent) in routers)
+            routerEvent.Invoke(senderClientId, entityDataPacket!);
+    }
+
+    private static void RoutePacket<T>(
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetRouters,
+        string entityId,
+        string senderClientId,
+        T entityDataPacket)
+    {
+        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, Event<string, object>>? routers))
+            return;
+
+        if (!routers.TryGetValue(entityId, out Event<string, object>? routerEvent))
+            return;
+
+        routerEvent.Invoke(senderClientId, entityDataPacket!);
+    }
+    #endregion
+
+    #region Packet Routers
+    private static void RegisterPacketRoutersFor(
+        INetworkEntity behaviour,
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetRouters,
+        Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods,
+        NetworkType networkType)
+    {
+        if (!packetArrivalMethods.TryGetValue(behaviour.GetType(), out Dictionary<Type, List<MethodInfo>>? arrivalMethods))
+            return;
+
+        foreach ((Type packetType, List<MethodInfo> methods) in arrivalMethods)
+            foreach (MethodInfo receiveMethod in methods)
+            {
+                if (!packetRouters.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? routers))
+                {
+                    routers = [];
+                    packetRouters.Add(packetType, routers);
+                }
+
+                Event<string, object> packetListenerEvent = new();
+                RegisterPacketListenerEvent(behaviour, packetListenerEvent, receiveMethod, networkType);
+                routers.Add(behaviour.Id, packetListenerEvent);
+            }
+    }
+
+    private static void RegisterPacketListenerEvent(
+        INetworkEntity behaviour,
+        Event<string, object> packetListenerEvent,
+        MethodInfo receiveMethod,
+        NetworkType networkType)
+    {
+        switch (networkType)
+        {
+            case NetworkType.Client: packetListenerEvent.AddListener((sender, @object) => receiveMethod.Invoke(behaviour, [@object])); break;
+            case NetworkType.Server: packetListenerEvent.AddListener((sender, @object) => receiveMethod.Invoke(behaviour, [sender, @object])); break;
+        }
+    }
+
+    private static void UnregisterPacketRoutersFor(
+        INetworkEntity behaviour,
+        Dictionary<Type, Dictionary<string, Event<string, object>>> packetRouters,
+        Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods)
+    {
+        if (!packetArrivalMethods.TryGetValue(behaviour.GetType(), out Dictionary<Type, List<MethodInfo>>? arrivalMethods))
+            return;
+
+        foreach ((Type packetType, List<MethodInfo> methods) in arrivalMethods)
+        {
+            if (!packetRouters.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? routers))
+                continue;
+
+            if (!routers.TryGetValue(behaviour.Id, out Event<string, object>? routerEvent))
+                continue;
+
+            routers.Remove(behaviour.Id);
+            routerEvent.Clear();
+        }
+    }
+    #endregion
+
+    #region Engine Callbacks
+    private void OnCollected(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourCollectedArguments args)
+    {
+        INetworkEntity collectedBehaviour = args.BehaviourCollected;
+
+        if (!_networkEntities.TryAdd(collectedBehaviour.Id, collectedBehaviour))
+            throw new($"Unable to add {collectedBehaviour.Id} to {nameof(NetworkManager)}");
+
+        RegisterPacketRoutersFor(collectedBehaviour, clientPacketRouters, clientPacketArrivalMethods, NetworkType.Client);
+        RegisterPacketRoutersFor(collectedBehaviour, serverPacketRouters, serverPacketArrivalMethods, NetworkType.Server);
+    }
+
+    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourRemovedArguments args)
+    {
+        INetworkEntity removedBehaviour = args.BehaviourRemoved;
+        if (!_networkEntities.Remove(args.BehaviourRemoved.Id))
+            return;
+
+        UnregisterPacketRoutersFor(removedBehaviour, clientPacketRouters, clientPacketArrivalMethods);
+        UnregisterPacketRoutersFor(removedBehaviour, serverPacketRouters, serverPacketArrivalMethods);
+    }
+
+    protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
+    protected override void OnEnteringUniverse(IUniverse universe)
+    {
+        _networkEntityCollector.Assign(universe);
+        NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
+    }
+    #endregion
+
+    #region Initialization
     public NetworkManager()
     {
-        CachePacketDelegates();
+        CachePacketRetrievalDelegates();
-        CacheListenerDelegates();
+        CachePacketArrivalMethods();
 
         _networkEntityCollector.OnCollected.AddListener(OnCollected);
         _networkEntityCollector.OnRemoved.AddListener(OnRemoved);
     }
 
-    private void CacheListenerDelegates()
+    private void CachePacketRetrievalDelegates()
     {
-        foreach (Type clientListenerClass in GetClassesImplementing(typeof(IPacketListenerClient<>)))
-        {
-            Dictionary<Type, List<DelegateData>> clientInterfaceListeners = [];
-            clientListenerDelegates.Add(clientListenerClass, clientInterfaceListeners);
-            foreach (Type clientListenerInterface in GetInterfacesImplementing(clientListenerClass, typeof(IPacketListenerClient<>)))
-            {
-                Type clientListenerParameterType = clientListenerInterface.GetGenericArguments().First();
-                List<DelegateData> delegateDataList = clientListenerInterface.GetMethods().Where(m => m.Name == nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived)).Select(m => new DelegateData(clientListenerParameterType, m)).ToList();
-                clientInterfaceListeners.Add(clientListenerParameterType, delegateDataList);
-            }
-        }
-
-        foreach (Type serverListenerClass in GetClassesImplementing(typeof(IPacketListenerServer<>)))
-        {
-            Dictionary<Type, List<DelegateData>> serverInterfaceListeners = [];
-            serverListenerDelegates.Add(serverListenerClass, serverInterfaceListeners);
-            foreach (Type serverListenerInterface in GetInterfacesImplementing(serverListenerClass, typeof(IPacketListenerServer<>)))
-            {
-                Type serverListenerParameterType = serverListenerInterface.GetGenericArguments().First();
-                List<DelegateData> delegateDataList = serverListenerInterface.GetMethods().Where(m => m.Name == nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived)).Select(m => new DelegateData(serverListenerParameterType, m)).ToList();
-                serverInterfaceListeners.Add(serverListenerParameterType, delegateDataList);
-            }
-        }
-    }
-
-    private void CachePacketDelegates()
-    {
-        // Find network packets implementing INetworkPacket
         IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
             .Where(t => typeof(INetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType);
 
@@ -92,37 +238,38 @@ public class NetworkManager : UniverseObject, INetworkManager
             Type genericDelegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(string), packetType);
             Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
 
-            delegates.Add((packetType, genericPacketReceivedDelegate));
+            packetRetrievalDelegates.Add((packetType, genericPacketReceivedDelegate));
         }
     }
 
-    private void SubscribeDelegates(INetworkCommunicator networkCommunicator)
+    private void CachePacketArrivalMethods()
     {
-        MethodInfo subscribeToPacketsMethod = typeof(INetworkCommunicator)
+        CachePacketArrivalMethods(clientPacketArrivalMethods, typeof(IPacketListenerClient<>), nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived));
-            .GetMethod(nameof(INetworkCommunicator.SubscribeToPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
+        CachePacketArrivalMethods(serverPacketArrivalMethods, typeof(IPacketListenerServer<>), nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived));
-
-        foreach ((Type packetType, Delegate callback) in delegates)
-        {
-            MethodInfo genericSubscribeMethod = subscribeToPacketsMethod.MakeGenericMethod(packetType);
-
-            genericSubscribeMethod.Invoke(networkCommunicator, [callback]);
-        }
     }
 
-    private void UnsubscribeDelegates(INetworkCommunicator networkCommunicator)
+    private static void CachePacketArrivalMethods(Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods, Type listenerType, string packetArrivalMethodName)
     {
-        MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
+        foreach (Type listenerClass in GetGenericsWith(listenerType))
-            .GetMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
-
-        foreach ((Type packetType, Delegate callback) in delegates)
         {
-            MethodInfo genericUnsubscribeMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);
+            Dictionary<Type, List<MethodInfo>> packetRouters = [];
+            packetArrivalMethods.Add(listenerClass, packetRouters);
 
-            genericUnsubscribeMethod.Invoke(networkCommunicator, [callback]);
+            foreach (Type packetListener in GetGenericInterfacesWith(listenerType, listenerClass))
+            {
+                Type packetType = packetListener.GetGenericArguments().First();
+
+                List<MethodInfo> arrivalMethods = packetListener
+                    .GetMethods()
+                    .Where(m => m.Name == packetArrivalMethodName)
+                    .ToList();
+
+                packetRouters.Add(packetType, arrivalMethods);
+            }
         }
     }
 
-    private static IEnumerable<Type> GetClassesImplementing(Type type)
+    private static IEnumerable<Type> GetGenericsWith(Type type)
         => AppDomain.CurrentDomain
             .GetAssemblies()
             .SelectMany(a =>
@@ -133,124 +280,11 @@ public class NetworkManager : UniverseObject, INetworkManager
                 )
             );
 
-    private static IEnumerable<Type> GetInterfacesImplementing(Type type, Type interfaceType)
+    private static IEnumerable<Type> GetGenericInterfacesWith(Type interfaceType, Type type)
         => type.GetInterfaces().Where(
             i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceType
         );
+    #endregion
 
-    private void OnPacketReceived<T>(string senderClientId, T entityDataPacket)
+    private enum NetworkType { Client, Server }
-    {
-        Type packetType = typeof(T);
-
-        if (entityDataPacket is IEntityNetworkPacket entityPacket)
-        {
-            if (networkCommunicator is INetworkCommunicatorClient)
-                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, 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, 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, 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)
-    {
-        INetworkEntity collectedBehaviour = args.BehaviourCollected;
-
-        if (!_networkEntities.TryAdd(collectedBehaviour.Id, collectedBehaviour))
-            throw new($"Unable to add {collectedBehaviour.Id} to {nameof(NetworkManager)}");
-
-        if (clientListenerDelegates.TryGetValue(collectedBehaviour.GetType(), out Dictionary<Type, List<DelegateData>>? clientInterfaceDelegates))
-            foreach ((Type clientListenerInterfaceType, List<DelegateData> clientDelegateDataList) in clientInterfaceDelegates)
-                foreach ((Type parameterType, MethodInfo receiveMethod) in clientDelegateDataList)
-                {
-                    if (!clientPacketListeners.TryGetValue(parameterType, out Dictionary<string, Event<string, object>>? clientListeners))
-                    {
-                        clientListeners = [];
-                        clientPacketListeners.Add(parameterType, clientListeners);
-                    }
-
-                    Event<string, object> clientListenerEvent = new();
-                    clientListenerEvent.AddListener((sender, @object) => receiveMethod.Invoke(collectedBehaviour, [@object]));
-                    clientListeners.Add(collectedBehaviour.Id, clientListenerEvent);
-                }
-
-        if (serverListenerDelegates.TryGetValue(collectedBehaviour.GetType(), out Dictionary<Type, List<DelegateData>>? serverInterfaceDelegates))
-            foreach ((Type serverListenerInterfaceType, List<DelegateData> serverDelegateDataList) in serverInterfaceDelegates)
-                foreach ((Type parameterType, MethodInfo receiveMethod) in serverDelegateDataList)
-                {
-                    if (!serverPacketListeners.TryGetValue(parameterType, out Dictionary<string, Event<string, object>>? serverListeners))
-                    {
-                        serverListeners = [];
-                        serverPacketListeners.Add(parameterType, serverListeners);
-                    }
-
-                    Event<string, object> serverListenerEvent = new();
-                    serverListenerEvent.AddListener((sender, @object) => receiveMethod.Invoke(collectedBehaviour, [sender, @object]));
-                    serverListeners.Add(collectedBehaviour.Id, serverListenerEvent);
-                }
-    }
-
-    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourRemovedArguments args)
-    {
-        INetworkEntity removedBehaviour = args.BehaviourRemoved;
-        if (!_networkEntities.Remove(args.BehaviourRemoved.Id))
-            return;
-
-        if (clientListenerDelegates.TryGetValue(removedBehaviour.GetType(), out Dictionary<Type, List<DelegateData>>? clientInterfaceDelegates))
-            foreach ((Type clientListenerInterfaceType, List<DelegateData> clientDelegateDataList) in clientInterfaceDelegates)
-                foreach ((Type parameterType, MethodInfo receiveMethod) in clientDelegateDataList)
-                {
-                    if (!clientPacketListeners.TryGetValue(parameterType, out Dictionary<string, Event<string, object>>? clientListeners))
-                        continue;
-
-                    if (!clientListeners.TryGetValue(removedBehaviour.Id, out Event<string, object>? clientListenerEvent))
-                        continue;
-
-                    clientListeners.Remove(removedBehaviour.Id);
-                    clientListenerEvent.Clear();
-                }
-
-        if (serverListenerDelegates.TryGetValue(removedBehaviour.GetType(), out Dictionary<Type, List<DelegateData>>? serverInterfaceDelegates))
-            foreach ((Type serverListenerInterfaceType, List<DelegateData> serverDelegateDataList) in serverInterfaceDelegates)
-                foreach ((Type parameterType, MethodInfo receiveMethod) in serverDelegateDataList)
-                {
-                    if (!serverPacketListeners.TryGetValue(parameterType, out Dictionary<string, Event<string, object>>? serverListeners))
-                        continue;
-
-                    if (!serverListeners.TryGetValue(removedBehaviour.Id, out Event<string, object>? serverListenerEvent))
-                        continue;
-
-                    serverListeners.Remove(removedBehaviour.Id);
-                    serverListenerEvent.Clear();
-                }
-    }
-
-    protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
-    protected override void OnEnteringUniverse(IUniverse universe)
-    {
-        _networkEntityCollector.Assign(universe);
-        NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
-    }
-
-    private record struct DelegateData(Type ParameterType, MethodInfo ReceiveMethod)
-    {
-        public static implicit operator (Type ParameterType, MethodInfo ReceiveMethod)(DelegateData value) => (value.ParameterType, value.ReceiveMethod);
-        public static implicit operator DelegateData((Type ParameterType, MethodInfo ReceiveMethod) value) => new(value.ParameterType, value.ReceiveMethod);
-    }
 }