className: FNetworkPredictionSettings

bForceEngineFixTickForcePhysics

description: Forces the engine to run in fixed tick mode when a NP physics simulation is running.

FixedTickFrameRate

description: Frame rate to use when running Fixed Tick simulations. Note: Engine::FixedFrameRate will take precedence if manually set.

FixedTickInputSendCount

description: Clients should send this number of most recent input commands together per update, for a Fixed Tick simulation.

FixedTickInterpolationBufferedMS

description: How much buffered time to keep for fixed ticking interpolated sims (client only).

IndependentTickInputSendCount

description: Clients should send this number of most recent input commands together per update, for an Independent Tick simulation.

IndependentTickInterpolationBufferedMS

description: How much buffered time to keep for fixed independent interpolated sims (client only).

description: Max buffered time to keep for fixed independent interpolated sims (client only).

MaximumRemoteInputFaultLimit

description: Cap the number of remote input commands required to be buffered before resuming input consumption after a fault.

PreferredTickingPolicy

description: Which ticking policy to use in cases where both are supported by the underlying simulation.

ReplicatedManagerClassOverride

type: TSubclassOf<AN...

description: Replicated Manager class.

SimulatedProxyNetworkLOD

description: Default NetworkLOD for simulated proxy simulations.


module: NetworkPrediction

code: void ClearPresentationView()


code: void UpdatePresentationView ( void * Sync, void * Aux )


code: void UpdateView ( int32 Frame, int32 InSimTimMS, void * Input, void * Sync, void * Aux )


className: FNetworkPredictionStateView

description: Generic view into a managed instance's state.

code: struct FNetworkPredictionStateView

bTickInProgress

type: bool

description: ::SimulationTick is in progress

CueDispatcher

type: FNetSimCueDispa...

description: CueDispatcher is exposed so that game code can invoke OOB cues Future versions may move this / make Invoking OOB cues go through a different API

PendingAuxState

type: void *

PendingFrame

description: Simulation PendingFrame number.

PendingInputCmd

description: Pending states: these are what will be used as input into the next SimulationTick call, if we are running a local tick.

PresentationSyncState

description: Presentation states: the latest locally smoothed/interpolated states that will not be fed back into the sim (these will be null in cases where there is no smoothing/interpolation)

SimTimeMS

description: Latest Simulation time.


className: ETraceUserState

code: enum ETraceUserState { Input, Sync, Aux, Physics, }


code: static void TraceBufferedInput ( int32 NumBufferedFrames, bool bFault )


code: static void TraceFixedTickOffset ( int32 Offset, bool bChanged )


code: static void TraceNetRecv ( int32 Frame, int32 TimeMS )


code: template<typename ModelDef, typename DriverType> static void TracePhysicsStateAtFrame ( int32 PhysicsFrame, [Chaos::FRewindData](API\Runtime\Chaos\FRewindData) * RewindData, DriverType * Driver )


code: template<typename ModelDef, typename DriverType> static void TracePhysicsStateCurrent ( DriverType * Driver )


code: template<typename ModelDef, typename PhysicsStateType> static void TracePhysicsStateRecv ( const PhysicsStateType & State )


code: static void TraceProduceInput ( int32 TraceID )


code: static void TracePIEStart()


code: static void TracePushInputFrame ( int32 Frame )


code: static void TraceOOBStateMod ( int32 SimulationId, int32 Frame, const FAnsiStringView & StrView )


code: static void TraceRollbackInject ( int32 TraceID )


code: static void TraceReconcile ( const FAnsiStringView & StrView )


code: static void TraceShouldReconcile ( int32 TraceID )


description: Used to lazy update user state after a simtick.

code: static void TraceSimState ( int32 TraceID )


code: static void TraceSimTick ( int32 TraceID )


code: static void TraceSimulationConfig ( int32 TraceID, ENetRole NetRole, bool bHasNetConnection, const [FNetworkPredictionInstanceArchetype](API\Plugins\NetworkPrediction\FNetworkPredictionInstanceArchet-) & Archetype, const [FNetworkPredictionInstanceConfig](API\Plugins\NetworkPrediction\FNetworkPredictionInstanceConfig) & Config, int32 ServiceMask )


code: template<typename ModelDef> static void TraceSimulationCreated ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, typename ModelDef::Driver * Driver )


code: static void TraceSimulationScope ( int32 TraceID )


code: static void TraceSystemFault ( const TCHAR * Fmt, ... )


code: static void TraceTick ( int32 StartMS, int32 DeltaMS, int32 OutputFrame )


code: template<typename ModelDef, typename StateType> static void TraceUserState ( const StateType * State, [ETraceUserState](API\Plugins\NetworkPrediction\FNetworkPredictionTrace\ETraceUserState) StateTypeEnum )


code: static void TraceWorldFrameStart ( [UGameInstance](API\Runtime\Engine\Engine\UGameInstance) * GameInstance, float DeltaSeconds )


code: static void TraceWorldPreInit()


className: FNetworkPredictionTrace

code: class FNetworkPredictionTrace


code: bool Identical ( const [FReplicationProxy](API\Plugins\NetworkPrediction\FReplicationProxy) * Other, uint32 PortFlags ) const


code: void Init ( [FNetworkPredictionProxy](API\Plugins\NetworkPrediction\FNetworkPredictionProxy) * InNetSimProxy, [EReplicationProxyTarget](API\Plugins\NetworkPrediction\EReplicationProxyTarget) InReplicationTarget )


code: bool NetSerialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [UPackageMap](API\Runtime\CoreUObject\UObject\UPackageMap) * Map, bool & bOutSuccess )


code: void OnPreReplication()


className: FReplicationProxy

description: Redirects NetSerialize to a dynamically set NetSerializeFunc. This is how we hook into the replication systems role-based serialization

NetSerializeFunc

type: TFunction< void...

NetSimProxy

type: FNetworkPredict...


className: FReplicationProxySet

description: Collection of each replication proxy.

code: struct FReplicationProxySet

AutonomousProxy

type: FReplicationPro...


description: Test NetUniqueness against another saved cue.

code: bool NetIdentical ( [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) & OtherCue ) const


description: Test NetUniqueness against an actual cue instance.

code: template<typename TCue> bool NetIdentical ( TCue & OtherCue ) const


code: void NetSerialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, const bool bSerializeFrameNumber )


code: [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) & operator= ( const [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) & )


code: [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) & operator= ( [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) && )


code: FSavedCue ( bool bInNetConfirmed )


code: FSavedCue ( const [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) & )


code: FSavedCue ( [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) && )


code: FSavedCue ( const [FNetSimCueTypeId](API\Plugins\NetworkPrediction\FNetSimCueTypeId) & InId, const int32 & InFrame, const int32 & InTime, const bool & bInAllowRollback, const bool & bInNetConfirmed, const bool & bInResimulates, [FNetSimCueWrapperBase](API\Plugins\NetworkPrediction\FNetSimCueWrapperBase) * Cue )


className: FSavedCue

description: SavedCue: a recorded Invocation of a NetSimCue

code: struct FSavedCue

Callbacks

type: FNetSimCueCallb...

CueInstance

type: TUniquePtr<FNe...

ID

type: FNetSimCueTypeI...

ReplicationTarget

type: ENetSimCueRepli...


code: FScopedBandwidthLimitBypass ( [AActor](API\Runtime\Engine\GameFramework\AActor) * OwnerActor )


code: ~FScopedBandwidthLimitBypass()


className: FScopedBandwidthLimitBypass

description: Helper struct to bypass the bandwidth limit imposed by the engine's NetDriver (QueuedBits, NetSpeed, etc). This is really a temp measure to make the system easier to drop in/try in a project without messing with your engine settings. (bandwidth optimizations have not been done yet and the system in general hasn't been stressed with packetloss / gaps in command streams) So, you are free to use this in your own code but it may be removed one day. Hopefully in general bandwidth limiting will also become more robust.

code: struct FScopedBandwidthLimitBypass


code: bool NetSerialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, class [UPackageMap](API\Runtime\CoreUObject\UObject\UPackageMap) * Map, bool & bOutSuccess )


code: void NetSerializeToProxy ( [FReplicationProxy](API\Plugins\NetworkPrediction\FReplicationProxy) & InProxy )


description: Receive flow: ctor() -> NetSerializetoProxy.

code: FServerReplicationRPCParameter()


className: TempStorage

code: static [TArray](API\Runtime\Core\Containers\TArray)< uint8 > TempStorage;


description: Send flow: ctor(Proxy) -> NetSerialize.

code: FServerReplicationRPCParameter ( [FReplicationProxy](API\Plugins\NetworkPrediction\FReplicationProxy) & InProxy )


className: FServerReplicationRPCParameter

description: FServerRPCProxyParameter Used for the client->Server RPC. Since this is instantiated on the stack by the replication system prior to net serializing, we have no opportunity to point the RPC parameter to the member variables we want. So we serialize into a generic temp byte buffer and move them into the real buffers on the component in the RPC body (via ::NetSerialzeToProxy).


className: FServiceTimeStep

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

