Remote procedure calls in Unity

Introduction

Remote procedure calls let different computers or devices talk and work together by asking each other to run specific tasks.

When you want players in a multiplayer game to see the same actions happen at the same time.

When you need to send a message from one device to another to update game data.

When you want to trigger an event on another player's game, like opening a door or playing a sound.

When you want to keep all players' game states in sync during online play.

Syntax

Unity

using UnityEngine;
using Unity.Netcode;

public class ExampleRPC : NetworkBehaviour
{
    [ServerRpc]
    public void MyServerRpc()
    {
        // Code runs on the server
    }

    [ClientRpc]
    public void MyClientRpc()
    {
        // Code runs on clients
    }
}

[ServerRpc] marks a method that clients call to run code on the server.

[ClientRpc] marks a method that the server calls to run code on all clients.

Examples

This example shows a method that a player calls to tell the server they jumped.

Unity

using UnityEngine;
using Unity.Netcode;

public class PlayerActions : NetworkBehaviour
{
    [ServerRpc]
    public void JumpServerRpc()
    {
        Debug.Log("Player jumped on server");
    }
}

This example shows the server telling all players to play a sound.

Unity

using UnityEngine;
using Unity.Netcode;

public class GameEvents : NetworkBehaviour
{
    [ClientRpc]
    public void PlaySoundClientRpc()
    {
        Debug.Log("Play sound on all clients");
    }
}

Sample Program

This program lets the player press space to jump. The jump is sent to the server with a ServerRpc. The server logs the jump and tells all clients to play a jump sound with a ClientRpc.

Unity

using UnityEngine;
using Unity.Netcode;

public class RPCExample : NetworkBehaviour
{
    void Update()
    {
        if (IsOwner && Input.GetKeyDown(KeyCode.Space))
        {
            JumpServerRpc();
        }
    }

    [ServerRpc]
    void JumpServerRpc()
    {
        Debug.Log("Server: Player jumped");
        PlayJumpSoundClientRpc();
    }

    [ClientRpc]
    void PlayJumpSoundClientRpc()
    {
        Debug.Log("Client: Play jump sound");
    }
}

Important Notes

Only the player who owns the object should call ServerRpc to avoid errors.

ServerRpc methods run on the server, ClientRpc methods run on all clients.

RPCs help keep multiplayer games in sync by sharing actions across devices.

Summary

Remote procedure calls let devices ask each other to run code.

Use [ServerRpc] for client-to-server calls.

Use [ClientRpc] for server-to-client calls.

Practice

1. What attribute do you use in Unity to make a method run on the server when called from a client?

easy

A. [ServerRpc]

B. [ClientRpc]

C. [RunOnServer]

D. [RemoteCall]

Solution

1. Step 1: Understand the direction of the call

   Client-to-server calls require a special attribute to mark the method that runs on the server.

2. Step 2: Identify the correct attribute in Unity

   Unity uses [ServerRpc] to mark methods that clients call to run on the server.

3. Final Answer:

   [ServerRpc] -> Option A

4. Quick Check:

   Client-to-server calls use [ServerRpc] [OK]

Hint: Client calls server methods with [ServerRpc] attribute [OK]

Common Mistakes:

• Confusing [ClientRpc] as client-to-server
• Using non-existent attributes like [RunOnServer]
• Thinking [RemoteCall] is a valid Unity attribute

2. Which of the following is the correct syntax to declare a server RPC method in Unity?

easy

A. public void MyMethod() { }

B. [ServerRpc] public void MyMethod() { }

C. [ClientRpc] public void MyMethod() { }

D. void [ServerRpc] MyMethod() { }

Solution

1. Step 1: Recall the attribute placement

   Attributes in C# go before the method declaration.

2. Step 2: Check the correct attribute and syntax

   The correct syntax is [ServerRpc] public void MyMethod() { }. void [ServerRpc] MyMethod() { } places the attribute incorrectly.

3. Final Answer:

   [ServerRpc] public void MyMethod() { } -> Option B

