NetworkPrediction

Will only play on the authority path and not replicate to anyone else.

This is required because these cvars live in header files that will be included across different compilation units Just using standard FAutoConsoleVariableRef will cause multiple registrations of the same variable

Traits for TNetSimCueDispatcher.

(Global) Tick state for fixed tick services

Generic def for kinematic (non physics) actor that doesn't have a backing simulation.

Generic model def for physics actors with no backing simulation

GlobalCueTypeTable: Cue types register with this to get a Type ID assigned (TCue::ID).

The parameters for NetSerialize that are passed around the system. Everything should use this, expecting to have to add more.

Callbacks

Non-templated, "networking model independent" base: this is what the pure simulation code gets to invoke cues.

System parameters for NetSimCue events

Wrapper: wraps the actual user NetSimCue.

TimeStep info that is passed into SimulationTick.

PhysicsState that is networked and marshelled between GT and PT.

This is the actual template to specialize when wanting to override functions.

Unique server assigned ID for a network sim instance.

How a registered instance should behave globally.

The config should tell us what services we should be subscribed to.

What a ModelDef of capable of.

Basic ModelDef type registry.

Generic view into a managed instance's state.

Redirects NetSerialize to a dynamically set NetSerializeFunc.

Collection of each replication proxy.

SavedCue: a recorded Invocation of a NetSimCue

Helper struct to bypass the bandwidth limit imposed by the engine's NetDriver (QueuedBits, NetSpeed, etc).

FServerRPCProxyParameter Used for the client->Server RPC.

Data that is needed to tick the internal ticking services but is not passed to the user code.

This is a replicated "manager" for network prediction.

Variable tick state tracking for independent tick services.

Non replicated but if a resimulate happens, the cue is undone and replayed.

Only invoked on authority and will replicate to everyone else.

Replicated to interpolating proxies, predicted by autonomous/simulated proxy Best for events you want everyone to see but don't need to get perfect in the predicting cases: doesn't need to rollback and cheap on cpu (no NetIdentical tests on predicted path)

Invoked and replicated to all.

Server -> AP Client

Server -> SP Client Like the AP case, the core payload is the same between fixed and independent: Input/Sync/Aux/Physics/Cues

Per-Receiver dispatch table. This is how we go from a serialized ID to a function call

AP Client -> Server replication

Helper to compile time check if NetIdentical exists (since argument is template type, must be wrapped in helper struct)

Helper to see if T has a Traits type or not.

Helper to call NetIdentical if type defines it.

Helper to call NetSerialize if type defines it.

Templated cue dispatcher that can be specialized per networking model definition. This is what the system actually uses internally, but is not exposed to user code.

Register a handler's cue types via a static "RegisterNetSimCueTypes" on the handler itself

Register a handler's cue types via an intermediate "set" class with a static "RegisterNetSimCueTypes" function

Actual trait struct that we use to look up traits.

Explicit trait settings. This can be used to explicitly set your traits without using a preset.

Register a cue type with the global table.

Type requirements: helper to determine if NetSerialize/NetIdentical functions need to be defined for user types based on the above traits.

Reference version of LazyWriter. This is what gets passed through chains of ::SimulationTick calls. This is to avoid copying the TFunction in TNetSimLazyWriterFunc around.

Helper struct to encapsulate optional, delayed writing of new element to TNetworkSimAuxBuffer buffer.

Output state: the output SyncState (always created) and TNetSimLazyWriter for the AuxState (created on demand since every tick does not generate a new aux frame)

Circular buffer for storing continuous frame data.

Tuple of state types.

State type defines.

Sparse buffer: each element has explicit Frame value.

Selects explicit traits set by T.

Just the Sync/Aux pair.

SFINAE helper.

UNetworkPredictionComponent This is the base component for running a TNetworkedSimulationModel through an actor component.

UNetworkPredictionPhysicsComponent

Non replicated cue that only plays during "latest" simulate.

Same as above but will play on all clients, just not the authority.

Same as above but will only play on the owning, autonomous proxy client (not on authority, not on simulated clients) Useful if the Cue is needed for only the controlling player, maybe like a HUD/UI notification pop

Default Traits: if you do not explicitly set Traits on your class, this is what it defaults to.

Input state is just a collection of references to the simulation state types.

High level "who can invoke this". Does not take resimulate into account yet. All combinations of this enum are valid (though Authority | SimExtrapolate is a bit weird maybe)

Who a NetSimCue should replicate/be accepted by.

Must be kept in sync with ENP_NetworkLOD.

Arbitrary sort values used by system default definitions.

Copyright Epic Games, Inc. All Rights Reserved.

Must be kept in sync with ENP_TickingPolicy.

Target of replication.

Copyright Epic Games, Inc. All Rights Reserved.

"Shipping const" cvars: cvars that should compile out to const functions in shipping/test builds This got a little tricky due to templated usage across different modules.

Helper to compile time check if NetSerialize exists.

Turns "Who can invoke this" + "Does this play during resimulate" into the final ESimulationTickContext mask we use at runtime. This is done so users can't make invalid configurations (like "Authority | Resimulate")

Set bit array contents to false.

Sets index to value, resizing bit array if necessary and setting new bits to false.

Resize BitArray to NewNum, setting default value of new bits to false.