code: struct FServiceTimeStep

EndTotalSimulationTime

description: Ending total sim time, needed for Cue dispatching.

LocalInputFrame

description: The local frame number, this is what should be used when mapping to local frame buffers for storage.


className: FSharedPackageMap

Items

type: TArray<FShared...


className: FSharedPackageMapItem

description: This is a replicated "manager" for network prediction. Its purpose is only to replicate system-wide data that is not bound to an actor. Currently this is only to house a "mini packagemap" which allows stable shared indices that map to a small set of uobjects to be.UPackageMapcan assign per-client net indices which invalidates sharing as well as forces 32 bit guis. this is a more specialzed case where we want to replicate IDs as btyes.

SoftPtr

type: TSoftObjectPtr<...


className: FInterpolationState

code: struct FInterpolationState

fTimeMS

type: float


code: [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) GetNextServiceTimeStep ( const [FFrame](API\Plugins\NetworkPrediction\FVariableTickState\FFrame) & PendingFrameData ) const


code: [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) GetNextTimeStep ( const [FFrame](API\Plugins\NetworkPrediction\FVariableTickState\FFrame) & PendingFrameData ) const


className: FVariableTickState

description: Variable tick state tracking for independent tick services.

code: struct FVariableTickState

Frames

type: TNetworkPredict...

Interpolation

type: FInterpolationS...


className: GetHighestNetworkLOD

code: static constexpr [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) GetHighestNetworkLOD ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Mask )


description: Function checking helpers - helps us do clean checks for member function (NetSerialize/NetIdentical) when registering types

code: GENERATE_MEMBER_FUNCTION_CHECK ( NetSerialize, void, [FArchive](API\Runtime\Core\Serialization\FArchive) & )


className: GetSimTickMask

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

code: static constexpr [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) GetSimTickMask ( const [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Invoker, const bool bAllowResimulate )


description:
Singleton-like access to this module's interface. This is just for convenience! Beware of calling this during the shutdown phase, though. Your module might have been unloaded already.
Returns singleton instance, loading the module on demand if needed

code: static [INetworkPredictionModule](API\Plugins\NetworkPrediction\INetworkPredictionModule) & Get()


className: INetworkPredictionModule

code: class INetworkPredictionModule : public [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface)


description:
Checks to see if this module is loaded and ready. It is only valid to callGet()ifIsAvailable()returns true.
True if the module is loaded and ready to use

code: static bool IsAvailable()


className: LexToString

code: [FString](API\Runtime\Core\Containers\FString) LexToString ( [EReplicationProxyTarget](API\Plugins\NetworkPrediction\EReplicationProxyTarget) A )


code: const TCHAR * LexToString ( [ENetworkPredictionStateType](API\Plugins\NetworkPrediction\ENetworkPredictionStateType) A )


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::ForceSendDefaultInputCommands() }


code: namespace NetworkPredictionCVars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionCVars::ForceSendDefaultInputCommandsAuto ( TEXT("np.ForceSendDefaultInputCommands"), (int32) 0, TEXT("While enabled on a client, it will send default input cmds to the server, rather than the locally-produced input. This is a way to introduce de-syncs/rollbacks for debugging.") ) }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetForceSendDefaultInputCommands ( int32 _V ) }


code: namespace NetworkPredictionPhysicsCvars { int32 NetworkPredictionPhysicsCvars::DebugPositionCorrections() }


code: namespace NetworkPredictionPhysicsCvars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionPhysicsCvars::DebugPositionCorrectionsAuto ( TEXT("np.Physics.DebugPositionCorrections"), (int32) 0, TEXT("Prints position history when correcting physics X") ) }


code: namespace NetworkPredictionPhysicsCvars { void NetworkPredictionPhysicsCvars::SetDebugPositionCorrections ( int32 _V ) }


code: namespace NetworkPredictionPhysicsCvars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionPhysicsCvars::FullPrecisionAuto ( TEXT("np.Physics.FullPrecision"), (int32) 1, TEXT("Replicatre physics state with full precision. Not to be toggled during gameplay.") ) }


code: namespace NetworkPredictionPhysicsCvars { int32 NetworkPredictionPhysicsCvars::FullPrecision() }


code: namespace NetworkPredictionPhysicsCvars { void NetworkPredictionPhysicsCvars::SetFullPrecision ( int32 _V ) }


code: namespace NetworkPredictionPhysicsCvars { void NetworkPredictionPhysicsCvars::SetToleranceX ( float _V ) }


code: namespace NetworkPredictionPhysicsCvars { void NetworkPredictionPhysicsCvars::SetToleranceR ( float _V ) }


code: namespace NetworkPredictionPhysicsCvars { void NetworkPredictionPhysicsCvars::SetToleranceV ( float _V ) }


code: namespace NetworkPredictionPhysicsCvars { void NetworkPredictionPhysicsCvars::SetToleranceW ( float _V ) }


code: namespace NetworkPredictionPhysicsCvars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionPhysicsCvars::ToleranceXAuto ( TEXT("np.Physics.Tolerance.X"), (float) 1. 0, TEXT("Absolute tolerance for position") ) }


code: namespace NetworkPredictionPhysicsCvars { float NetworkPredictionPhysicsCvars::ToleranceX() }


code: namespace NetworkPredictionPhysicsCvars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionPhysicsCvars::ToleranceRAuto ( TEXT("np.Physics.Tolerance.R"), (float) 0. 1, TEXT("Normalized error tolerance between rotation (0..1)") ) }


code: namespace NetworkPredictionPhysicsCvars { float NetworkPredictionPhysicsCvars::ToleranceR() }


code: namespace NetworkPredictionPhysicsCvars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionPhysicsCvars::ToleranceVAuto ( TEXT("np.Physics.Tolerance.V"), (float) 1. 0, TEXT("Absolute error tolerance for velocity ") ) }


code: namespace NetworkPredictionPhysicsCvars { float NetworkPredictionPhysicsCvars::ToleranceV() }


code: namespace NetworkPredictionPhysicsCvars { float NetworkPredictionPhysicsCvars::ToleranceW() }


code: namespace NetworkPredictionPhysicsCvars { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) NetworkPredictionPhysicsCvars::ToleranceWAuto ( TEXT("np.Physics.Tolerance.W"), (float) 1. 0, TEXT("Absolute error tolerance for rotational velocity ") ) }


className: InvokeMask

code: static constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InvokeMask { ENetSimCueInvoker::All };


className: ReplicationTarget

code: static constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationTarget { ENetSimCueReplicationTarget::None };


className: Resimulate

code: static constexpr bool Resimulate { true };


className: NonReplicatedResimulated

description: Non replicated but if a resimulate happens, the cue is undone and replayed. This is not common and doesn't really have a clear use case. But the system can support it.

code: struct NonReplicatedResimulated


className: NpClearBitArray

description: Set bit array contents to false.

code: template<typename BitArrayType> void NpClearBitArray ( BitArrayType & BitArray )


className: NpResizeAndSetBit

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

code: template<typename BitArrayType> void NpResizeAndSetBit ( BitArrayType & BitArray, int32 Index, bool Value )


className: NpResizeForIndex

code: template<typename ArrayType> void NpResizeForIndex ( ArrayType & Array, int32 Index )


className: NpResizeBitArray

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

code: template<typename BitArrayType> void NpResizeBitArray ( BitArrayType & BitArray, int32 NewNum )


className: operator&

code: constexpr [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) operator& ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Lhs, [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Rhs )


code: constexpr [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) operator& ( [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) Lhs, [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) Rhs )


code: constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) operator& ( [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Lhs, [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Rhs )


code: constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) operator& ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) Lhs, [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) Rhs )


className: operator&=

code: [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) & operator&= ( [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) & Lhs, [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) Rhs )


code: [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) & operator&= ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) & Lhs, [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Rhs )


code: [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) & operator&= ( [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) & Lhs, [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) Rhs )


code: [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) & operator&= ( [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) & Lhs, [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Rhs )


code: [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) & operator&= ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) & Lhs, [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) Rhs )


className: operator~

code: constexpr [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) operator~ ( [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) E )


code: constexpr [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) operator~ ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) E )


code: constexpr [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) operator~ ( [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) E )


code: constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) operator~ ( [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) E )


className: operator^

code: constexpr [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) operator^ ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Lhs, [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Rhs )


code: constexpr [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) operator^ ( [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) Lhs, [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) Rhs )


code: constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) operator^ ( [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Lhs, [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Rhs )


code: constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) operator~ ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) E )


code: constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) operator^ ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) Lhs, [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) Rhs )


className: operator^=

code: [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) & operator^= ( [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) & Lhs, [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) Rhs )


code: [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) & operator^= ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) & Lhs, [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) Rhs )


code: [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) & operator^= ( [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) & Lhs, [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) Rhs )


code: [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) & operator^= ( [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) & Lhs, [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) Rhs )


code: [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) & operator^= ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) & Lhs, [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) Rhs )


className: operator!

