Remote procedure calls in Unity - Step-by-Step Execution

Concept Flow - Remote procedure calls

Client calls function

↓

Serialize data

↓

Send data over network

↓

Server receives data

↓

Deserialize data

↓

Execute function on server

↓

Serialize response

↓

Send response back

↓

Client receives response

↓

Deserialize response

↓

Use result in client

This flow shows how a client calls a function on a server by sending data, the server runs the function, and sends back the result.

Execution Sample

Unity

using Unity.Netcode;

public class Example : NetworkBehaviour {
    [ServerRpc]
    public void AddNumbersServerRpc(int a, int b) {
        int sum = a + b;
        Debug.Log($"Sum is {sum}");
    }
}

This code shows a server RPC in Unity that adds two numbers sent from a client and logs the sum on the server.

Execution Table

Step	Action	Data Sent	Server Action	Result/Output
1	Client calls AddNumbersServerRpc(3, 4)	a=3, b=4	None yet	None yet
2	Serialize data	Serialized (3,4)	None yet	None yet
3	Send data over network	Serialized (3,4)	None yet	None yet
4	Server receives data	Serialized (3,4)	Deserialize data	a=3, b=4
5	Execute AddNumbersServerRpc on server	a=3, b=4	Calculate sum = 7	Log: Sum is 7
6	Serialize response (if any)	None (void)	Prepare response	None
7	Send response back to client	None	None	None
8	Client receives response	None	None	None
9	Client uses result (none here)	None	None	None
10	End of RPC call	None	None	Sum logged on server

💡 RPC call ends after server executes function and client receives any response.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
a	undefined	3	3	3
b	undefined	4	4	4
sum	undefined	undefined	7	7

Key Moments - 3 Insights

Why does the client not execute the function directly?

Because the function is marked as ServerRpc, it runs only on the server. The client sends data to the server, which executes the function (see execution_table step 5).

What happens to the data when sent over the network?

The data is serialized into a format that can be sent over the network (step 2 and 3), then deserialized on the server (step 4) to restore the original values.

Why is there no result sent back to the client in this example?

The ServerRpc function returns void, so no data is sent back. The client only triggers the server to run the function (see steps 6-9).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'sum' after step 5?

A undefined

B 3

C 7

D 4

💡 Hint

Check the 'sum' variable in variable_tracker after step 5.

At which step does the server deserialize the data sent from the client?

A Step 4

B Step 2

C Step 6

D Step 8

💡 Hint

Look at the 'Server Action' column in the execution_table.

If the ServerRpc function returned a value, what would change in the execution table?

A The client would execute the function instead of the server.

B There would be serialized response data sent back to the client.

C The data would not be serialized before sending.

D The server would not log the sum.

💡 Hint

Refer to steps 6-9 about response handling in the execution_table.

Concept Snapshot

Remote Procedure Calls (RPC) in Unity:
- Client calls a function marked with [ServerRpc]
- Data is serialized and sent to the server
- Server deserializes and runs the function
- Server can send back a response
- Client receives and uses the response
- RPCs enable communication between client and server code

Full Transcript

Remote procedure calls in Unity let a client ask the server to run a function. The client calls a function marked with [ServerRpc]. The data is packed up (serialized) and sent over the network. The server unpacks (deserializes) the data and runs the function. The server can send back a result, which the client receives and uses. This process helps client and server talk and work together in a game.

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