Fixed MirrorSendRpcPatch

Author: marchellcx

LabExtended/Events/MirrorEvents.cs

@@ -95,22 +95,22 @@ public delegate void BehaviourUpdatedSyncVarEventHandler(NetworkBehaviour behavi
     public delegate void RemovedObserverEventHandler(NetworkIdentity identity, ExPlayer observer);
 
     /// <summary>
-    /// Represents the method that handles the event raised before a remote procedure call (RPC) is sent to network
-    /// targets.
-    /// </summary>
-    /// <remarks>This event allows inspection or modification of the RPC message and its delivery. Handlers
-    /// can change the message contents or cancel the RPC by setting <paramref name="isAllowed"/> to <see
-    /// langword="false"/>.</remarks>
-    /// <param name="behaviour">The network behaviour instance initiating the RPC.</param>
-    /// <param name="rpcName">The name of the RPC method being invoked.</param>
+    /// Represents the method that handles the event raised before a remote procedure call (RPC) is sent to specified
+    /// targets on the network.
+    /// </summary>
+    /// <remarks>This event allows inspection and modification of RPC data and targets before the message is
+    /// sent. It can be used to implement custom filtering, logging, or security checks. Modifying <paramref
+    /// name="isAllowed"/> to <see langword="false"/> will prevent the RPC from being sent.</remarks>
+    /// <param name="behaviour">The network behaviour instance that is invoking the RPC.</param>
+    /// <param name="rpcName">The name of the RPC method being called.</param>
     /// <param name="rpcHash">The hash value identifying the RPC method.</param>
-    /// <param name="writer">The writer used to serialize the RPC parameters.</param>
-    /// <param name="targets">The list of target players to whom the RPC will be sent.</param>
-    /// <param name="message">A reference to the RPC message that will be sent. Can be modified to alter the outgoing message.</param>
-    /// <param name="isAllowed">A reference to a value indicating whether the RPC is permitted to be sent. Set to <see langword="false"/> to
-    /// prevent the RPC from being sent.</param>
-    public delegate void SendingRpcEventHandler(NetworkBehaviour behaviour, string rpcName, int rpcHash, NetworkWriter writer, List<ExPlayer> targets, 
-        ref RpcMessage message, ref bool isAllowed);
+    /// <param name="writer">The writer used to serialize the RPC payload data.</param>
+    /// <param name="connectionTargets">The list of network connections to which the RPC will be sent.</param>
+    /// <param name="message">A reference to the RPC message being sent. Can be modified to alter the message before transmission.</param>
+    /// <param name="isAllowed">A reference to a Boolean value indicating whether the RPC is permitted to be sent. Set to <see
+    /// langword="false"/> to block the RPC.</param>
+    public delegate void SendingRpcEventHandler(NetworkBehaviour behaviour, string rpcName, int rpcHash, NetworkWriter writer, 
+        List<NetworkConnection> connectionTargets, List<ExPlayer> playerTargets, ref RpcMessage message, ref bool isAllowed);
 
     /// <summary>
     /// Represents the method that handles an event triggered when a remote procedure call (RPC) is sent from a network
@@ -372,13 +372,14 @@ public static void OnUpdatedSyncVar(NetworkBehaviour behaviour, Type syncVarType
     /// <summary>
     /// Invokes the <see cref="SendingRpc"/> event.
     /// </summary>
-    public static bool OnSendingRpc(NetworkBehaviour behaviour, string rpcName, int rpcHash, NetworkWriter writer, List<ExPlayer> targets, ref RpcMessage message)
+    public static bool OnSendingRpc(NetworkBehaviour behaviour, string rpcName, int rpcHash, NetworkWriter writer, List<NetworkConnection> connections, 
+        List<ExPlayer> players, ref RpcMessage message)
     {
         var isAllowed = true;
 
         try
         {
-            SendingRpc?.Invoke(behaviour, rpcName, rpcHash, writer, targets, ref message, ref isAllowed);
+            SendingRpc?.Invoke(behaviour, rpcName, rpcHash, writer, connections, players, ref message, ref isAllowed);
         }
         catch (Exception ex)
         {
@@ -405,4 +406,7 @@ public static void OnSentRpc(NetworkBehaviour behaviour, string rpcName, int rpc
 
     internal static bool Internal_AnySyncVarSubsribers()
         => UpdatingSyncVar is not null || UpdatedSyncVar is not null;
+
+    internal static bool Internal_AnySerializingSubscribers()
+        => BehaviourSerializing is not null || BehaviourSerialized is not null;
 }

LabExtended/Patches/Events/Mirror/MirrorBehaviourSerializePatch.cs

@@ -14,6 +14,9 @@ public static class MirrorBehaviourSerializePatch
         [HarmonyPatch(typeof(NetworkIdentity), nameof(NetworkIdentity.SerializeServer))]
         private static bool Prefix(NetworkIdentity __instance, bool initialState, NetworkWriter ownerWriter, NetworkWriter observersWriter)
         {
+            if (!MirrorEvents.Internal_AnySerializingSubscribers())
+                return true;
+
             __instance.ValidateComponents();
 
             var behaviours = __instance.NetworkBehaviours;

LabExtended/Patches/Events/Mirror/MirrorSendRpcPatch.cs

@@ -25,54 +25,63 @@ private static bool SendAllRpcPrefix(NetworkBehaviour __instance, string functio
                 return false;
             }
 
-            if (__instance.netIdentity.observers == null || __instance.netIdentity.observers.Count == 0)
-                return false;
-
             var rpcMessage = new RpcMessage
             {
                 netId = __instance.netId,
                 componentIndex = __instance.ComponentIndex,
-
                 functionHash = (ushort)functionHashCode,
                 payload = writer.ToArraySegment()
             };
 
+            if (__instance.netIdentity.observers == null || __instance.netIdentity.observers.Count == 0)
+                return false;
+
             var players = ListPool<ExPlayer>.Shared.Rent();
+            var connections = ListPool<NetworkConnection>.Shared.Rent();
 
-            for (var i = 0; i < ExPlayer.Players.Count; i++)
+            foreach (var pair in __instance.netIdentity.observers)
             {
-                var player = ExPlayer.Players[i];
-
-                if (player?.ReferenceHub == null || !player.Connection.isReady)
-                    continue;
-
-                if (__instance.netIdentity.connectionToClient != null && __instance.netIdentity.connectionToClient == player.Connection && !includeOwner)
-                    continue;
-
-                if (!__instance.netIdentity.observers.ContainsKey(player.ConnectionId))
-                    continue;
+                if (ExPlayer.TryGet(pair.Value, out var player))
+                {
+                    players.Add(player);
+                }
+                else
+                {
+                    if (__instance.connectionToClient == pair.Value && !includeOwner)
+                        continue;
 
-                players.Add(player);
+                    connections.Add(pair.Value);
+                }
             }
 
-            if (players.Count > 0)
+            if (MirrorEvents.OnSendingRpc(__instance, functionFullName, functionHashCode, writer, connections, players, ref rpcMessage))
             {
-                if (MirrorEvents.OnSendingRpc(__instance, functionFullName, functionHashCode, writer, players, ref rpcMessage)
-                    && players.Count > 0)
-                {
-                    using var writer2 = NetworkWriterPool.Get();
+                using var writer2 = NetworkWriterPool.Get();
 
-                    writer2.Write(rpcMessage);
+                writer2.Write(rpcMessage);
 
-                    var segment = writer2.ToArraySegment();
+                players.ForEach(ply =>
+                {
+                    if (ply.Connection.isReady)
+                    {
+                        ply.Connection.Send(rpcMessage, channelId);
+                    }
+                });
 
-                    players.ForEach(ply => ply.ConnectionToClient.Send(segment, channelId));
+                connections.ForEach(conn =>
+                {
+                    if (conn.isReady)
+                    {
+                        conn.Send(rpcMessage, channelId);
+                    }
+                });
 
-                    MirrorEvents.OnSentRpc(__instance, functionFullName, functionHashCode, writer, players, ref rpcMessage);
-                }
+                MirrorEvents.OnSentRpc(__instance, functionFullName, functionHashCode, writer, players, ref rpcMessage);
             }
 
             ListPool<ExPlayer>.Shared.Return(players);
+            ListPool<NetworkConnection>.Shared.Return(connections);
+
             return false;
         }
 
@@ -103,24 +112,21 @@ private static bool SendTargetRpcPrefix(NetworkBehaviour __instance, NetworkConn
             };
 
             var players = ListPool<ExPlayer>.Shared.Rent();
+            var connections = ListPool<NetworkConnection>.Shared.Rent();
 
             players.Add(player);
+            connections.Add(conn);
 
-            if (MirrorEvents.OnSendingRpc(__instance, functionFullName, functionHashCode, writer, players, ref rpcMessage)
-                && players.Count > 0)
+            if (MirrorEvents.OnSendingRpc(__instance, functionFullName, functionHashCode, writer, connections, players, ref rpcMessage))
             {
-                using var writer2 = NetworkWriterPool.Get();
-
-                writer2.Write(rpcMessage);
-
-                var segment = writer2.ToArraySegment();
-
-                player.ConnectionToClient.Send(segment, channelId);
+                conn.Send(rpcMessage, channelId);
 
                 MirrorEvents.OnSentRpc(__instance, functionFullName, functionHashCode, writer, players, ref rpcMessage);
             }
 
             ListPool<ExPlayer>.Shared.Return(players);
+            ListPool<NetworkConnection>.Shared.Return(connections);
+
             return false;
         }
     }