Networking

Networking module API reference: 41 headers · 152 types · 2040 symbols.

Generated from networking.json · Nov 4, 2026Version 1.0.0
Build name
MowoEngine.Networking
Source
Engine/Source/Runtime/Networking/Public
Category
Runtime
Contents
41 headers · 152 types · 2040 symbols

Networking/Achievements.h

KindTypeSummary
structFAchievementDefinitionOne achievement as Config/Achievements.ini declares it:
structFStatDefinition[Stat STAT_SCANS] Type=Int (or Float) Default=0
classFAchievementsAchievements 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 —

Networking/Auth/AuthProtocol.h

KindTypeSummary
enumEAuthPacketTypePre-authentication handshake framing.
classFAuthProtocol

Networking/ClientAuth.h

KindTypeSummary
classFClientAuthClient-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

Networking/Components/NetAnimationStateComponent.h

KindTypeSummary
structNetAnimationStateComponentThe 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.

Networking/Components/NetMovementStateComponent.h

KindTypeSummary
structNetMovementStateComponent

Networking/Components/NetworkObjectComponent.h

KindTypeSummary
enumNetRelevancyModePer-entity relevancy policy. Distance = culled against the client's viewer position; Always = every client (gamemode/global state); Never = server-only, never replicated.
enumNetPriorityTierSend-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
structNetworkObjectComponentMarks 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

Networking/Components/PlayerStateComponent.h

KindTypeSummary
structPlayerStateComponent

Networking/CompositeTransport.h

KindTypeSummary
classFCompositeTransportAddress-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
enumFCompositeTransport::EAddressKind

Networking/ENetTransport.h

KindTypeSummary
classENetTransport

Networking/FNetworkModule.h

KindTypeSummary
classFNetworkModule

Networking/GnsTransport.h

KindTypeSummary
classFGnsTransportINetworkTransport 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

Networking/INetworkTransport.h

KindTypeSummary
classINetworkTransportBoth ENet and Steam Networking Sockets implement this.

Networking/NetCrypto.h

KindTypeSummary
enumENetEncryptionMode
enumENetCryptoMessage
classFNetCrypto
structFNetReplayWindowAnti-replay bitmap, one per receive channel. Strict monotonicity would drop legitimate unreliable/unsequenced traffic — ENet reorders both.
classFNetCryptoSession

Free functions

SignatureDescription
static constexpr uint8_t NET_CRYPTO_VERSION = 1
static constexpr uint32_t NET_CRYPTO_KEY_SIZE = 32
static constexpr uint32_t NET_CRYPTO_MAC_SIZE = 16
static constexpr uint32_t NET_CRYPTO_SALT_SIZE = 15
static constexpr uint32_t NET_CRYPTO_TAG_SIZE = 16
static constexpr uint32_t NET_CRYPTO_HEADER_SIZE = 10
static constexpr uint32_t NET_CRYPTO_OVERHEAD = NET_CRYPTO_HEADER_SIZE + NET_CRYPTO_MAC_SIZE
static constexpr uint32_t NET_CRYPTO_REPLAY_WINDOW = 1024
static constexpr uint32_t NET_CRYPTO_CHANNELS = 4
static constexpr uint32_t NET_CRYPTO_HANDSHAKE_TIMEOUT_MS = 5000

Networking/NetSimulation.h

KindTypeSummary
structFNetSimSettings
structFNetSimFrameOne frame parked in the delay queue. sequence breaks ties so a drain is deterministic even when two frames come due in the same millisecond.
structFNetSimStats
structFNetSimTransportStatsSend + 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.
classFNetSimulator
structFNetSimulator::FDecision
classFNetSimQueueThe injector itself: one instance per direction (send / receive) inside a transport. Submit hands a frame over; Release yields the ones now due.

Networking/NetTransportFactory.h

KindTypeSummary
classFNetTransportFactoryWhich 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

Networking/NetworkManager.h

KindTypeSummary
classNetworkManagerSingleton network manager. Owns the active transport backend (ENet or Steam). Does NOT know game logic — pure transport management.

Networking/NetworkTypes.h

Free functions

SignatureDescription
static constexpr uint8_t NETWORK_CHANNEL_COUNT = 4

Networking/OnlineService.h

KindTypeSummary
enumEOnlineGamepadButtonOne 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
structFOnlineTextInputRequestA 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
structFOnlineTextInputResult
enumEOnlinePlatformHardware
enumEOnlineHardwareDefaultConfigThe default settings profile the platform recommends for this device (Steam: GetSteamHardwareDefaultConfig, tunable per device on the partner site without rebuilding the game).
enumEOnlineTimelineModeWhat the player is doing, so a platform recorder (Steam Timeline) can mark gameplay apart from menus and loading when it offers clips.
enumEOnlineClipPriorityHow strongly a timeline event suggests itself as a clip.
structFOnlineVoiceSettingsThe 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.
structFOnlineUgcItemOne Workshop (UGC) item the player is subscribed to. Folder is set once the item is installed; the byte counts describe a download in flight.
structFOnlineLeaderboardEntryOne row of a platform leaderboard. Lower or higher is better as the board was created; the platform returns rows already ranked.
enumEOnlineLeaderboardRangeWhich slice of a leaderboard to download.
structFOnlineFriendA friend on a social platform. presence: 0 offline, 1 online elsewhere, 2 playing this game.
structFOnlineLobbyMemberA player in the current lobby.
classIOnlineService
classFOnlineServicesThe 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.

