Why Remote procedure calls in Unity? - Purpose & Use Cases

The Big Idea

What if you could make your game's remote players act instantly with just a simple function call?

The Scenario

Imagine you are building a multiplayer game in Unity where players interact in real time. Without remote procedure calls, you would have to manually send and receive messages for every action, like moving a character or shooting, and then write extra code to interpret those messages on each player's device.

The Problem

This manual messaging is slow and complicated. It's easy to make mistakes, like sending wrong data or missing updates. Debugging becomes a nightmare because you have to track many small messages and their timing. The game feels laggy or buggy, frustrating players.

The Solution

Remote procedure calls (RPCs) let you call functions on other players' devices as if they were local. You write simple code like calling a method, and Unity handles sending the message and running the code remotely. This makes your multiplayer code clean, fast, and easier to manage.

Before vs After

✗ Before

SendMessageToAllPlayers("Move", x, y, z);
// Then parse and apply movement on each client

✓ After

[ClientRpc]
void RpcMove(Vector3 position) {
  transform.position = position;
}

What It Enables

RPCs enable smooth, real-time multiplayer interactions by making remote actions feel local and automatic.

Real Life Example

In a Unity racing game, when one player presses the accelerate button, an RPC updates all other players' cars instantly to show the speed change without delay or confusion.

Key Takeaways

Manual message handling is slow and error-prone for multiplayer games.

RPCs let you call functions remotely as if they were local.

This makes multiplayer code simpler, faster, and more reliable.

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