Networking & Replication

Server authority means the server is the single source of truth for game state. Only the server decides outcomes — health, scores, hits — and replicates results to clients, which send requests via Server RPCs.

A replicated property is a variable marked with the Replicated specifier so the server pushes its value to clients. The server owns it; when it changes, the engine syncs it to relevant clients automatically.

An RPC is a function marked with a network specifier that runs on a different machine than the caller. Server RPCs go Client→Server, Client RPCs go Server→owning Client, and Multicast RPCs run everywhere.

Replication is Unreal's networking mechanism that synchronizes Actor state from the authoritative server to connected clients. It mirrors marked properties and routes RPCs, keeping every client's world consistent with the server.

bReplicates enables an Actor for networking. When true, the server spawns and tracks the Actor on relevant clients and processes its replicated properties. When false, the Actor exists only locally and never syncs.

Ownership links an Actor to a Connection via its Owner chain up to a PlayerController. A Server RPC fires only if the calling client owns the Actor; a Client RPC reaches only the owning client. Without ownership those RPCs are dropped.

Common bugs: changing replicated state on the client instead of the server, forgetting DOREPLIFETIME registration, calling RPCs from a non-owning Actor, using an RPC where late joiners need a property, and assuming OnRep fires on the server.

GetLifetimeReplicatedProps() is where you register a class's replicated properties, usually via the DOREPLIFETIME macro. The engine calls it to learn which properties to track and lets you attach replication conditions per property.

In single-player one machine is both server and client, so unreplicated state and client-side mutations just work. In multiplayer the server and clients are separate, exposing missing replication, wrong-authority writes, and ungated RPC calls. Here OnPickup has no authority guard, so a client destroys the item only locally, and Count is never registered for replication, so remote clients never see it change.

Mark Health as a UPROPERTY(ReplicatedUsing=OnRep_Health), register it in GetLifetimeReplicatedProps with DOREPLIFETIME, and modify it only on the server. The OnRep_Health callback updates the HUD on clients when the value arrives.

Use a replicated property for persistent state that any joining client must see — health, score. Use an RPC for one-off events that needn't persist — a hit sound, a muzzle flash. Properties sync state; RPCs deliver transient actions.

A Server RPC runs on the server, called by the owning client. A Client RPC runs on the owning client, called by the server. A NetMulticast RPC, called on the server, runs on the server and all relevant clients.

Server authority means the server owns the true game state and validates every change. Client prediction lets a client apply its own input locally for responsiveness, then reconcile against the server's authoritative result, correcting any mismatch.

A Reliable RPC is guaranteed to arrive and execute, retried until acknowledged. Not every RPC should be reliable: the reliable buffer is limited, and flooding it with frequent calls overflows it and drops the client. Use Unreliable for cosmetics.

Spawn the projectile on the server as a replicated Actor; the engine creates it on relevant clients. Let ProjectileMovementComponent simulate motion locally on each side, and resolve hits and damage authoritatively on the server.

ReplicatedUsing=OnRep_Func marks a property as replicated and names a callback. When the value changes on a client, the engine calls that OnRep function, letting you react — update UI, play effects — instead of just storing the new value.

A clean local PIE session has no latency or loss, so it hides the bug. Reproduce in PIE multi-client, then use Net PktLag/PktLoss to simulate bad networks, the showdebug net overlay, Net.DumpRelevantActors, and authority logging to confirm which machine writes state and whether the property is registered.

Relevancy is the per-connection decision of whether an Actor is replicated to a given client. The server skips irrelevant Actors — too far, not visible — saving bandwidth. IsNetRelevantFor and settings like NetCullDistanceSquared drive it.

Dormancy lets a replicated Actor stop being processed for replication while its state is static, saving server CPU. A dormant Actor is skipped each tick until you call FlushNetDormancy or set it awake to push a change.

Cut per-tick work: tune NetUpdateFrequency and NetCullDistanceSquared, use dormancy for static actors, gate properties with DOREPLIFETIME_CONDITION, and adopt the Replication Graph for spatial culling at scale.

The Replication Graph is a scalable replication system that organizes Actors into spatial nodes and gathers per-connection lists from them. It exists because the default per-Actor relevancy loop costs too much CPU with many actors and players.