Achievements and stats for game code, whatever platform is (or is not) up. Every write lands in a local store first — the game reads its own values back with no Steam client, and the editor can test unlock logic in PIE —
Client-side encrypted-ticket handshake — the producer half of the dedicated server's Steam Encrypted App Ticket auth. Arm it right after Connect: it asks Steam for a fresh ticket and ships it (auth-framed, so the replica
The replicated animation state of a networked character — UE's replicated-montage plus the handful of graph parameters a remote AnimInstance would otherwise derive from replicated movement.
Per-entity relevancy policy. Distance = culled against the client's viewer position; Always = every client (gamemode/global state); Never = server-only, never replicated.
Send-order class under a tight budget. Priority is a float that a starving object's staleness eventually overtakes, so with one number everything competes with everything: at 48 kbit/s a client's own pawn waits behind a
Marks an entity as participating in network replication. The server authoritatively sets networkId at spawn time and sends a Spawn packet so a client materializes a corresponding ghost entity. From then on the server e
Address-form dispatching transport. Owns an ENet backend (always) and a Steam P2P backend (lazily, only when the Steam client is up), and picks per-call: Connect("127.0.0.1") → ENet (contains '.') Connect("f
INetworkTransport over Valve's GameNetworkingSockets, linked standalone (no Steam client): client/server over IP for dedicated and listen servers. The library brings what ENet leaves to the engine — per-connection encryp
Send + receive queues live as two separate FNetSimQueue instances inside whichever transport runs the injector; a debug panel wants the combined picture without reaching past the transport interface to tell them apart.
Which wire transport NetworkManager runs, from net.Transport: composite ENet for addresses, plus the platform relay (Steam) for SteamID64 targets and dual-listen hosting — the default enet ENet only gns G
One online-platform integration (Steam, Discord, ...) contributed by an engine plugin. Every capability has a safe no-op default so a service implements only what its platform really offers — Discord is presence only, St
A request for the platform's on-screen keyboard. A field rect (in window pixels) asks for the floating keyboard that types straight into the focused field (Steam Deck); without one the full-screen keyboard returns the te
The default settings profile the platform recommends for this device (Steam: GetSteamHardwareDefaultConfig, tunable per device on the partner site without rebuilding the game).
The player's own voice client state, where a platform shares it (Discord GetVoiceSettings). In-game voice follows mute and deafen, so a player who muted themselves in Discord is not still transmitting through the game.
The registry plugin InitializeModule hooks write into. Registration happens at plugin load (before any project opens); Init runs when the project's platform settings arrive through FPlatformInit::Apply.
Character movement over the network, UE CharacterMovement-shaped. The client records a move per send (its input and the time it covers), predicts it locally and sends it with the moves the server has not acknowledged yet
Kinematic state the predicted step reads and writes across ticks — the parts of CharacterControllerComponent the Walking model touches. groundHeight is the flat-plane the client-side collision clamps to (full collision i
The typed array. TItem derives from FNetFastArrayItem and provides void NetSerialize(FNetBitWriter& w) const; bool NetDeserialize(FNetBitReader& r); Removal on the server is an ordinary erase from Items followed by MarkA
One game-installed callback slot, stored the only way a slot crossing a DLL boundary can be stored safely: a plain function pointer, an opaque context, and a release hook for the context.
Drives the server/client side of state replication for every entity carrying a NetworkObjectComponent. Owned by the World; registered in runtime + simulation system sets.
Client ghost materialization. The provider owns prefab instantiation (Scene + PrefabInstantiator up in Game) and returns the root entity, or INVALID_ENTITY to make the manager fall back to a bare world-entity + Transform
RPC authority DEFAULT-DENY. A client→server RPC reaches the receiver only when its (methodId, methodIndex) pair has been EXPLICITLY allow-listed and the sending peer meets the declared authority. Without this, a peer cou
The full-pose entry. The live Snapshot packet ships field-level deltas instead (see ReplicationPacketType::Snapshot); this struct is the fixed-layout pose record the server's lag-compensation history stores.
Client → server. Cumulative in effect: the server confirms every baseline whose carrying packetId is <= this one, so a lost ack is covered by the next.
One client-predicted input awaiting server acknowledgement — buffered by ReplicationManager, replayed by FCharacterPrediction::Reconcile. Lives with the wire structs so the prediction code needs no Game headers.
Bumped whenever the packet layout changes incompatibly. Every header carries it and a peer speaking another version is refused with an error rather than decoded — a mismatched delta would write foreign bytes into live components. 1 — transform-only snapshots, entries were [networkId][len][delta] 2 — arbitrary replicated components, entries carry a component slot 3 — the Rpc body names a (componentId, methodIndex) pair; the authority policy keys on both, so a grant opens one method rather than every MFUNCTION on the component 4 — Spawn carries the authored placed-object GUID after the prefab path, so a client adopts its scene-placed twin by identity instead of by proximity. Appended at the tail and decoded tolerantly: a body that ends early yields 0, which is exactly what an unauthored (pre-v4) scene stores, so the receiver falls back to the positional match. 5 — an RPC names its component by a stable wire id (FReplicatedComponentRegistry::ToRpcWireId), not by the sender's first-use ComponentID. 6 — snapshot entries carry the packed delta (changemask + bit-packed, MNET_QUANTIZE-narrowed fields, struct and array-of-struct values) instead of [uint16 index][raw bytes] per field. 7 — an Input packet carries [uint8 count] and then up to kMaxInputMovesPerPacket moves, oldest first, each stamped with its own delta time (ReplicationInputBody::dtTenthMs); the server steps every move exactly once, in order. 8 — Blob / BlobAck carry a large reliable RPC in chunks under flow control, an Rpc body whose argByteLen is 0xFFFF is followed by a uint32 length, and OwnerChange tells clients an object's new owner. 9 — SpatialData / SpatialAck / SpatialInterest carry the keyed delta stream (FSpatialStreamServer / Client), which does its own acknowledgement and resend.
constexpr uint8_t kMaxInputMovesPerPacket = 3
The unacknowledged moves a client repeats in every Input packet, so one lost datagram costs the server no move.
using NetworkId = uint16_t
Compact identifier for a replicated entity within a single session. EntityID is a 64-bit UUID, but bandwidth-sensitive snapshot loops benefit from a smaller per-session id assigned at spawn. 16-bit supports 65k concurrent network objects per game — plenty for any realistic deathmatch / MMO shard, and 2 bytes per snapshot entry adds up at 20 Hz.
Outcome of RouteActorRpc. Sent = shipped on the wire; RunLocal = the resolved destination is THIS machine (a Client RPC whose owning client is the listen host), so the caller must invoke it locally; Failed = the call cou
Rate class of a client→server session event, mirroring the replication layer's ENetRpcChannelClass. HighRate puts the event on its own token bucket and the unreliable-sequenced channel — the shape a swept sensor or a hel
Why the session's hooks are coming down. Left is a deliberate exit and ends the replication session outright; DroppedPendingRejoin is a link that failed while the grace window is open, and must NOT end it — the id ma
The session surface a co-op game actually calls. Owns the host/join/leave state machine on top of NetworkManager + ReplicationManager, one player record per connection (pawn spawned on join, destroyed on leave), and a ga
A peer id no transport hands out. A player held through the rejoin grace window carries it so nothing — an owner check, a send, a roster lookup — can mistake the empty slot for a live connection, and so a peer id the transport later reuses cannot inherit the held player's pawn.
The one place the platform's lobby/invite surface is reached from, and the single owner of the Steam join-requested delegate. Everything is a safe no-op (false / empty) when Steam is absent or the SDK was not compiled in
Where a hosted session is. A co-op run gathers in the Lobby (the hub: ready up, swap gear, take new players) and plays InRun; the host moves it between the two and every client follows.
Who may join mid-session. Anytime is the engine default; LobbyOnly is the co-op rule — a stranger dropped into the middle of a run breaks it — and still lets a dropped crew member rejoin their held slot.
Server-side validator for Steam Encrypted App Tickets. Uses sdkencryptedappticket64.dll — does NOT require a running Steam client. The symmetric key comes from the Steamworks Partner site (App Admin > Auth & Security).