code: constexpr bool operator! ( [ENetworkPredictionTickingPolicy](API\Plugins\NetworkPrediction\ENetworkPredictionTickingPolicy) E )


code: constexpr bool operator! ( [ENetworkLOD](API\Plugins\NetworkPrediction\ENetworkLOD) E )


code: constexpr bool operator! ( [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) E )


code: constexpr bool operator! ( [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) E )


code: constexpr bool operator! ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) E )


code: static constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InvokeMask { ENetSimCueInvoker::Authority };


code: static constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationTarget { ENetSimCueReplicationTarget::All };


code: static constexpr bool Resimulate { false };


className: ReplicatedNonPredicted

description: Only invoked on authority and will replicate to everyone else. Not predicted so controlling client will see delays! Best for events that are critical that cannot be rolled back/undown and do not need to be predicted.

code: struct ReplicatedNonPredicted


code: static constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InvokeMask { ENetSimCueInvoker::All };


code: static constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationTarget { ENetSimCueReplicationTarget::Interpolators };


className: ReplicatedXOrPredicted

description: 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)

code: struct ReplicatedXOrPredicted


className: ENetworkPredictionService

description: Enum that maps to internal NetworkPrediction services, see notes in NetworkPredictionServiceRegistry.h.

code: enum ENetworkPredictionService { None = 0, ServerRPC = 1 << 0, MAX_COMMON = ServerRPC, FixedRollback = 1 << 1, FixedExtrapolate = 1 << 2, FixedInterpolate = 1 << 3, FixedInputLocal = 1 << 4, FixedInputRemote = 1 << 5, FixedTick = 1 << 6, FixedSmoothing = 1 << 7, FixedFinalize = 1 << 8, FixedPhysics = 1 << 9, MAX_FIXED = FixedPhysics, IndependentRollback = 1 << 10, IndependentExtrapolate = 1 << 11, IndependentInterpolate = 1 << 12, IndependentLocalInput = 1 << 13, IndependentLocalTick = 1 << 14, IndependentRemoteTick = 1 << 15, IndependentSmoothingFinalize = 1 << 16, IndependentLocalFinalize = 1 << 17, IndependentRemoteFinalize = 1 << 18, MAX_INDEPENDENT = IndependentRemoteFinalize, ANY_COMMON = (MAX_COMMON<<1)-1, ANY_FIXED = ((MAX_FIXED<<1)-1) & ~ANY_COMMON, ANY_INDEPENDENT = (((MAX_INDEPENDENT<<1)-1) & ~ANY_FIXED) & ~ANY_COMMON, }


description: DataStore

code: template<typename ModelDef> [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< ModelDef > * GetDataStore()


description: Register / Unregister

code: template<typename ModelDef> void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TInstanceData](API\Plugins\NetworkPrediction\Services\TInstanceData)< ModelDef > & InstanceData, [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) ServiceMask )


className: TServiceStorage

description: Services

code: template<typename InServiceInterface, int32 NumInlineServices> struct TServiceStorage

Array

type: TSparseArray<T...


code: template<typename ModelDef> void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


className: FNetworkPredictionServiceRegistry

description: Future Improvements: -All services template classes are currently instantiated for all ModelDefs (the templated code is generated for each ModelDef) -Even if ModelDefs are incompatible for a given service. E.g, a pure physics ModelDef with no Simulation still has the TLocalInputServicecode instantiated. -To be clear: it does not instantiate an instance ofTLocalInputServiceat runtime, but the code is generated and almost certainly cannot be culled by the compiler. -Concepts could be used to determine if ModelDefs are compatible with Services and we could avoid the template code instantiation. -This would add more template machinery, and basically requires all TServicebe hidden behind SFINAE walls. E.g, Factories for instantiating and CallOrNot for Register/Unregister. -Its not clear if its worth the effort at this point. In practice there should be relatively few ModelDefs that would benefit from this. -But it could make a difference in some cases for build time and exe size

code: class FNetworkPredictionServiceRegistry

FixedFinalize

type: TServiceStorage...

ServerRPC

description: Declares generic storage for the service type: TServiceStorage


code: void FinalizeFrame ( float DeltaTimeSeconds, const int32 SimFrame, const int32 SimTimeMS, const int32 FixedStepMS )


code: virtual ~IFinalizeService()


className: IFinalizeService

code: class IFinalizeService


code: void FinalizeFrame ( float DeltaTimeSeconds, const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: void Reconcile ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: virtual ~IFixedInterpolateService()


className: IFixedInterpolateService

description: Note: Interpolation ignores the TickState->Offset that forward predicted services use. Instead, we copy into the local frame buffers @ the server frame numbers.

code: class IFixedInterpolateService


code: void PreStepRollback ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep, const int32 Offset, const bool bFirstStepInResim )


code: int32 QueryRollback ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: void StepRollback ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep )


code: virtual ~IFixedRollbackService()


className: IFixedRollbackService

code: class IFixedRollbackService


code: void FinalizeFrame ( float DeltaTimeSeconds, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


code: void Reconcile ( const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


className: IIndependentInterpolateService

description: We potentially could special case server-controlled independent simulations since they will at least all line up on the same frame boundaries (rep frequency will mean there are still gaps though). But we don't distinguish this (server remote vs local) on simulated clients. Seems simpler to just handle all SP sims the same.

code: class IIndependentInterpolateService


className: IIndependentRollbackService

code: class IIndependentRollbackService


code: void ProduceInput ( int32 DeltaTimeMS )


code: virtual ~IIndependentRollbackService()


code: virtual ~IInputService()


className: IInputService

code: class IInputService


code: void Tick ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep )


code: virtual ~ILocalTickService()


className: ILocalTickService

description: The tick service's role is to tick new simulation frames based on local frame state (fixed or independent/variable)

code: class ILocalTickService


code: void EnsureDataInSync ( const TCHAR * ContextStr )


code: void PostNetworkPredictionFrame ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: virtual ~IPhysicsService()


code: void PostResimulate ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


className: IPhysicsService

description: The PhysicsService does bookkeeping for physics objects -Tracing -Updates PendingFrame for physics-only sims (no backing NetworkPrediction simulation)

code: class IPhysicsService


code: void FinalizeFrame ( float DeltaTimeSeconds )


code: virtual ~IRemoteFinalizeService()


className: IRemoteFinalizeService

code: class IRemoteFinalizeService


code: void Tick ( float DeltaTimeSeconds, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * VariableTickState )


code: void CallServerRPC ( float DeltaTimeSeconds )


code: virtual ~IServerRPCService()


className: IRemoteIndependentTickService

description: Service for ticking independent simulations that are remotely controlled. E.g, only used by the server for ticking remote clients that are in independent ticking mode,

code: class IRemoteIndependentTickService


className: IServerRPCService

description: The implementation here is very basic. It may make sense to have some scalability at this level, options for throttling send rate, etc.

code: class IServerRPCService


description: These are pretty bare bones. Will move to Insights tracing in the future for interpolation debugging.

code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::PrintSyncInterpolationAuto; }


code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::DrawInterpolationAuto; }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::ForceReconcileExtraFrames() }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetForceReconcileExtraFrames ( int32 _V ) }


code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::DisableInterpolationAuto; }


code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::ForceReconcileExtraFramesAuto; }


code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::PrintReconcilesAuto; }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::PrintSyncInterpolation() }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetPrintSyncInterpolation ( int32 _V ) }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetDrawInterpolation ( int32 _V ) }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::DisableInterpolation() }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetDisableInterpolation ( int32 _V ) }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::DrawInterpolation() }


code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::ForceReconcileAuto; }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::ForceReconcile() }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::PrintReconciles() }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetForceReconcile ( int32 _V ) }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetPrintReconciles ( int32 _V ) }


code: namespace NetworkPredictionCVars { void NetworkPredictionCVars::SetSkipReconcile ( int32 _V ) }


code: namespace NetworkPredictionCVars { static NetworkPredictionCVars::SkipReconcileAuto; }


code: namespace NetworkPredictionCVars { int32 NetworkPredictionCVars::SkipReconcile() }


className: operator&

code: constexpr [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) operator& ( [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) Lhs, [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) Rhs )


className: operator&=

code: [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) & operator&= ( [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) & Lhs, [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) Rhs )


className: operator~

code: constexpr [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) operator~ ( [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) E )


className: operator^

code: constexpr [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) operator^ ( [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) Lhs, [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) Rhs )


className: operator!

code: constexpr bool operator! ( [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) E )


className: AuxType

code: typedef typename StateTypes::AuxType AuxType


className: InputType

code: typedef typename StateTypes::InputType InputType


className: PhysicsState

code: typedef typename ModelDef::PhysicsState PhysicsState


className: StateTypes

code: typedef typename ModelDef::StateTypes StateTypes


className: SyncType

code: typedef typename StateTypes::SyncType SyncType


className: TClientRecvData

description: Data the client receives from the server.

code: template<typename ModelDef> struct TClientRecvData

AuxState

type: TConditionalSta...

NetRole

type: ENetRole

TraceID

description: Acceleration data.


className: DriverType

