State synchronization in Unity - Deep Dive

Overview - State synchronization

What is it?

State synchronization is the process of keeping the game state consistent across multiple players in a multiplayer game. It ensures that all players see the same game world, actions, and events happening at the same time. This is done by sharing and updating data like player positions, scores, and object states between devices. Without it, players would see different versions of the game, causing confusion and unfairness.

Why it matters

Without state synchronization, multiplayer games would be chaotic because each player would have their own version of the game world. Imagine playing a game where your friend sees you in one place, but you are somewhere else on your screen. This breaks the experience and makes the game unplayable. State synchronization solves this by making sure everyone shares the same reality, creating fair and fun gameplay.

Where it fits

Before learning state synchronization, you should understand basic Unity game development and how multiplayer networking works. After mastering state synchronization, you can explore advanced topics like lag compensation, prediction, and network optimization to make multiplayer games smoother and more responsive.

Mental Model

Core Idea

State synchronization is like a shared notebook where all players write and read the same game updates to keep their views identical.

Think of it like...

Imagine a group of friends drawing a picture together on a shared whiteboard. Each friend adds or changes something, and everyone sees the updates instantly so the picture stays the same for all. State synchronization works the same way for game data across players.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Player 1      │       │ Server/Host   │       │ Player 2      │
│ - Sends input │──────▶│ - Receives    │◀──────│ - Sends input │
│ - Receives    │◀──────│   updates     │──────▶│ - Receives    │
│   updates     │       │ - Broadcasts  │       │   updates     │
└───────────────┘       └───────────────┘       └───────────────┘

All players keep their game state synced by exchanging updates through the server.

Build-Up - 7 Steps

1

Foundation

What is game state in multiplayer

Concept: Introduce the idea of game state as the collection of all important data that defines the current game world.

In a multiplayer game, the game state includes player positions, health, scores, and object statuses. This data changes as players move, act, or interact. Understanding what game state means is the first step to knowing why it needs to be shared.

Result

You understand that game state is the snapshot of everything important in the game at a moment.

Knowing what game state means helps you see why keeping it consistent is crucial for multiplayer fairness.

2

Foundation

Basics of network communication

Concept: Explain how devices send and receive data over a network to share game state.

Players' devices connect over the internet or local network. They send messages with data like positions or actions. These messages travel between devices or through a server. This communication is the foundation for sharing game state.

Result

You grasp that network messages carry game state updates between players.

Understanding network communication basics prepares you to see how synchronization happens in real time.

3

Intermediate

Client-server synchronization model

🤔Before reading on: do you think all players send updates directly to each other, or through a central server? Commit to your answer.

Concept: Introduce the common client-server model where a central server manages and distributes game state updates.

In the client-server model, each player (client) sends their actions to a server. The server processes these and sends back the updated game state to all players. This central control helps avoid conflicts and keeps everyone in sync.

Result

You see how a server acts as the 'referee' to keep game state consistent.

Knowing the client-server model explains why servers are key to reliable synchronization.

4

Intermediate

State update methods: snapshot vs delta

🤔Before reading on: do you think sending the entire game state every time is better, or just the changes? Commit to your answer.

Concept: Explain two ways to send updates: full snapshots of the state or only the changes (deltas).

Snapshot updates send the whole game state regularly, which is simple but can use a lot of data. Delta updates send only what changed since the last update, saving bandwidth but requiring more logic to apply changes correctly.

Result

You understand trade-offs between sending full state or just changes.

Knowing update methods helps optimize network use and game performance.

5

Intermediate

Handling latency and prediction

🤔Before reading on: do you think players see exactly what others do instantly, or is there a delay? Commit to your answer.

Concept: Introduce the problem of network delay (latency) and how prediction techniques help smooth gameplay.

Because data takes time to travel, players see delayed updates. To hide this, games predict where players or objects will be next, updating smoothly when real data arrives. This keeps the game feeling responsive.

Result

You realize latency causes delays and prediction improves player experience.

Understanding latency and prediction is key to making multiplayer games feel fair and smooth.

6

Advanced

State synchronization in Unity with NetworkTransform

🤔Before reading on: do you think Unity automatically syncs all object data, or do you need to specify what to sync? Commit to your answer.

Concept: Show how Unity’s NetworkTransform component helps sync object positions and rotations automatically.

Unity provides NetworkTransform to sync an object's position, rotation, and scale over the network. You attach it to game objects, and it sends updates to keep all players’ views aligned. You can customize update rates and interpolation for smooth movement.

Result

You know how to use Unity’s built-in tools to sync object states easily.

Knowing Unity’s NetworkTransform simplifies implementing synchronization without building from scratch.

7

Expert

Optimizing synchronization for large-scale games

🤔Before reading on: do you think sending all state updates to every player is efficient, or can it be improved? Commit to your answer.

Concept: Explore advanced techniques like interest management and compression to reduce network load in big multiplayer games.

In large games, sending all updates to all players wastes bandwidth. Interest management sends updates only about nearby or relevant objects. Compression reduces data size. Combining these keeps the game scalable and responsive.