4. Quick Check:

   Attributes precede method declarations [OK]

Hint: Attributes go before method signature in C# [OK]

Common Mistakes:

• Placing attribute after method name
• Using [ClientRpc] for server RPC
• Omitting the attribute entirely

3. Consider this Unity code snippet:

[ServerRpc]
public void SendMessageToClients(string msg) {
    Debug.Log("Server received: " + msg);
    BroadcastMessageClientRpc(msg);
}

[ClientRpc]
void BroadcastMessageClientRpc(string message) {
    Debug.Log("Client received: " + message);
}

What will be printed on the client when SendMessageToClients("Hello") is called from a client?

medium

A. Server received: Hello
Client received: Hello

B. Server received: Hello

C. Client received: Hello

D. Nothing is printed on client

Solution

1. Step 1: Understand the call flow

   The client calls SendMessageToClients which runs on the server due to [ServerRpc]. The server logs "Server received: Hello".

2. Step 2: Server calls client method

   The server then calls BroadcastMessageClientRpc on all clients, which logs "Client received: Hello" on each client.

3. Final Answer:

   Client received: Hello -> Option C

4. Quick Check:

   ClientRpc runs on clients, so clients see "Client received: Hello" [OK]

Hint: Client sees ClientRpc logs, server sees ServerRpc logs [OK]

Common Mistakes:

• Thinking server logs appear on client
• Assuming both logs print on client
• Confusing which method runs where

4. What is wrong with this Unity RPC method?

[ServerRpc]
public void UpdateScoreClientRpc(int score) {
    Debug.Log("Score updated: " + score);
}

medium

A. [ServerRpc] methods must be private

B. Missing return type for RPC method

C. RPC methods cannot have parameters

D. Method name suggests client RPC but uses [ServerRpc] attribute

Solution

1. Step 1: Analyze method name and attribute

   The method name contains "ClientRpc" but the attribute is [ServerRpc], which is confusing and likely a mistake.

2. Step 2: Check RPC method rules

   RPC methods can have parameters and must have a return type (void is valid). They can be public. The mismatch between name and attribute is the main issue.

3. Final Answer:

   Method name suggests client RPC but uses [ServerRpc] attribute -> Option D

4. Quick Check:

   Method name and attribute must match RPC direction [OK]

Hint: Match method name with RPC attribute to avoid confusion [OK]

Common Mistakes:

• Ignoring method name and attribute mismatch
• Thinking parameters are not allowed
• Assuming RPC methods must be private

5. You want to send a message from the server to all clients except the one who sent the original request. Which approach using Unity RPCs is correct?

hard

A. Use [ClientRpc] with a special NetworkConnection parameter to exclude sender

B. Use [ServerRpc] to send message to clients except sender

C. Use [ClientRpc] and check inside the client to ignore messages from itself

D. Use [ClientRpc] with a parameter to exclude the sender client inside the method

Solution

1. Step 1: Understand RPC direction

   Server sends messages to clients using [ClientRpc]. To exclude a client, the server must know which client to exclude.

2. Step 2: Use NetworkConnection parameter

   Unity allows [ClientRpc] methods to take a NetworkConnection parameter to exclude that client from receiving the RPC.

3. Step 3: Confirm other options

   Use [ClientRpc] with a parameter to exclude the sender client inside the method is incorrect because exclusion logic cannot be done inside the client method. Use [ServerRpc] to send message to clients except sender is wrong direction. Use [ClientRpc] and check inside the client to ignore messages from itself relies on client ignoring messages, which is inefficient.

4. Final Answer:

   Use [ClientRpc] with a special NetworkConnection parameter to exclude sender -> Option A

5. Quick Check:

   Exclude sender with NetworkConnection parameter in ClientRpc [OK]

Hint: Exclude sender using NetworkConnection param in ClientRpc [OK]

Common Mistakes:

• Trying to exclude sender inside client code
• Using ServerRpc to send to clients
• Not using NetworkConnection parameter for exclusion