code: typedef typename ModelDef::Driver DriverType


className: operator^=

code: [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) & operator^= ( [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) & Lhs, [ENetworkPredictionService](API\Plugins\NetworkPrediction\Services\ENetworkPredictionService) Rhs )


code: virtual void FinalizeFrame ( float DeltaTimeSeconds, const int32 ServerSimFrame, const int32 SimTimeMS, const int32 FixedStepMS )


className: ModelDef

code: typedef InModelDef ModelDef


code: void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: TFinalizeService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TFinalizeService\ModelDef) > * InDataStore )


className: TFinalizeService

code: template<typename InModelDef> class TFinalizeService : public [IFinalizeService](API\Plugins\NetworkPrediction\Services\IFinalizeService)


className: bHasPhysics

code: static constexpr bool bHasPhysics = FNetworkPredictionDriver<ModelDef>::HasPhysics();


code: virtual void FinalizeFrame ( float DeltaTimeSeconds, const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: virtual void Reconcile ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: TFixedInterpolateService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TFixedInterpolateService\ModelDef) > * InDataStore )


className: TFixedInterpolateService

code: template<typename InModelDef> class TFixedInterpolateService : public [IFixedInterpolateService](API\Plugins\NetworkPrediction\Services\IFixedInterpolateService)


className: bNeedsTickService

code: static constexpr bool bNeedsTickService = FNetworkPredictionDriver<ModelDef>::HasSimulation();


code: virtual void PreStepRollback ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep, const int32 Offset, const bool bFirstStepInResim )


code: virtual int32 QueryRollback ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: typedef typename ModelDef::StateTypes StateTypes


code: virtual void StepRollback ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep )


code: TFixedRollbackService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TFixedRollbackService\ModelDef) > * InDataStore )


className: TFixedRollbackService

code: template<typename InModelDef> class TFixedRollbackService : public [IFixedRollbackService](API\Plugins\NetworkPrediction\Services\IFixedRollbackService)


code: typedef typename StateTypes::AuxType AuxType


code: virtual void FinalizeFrame ( float DeltaTimeSeconds, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


code: typedef InModelDef ModelDef


code: virtual void Reconcile ( const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


code: void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: typedef typename StateTypes::SyncType SyncType


code: void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: TIndependentInterpolateService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TIndependentInterpolateService\ModelDef) > * InDataStore )


className: TIndependentInterpolateService

code: template<typename InModelDef> class TIndependentInterpolateService : public [IIndependentInterpolateService](API\Plugins\NetworkPrediction\Services\IIndependentInterpolateService)


code: TIndependentRollbackService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TIndependentRollbackService\ModelDef) > * InDataStore )


className: TIndependentRollbackService

code: template<typename InModelDef> class TIndependentRollbackService : public [IIndependentRollbackService](API\Plugins\NetworkPrediction\Services\IIndependentRollbackService)


className: TInstanceData

description: Basic data that all instances have.

code: template<typename ModelDef> struct TInstanceData

CueDispatcher

type: TUniqueObj<TNe...

ServiceMask

type: ENetworkPredict...


className: FFrame

code: struct FFrame


className: InputType

code: typedef typename StateTypes::InputType InputType


code: typedef typename ModelDef::StateTypes StateTypes


code: T * Find ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


className: TInstanceFrameState

description: Frame data that instances with StateTypes will have. (a pure physics object would not have this for example)

code: template<typename ModelDef> struct TInstanceFrameState


code: T & FindOrAdd ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: T & GetByIndexChecked ( int32 idx )


code: int32 GetIndex ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: int32 GetIndexChecked ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: void Remove ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


className: TInstanceMap

description: Generic associative container for instance data keyed off of theFNetworkPredictionIDSortedMap + SparseArray provides: -O(log n) add/remove. -Stable index that can be cached for O(1) lookup in various service acceleration structures -Data* are not stable out of this data structure

code: template<typename T> struct TInstanceMap


code: typedef typename ModelDef::Driver DriverType


code: typedef InModelDef ModelDef


code: virtual void ProduceInput ( int32 DeltaTimeMS )


code: void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: TLocalInputService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TLocalInputService\ModelDef) > * InDataStore )


code: void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: TLocalTickService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< InModelDef > * InDataStore )


className: TLocalInputService

description: Calls ProduceInput on driver to get local input Requires validFNetworkPredictionDriver::ProduceInputfunction

code: template<typename InModelDef> class TLocalInputService : public [IInputService](API\Plugins\NetworkPrediction\Services\IInputService)


className: TLocalTickService

description: To allow template specialization.

code: template<typename InModelDef> class TLocalTickService : public [TLocalTickServiceBase< InModelDef >](API\Plugins\NetworkPrediction\Services\TLocalTickServiceBase)


className: AuxType

code: typedef typename StateTypes::AuxType AuxType


code: void BeginRollback ( const int32 LocalFrame, const int32 StartTimeMS, const int32 ServerFrame )


className: FInstance

code: struct FInstance


code: template<bool bIsResim> [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) GetTickContext ( ENetRole NetRole )


code: typedef typename StateTypes::InputType InputType


className: SyncType

code: typedef typename StateTypes::SyncType SyncType


className: StateTypes

code: typedef typename ModelDef::StateTypes StateTypes


code: virtual void Tick ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep )


code: void TickResim ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep )


code: template<bool bIsResim> void Tick_Internal ( const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const [FServiceTimeStep](API\Plugins\NetworkPrediction\FServiceTimeStep) & ServiceStep )


code: TLocalTickServiceBase ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TLocalTickServiceBase\ModelDef) > * InDataStore )


className: TModelDataStore

description: Stores all public data for a given model def.

code: template<typename ModelDef> struct TModelDataStore

ClientRecv

type: TInstanceMap<T...

ClientRecvBitMask

type: TBitArray

Instances

type: TStableInstance...


className: TLocalTickServiceBase

code: template<typename InModelDef> class TLocalTickServiceBase : public [ILocalTickService](API\Plugins\NetworkPrediction\Services\ILocalTickService)

DataStore

type: TModelDataStore...

InstancesToTick

type: TSortedMap< int...


className: DriverType

code: typedef typename ModelDef::Driver DriverType


className: ModelDef

code: typedef InModelDef ModelDef


className: PhysicsState

code: typedef typename ModelDef::PhysicsState PhysicsState


code: virtual void PostNetworkPredictionFrame ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: virtual void PostPhysics()


code: virtual void PostResimulate ( const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


className: UpdatePendingFrame

code: enum { UpdatePendingFrame = !FNetworkPredictionDriver<ModelDef>::HasSimulation() }


code: TPhysicsService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TPhysicsService\ModelDef) > * InDataStore )


className: TPhysicsService

code: template<typename InModelDef> class TPhysicsService : public [IPhysicsService](API\Plugins\NetworkPrediction\Services\IPhysicsService)


code: typedef typename StateTypes::AuxType AuxType


code: virtual void FinalizeFrame ( float DeltaTimeSeconds )


code: typedef typename StateTypes::InputType InputType


code: virtual void EnsureDataInSync ( const TCHAR * ContextStr )


code: typedef typename ModelDef::StateTypes StateTypes


code: typedef typename StateTypes::SyncType SyncType


code: TRemoteFinalizeService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TRemoteFinalizeService\ModelDef) > * InDataStore )


className: TRemoteFinalizeService

code: template<typename InModelDef> class TRemoteFinalizeService : public [IRemoteFinalizeService](API\Plugins\NetworkPrediction\Services\IRemoteFinalizeService)


className: MaxRemoteClientStepMS

code: static constexpr int32 MaxRemoteClientStepMS = 100;


className: MaxRemoteClientStepsPerFrame

code: static constexpr int32 MaxRemoteClientStepsPerFrame = 6;


className: MinRemoteClientStepMS

description: These are rough ballparks, maybe should be configurable.

code: static constexpr int32 MinRemoteClientStepMS = 1;


className: MaxRemoteClientTotalMSPerFrame

code: static constexpr int32 MaxRemoteClientTotalMSPerFrame = 200;


code: typedef InModelDef ModelDef


code: void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: virtual void Tick ( float DeltaTimeSeconds, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * VariableTickState )


code: void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: TRemoteIndependentTickService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TRemoteIndependentTickService\ModelDef) > * InDataStore )


className: TRemoteIndependentTickService

description: Ticking remote clients on the server.

code: template<typename InModelDef> class TRemoteIndependentTickService : public [IRemoteIndependentTickService](API\Plugins\NetworkPrediction\Services\IRemoteIndependentTickService)


code: typedef typename ModelDef::Driver DriverType


className: InputType

code: typedef typename StateTypes::InputType InputType


className: MaxFaultLimit

code: static int32 MaxFaultLimit = 6;


code: virtual void ProduceInput ( int32 DeltaTimeMS )


code: static void SetMaxFaultLimit ( int32 InMaxFaultLimit )


code: typedef typename ModelDef::StateTypes StateTypes


code: TRemoteInputService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TRemoteInputService\ModelDef) > * InDataStore )


className: TRemoteInputService

