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.

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

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.

Base for Network Simulation Model Defs (defines types used by the model)

Ticking parameters use to drive the simulation

FNetSimTimeStep Time data structure that is passed into SimulationTick

The main Simulation time type. All sims use this to talk about time.

FReplicationProxyReplicated USTRUCT that point to the IReplicationProxy to do the replication.

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.

FSimulationTickState: Holds active state for simulation ticking.

Debugger support classes

Interface that the proxy talks to. This is what will implement the replication.

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.

Helper struct for enum-based access. This has to be done in an outside struct because we cant specialize inside TNetworkSimBufferContainer on all compilers.

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

Wraps an input command (BaseType) in a NetworkSimulation time.

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.

"Internal" Buffers: Helper to turn user supplied buffer types into the "real" buffer types: the InputCmd struct is wrapped in TFrameCmd -Outside/User code will always use the user supplied buffer types in callbacks/APIs etc -Internal code to the TNetworkedSimulationModel will use the internal buffer types

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.

Input state: const references to the InputCmd/SyncState/AuxStates.

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 buffer.

Template struct to specialize per-model.

Traits for which RepController structs are used internally.

Internal traits that are derived from the user settings (E.g, these can't go in FNetSimModelDefBase because they are dependent on the user types) These can be overridden as well via template specialization but we don't expect this to be common.

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)

Accessors - helper structs that provide safe/cleaner access to the underlying NetSim states/events This is the equivlent of directly calling TNetworkedSimulationModel::GetPendingStateRead() / GetPendingStateWrite()

The actual NetworkedSimulationModel templated class.

Copyright Epic Games, Inc. All Rights Reserved.

Common implementations shared by TNetworkSimContiguousBuffer/TNetworkSimSparseBuffer.

The main container for all of our buffers.

Generic iterator for iterating over each frame from tail to head.

A collection of the system's buffer types. This allows us to collapse the 4 types into a single type to use a template argument elsewhere.

Frame: arbitrary identifier for data.

Holds per-simulation settings about how ticking is supposed to happen.

Accumulator: Helper for accumulating real time into sim time based on TickSettings

Replicates TSyncState and does basic reconciliation.

Base implementation with minimal functionality: will grant simulation time and call finalize frame.

Special replicator for debug buffer, this preserves the local buffer and receives into a replicator-owned buffer (we want these buffers to be distinct/not merged)

Empty RepController: zero functionality, just stubbed out functions and using definitions for convenience.

Sequence replicator

Server Replication Controller (FIXME: should this be called something like "client autonomous proxy -> Server RPC" ?

Simulation Time replicator Just serializes simulation time.

Simulated: "non locally controlled" simulations.

Scoped helper to be used right before entering a call to the sim's ::SimulationTick function.

Selects explicit traits set by T.

Helper needed to specialize TNetworkSimBufferTypes::Get (must be done outside of templated struct)

"Ticker" that actually allows us to give the simulation time. This struct will generally not be passed around outside of the core TNetworkedSimulationModel/Replicators

SFINAE helper.

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

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.

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.

Copyright Epic Games, Inc. All Rights Reserved.

Copyright Epic Games, Inc. All Rights Reserved.

Helper to compile time check if NetSerialize exists.

Helpers

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")

Catchup means "interpolate faster than realtime".

Snap means "we are too far behind, just jump to a specific point".

Helper to generate a local input cmd if we have simulation time to spend and advance the simulation's MaxAllowedFrame so that it can be processed.