Add a Try and Catch in the RPC invoking code

[Arvoutdev]

When a RPC encounters a error, it makes all RPCs that were to come after it not run.

[ServerRpc]
public void Test()
{
   int zero = 0;
   print(zero / zero);
}

public override void OnStartClient()
{
   //this will only print an error once
   Test();
   Test();
   Test();
}

The solution to this is to add a try-catch block where all RPCs get invoked: NetworkBehaviour.RPCs.cs. This could be an option on the network manager.

The Regex below is to fix the issue with printing Exceptions, where they will not have the correct blue links that take you to the line in your code.

//Old code
if (_serverRpcDelegates.TryGetValueIL2CPP(hash, out ServerRpcDelegate data))
{
   data.Invoke(reader, channel, sendingClient);
}

//New code
if (_serverRpcDelegates.TryGetValueIL2CPP(hash, out ServerRpcDelegate data))
{
   if (_networkObjectCache.NetworkManager.CatchRpcErrors)
   {
      try
      {
         data.Invoke(reader, channel, sendingClient);
      }
      catch (Exception ex)
      {
         var stack = ex.ToString();
         var realText = Regex.Replace(
            stack,
            @"[a-zA-Z]:\\.*?(Assets[\\/][^:\r\n]+\.cs):(\d+)",
            m => {
               string path = m.Groups[1].Value.Replace('\\', '/');
               string lineNum = m.Groups[2].Value;
               return $"<a href=\"{path}\" line=\"{lineNum}\">{path}:{lineNum}</a>";
            }, RegexOptions.Multiline);
   
         _networkObjectCache.NetworkManager.LogError(realText);
      }
   }
   else
   {
      data.Invoke(reader, channel, sendingClient);
   }
}

[meyshad]

Catching at the individual RPC dispatch boundary makes sense if each RPC is already length-framed. A user exception should fail that RPC, not abort processing of later RPCs in the same batch.

The exception should be logged as an exception object, though. Converting it to text and rebuilding Unity links with a Windows-path regex will break on Unix paths, generated code, and several valid stack-trace formats. Unity already makes Debug.LogException stack frames clickable:

if (_serverRpcDelegates.TryGetValueIL2CPP(
        hash, out ServerRpcDelegate data))
{
    try
    {
        data.Invoke(reader, channel, sendingClient);
    }
    catch (Exception exception)
    {
        Debug.LogException(exception, gameObject);
    }
}
else
{
    _networkObjectCache.NetworkManager.LogError(
        $"ServerRpc not found for hash {hash} on object " +
        $"{gameObject.name} [id {ObjectId}].");
}

The same policy should be applied consistently to ServerRpc, ObserversRpc, TargetRpc, and ReconcileRpc dispatch, ideally through one helper. The catch should surround the generated delegate invocation only, not the whole packet parser.

One caveat is deserialization: continuing is safe only when the outer reader knows the RPC payload length and advances to the next frame even if the generated delegate throws before consuming all arguments. That invariant deserves a regression test alongside the change. The current unguarded invocation is here: NetworkBehaviour.RPCs.cs.