diff --git a/Engine b/Engine
index 2df41e1..8f8558a 160000
--- a/Engine
+++ b/Engine
@@ -1 +1 @@
-Subproject commit 2df41e18818e314ebfa21e578500d5e3161cf850
+Subproject commit 8f8558a262a20d584afd38369b02c4c50d86b20f
diff --git a/Shared/Network/NetworkManager.cs b/Shared/Network/NetworkManager.cs
index 3979395..9cee79d 100644
--- a/Shared/Network/NetworkManager.cs
+++ b/Shared/Network/NetworkManager.cs
@@ -28,8 +28,8 @@ public class NetworkManager : UniverseObject, INetworkManager
         }
     }
 
-    private readonly Dictionary<Type, Dictionary<string, object>> clientPacketListeners = [];
-    private readonly Dictionary<Type, Dictionary<string, object>> serverPacketListeners = [];
+    private readonly Dictionary<Type, Dictionary<string, PacketListenerData>> clientPacketListeners = [];
+    private readonly Dictionary<Type, Dictionary<string, PacketListenerData>> serverPacketListeners = [];
 
     private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
     public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
@@ -98,39 +98,27 @@ public class NetworkManager : UniverseObject, INetworkManager
         if (entityDataPacket is IEntityNetworkPacket entityPacket)
         {
             if (networkCommunicator is INetworkCommunicatorClient)
-                if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, object>? clientListeners))
-                    if (clientListeners.TryGetValue(entityPacket.EntityId, out object? clientListener))
-                    {
-                        MethodInfo clientListenerReceiveMethod = typeof(IPacketListenerClient<>).MakeGenericType(packetType).GetMethods().First(m => m.Name == nameof(IPacketListenerClient<T>.OnClientPacketArrived));
-                        clientListenerReceiveMethod.Invoke(clientListener, [entityDataPacket]);
-                    }
+                if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? clientListeners))
+                    if (clientListeners.TryGetValue(entityPacket.EntityId, out PacketListenerData clientListenerData))
+                        clientListenerData.ListenerMethod.Invoke(clientListenerData.Object, [entityDataPacket]);
 
             if (networkCommunicator is INetworkCommunicatorServer)
-                if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, object>? serverListeners))
-                    if (serverListeners.TryGetValue(entityPacket.EntityId, out object? serverListener))
-                    {
-                        MethodInfo serverListenerReceiveMethod = typeof(IPacketListenerServer<>).MakeGenericType(packetType).GetMethods().First(m => m.Name == nameof(IPacketListenerServer<T>.OnServerPacketArrived));
-                        serverListenerReceiveMethod.Invoke(serverListener, [entityDataPacket, fromClientId]);
-                    }
+                if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? serverListeners))
+                    if (serverListeners.TryGetValue(entityPacket.EntityId, out PacketListenerData serverListenerData))
+                        serverListenerData.ListenerMethod.Invoke(serverListenerData.Object, [entityDataPacket, fromClientId]);
 
             return;
         }
 
         if (networkCommunicator is INetworkCommunicatorClient)
-            if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, object>? clientListeners))
-            {
-                MethodInfo clientListenerReceiveMethod = typeof(IPacketListenerClient<>).MakeGenericType(packetType).GetMethods().First(m => m.Name == nameof(IPacketListenerClient<T>.OnClientPacketArrived));
-                foreach ((string id, object clientListener) in clientListeners)
-                    clientListenerReceiveMethod.Invoke(clientListener, [entityDataPacket]);
-            }
+            if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? clientListeners))
+                foreach ((string id, PacketListenerData clientListenerData) in clientListeners)
+                    clientListenerData.ListenerMethod.Invoke(clientListenerData.Object, [entityDataPacket]);
 
         if (networkCommunicator is INetworkCommunicatorServer)
-            if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, object>? serverListeners))
-            {
-                MethodInfo serverListenerReceiveMethod = typeof(IPacketListenerServer<>).MakeGenericType(packetType).GetMethods().First(m => m.Name == nameof(IPacketListenerServer<T>.OnServerPacketArrived));
-                foreach ((string id, object serverListener) in serverListeners)
-                    serverListenerReceiveMethod.Invoke(serverListener, [entityDataPacket, fromClientId]);
-            }
+            if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? serverListeners))
+                foreach ((string id, PacketListenerData serverListenerData) in serverListeners)
+                    serverListenerData.ListenerMethod.Invoke(serverListenerData.Object, [entityDataPacket, fromClientId]);
     }
 
     private void OnCollected(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourCollected)
@@ -141,27 +129,29 @@ public class NetworkManager : UniverseObject, INetworkManager
         foreach (Type clientListenerType in behaviourCollected.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketListenerClient<>)))
         {
             Type clientListenerParameterType = clientListenerType.GetGenericArguments().First();
+            MethodInfo clientListenerReceiveMethod = clientListenerType.GetMethods().First(m => m.Name == nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived));
 
-            if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out Dictionary<string, object>? clientListeners))
+            if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out Dictionary<string, PacketListenerData>? clientListeners))
             {
                 clientListeners = [];
                 clientPacketListeners.Add(clientListenerParameterType, clientListeners);
             }
 
-            clientListeners.Add(behaviourCollected.Id, behaviourCollected);
+            clientListeners.Add(behaviourCollected.Id, new(behaviourCollected, clientListenerReceiveMethod));
         }
 
         foreach (Type serverListenerType in behaviourCollected.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketListenerServer<>)))
         {
             Type serverListenerParameterType = serverListenerType.GetGenericArguments().First();
+            MethodInfo serverListenerReceiveMethod = serverListenerType.GetMethods().First(m => m.Name == nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived));
 
-            if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out Dictionary<string, object>? serverListeners))
+            if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out Dictionary<string, PacketListenerData>? serverListeners))
             {
                 serverListeners = [];
                 serverPacketListeners.Add(serverListenerParameterType, serverListeners);
             }
 
-            serverListeners.Add(behaviourCollected.Id, behaviourCollected);
+            serverListeners.Add(behaviourCollected.Id, new(behaviourCollected, serverListenerReceiveMethod));
         }
     }
 
@@ -176,4 +166,10 @@ 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);
+    }
 }