Networking/Replication/AnimationNetDriver.h

Networking/Replication/CharacterNetDriver.h

KindTypeSummary
classFCharacterNetDriverCharacter 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

Networking/Replication/CharacterPrediction.h

KindTypeSummary
classFCharacterPrediction
structFCharacterPrediction::FMoveStateKinematic 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

Networking/Replication/NetBlobChannel.h

Free functions

SignatureDescription
static_assert(sizeof(FNetBlobChunkHeader) == 24, "FNetBlobChunkHeader is wire format")
static_assert(sizeof(FNetBlobAckBody) == 8, "FNetBlobAckBody is wire format")

Networking/Replication/NetFastArray.h

KindTypeSummary
structFNetFastArrayItem
structFNetFastArrayPeerState
classFNetFastArrayBase
classTNetFastArrayThe 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

Networking/Replication/NetPush.h

KindTypeSummary
classFNetPush

Networking/Replication/ReplicatedComponentRegistry.h

Networking/Replication/ReplicationManager.h

KindTypeSummary
structTReplicationSlotOne 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.
classReplicationManagerDrives the server/client side of state replication for every entity carrying a NetworkObjectComponent. Owned by the World; registered in runtime + simulation system sets.
structReplicationManager::FGhostSpawnDescClient 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
structReplicationManager::FProtocolStats
structReplicationManager::FRelevancyStats
enumReplicationManager::ENetRpcAuthorityRPC 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
enumReplicationManager::ENetRpcChannelClassWhich rate bucket a method's client→server calls are charged to, and on which channel the engine ships it by default.
structReplicationManager::FRpcSecurityStats

Networking/Replication/ReplicationPackets.h

KindTypeSummary
enumReplicationPacketType
structReplicationPacketHeaderFixed-size header in front of every packet body. We don't put length here because the transport layer already framing-delimits messages.
structReplicationSpawnBodyLayout: header | SpawnBody | prefabPath (variable-length, length-prefixed uint16) | placedGuid (uint64, v4+). Variable bits live AFTER the fixed struct so SpawnBody itself stays trivially-copyable.
structReplicationOwnerChangeBody
structReplicationDestroyBody
structReplicationSnapshotEntryThe 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.
structReplicationAckBodyClient → server. Cumulative in effect: the server confirms every baseline whose carrying packetId is <= this one, so a lost ack is covered by the next.
structReplicationRpcBody
structReplicationInputBody
structFPendingInputOne 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.

Free functions

SignatureDescription
constexpr uint8_t REPLICATION_PROTOCOL_VERSION = 9Bumped 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 = 3The unacknowledged moves a client repeats in every Input packet, so one lost datagram costs the server no move.
using NetworkId = uint16_tCompact 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.
constexpr NetworkId INVALID_NETWORK_ID = 0
static_assert(sizeof(ReplicationPacketHeader) == 16, "ReplicationPacketHeader must stay 16 bytes — wire format")
static_assert(sizeof(ReplicationOwnerChangeBody) == 8, "ReplicationOwnerChangeBody is wire format")
static_assert(sizeof(ReplicationSnapshotEntry) == 40, "ReplicationSnapshotEntry layout drift — break wire format")

Networking/Replication/RpcDispatcher.h

KindTypeSummary
classFRpcDispatcher

Networking/Replication/SpatialStream.h

Free functions

SignatureDescription
using FSpatialDistanceFn = std::function<float(const FSpatialKey&)>Distance of a key from one client, in whatever unit the radii use. A negative result means "never interested".
using FSpatialSendFn = std::function<void(uint32_t clientId, const uint8_t* data, size_t len, bool bulk)>

Networking/Session/FNetSession.h

KindTypeSummary
structFNetPlayer
enumENetActorRpcRouteOutcome 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
enumENetEventRateRate 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
enumENetSessionTeardownWhy 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
classFNetSessionThe 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

Free functions

SignatureDescription
static constexpr uint32_t NET_DETACHED_PEER_ID = 0xFFFFFFFFuA 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.

Networking/Session/LidarShotAuthority.h

Networking/Session/NetEventCodec.h

KindTypeSummary
classFNetEventWriter
classFNetEventReader

Networking/Session/NetPawnHost.h

KindTypeSummary
classINetPawnHost

Networking/Session/NetSessionPlatform.h

KindTypeSummary
classFNetSessionPlatformThe 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

Networking/Session/NetSessionTypes.h

KindTypeSummary
enumENetSessionState
enumENetSessionFailure
enumENetSessionPhaseWhere 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.
enumENetLateJoinPolicyWho 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.
enumENetSessionRoute
structFNetSessionSettings
classFNetSessionEventIds
classFNetPlayerState
structFNetLidarShot
structFNetPlayerInfo

Networking/Session/PlayerStateSystem.h

KindTypeSummary
classFPlayerStateSystem

Networking/SocialService.h

Networking/SocialSupport.h

Networking/SteamTicketValidator.h

KindTypeSummary
structTicketValidationResult
classSteamTicketValidatorServer-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).

Networking/Subsystems/MNetSessionSubsystem.h

KindTypeSummary
classMNetSessionSubsystem

Networking/Subsystems/MPlatformSubsystem.h

KindTypeSummary
classMPlatformSubsystem

Page feedback

Was this page helpful?