Result

You understand how to scale synchronization for many players efficiently.

Knowing optimization techniques prevents network overload and keeps gameplay smooth in big multiplayer worlds.

Under the Hood

State synchronization works by serializing game data into messages that travel over the network. The server or host collects inputs from clients, updates the authoritative game state, then serializes and broadcasts the updated state or changes back. Clients deserialize these messages and update their local game objects accordingly. Unity’s networking layers handle serialization, message delivery, and timing to keep states aligned despite network delays and packet loss.

Why designed this way?

This design balances consistency and performance. A central server prevents conflicting states and cheating. Sending only changes or snapshots reduces bandwidth. Prediction and interpolation hide latency effects. Alternatives like peer-to-peer were rejected for complexity and security risks. Unity’s built-in components simplify common tasks to speed development.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Client Input  │──────▶│ Server Logic  │──────▶│ State Update  │
│ (Player moves)│       │ (Processes    │       │ Broadcast to  │
│               │       │ inputs,       │       │ all clients   │
└───────────────┘       │ updates state)│       └───────────────┘
                        └───────────────┘
                               ▲
                               │
                        ┌───────────────┐
                        │ Client State  │
                        │ Update &      │
                        │ Render        │
                        └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think all players always have exactly the same game state at the same time? Commit to yes or no.

Common Belief: All players see the exact same game state instantly without any delay.

Reality: Due to network delays, players have slightly different views that are synchronized over time using prediction and interpolation.

Why it matters: Expecting perfect instant sync leads to confusion when players see small differences or lag, causing frustration if not handled properly.

Quick: Do you think sending the entire game state every frame is the best way to sync? Commit to yes or no.

Common Belief: Sending the full game state every update is simple and always best.

Reality: Sending full state wastes bandwidth; sending only changes (deltas) is more efficient and common in production.

Why it matters: Ignoring efficient update methods can cause network congestion and poor game performance.

Quick: Do you think peer-to-peer networking is the same as client-server for synchronization? Commit to yes or no.

Common Belief: Peer-to-peer networking synchronizes state just like client-server models.

Reality: Peer-to-peer is more complex and less secure; client-server is preferred for authoritative control and easier synchronization.

Why it matters: Choosing peer-to-peer without understanding risks can lead to cheating and inconsistent game states.

Quick: Do you think Unity automatically syncs all object data without developer setup? Commit to yes or no.

Common Belief: Unity automatically synchronizes all game object data across the network without extra work.

Reality: Developers must specify what to sync using components like NetworkTransform or custom scripts.

Why it matters: Assuming automatic sync leads to missing updates and bugs in multiplayer games.

Expert Zone

1

State synchronization often balances between consistency and responsiveness, requiring trade-offs that depend on game type and player expectations.

2

Interpolation and extrapolation techniques are subtle but critical to hide network jitter and latency without causing visual glitches.

3

Custom serialization and compression tailored to game data can drastically reduce bandwidth compared to default methods.

When NOT to use

State synchronization is not suitable for turn-based or asynchronous multiplayer games where exact real-time consistency is unnecessary. Instead, use event-based or lockstep synchronization methods.

Production Patterns

In production, developers use authoritative servers with client-side prediction, interest management to limit updates to relevant players, and layered update frequencies for critical vs. non-critical data to optimize performance.

Connections

Distributed Systems

State synchronization in games is a specialized form of distributed state consistency.

Understanding distributed systems concepts like consensus and eventual consistency helps grasp multiplayer synchronization challenges.

Real-time Collaborative Editing

Both require syncing shared state among multiple users in real time.

Techniques from collaborative editors like operational transforms inspire multiplayer synchronization methods.

Human Perception and Latency

Synchronization design must consider how humans perceive delays and smoothness.

Knowing human reaction to latency guides prediction and interpolation strategies to improve player experience.

Common Pitfalls

#1 Sending all game state data every frame causes network overload.

Wrong approach:

Send full position, rotation, health, and all variables for every object every update.

Correct approach:

Send only changed data (deltas) or use interest management to limit updates to relevant objects.

Root cause:

Misunderstanding that full state updates are inefficient and unnecessary.

#2 Assuming players see exactly the same state instantly leads to ignoring latency effects.

Wrong approach:

Update player positions only when new data arrives, causing jerky movement.

Correct approach:

Use interpolation and prediction to smooth movement between updates.

Root cause:

Not accounting for network delay and human perception.

#3 Relying on Unity to sync all object data without setup causes missing updates.

Wrong approach:

Attach no NetworkTransform or sync components and expect automatic syncing.

Correct approach:

Attach NetworkTransform or write custom sync scripts for needed data.

Root cause:

Assuming Unity handles all synchronization automatically.

Key Takeaways

State synchronization keeps multiplayer game worlds consistent by sharing and updating game data across players.

A central server usually manages synchronization to avoid conflicts and cheating.

Efficient synchronization sends only changes and uses prediction to hide network delays.

Unity provides tools like NetworkTransform to simplify syncing object states.

Advanced games optimize synchronization with interest management and compression to scale well.