description: Pulls input from ServerRecvData. E.g: server side input buffering.

code: template<typename InModelDef> class TRemoteInputService : public [IInputService](API\Plugins\NetworkPrediction\Services\IInputService)


description: Data the server receives from a fixed ticking AP client.

code: template<typename ModelDef> struct TServerRecvData_Fixed

LastConsumedFrame

description: Note that these are client frame numbers, they do not match the servers local PendingFrame.


className: FFrame

code: struct FFrame


description: Data the server receives from an independent ticking AP client.

code: template<typename ModelDef> struct TServerRecvData_Independent

TraceID

description: Acceleration data.


code: virtual void CallServerRPC ( float DeltaTimeSeconds )


code: typedef InModelDef ModelDef


code: void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: void UnregisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID )


code: TServerRPCService ( [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\Services\TServerRPCService\ModelDef) > * InDataStore )


className: TServerRPCService

code: template<typename InModelDef> class TServerRPCService : public [IServerRPCService](API\Plugins\NetworkPrediction\Services\IServerRPCService)


code: T * Find ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: T & FindOrAdd ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: T & GetByIndexChecked ( int32 idx )


code: int32 GetIndex ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: int32 GetIndexChecked ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


code: void Remove ( const [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) & ID )


className: TStableInstanceMap

code: template<typename T> struct TStableInstanceMap


className: AuxType

code: typedef typename StateTypes::AuxType AuxType


code: template<typename SimulationType> static [TEnableIf](API\Runtime\Core\Templates\TEnableIf)<!std::is_same_v< SimulationType, void > >::Type DoTick ( [TInstanceData](API\Plugins\NetworkPrediction\Services\TInstanceData)< ModelDef > & Instance, [FrameDataType](API\Plugins\NetworkPrediction\Services\TTickUtil\FrameDataType) & InputFrameData, [FrameDataType](API\Plugins\NetworkPrediction\Services\TTickUtil\FrameDataType) & OutputFrameData, const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const int32 CueTimeMS, [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) TickContext )


code: template<typename SimulationType> static [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same_v< SimulationType, void > >::Type DoTick ( [TInstanceData](API\Plugins\NetworkPrediction\Services\TInstanceData)< ModelDef > & Instance, [FrameDataType](API\Plugins\NetworkPrediction\Services\TTickUtil\FrameDataType) & InputFrameData, [FrameDataType](API\Plugins\NetworkPrediction\Services\TTickUtil\FrameDataType) & OutputFrameData, const [FNetSimTimeStep](API\Plugins\NetworkPrediction\FNetSimTimeStep) & Step, const int32 EndTimeMS, [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) TickContext )


className: FrameDataType

code: typedef typename [TInstanceFrameState](API\Plugins\NetworkPrediction\Services\TInstanceFrameState)< ModelDef >::[FFrame](API\Runtime\CoreUObject\UObject\FFrame) FrameDataType


code: typedef typename StateTypes::InputType InputType


className: StateTypes

code: typedef typename ModelDef::StateTypes StateTypes


className: SyncType

code: typedef typename StateTypes::SyncType SyncType


className: TTickUtil

description: Common util used by the ticking services. Might make sense to move toFNetworkPredictionDriverBaseif needed elsewhere.

code: template<typename ModelDef> struct TTickUtil


className: ReplicationTarget

code: static constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationTarget { ENetSimCueReplicationTarget::All };


className: InvokeMask

code: static constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InvokeMask { ENetSimCueInvoker::All };


className: Resimulate

code: static constexpr bool Resimulate { true };


className: Strong

description: Invoked and replicated to all. NetIdentical testing to avoid double playing, rollbackable so that it can (re)play during resimulates Most expensive (bandwidth/CPU) and requires rollback callbacks to be implemented to be correct. But will always be shown "as correct as possible"

code: struct Strong


code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TInstanceData](API\Plugins\NetworkPrediction\Services\TInstanceData)< ModelDef > & InstanceData, [TClientRecvData](API\Plugins\NetworkPrediction\Services\TClientRecvData)< ModelDef > & ClientRecvState )


code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TInstanceData](API\Plugins\NetworkPrediction\Services\TInstanceData)< ModelDef > & InstanceData, typename [TInstanceFrameState](API\Plugins\NetworkPrediction\Services\TInstanceFrameState)< ModelDef >::[FFrame](API\Runtime\CoreUObject\UObject\FFrame) & FrameData )


description: Where this data comes from differs between Fixed/Independent.

code: template<typename ModelDef> class TCommonReplicator_AP


className: ModelDef

code: typedef InModelDef ModelDef


code: template<typename ClientRecvDataType> static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, ClientRecvDataType & ClientRecvState, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TCommonReplicator_SP\ModelDef) > * DataStore )


code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TCommonReplicator_SP\ModelDef) > * DataStore, [TInstanceData](API\Plugins\NetworkPrediction\Services\TInstanceData)< [ModelDef](API\Plugins\NetworkPrediction\TCommonReplicator_SP\ModelDef) > * InstanceData, int32 PendingFrame )


description: Independent Tick, locally controlled: send total sim time, which comes from the server's local VariableTickState.

code: template<typename InModelDef> class TCommonReplicator_SP


code: void CopyTo ( UnderlyingType * Dest ) const


code: const UnderlyingType * Get() const


code: const UnderlyingType * operator->() const


code: UnderlyingType * operator->()


code: operator UnderlyingType *()


className: Valid

code: enum { Valid = true }


className: TConditionalState

description: TConditionalState< void, UnderlyingType >

code: template<typename TestType, typename UnderlyingType> struct TConditionalState


className: TConditionalState< void, UnderlyingType >::CopyTo

code: void CopyTo &40; void &42; Dest &41; const


className: TConditionalState< void, UnderlyingType >::Get


code: const void &42; Get&40;&41; const


className: TConditionalState< void, UnderlyingType >::operator->

code: const void &42; operator&45;>&40;&41; const


className: TConditionalState< void, UnderlyingType >::operator void *

code: operator void &42;&40;&41; const


code: enum &123; Valid = false &125;


code: template<typename UnderlyingType> struct TConditionalState< void, UnderlyingType >


className: TCueDispatcherTraits

code: template<typename T> struct TCueDispatcherTraits : public [FCueDispatcherTraitsBase](API\Plugins\NetworkPrediction\FCueDispatcherTraitsBase)


code: void Dispatch ( [FSavedCue](API\Plugins\NetworkPrediction\FSavedCue) & SavedCue, TCueHandler & Handler, const int32 & TimeSinceInvocation )


code: static [TCueDispatchTable](API\Plugins\NetworkPrediction\TCueDispatchTable)< TCueHandler > & Get()


description: All types that the receiver can handle must be registered here. This is where we create theTFunctionto call ::HandleCue.

code: template<typename TCue> void RegisterType()


className: Singleton

code: static [TCueDispatchTable](API\Plugins\NetworkPrediction\TCueDispatchTable)< TCueHandler > Singleton;


className: TCueDispatchTable

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

code: template<typename TCueHandler> class TCueDispatchTable


code: typedef InModelDef ModelDef


description: AP Client receives from the server

code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TClientRecvData](API\Plugins\NetworkPrediction\Services\TClientRecvData)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_AP\ModelDef) > & ClientRecvState, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_AP\ModelDef) > * DataStore, [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: static void EatCmd ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P )


code: template<typename InModelDef> class TFixedTickReplicator_AP


description: Server sends to AP client

code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_AP\ModelDef) > * DataStore, const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


className: InputType

code: typedef typename StateTypes::InputType InputType


description: TFixedTickReplicator_Server::NetRecvServer Receiving from AP client

code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TServerRecvData_Fixed](API\Plugins\NetworkPrediction\Services\TServerRecvData_Fixed)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_Server\ModelDef) > & ServerRecvData, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_Server\ModelDef) > * DataStore, [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


description: TFixedTickReplicator_Server::NetSendAP Client sending to server

code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_Server\ModelDef) > * DataStore, [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


className: NumInputsPerSend

code: static int32 NumInputsPerSend = 6;


code: static void SetNumInputsPerSend ( int32 NumToSend )


className: StateTypes

code: typedef typename ModelDef::StateTypes StateTypes


description: The Fixed/Independent ticking implementations are a more than trivially different so they are split into separate implementations. Both currently send the last 'NumInputsPerSend' per serialization, determined from config settings. This could be improved with something more dynamic.

code: template<typename InModelDef> class TFixedTickReplicator_Server


description: SP Client receives from the server

code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TClientRecvData](API\Plugins\NetworkPrediction\Services\TClientRecvData)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_SP\ModelDef) > & ClientRecvState, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_SP\ModelDef) > * DataStore, [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: template<typename InModelDef> class TFixedTickReplicator_SP


description: Server sends to SP Client

code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TFixedTickReplicator_SP\ModelDef) > * DataStore, const [FFixedTickState](API\Plugins\NetworkPrediction\FFixedTickState) * TickState )


code: GENERATE_MEMBER_FUNCTION_CHECK ( NetIdentical, bool, const, const TCue & )


