Unity Netcode overview - Step-by-Step Execution

Concept Flow - Unity Netcode overview

Start: Game Launch

↓

Initialize Network Manager

↓

Choose Role: Host / Client

↓

Host: Start Server

↓

Synchronize Game State

↓

Send/Receive Network Messages

↓

Update Game Objects Across Network

↓

Gameplay

↓

End or Disconnect

This flow shows how Unity Netcode starts with initializing the network, choosing host or client roles, connecting, syncing game state, and updating objects during gameplay.

Execution Sample

Unity

NetworkManager.Singleton.StartHost();
// Host starts server and client

NetworkManager.Singleton.StartClient();
// Client connects to server

// Networked objects sync automatically

This code starts a host or client in Unity Netcode, enabling networked gameplay with automatic synchronization.

Execution Table

Step	Action	NetworkManager State	Result
1	Call StartHost()	IsHost = false, IsClient = false	Starts server and client, IsHost = true, IsClient = true
2	Host waits for clients	IsHost = true, IsClient = true	Server ready, waiting for clients to connect
3	Call StartClient() on client	IsHost = false, IsClient = false	Client connects to server, IsClient = true
4	Server and client synchronize	IsHost = true, IsClient = true (host), IsClient = true (client)	Game state synced across network
5	Networked objects update	Objects have NetworkObject component	Objects' states replicate on all clients
6	Gameplay continues	NetworkManager running	Players interact with synced game world
7	Disconnect or stop	NetworkManager active	Network session ends, cleanup happens

💡 Execution stops when the network session ends or game closes.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	Final
IsHost	false	true	false	false	false (after disconnect)
IsClient	false	true	true	true	false (after disconnect)
Network Objects Synced	No	No	No	Yes	No (after disconnect)

Key Moments - 3 Insights

Why does the host have both IsHost and IsClient true?

Because the host runs both server and client in one instance, as shown in execution_table step 1.

How do networked objects update on all players?

Objects with NetworkObject component automatically sync their state across clients, as in step 5.

What happens if a client disconnects?

The network session cleans up and stops syncing for that client, shown in the exit_note and final variable states.

Visual Quiz - 3 Questions

Look at the execution_table, what is the NetworkManager state after calling StartHost()?

A IsHost = false, IsClient = true

B IsHost = true, IsClient = true

C IsHost = true, IsClient = false

D IsHost = false, IsClient = false

💡 Hint

Check execution_table row 1 under NetworkManager State.

At which step do networked objects start syncing their state?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look at execution_table row 5 describing object updates.

If the client never calls StartClient(), what happens to IsClient variable in variable_tracker?

A It toggles between true and false

B It becomes true anyway

C It stays false

D It causes an error

💡 Hint

Refer to variable_tracker row for IsClient and step 3 in execution_table.

Concept Snapshot

Unity Netcode overview:
- Use NetworkManager to start Host or Client
- Host runs server and client together
- Clients connect to Host server
- NetworkObjects sync state automatically
- NetworkManager manages connection lifecycle
- Gameplay updates sync across network

Full Transcript

Unity Netcode starts by initializing the NetworkManager. The game chooses a role: host or client. The host starts both server and client, setting IsHost and IsClient to true. Clients connect to the host by calling StartClient, setting IsClient to true. The server and clients synchronize game state automatically through NetworkObjects. During gameplay, all networked objects update their state across all players. When the session ends or a player disconnects, the network cleans up and stops syncing. This flow ensures smooth multiplayer gameplay with automatic state synchronization.

Practice

1. What is the main purpose of Unity Netcode in game development?

easy

A. To help build multiplayer games by syncing data between players

B. To create single-player game levels

C. To design game graphics and animations

D. To optimize game performance on mobile devices

Solution

1. Step 1: Understand Unity Netcode's role

   Unity Netcode is designed to help developers create multiplayer games by sharing data between players.

2. Step 2: Compare options with this role

   Only To help build multiplayer games by syncing data between players matches this purpose; others relate to different game development areas.

3. Final Answer:

   To help build multiplayer games by syncing data between players -> Option A

4. Quick Check:

   Unity Netcode = Multiplayer data sync [OK]

Hint: Focus on multiplayer data sharing role [OK]