className: Value

code: enum { Value = THasMemberFunction_NetIdentical<TCue>::Value }


className: THasNetIdenticalHelper

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

code: template<typename TCue> struct THasNetIdenticalHelper


code: enum { Value = false }


className: THasNetSimCueTraits

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

code: template<typename T, typename dummy> struct THasNetSimCueTraits


code: typedef InModelDef ModelDef


description: AP Client receives from the server

code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TClientRecvData](API\Plugins\NetworkPrediction\Services\TClientRecvData)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_AP\ModelDef) > & ClientRecvState, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_AP\ModelDef) > * DataStore, [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


description: Server sends to AP client

code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_AP\ModelDef) > * DataStore, [TServerRecvData_Independent](API\Plugins\NetworkPrediction\Services\TServerRecvData_Independent)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_AP\ModelDef) > & ServerRecvData, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * VariableTickState )


code: template<typename InModelDef> class TIndependentTickReplicator_AP


code: typedef typename StateTypes::InputType InputType


description: TIndependentTickReplicator_Server::NetRecvAP Client sending to server

code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TServerRecvData_Independent](API\Plugins\NetworkPrediction\Services\TServerRecvData_Independent)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_Serve-\ModelDef) > & ServerRecvData, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_Serve-\ModelDef) > * DataStore )


code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_Serve-\ModelDef) > * DataStore, [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


code: static int32 NumInputsPerSend = 6;


code: static void SetNumInputsPerSend ( int32 NumToSend )


code: typedef typename ModelDef::StateTypes StateTypes


code: template<typename InModelDef> class TIndependentTickReplicator_Server


description: SP Client receives from the server

code: static void NetRecv ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [TClientRecvData](API\Plugins\NetworkPrediction\Services\TClientRecvData)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_SP\ModelDef) > & ClientRecvState, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_SP\ModelDef) > * DataStore, [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


description: Server sends to SP Client

code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_SP\ModelDef) > * DataStore, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * TickState )


description: For remotely controlled/ticked actors on the server.

code: static void NetSend ( const [FNetSerializeParams](API\Plugins\NetworkPrediction\FNetSerializeParams) & P, [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, [TModelDataStore](API\Plugins\NetworkPrediction\Services\TModelDataStore)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_SP\ModelDef) > * DataStore, const [TServerRecvData_Independent](API\Plugins\NetworkPrediction\Services\TServerRecvData_Independent)< [ModelDef](API\Plugins\NetworkPrediction\TIndependentTickReplicator_SP\ModelDef) > & IndependentTickState, const [FVariableTickState](API\Plugins\NetworkPrediction\FVariableTickState) * VariableTickState )


code: static void NetSend &40; const FNetSerializeParams & P, FNetworkPredictionID ID, TModelDataStore< ModelDef > &42; DataStore, int32 IndependentSimTime, int32 ServerTotalSimTime, int32 PendingFrame &41;


code: template<typename InModelDef> class TIndependentTickReplicator_SP


className: TNetCueNetIdenticalHelper

description: TNetCueNetIdenticalHelper< TCue, true >

code: template<typename TCue, bool Enabled> struct TNetCueNetIdenticalHelper


code: static bool CallNetIdenticalOrNot ( const TCue & Cue, const TCue & Other )


className: TNetCueNetIdenticalHelper< TCue, true >::CallNetIdenticalOrNot

code: static bool CallNetIdenticalOrNot &40; const TCue & Cue, const TCue & Other &41;


className: TNetCueNetIdenticalHelper< TCue, true >

code: template<typename TCue> struct TNetCueNetIdenticalHelper< TCue, true >


code: static void CallNetSerializeOrNot ( TCue & Cue, [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


className: TNetCueNetSerializeHelper

description: TNetCueNetSerializeHelper< TCue, true >

code: template<typename TCue, bool Enabled> struct TNetCueNetSerializeHelper


className: TNetCueNetSerializeHelper< TCue, true >::CallNetSerializeOrNot

code: static void CallNetSerializeOrNot &40; TCue & Cue, FArchive & Ar &41;


className: TNetCueNetSerializeHelper< TCue, true >

code: template<typename TCue> struct TNetCueNetSerializeHelper< TCue, true >


description: Dispatches and prunes saved/transient cues.

code: template<typename T> void DispatchCueRecord ( T & Handler, const int32 SimFrame, const int32 CurrentSimTime, const int32 FixedTimeStepMS )


className: DriverType

code: typedef typename ModelDef::Driver DriverType


code: virtual [FString](API\Runtime\Core\Containers\FString) GetDebugName() const


code: void NetRecvSavedCues ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, const bool bSerializeFrameNumber, const int32 InLastRecvFrame, const int32 InLastRecvTime )


description: Serializes all saved cues bSerializeFrameNumber - whether to serialize Frame# or Time to this target. Frame is more accurate but some cases require time based replication.

code: void NetSendSavedCues ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationMask, bool bSerializeFrameNumber )


description: Tell dispatcher that we've rolled back to a new simulation time (resimulate steps to follow, most likely)

code: void NotifyRollback ( int32 InRollbackFrame )


description: Set which cues we should accept locally (if they get sent to us)

code: void SetReceiveReplicationTarget ( [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) InReplicationMask )


className: TNetSimCueDispatcher

description: 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.

code: template<typename ModelDef> struct TNetSimCueDispatcher : public [FNetSimCueDispatcher](API\Plugins\NetworkPrediction\FNetSimCueDispatcher)

Driver

type: DriverType*...


code: TNetSimCueHandlerAutoRegisterHelper()


code: ~TNetSimCueHandlerAutoRegisterHelper()


className: TNetSimCueHandlerAutoRegisterHelper

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

code: template<typename THandler> struct TNetSimCueHandlerAutoRegisterHelper


className: TNetSimCueSetHandlerAutoRegisterHelper

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

code: template<typename THandler, typename TCueSet> struct TNetSimCueSetHandlerAutoRegisterHelper


className: InvokeMask

code: static constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InvokeMask { Traits::InvokeMask };


className: ReplicationTarget

code: static constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationTarget { Traits::ReplicationTarget };


className: Resimulate

code: static constexpr bool Resimulate { Traits::Resimulate };


code: static constexpr [ESimulationTickContext](API\Plugins\NetworkPrediction\ESimulationTickContext) SimTickMask()


className: Traits

code: typedef typename [TSelectNetSimCueTraits](API\Plugins\NetworkPrediction\TSelectNetSimCueTraits)< TCue >::[Traits](API\Plugins\NetworkPrediction\TNetSimCueTraits\Traits) Traits


className: TNetSimCueTraits

description: Automatically falls back toNetSimCueTraits::Defaultif not explicitly set above

code: template<typename TCue> struct TNetSimCueTraits


description: Who can Invoke this Cue in their simulation (if this test fails, the Invoke call is suppressed locally)

code: static constexpr [ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InvokeMask { InInvokeMask };


description: Does the cue replicate? (from authority). This will also determine if the cue needs to be saved locally for NetIdentical tests (to avoid double playing)

code: static constexpr [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) ReplicationTarget { InReplicationTarget };


description: Whether the cue will be invoked during resimulates (which will require cue to be rollbackable)

code: static constexpr bool Resimulate { InResimulate };


className: TNetSimCueTraitsExplicit

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

code: template<[ENetSimCueInvoker](API\Plugins\NetworkPrediction\ENetSimCueInvoker) InInvokeMask, [ENetSimCueReplicationTarget](API\Plugins\NetworkPrediction\ENetSimCueReplicationTarget) InReplicationTarget, bool InResimulate> struct TNetSimCueTraitsExplicit


code: TNetSimCueTypeAutoRegisterHelper ( const [FString](API\Runtime\Core\Containers\FString) & Name )


code: ~TNetSimCueTypeAutoRegisterHelper()


className: TNetSimCueTypeAutoRegisterHelper

description: Register a cue type with the global table.

code: template<typename TCue> struct TNetSimCueTypeAutoRegisterHelper


className: RequiresNetIdentical

description: Likewise for NetIdentical, but also if we plan to invoke during Resimulate too (even if non replicated, we use NetIdentical for comparisons. though this is probably a non practical use case).

code: enum { RequiresNetIdentical = (TNetSimCueTraits<TCue>::ReplicationTarget != ENetSimCueReplicationTarget::None) || (TNetSimCueTraits<TCue>::Resimulate) }


className: RequiresNetSerialize

description: NetSerialize is required if we ever need to replicate.

code: enum { RequiresNetSerialize = (TNetSimCueTraits<TCue>::ReplicationTarget != ENetSimCueReplicationTarget::None) }


className: TNetSimCueTypeRequirements

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

code: template<typename TCue> struct TNetSimCueTypeRequirements


code: virtual void * CueData() const


code: virtual bool NetIdentical ( const void * OtherCueData ) const


code: virtual void NetSerialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


code: template<typename... ArgsType> TNetSimCueWrapper ( ArgsType &&... Args )


className: TNetSimCueWrapper

code: template<typename TCue> struct TNetSimCueWrapper : public [FNetSimCueWrapperBase](API\Plugins\NetworkPrediction\FNetSimCueWrapperBase)

Instance

type: TCue


className: TNetSimInput

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

code: typedef [TNetworkPredictionState](API\Plugins\NetworkPrediction\TNetworkPredictionState)< StateTypes > TNetSimInput


code: ElementType * Get() const


code: template<typename TLazyWriter> TNetSimLazyWriter ( const TLazyWriter & Parent )


className: TNetSimLazyWriter

code: template<typename ElementType> struct TNetSimLazyWriter

GetFunc

type: TFunctionRef< v...


description: Hack.

code: TNetSimLazyWriterFunc ( void * Data )


code: template<typename TBuffer> TNetSimLazyWriterFunc ( TBuffer & Buffer, int32 PendingFrame )


className: TNetSimLazyWriterFunc

description: Helper struct to encapsulate optional, delayed writing of new element toTNetworkSimAuxBufferbuffer.

code: template<typename ElementType> struct TNetSimLazyWriterFunc

type: TFunction< void...


className: AuxType

code: typedef typename StateType::AuxType AuxType


className: InputType

code: typedef typename StateType::InputType InputType


className: SyncType

code: typedef typename StateType::SyncType SyncType


code: TNetSimOutput ( [SyncType](API\Plugins\NetworkPrediction\TNetSimOutput\SyncType) * InSync, const [TNetSimLazyWriter](API\Plugins\NetworkPrediction\TNetSimLazyWriter)< [AuxType](API\Plugins\NetworkPrediction\TNetSimOutput\AuxType) > & InAux, [FNetSimCueDispatcher](API\Plugins\NetworkPrediction\FNetSimCueDispatcher) & InCueDispatch )


className: TNetSimOutput

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

code: template<typename StateType> struct TNetSimOutput

Aux

type: constTNetSimLa...

CueDispatch

type: FNetSimCueDispa...

Sync

type: SyncType*


className: TNetworkedSimulationState

code: template<typename Model> struct TNetworkedSimulationState


description: Resizes while preserving contents from head position.

code: void Resize ( int32 NewSize, int32 PrevHead )


code: TNetworkPredictionBuffer ( int32 Capacity )


code: [TNetworkPredictionBuffer](API\Plugins\NetworkPrediction\TNetworkPredictionBuffer)< ElementType, SingleElement > & operator= ( [TNetworkPredictionBuffer](API\Plugins\NetworkPrediction\TNetworkPredictionBuffer)< ElementType, SingleElement > && Other )


code: ElementType & operator[] ( int32 Index )


code: const ElementType & operator[] ( int32 Index ) const


code: TNetworkPredictionBuffer ( const [TNetworkPredictionBuffer](API\Plugins\NetworkPrediction\TNetworkPredictionBuffer)< ElementType, SingleElement > && Other )


className: TNetworkPredictionBuffer

description: TNetworkPredictionBuffer< ElementType, true >

code: template<typename ElementType, bool SingleElement> struct TNetworkPredictionBuffer


className: TNetworkPredictionBuffer< ElementType, true >::Capacity

code: int32 Capacity&40;&41; const


className: TNetworkPredictionBuffer< ElementType, true >::operator[]

code: ElementType & operator&91;&93; &40; int32 Index &41;


code: const ElementType & operator&91;&93; &40; int32 Index &41; const


className: TNetworkPredictionBuffer< ElementType, true >::Resize

code: void Resize &40; int32 NewSize, int32 PrevHead &41;


code: template<typename ElementType> struct TNetworkPredictionBuffer< ElementType, true >


code: template<typename ModelDef> struct TNetworkPredictionModelDefRegisterHelper


className: DriverType

code: typedef typename ModelDef::Driver DriverType


className: PhysicsState

code: typedef typename ModelDef::PhysicsState PhysicsState


className: SimulationType

code: typedef typename ModelDef::Simulation SimulationType


className: TNetworkPredictionModelInfo

code: template<typename ModelDef> struct TNetworkPredictionModelInfo

Simulation

type: FConditionalSim...

View

type: FNetworkPredict...


code: TNetworkPredictionModelInfo ( [SimulationType](API\Plugins\NetworkPrediction\TNetworkPredictionModelInfo\SimulationType) * InSimulation, [DriverType](API\Plugins\NetworkPrediction\TNetworkPredictionModelInfo\DriverType) * InDriver, [FNetworkPredictionStateView](API\Plugins\NetworkPrediction\FNetworkPredictionStateView) * InView )


code: typedef typename StateType::AuxType AuxType


code: typedef typename StateType::InputType InputType


code: typedef typename StateType::SyncType SyncType


description: Allows implicit downcasting to a parent simulation's types.

code: template<typename T> TNetworkPredictionState ( const [TNetworkPredictionState](API\Plugins\NetworkPrediction\TNetworkPredictionState)< T > & Other )


code: TNetworkPredictionState ( const [InputType](API\Plugins\NetworkPrediction\TNetworkPredictionState\InputType) * InInputCmd, const [SyncType](API\Plugins\NetworkPrediction\TNetworkPredictionState\SyncType) * InSync, const [AuxType](API\Plugins\NetworkPrediction\TNetworkPredictionState\AuxType) * InAux )


className: TNetworkPredictionState

description: Tuple of state types.

code: template<typename StateType> struct TNetworkPredictionState

Aux

type: constAuxType&...

Cmd

type: constInputType...

Sync

type: constSyncType...


code: typedef InAuxState AuxType


code: typedef InInputCmd InputType


code: typedef InSyncState SyncType


className: TNetworkPredictionStateTypes

description: State type defines.

code: template<typename InInputCmd, typename InSyncState, typename InAuxState> struct TNetworkPredictionStateTypes


code: [TNetSimLazyWriterFunc](API\Plugins\NetworkPrediction\TNetSimLazyWriterFunc)< ElementType > LazyWriter ( int32 Frame )


code: ElementType * operator[] ( int32 Frame )


code: const ElementType * operator[] ( int32 Frame ) const


code: void Resize ( int32 NewSize )


description: Writes a new element at Frame. Copies previous frames contents into new element.

code: ElementType * WriteAtFrame ( int32 Frame )


code: TNetworkSimAuxBuffer ( int32 Capacity )


className: TNetworkSimAuxBuffer

description: Sparse buffer: each element has explicit Frame value.

code: template<typename ElementType> struct TNetworkSimAuxBuffer


className: Traits

code: typedef typename T::Traits Traits


className: TSelectNetSimCueTraits

description: TSelectNetSimCueTraits< T, false >

code: template<typename T, bool HasTraits> struct TSelectNetSimCueTraits


code: typedef NetSimCueTraits::Default Traits


className: TSelectNetSimCueTraits< T, false >

description: Fall back to Default traits.

code: template<typename T> struct TSelectNetSimCueTraits< T, false >


className: WithIdentical

code: enum &123; WithIdentical = true &125;


className: WithNetSerializer

code: enum &123; WithNetSerializer = true &125;


code: template<> struct TStructOpsTypeTraits< FNetworkPredictionProxy > : public [TStructOpsTypeTraitsBase2< FNetworkPredictionProxy >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


code: template<> struct TStructOpsTypeTraits< FReplicationProxy > : public [TStructOpsTypeTraitsBase2< FReplicationProxy >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


code: template<> struct TStructOpsTypeTraits< FServerReplicationRPCParameter > : public [TStructOpsTypeTraitsBase2< FServerReplicationRPCParameter >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


className: AuxType

code: typedef typename StateType::AuxType AuxType


className: SyncType

code: typedef typename StateType::SyncType SyncType


code: template<typename T> TSyncAuxPair ( const [TSyncAuxPair](API\Plugins\NetworkPrediction\TSyncAuxPair)< T > & Other )


code: TSyncAuxPair ( const [SyncType](API\Plugins\NetworkPrediction\TSyncAuxPair\SyncType) * InSync, const [AuxType](API\Plugins\NetworkPrediction\TSyncAuxPair\AuxType) * InAux )


className: TSyncAuxPair

description: Just the Sync/Aux pair.

code: template<typename StateType> struct TSyncAuxPair


className: TToVoid

description: NetSimCue Traits template helpers

code: template<typename T> struct TToVoid


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::bFutureInputsAuto ( TEXT("np2.FutureInputs"), (int32) 0, TEXT("Enable FutureInputs feature") ) }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::bFutureInputs() }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::bInputDecay() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::bInputDecayAuto ( TEXT("np2.InputDecay"), (int32) 0, TEXT("Enable Input Decay Feature") ) }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::DampYawVelocityKAuto ( TEXT("np2.Mock.DampYawVelocityK"), (float) 2. f, TEXT("Coefficient for damping angular velocity in yaw direction only. This is only enabled when auto target yaw is disabled.") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::DampYawVelocityK() }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::DragK() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::DragKAuto ( TEXT("np2.Mock.DragK"), (float) 1. 12f, TEXT("Drag Coefficient (higher=more drag)") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::InputDecayRate() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::InputDecayRateAuto ( TEXT("np2.InputDecayRate"), (float) 0. 99f, TEXT("Rate of input decay") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::JumpForce() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::JumpForceAuto ( TEXT("np2.Mock.JumpForce"), (float) 70, TEXT("Per-Frame force to apply while jumping.") ) }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::JumpFrameDuration() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::JumpFrameDurationAuto ( TEXT("np2.Mock.JumpFrameDuration"), (int32) 4, TEXT("How many frames to apply jump force for") ) }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::JumpFudgeFramesAuto ( TEXT("np2.Mock.JumpFudgeFrames"), (int32) 10, TEXT("How many frames after being in air do we still allow a jump to begin") ) }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::JumpFudgeFrames() }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::JumpHack() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::JumpHackAuto ( TEXT("np2.Mock.JumpHack"), (int32) 0, TEXT("Make jump not rely on trace which currently causes non determinism") ) }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::JumpMisPredictAuto ( TEXT("np2.Mock.JumpMisPredict"), (int32) 0, TEXT("Make jump do random impulse which will cause a misprediction") ) }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::JumpMisPredict() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::MaxAngularVelocityAuto ( TEXT("np2.Mock.MaxAngularVelocity"), (float) 30. f, TEXT("Limits how fast character can possibly rotate.") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::MaxAngularVelocity() }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::MockDebug() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::MockDebugAuto ( TEXT("np2.Mock.MockDebug"), (int32) 0, TEXT("Enabled spammy log debugging of mock physics object state") ) }