Common Mistakes:

• Confusing Netcode with graphics or performance tools
• Thinking it is for single-player only
• Assuming it handles animations

2. Which of the following is the correct way to declare a network variable in a Unity Netcode script?

easy

A. int playerScore = NetworkVariable<int>();

B. public NetworkVariable<int> playerScore = new NetworkVariable<int>();

C. NetworkVariable playerScore = int();

D. var playerScore = new int NetworkVariable();

Solution

1. Step 1: Recall correct syntax for NetworkVariable declaration

   NetworkVariable must be declared with its type and initialized with new NetworkVariable<Type>().

2. Step 2: Check each option's syntax

   public NetworkVariable<int> playerScore = new NetworkVariable<int>(); matches the correct syntax; others have wrong order or missing keywords.

3. Final Answer:

   public NetworkVariable<int> playerScore = new NetworkVariable<int>(); -> Option B

4. Quick Check:

   Correct NetworkVariable syntax = public NetworkVariable<int> playerScore = new NetworkVariable<int>(); [OK]

Hint: Look for 'new NetworkVariable<Type>()' pattern [OK]

Common Mistakes:

• Omitting 'new' keyword
• Wrong order of type and variable
• Using 'var' incorrectly

3. Given this code snippet in a Unity Netcode script:

public class Player : NetworkBehaviour {
    public NetworkVariable<int> health = new NetworkVariable<int>(100);

    public override void OnNetworkSpawn() {
        if (IsServer) {
            health.Value -= 10;
        }
    }
}

What will be the value of health.Value on clients after spawning?

medium

A. 90

B. 10

C. 100

D. 0

Solution

1. Step 1: Understand initial health value and server change

   Health starts at 100. On network spawn, server reduces health by 10, so health becomes 90.

2. Step 2: Recognize NetworkVariable sync behavior

   NetworkVariable syncs its value from server to clients, so clients see updated value 90.

3. Final Answer:

   90 -> Option A

4. Quick Check:

   Server changes health to 90, clients sync = 90 [OK]

Hint: Server changes sync to clients automatically [OK]

Common Mistakes:

• Assuming clients keep initial value 100
• Confusing subtraction amount
• Ignoring server-only code effect

4. Identify the error in this Unity Netcode script snippet:

public class Player : NetworkBehaviour {
    public NetworkVariable<int> score = new NetworkVariable<int>();

    void Update() {
        if (IsClient) {
            score.Value += 1;
        }
    }
}

medium

A. Not declaring score as private

B. Missing initialization of NetworkVariable

C. Using Update() instead of FixedUpdate()

D. Modifying NetworkVariable on client instead of server

Solution

1. Step 1: Check where NetworkVariable is modified

   The code modifies score.Value inside Update() only if IsClient is true.

2. Step 2: Recall server authority rule

   In Unity Netcode, only the server should modify NetworkVariables to keep data consistent.

3. Final Answer:

   Modifying NetworkVariable on client instead of server -> Option D

4. Quick Check:

   Server-only changes = correct [OK]

Hint: Only server can change NetworkVariables [OK]

Common Mistakes:

• Changing variables on clients causes sync issues
• Ignoring server authority
• Thinking Update timing matters here

5. You want to create a multiplayer game where each player's position updates smoothly and is synced across all clients. Which Unity Netcode approach is best to achieve this?

hard

A. Use local variables for position and send updates manually via RPCs

B. Update position on each client independently without syncing

C. Use NetworkVariable<Vector3> for position and update it only on the server

D. Use NetworkVariable<int> to store position as integers

Solution

1. Step 1: Identify how to sync position data

   Positions are Vector3 values and should be synced using NetworkVariable<Vector3> to keep all clients updated.

2. Step 2: Ensure server authority for smooth updates

   Updating position only on the server ensures consistent and fair game state across clients.

3. Final Answer:

   Use NetworkVariable<Vector3> for position and update it only on the server -> Option C

4. Quick Check:

   Server updates Vector3 NetworkVariable = smooth sync [OK]

Hint: Use Vector3 NetworkVariable updated by server [OK]

Common Mistakes:

• Using local variables without syncing
• Sending manual RPCs for every position change
• Storing position as int loses precision