code: namespace UE_NETWORK_PHYSICS { int32 UE_NETWORK_PHYSICS::MockImpulse() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::MockImpulseAuto ( TEXT("np2.Mock.BallImpulse"), (int32) 1, TEXT("Make jump not rely on trace which currently causes non determinism") ) }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::MockImpulseXAuto ( TEXT("np2.Mock.BallImpulse.X"), (float) 500. 0f, TEXT("X magnitude") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::MockImpulseX() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::MockImpulseZAuto ( TEXT("np2.Mock.BallImpulse.Z"), (float) 300. 0f, TEXT("Z magnitude") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::MockImpulseZ() }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::MovementK() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::MovementKAuto ( TEXT("np2.Mock.MovementK"), (float) 1. 25, TEXT("Movement Coefficient (higher=faster movement)") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::RotationK() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::RotationKAuto ( TEXT("np2.Mock.RotationK"), (float) 1. 25, TEXT("Rotation Coefficient (higher=faster movement)") ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetbFutureInputs ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetbInputDecay ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetDampYawVelocityK ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetDragK ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetInputDecayRate ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetJumpForce ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetJumpFudgeFrames ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetJumpFrameDuration ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetJumpHack ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetJumpMisPredict ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetMaxAngularVelocity ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetMockDebug ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetMockImpulse ( int32 _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetMockImpulseX ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetMockImpulseZ ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetMovementK ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetRotationK ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetTurnDampK ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { void UE_NETWORK_PHYSICS::SetTurnK ( float _V ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::TurnDampK() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::TurnDampKAuto ( TEXT("np2.Mock.TurnDampK"), (float) 100. f, TEXT("Coefficient for damping portion of turn. Higher=more damping but too higher will lead to instability.") ) }


code: namespace UE_NETWORK_PHYSICS { float UE_NETWORK_PHYSICS::TurnK() }


code: namespace UE_NETWORK_PHYSICS { static [FConditionalAutoConsoleRegister](API\Plugins\NetworkPrediction\FConditionalAutoConsoleRegister) UE_NETWORK_PHYSICS::TurnKAuto ( TEXT("np2.Mock.TurnK"), (float) 100000000. f, TEXT("Coefficient for automatic turning (higher=quicker turning)") ) }


description: Invoke the ServerRPC, called fromUNetworkPredictionWorldManagervia theTServerRPCService.

code: void CallServerRPC()


description: Helper: Checks if the owner's role has changed and calls InitializeForNetworkRole if necessary.

code: bool CheckOwnerRoleChange()


description: Ends gameplay for this component. Called fromAActor::EndPlayonly if bHasBegunPlay is true

code: virtual void EndPlay ( const [EEndPlayReason::Type](API\Runtime\Engine\Engine\EEndPlayReason__Type) EndPlayReason )


description: Initializes the component. Occurs at level startup or actor spawn. This is before BeginPlay (Actor or Component). All Components in the level will be Initialized on load before any Actor/Component gets BeginPlay Requires component to be registered, and bWantsInitializeComponent to be true.

code: virtual void InitializeComponent()


description: Finalizes initialization when NetworkRole changes. Does not need to be overridden.

code: virtual void InitializeForNetworkRole ( ENetRole Role, const bool bHasNetConnection )


description: Classes must initialize the NetworkPredictionProxy (register with the NetworkPredictionSystem) here. EndPlay will unregister.


description: Called right before receiving a bunch

code: virtual void PreNetReceive()


description: Called on the component right before replication occurs

code: virtual void PreReplication ( [IRepChangedPropertyTracker](API\Runtime\CoreUObject\UObject\IRepChangedPropertyTracker) & ChangedPropertyTracker )


description: The actual ServerRPC. This needs to be a UFUNCTION but is generic and not dependent on the simulation instance.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(Server, Unreliable, WithValidation) void ServerReceiveClientInput ( const [FServerReplicationRPCParameter](API\Plugins\NetworkPrediction\FServerReplicationRPCParameter) & ProxyParameter )


code: UNetworkPredictionComponent()


className: UNetworkPredictionComponent

description: Its also worth pointing out that nothing about being aUActorComponentis essential here. All that this component does could be done within anAActoritself. An actor component makes sense for flexible/reusable code provided by the plugin. But there is nothing stopping you from copying this directly into an actor if you had reason to.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class UNetworkPredictionComponent : public [UActorComponent](API\Runtime\Engine\Components\UActorComponent)

NetworkPredictionProxy

description: Proxy to interface with the NetworkPrediction system.

type: FReplicationPro...

description: ReplicationProxies are just pointers to the data/NetSerialize functions within the NetworkSim.


code: virtual void SetPrimitiveComponent ( [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * NewUpdatedComponent )


code: UNetworkPredictionPhysicsComponent()


className: UNetworkPredictionPhysicsComponent

description: Even then, it is just sort of an example. An extra component may not be the best way to use this. It may make more sense to just put the important bits on your actor class and set the exact UpdatedPrimitive you want (really PhysicsActorHandle is all that matters!)

PhysicsActorHandle

type: FPhysicsActorHa...

UpdatedPrimitive

type: TObjectPtr<UPr...


description: Called when a property on this object has been modified externally

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


className: UNetworkPredictionSettingsObject

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Config=NetworkPrediction, defaultconfig, Meta=(DisplayName="Network Prediction")) class UNetworkPredictionSettingsObject : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

DevHUDs

type: TArray<FNetwor...


className: ActiveInstance

code: static [UNetworkPredictionWorldManager](API\Plugins\NetworkPrediction\UNetworkPredictionWorldManager) * ActiveInstance =nullptr;


description: Is the engine currently setup to fix tick physics.

code: bool CanPhysicsFixTick() const


description: This is the function that takes the config and current network state (role/connection) and subscribes to the appropriate internal NetworkPrediction services.

code: template<typename ModelDef> void ConfigureInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, const [FNetworkPredictionInstanceArchetype](API\Plugins\NetworkPrediction\FNetworkPredictionInstanceArchet-) & Archetype, const [FNetworkPredictionInstanceConfig](API\Plugins\NetworkPrediction\FNetworkPredictionInstanceConfig) & Config, [FReplicationProxySet](API\Plugins\NetworkPrediction\FReplicationProxySet) RepProxies, ENetRole Role, bool bHasNetConnection )


description: Returns unique ID for a new simulation instance regardless of type. Clients set bForClient to get a negative, temp ID to use until server version comes in

code: [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) CreateSimulationID ( const bool bForClient )


description: Implement this for deinitialization of instances of the system

code: virtual void Deinitialize()


code: const [FNetworkPredictionSettings](API\Plugins\NetworkPrediction\FNetworkPredictionSettings) & GetSettings() const


description: Subsystem Init/Deinit.

code: virtual void Initialize ( [FSubsystemCollectionBase](API\Runtime\Engine\Subsystems\FSubsystemCollectionBase) & Collection )


code: template<typename ModelDef> void RegisterInstance ( [FNetworkPredictionID](API\Plugins\NetworkPrediction\FNetworkPredictionID) ID, const [TNetworkPredictionModelInfo](API\Plugins\NetworkPrediction\TNetworkPredictionModelInfo)< ModelDef > & ModelInfo )


className: FOnHandleDeferredServiceConfig

description: Callbacks to change subscribed services, that couldn't be made inline.

code: typedef TMulticastDelegate_OneParam< void, [UNetworkPredictionWorldManager](API\Plugins\NetworkPrediction\UNetworkPredictionWorldManager) * > FOnHandleDeferredServiceConfig