NetDriver.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
//
// Base class of a network driver attached to an active or pending level.
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/EngineBaseTypes.h"
#include "Engine/EngineTypes.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "Net/NetworkMetricsDatabase.h"
#endif
#include "HAL/IConsoleManager.h"
#include "Math/RandomStream.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/Object.h"
#include "UObject/ObjectKey.h"
#include "Misc/NetworkGuid.h"
#include "UObject/CoreNet.h"
#include "Channel.h"
#include "Net/Core/Connection/ConnectionHandle.h"
#include "Net/Core/Misc/DDoSDetection.h"
#include "IPAddress.h"
#include "Net/NetAnalyticsTypes.h"
#include "Net/NetConnectionIdHandler.h"
#include "HAL/LowLevelMemTracker.h"
#include "Templates/PimplPtr.h"
#include "NetDriver.generated.h"
 
LLM_DECLARE_TAG_API(NetDriver, ENGINE_API);
 
class Error;
class FNetGUIDCache;
struct FNetSyncLoadReport;
class FNetworkNotify;
class FNetworkObjectList;
class FObjectReplicator;
class FRepChangedPropertyTracker;
class FRepLayout;
class FReplicationChangelistMgr;
class FVoicePacket;
class StatelessConnectHandlerComponent;
class UNetConnection;
class UNetworkMetricsDatabase;
class UNetworkMetricsBaseListener;
class UReplicationDriver;
struct FNetworkObjectInfo;
class UChannel;
class IAnalyticsProvider;
class FNetAnalyticsAggregator;
class UNetDriver;
class UActorChannel;
class PacketHandler;
struct FReplicatedStaticActorDestructionInfo;
 
enum class ECreateReplicationChangelistMgrFlags;
enum class EEngineNetworkRuntimeFeatures : uint16;
class UReplicationSystem;
namespace UE::Net
{
    class FNetObjectGroupHandle;
}
 
namespace UE::Net
{
    class FNetTokenStore;
    class FNetIDVariant;
    struct FServerReplicateActors_ForConnectionParams;
 
    class FScopedIgnoreStaticActorDestruction
    {
    public:
        FScopedIgnoreStaticActorDestruction();
        ~FScopedIgnoreStaticActorDestruction();
 
        UE_NONCOPYABLE(FScopedIgnoreStaticActorDestruction);
 
    private:
        bool bCachedValue = false;
    };
 
    bool ShouldIgnoreStaticActorDestruction();
 
    ENGINE_API uint32 CountReplicatedSubObjectsOfActor(AActor* ReplicatedActor);
}
 
using FConnectionMap = TMap<TSharedRef<const FInternetAddr>, TObjectPtr<UNetConnection>, FDefaultSetAllocator, FInternetAddrConstKeyMapFuncs<TObjectPtr<UNetConnection>>>;
 
extern ENGINE_API TAutoConsoleVariable<int32> CVarNetAllowEncryption;
extern ENGINE_API int32 GNumSaturatedConnections;
extern ENGINE_API int32 GNumSharedSerializationHit;
extern ENGINE_API int32 GNumSharedSerializationMiss;
extern ENGINE_API int32 GNumReplicateActorCalls;
extern ENGINE_API bool GReplicateActorTimingEnabled;
extern ENGINE_API bool GReceiveRPCTimingEnabled;
extern ENGINE_API double GReplicateActorTimeSeconds;
extern ENGINE_API uint32 GNetOutBytes;
extern ENGINE_API double GReplicationGatherPrioritizeTimeSeconds;
extern ENGINE_API double GServerReplicateActorTimeSeconds;
extern ENGINE_API int32 GNumClientConnections;
extern ENGINE_API int32 GNumClientUpdateLevelVisibility;
 
namespace UE::Net::Private
{
    extern int32 SerializeNewActorOverrideLevel;
}
 
// Delegates
 
#if !UE_BUILD_SHIPPING
DECLARE_DELEGATE_SevenParams(FOnSendRPC, AActor* /*Actor*/, UFunction* /*Function*/, void* /*Parameters*/,
                                    FOutParmRec* /*OutParms*/, FFrame* /*Stack*/, UObject* /*SubObject*/, bool& /*bBlockSendRPC*/);
 
DECLARE_DELEGATE_RetVal(bool, FShouldSkipRepNotifies);
 
#endif
 
struct ConsiderListUpdateParams
{
    float DeltaSeconds = 0;
    UNetConnection* Connection = nullptr;
    bool bCPUSaturated = false;
};
 
DECLARE_DELEGATE_ThreeParams(FOnConsiderListUpdate, const ConsiderListUpdateParams& UpdateParams, int32& OutUpdated, const TArray<FNetworkObjectInfo*>& ConsiderList);
 
//
// Whether to support net lag and packet loss testing.
//
#define DO_ENABLE_NET_TEST !(UE_BUILD_SHIPPING)
 
#ifndef NET_DEBUG_RELEVANT_ACTORS
#define NET_DEBUG_RELEVANT_ACTORS !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
#endif 
 
USTRUCT()
struct FPacketSimulationSettings
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category="Simulation Settings")
    int32   PktLoss = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktLossMaxSize = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktLossMinSize = 0;
 
    UPROPERTY(EditAnywhere, Category="Simulation Settings")
    int32   PktOrder = 0;
 
    UPROPERTY(EditAnywhere, Category="Simulation Settings")
    int32   PktDup = 0;
    
    UPROPERTY(EditAnywhere, Category="Simulation Settings")
    int32   PktLag = 0;
    
    UPROPERTY(EditAnywhere, Category="Simulation Settings")
    int32   PktLagVariance = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktLagMin = 0;
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktLagMax = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktIncomingLagMin = 0;
    
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktIncomingLagMax = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktIncomingLoss = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktJitter = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktFrameDelay = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32   PktIncomingFrameDelay = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32 PktBufferBloatInMS = 0;
 
    UPROPERTY(EditAnywhere, Category = "Simulation Settings")
    int32 PktIncomingBufferBloatInMS = 0;
 
    ENGINE_API void LoadConfig(const TCHAR* OptionalQualifier = nullptr);
    
    ENGINE_API bool LoadEmulationProfile(const TCHAR* ProfileName);
 
    ENGINE_API void ApplySettings(const FPacketSimulationSettings& NewSettings);
 
    ENGINE_API void ValidateSettings();
    ENGINE_API void ResetSettings();
 
    bool ShouldDropPacketOfSize(int32 NumBits) const
    {
        const bool bIsBigEnough = NumBits > PktLossMinSize * 8;
        const bool bIsSmallEnough = PktLossMaxSize == 0 || NumBits < PktLossMaxSize * 8;
        return bIsBigEnough && bIsSmallEnough;
    }
 
    ENGINE_API bool ParseSettings(const TCHAR* Stream, const TCHAR* OptionalQualifier=nullptr);
 
    ENGINE_API bool ParseHelper(const TCHAR* Cmd, const TCHAR* Name, int32& Value, const TCHAR* OptionalQualifier);
 
    ENGINE_API bool ConfigHelperInt(const TCHAR* Name, int32& Value, const TCHAR* OptionalQualifier);
    ENGINE_API bool ConfigHelperBool(const TCHAR* Name, bool& Value, const TCHAR* OptionalQualifier);
};
 
struct FActorDestructionInfo
{
public:
    FActorDestructionInfo()
        : Reason(EChannelCloseReason::Destroyed)
        , bIgnoreDistanceCulling(false) 
    {}
 
    TWeakObjectPtr<ULevel> Level; 
    TWeakObjectPtr<UObject> ObjOuter;
    FVector DestroyedPosition;
    FNetworkGUID NetGUID;
    FString PathName;
    FName StreamingLevelName;
    EChannelCloseReason Reason;
 
    bool bIgnoreDistanceCulling;
 
    void CountBytes(FArchive& Ar)
    {
        PathName.CountBytes(Ar);
    }
};
 
USTRUCT()
struct FNetDriverReplicationSystemConfig
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    uint32 MaxReplicatedObjectCount = 0;
 
    UPROPERTY()
    uint32 InitialNetObjectListCount = 0;
 
    UPROPERTY()
    uint32 NetObjectListGrowCount = 0;
 
    UPROPERTY()
    uint32 PreAllocatedMemoryBuffersObjectCount = 0;
 
    UPROPERTY()
    uint32 MaxReplicationWriterObjectCount = 0;
    
    UPROPERTY()
    uint32 MaxDeltaCompressedObjectCount = 0;
    
    UPROPERTY()
    uint32 MaxNetObjectGroupCount = 0;
 
    UPROPERTY()
    bool bAllowParallelTasks = false;   
};
 
//
// Priority sortable list.
//
struct FActorPriority
{
    int32                       Priority;   // Update priority, higher = more important.
    
    FNetworkObjectInfo*         ActorInfo;  // Actor info.
    UActorChannel*              Channel;    // Actor channel.
 
    FActorDestructionInfo * DestructionInfo;    // Destroy an actor
 
    FActorPriority() : 
        Priority(0), ActorInfo(NULL), Channel(NULL), DestructionInfo(NULL)
    {}
 
    ENGINE_API FActorPriority(class UNetConnection* InConnection, UActorChannel* InChannel, FNetworkObjectInfo* InActorInfo, const TArray<struct FNetViewer>& Viewers, bool bLowBandwidth);
    ENGINE_API FActorPriority(class UNetConnection* InConnection, FActorDestructionInfo * DestructInfo, const TArray<struct FNetViewer>& Viewers );
};
 
struct FCompareFActorPriority
{
    inline bool operator()( const FActorPriority& A, const FActorPriority& B ) const
    {
        return B.Priority < A.Priority;
    }
};
 
USTRUCT()
struct FChannelDefinition
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName ChannelName;          // Channel type identifier
 
    UPROPERTY()
    FName ClassName;            // UClass name used to create the UChannel
 
    UPROPERTY()
    TObjectPtr<UClass> ChannelClass;        // UClass used to create the UChannel
 
    UPROPERTY()
    int32 StaticChannelIndex;   // Channel always uses this index, INDEX_NONE if dynamically chosen
 
    UPROPERTY()
    uint8 bTickOnCreate : 1;            // Whether to immediately begin ticking the channel after creation
 
    UPROPERTY()
    uint8 bServerOpen : 1;          // Channel opened by the server
 
    UPROPERTY()
    uint8 bClientOpen : 1;          // Channel opened by the client
 
    UPROPERTY()
    uint8 bInitialServer : 1;       // Channel created on server when connection is established
 
    UPROPERTY()
    uint8 bInitialClient : 1;       // Channel created on client before connecting
 
    FChannelDefinition() : 
        ChannelName(NAME_None),
        ClassName(NAME_None),
        ChannelClass(nullptr),
        StaticChannelIndex(INDEX_NONE),
        bTickOnCreate(false),
        bServerOpen(false),
        bClientOpen(false),
        bInitialServer(false),
        bInitialClient(false)
    {
    }
};
 
struct FDisconnectedClient
{
    TSharedRef<const FInternetAddr> Address;
 
    double                      DisconnectTime;
 
    FDisconnectedClient(TSharedRef<const FInternetAddr>& InAddress, double InDisconnectTime)
        : Address(InAddress)
        , DisconnectTime(InDisconnectTime)
    {
    }
};
 
enum class EProcessRemoteFunctionFlags : uint32
{
    None = 0,
    ReplicatedActor = 1 << 0,   
};
ENUM_CLASS_FLAGS(EProcessRemoteFunctionFlags);
 
UCLASS(Abstract, customConstructor, transient, MinimalAPI, config=Engine)
class UNetDriver : public UObject, public FExec
{
    GENERATED_UCLASS_BODY()
 
protected:
 
    virtual ENGINE_API void InternalProcessRemoteFunction(
        class AActor* Actor,
        class UObject* SubObject,
        class UNetConnection* Connection,
        class UFunction* Function,
        void* Parms,
        FOutParmRec* OutParms,
        FFrame* Stack,
        bool bIsServer);
 
private:
 
    void InternalProcessRemoteFunctionPrivate(
        class AActor* Actor,
        class UObject* SubObject,
        class UNetConnection* Connection,
        class UFunction* Function,
        void* Parms,
        FOutParmRec* OutParms,
        FFrame* Stack,
        const bool bIsServer,
        EProcessRemoteFunctionFlags& RemoteFunctionFlags);
 
public:
 
    ENGINE_API virtual ~UNetDriver();
 
    UPROPERTY(Config)
    FString NetConnectionClassName;
 
    UPROPERTY(Config)
    FString ReplicationDriverClassName;
 
    UPROPERTY(Config)
    FString ReplicationBridgeClassName;
    
    UPROPERTY(Config)
    FNetDriverReplicationSystemConfig ReplicationSystemConfigServer;
 
    UPROPERTY(Config)
    FNetDriverReplicationSystemConfig ReplicationSystemConfigClient;
 
    UPROPERTY(Config)
    int32 MaxDownloadSize;
 
    UPROPERTY(Config)
    uint32 bClampListenServerTickRate:1;
 
    UE_DEPRECATED(5.3, "Variable will be made private. Use GetNetServerMaxTickRate and SetNetServerMaxTickRate instead.")
    UPROPERTY(Config)
    int32 NetServerMaxTickRate;
 
    int32 GetNetServerMaxTickRate() const 
    { 
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return NetServerMaxTickRate;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    ENGINE_API void SetNetServerMaxTickRate(int32 InServerMaxTickRate);
 
    void TryUpgradeNetworkFeatures(EEngineNetworkRuntimeFeatures RemoteFeatures);
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnNetServerMaxTickRateChanged, UNetDriver*, int32, int32);
    FOnNetServerMaxTickRateChanged OnNetServerMaxTickRateChanged;
 
    UPROPERTY(Config)
    int32 MaxNetTickRate;
 
    UPROPERTY(Config)
    int32 MaxInternetClientRate;
 
    UPROPERTY(Config)
    int32 MaxClientRate;
 
    UPROPERTY(Config)
    float ServerTravelPause;
 
    UPROPERTY(Config)
    float SpawnPrioritySeconds;
 
    UPROPERTY(Config)
    float RelevantTimeout;
 
    UPROPERTY(Config)
    float KeepAliveTime;
 
    UPROPERTY(Config)
    float InitialConnectTimeout;
 
    UPROPERTY(Config)
    float ConnectionTimeout;
 
    UPROPERTY(Config)
    float GracefulCloseConnectionTimeout = 2.0f;
 
    UPROPERTY(Config)
    float TimeoutMultiplierForUnoptimizedBuilds;
 
    UPROPERTY()
    TObjectPtr<class UNetConnection> ServerConnection;
 
    UPROPERTY()
    TArray<TObjectPtr<UNetConnection>> ClientConnections;
 
    FConnectionMap MappedClientConnections;
 
    TArray<FDisconnectedClient> RecentlyDisconnectedClients;
 
    UPROPERTY(Config)
    int32 RecentlyDisconnectedTrackingTime;
 
 
    TUniquePtr<PacketHandler> ConnectionlessHandler;
 
    TWeakPtr<StatelessConnectHandlerComponent> StatelessConnectComponent;
 
    TSharedPtr<IAnalyticsProvider> AnalyticsProvider;
 
    TSharedPtr<FNetAnalyticsAggregator> AnalyticsAggregator;
 
    UPROPERTY()
    TObjectPtr<class UWorld> World;
 
    UPROPERTY()
    TObjectPtr<class UPackage> WorldPackage;
 
    //UE_DEPRECATED(5.6, "Variable will be made private. Use GetNetGuidCache() methods instead.")
    TSharedPtr<class FNetGUIDCache> GuidCache;
 
    TSharedPtr< class FClassNetCacheMgr >   NetCache;
 
    UPROPERTY()
    TObjectPtr<UClass> NetConnectionClass;
 
    UPROPERTY()
    TObjectPtr<UClass> ChildNetConnectionClass;
 
    UPROPERTY()
    TObjectPtr<UClass> ReplicationDriverClass;
 
    UPROPERTY(transient)
    TObjectPtr<UClass> ReplicationBridgeClass;
 
    FProperty* RoleProperty;
    
    FProperty* RemoteRoleProperty;
 
    UPROPERTY(Config)
    FName NetDriverName;
 
    UPROPERTY(Config)
    TArray<FChannelDefinition> ChannelDefinitions;
 
    UPROPERTY()
    TMap<FName, FChannelDefinition> ChannelDefinitionMap;
 
    inline bool IsKnownChannelName(const FName& ChName) const
    {
        return ChannelDefinitionMap.Contains(ChName);
    }
 
    ENGINE_API void CreateInitialClientChannels();
 
    ENGINE_API void CreateInitialServerChannels(UNetConnection* ClientConnection);
    
    ENGINE_API void AddObjectToNetworkIdCache(UObject* Object);
 
    ENGINE_API void RemoveObjectFromNetworkIdCache(UObject* Object);
 
protected:
    ENGINE_API virtual void SetupNetworkMetrics();
 
private:
 
    UPROPERTY()
    TArray<TObjectPtr<UChannel>> ActorChannelPool;
 
    FName NetDriverDefinition;
 
    int32 MaxChannelsOverride;
 
    UPROPERTY()
    TObjectPtr<UNetworkMetricsDatabase> NetworkMetricsDatabase;
 
    UPROPERTY()
    TMap<FName, TObjectPtr<UNetworkMetricsBaseListener>> NetworkMetricsListeners;
 
    void SetupNetworkMetricsListeners(bool bIsClient);
 
    void RegisterStatsListener(const FName MetricName, const FName StatName);
 
    void ResetNetworkMetrics();
 
public:
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnNetUpdateFrequencyChanged, const AActor* Actor);
    FOnNetUpdateFrequencyChanged& GetOnNetUpdateFrequencyChanged() { return OnNetUpdateFrequencyChanged; };
 
private:
    FOnNetUpdateFrequencyChanged OnNetUpdateFrequencyChanged;
 
public:
    int32 GetMaxChannelsOverride() const { return MaxChannelsOverride; }
 
    UChannel* GetOrCreateChannelByName(const FName& ChName);
 
    void ReleaseToChannelPool(UChannel* Channel);
 
    void SetNetDriverName(FName NewNetDriverNamed);
 
    void SetNetDriverDefinition(FName NewNetDriverDefinition);
 
    FName GetNetDriverDefinition() const { return NetDriverDefinition; }
 
    ENGINE_API void PostCreation(bool bInitializeWithIris);
 
    ENGINE_API void ReinitBase();
 
    void InitPacketSimulationSettings();
 
#if DO_ENABLE_NET_TEST
    bool IsSimulatingPacketLossBurst() const;
#endif
 
    class FNetworkNotify*       Notify;
    
    double GetElapsedTime() const { return ElapsedTime; }
    void ResetElapsedTime() { ElapsedTime = 0.0; }
 
    ENGINE_API void RequestNetDriverDestruction();
 
    bool IsInTick() const { return bInTick; }
 
    bool GetPendingDestruction() const { return bPendingDestruction; }
 
    UE_DEPRECATED(5.6, "SetPendingDestruction will be made private. Use RequestNetDriverDestruction instead")
    ENGINE_API void SetPendingDestruction(bool bDestroy);
 
    const TSharedPtr<class FNetGUIDCache>& GetNetGuidCache() const
    {
        // Disabled until we have addressed the issues found.
        //ensureMsgf(!IsUsingIrisReplication(), TEXT("Using NetGuidCache/FNetworkGUIDs is not supported when using Iris replication."));
    
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GuidCache;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    TSharedPtr<class FNetGUIDCache>& GetNetGuidCache()
    {
        // Disabled until we have addressed the issues found.
        //ensureMsgf(!IsUsingIrisReplication(), TEXT("Using NetGuidCache/FNetworkGUIDs is not supported using Iris replication."));
    
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GuidCache;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
private:
 
    double ElapsedTime;
 
    bool bInTick;
 
    uint8 bPendingDestruction : 1;
 
#if DO_ENABLE_NET_TEST
    uint8 bForcedPacketSettings : 1;
#endif 
 
    uint8 bDidHitchLastFrame : 1;
 
    uint8 bHasReplayConnection : 1;
 
protected:
    uint8 bMaySendProperties : 1;
 
    uint8 bSkipServerReplicateActors : 1;
 
    uint8 bSkipClearVoicePackets : 1;
 
public:
    UPROPERTY(Config)
    uint8 bNoTimeouts : 1;
 
    UPROPERTY(Config)
    uint8 bNeverApplyNetworkEmulationSettings : 1;
 
    uint8                       bIsPeer : 1;
    uint8                       ProfileStats : 1;
    uint8                       bSkipLocalStats : 1;
    uint8 bCollectNetStats : 1;
    uint8                       bIsStandbyCheckingEnabled : 1;
    uint8                       bHasStandbyCheatTriggered : 1;
 
    double                      LastTickDispatchRealtime;
    int32                       SendCycles;
    uint32                      InBytesPerSecond;
    uint32                      OutBytesPerSecond;
    uint32                      InBytes;
    uint32                      InTotalBytes;
    uint32                      OutBytes;
    uint32                      OutTotalBytes;
    uint32                      NetGUIDOutBytes;
    uint32                      NetGUIDInBytes;
    uint32                      InPackets;
    uint32                      PrevInPackets;
    uint32                      InTotalPackets;
    uint32                      OutPackets;
    uint32                      PrevOutPackets;
    uint32                      OutTotalPackets;
    uint32                      InBunches;
    uint32                      OutBunches;
    uint32                      InTotalBunches;
    uint32                      OutTotalBunches;
    uint32                      OutTotalReliableBunches;
    uint32                      InTotalReliableBunches;
    uint32                      InPacketsLost;
    uint32                      PrevInPacketsLost;
    uint32                      InTotalPacketsLost;
    uint32                      OutPacketsLost;
    uint32                      PrevOutPacketsLost;
    uint32                      OutTotalPacketsLost;
    uint32                      VoicePacketsSent;
    uint32                      VoiceBytesSent;
    uint32                      VoicePacketsRecv;
    uint32                      VoiceBytesRecv;
    uint32                      VoiceInPercent;
    uint32                      VoiceOutPercent;
    double                      StatUpdateTime;
    float                       StatPeriod;
    uint32                      TotalRPCsCalled;
    uint32                      OutTotalAcks;
 
    double                      LastCleanupTime;
    float                       StandbyRxCheatTime;
    float                       StandbyTxCheatTime;
    int32                       BadPingThreshold;
    float                       PercentMissingForRxStandby;
    float                       PercentMissingForTxStandby;
    float                       PercentForBadPing;
    float                       JoinInProgressStandbyWaitTime;
    int32                       NetTag;
 
#if NET_DEBUG_RELEVANT_ACTORS
    bool                        DebugRelevantActors;
 
    TArray< TWeakObjectPtr<AActor> >    LastPrioritizedActors;
    TArray< TWeakObjectPtr<AActor> >    LastRelevantActors;
    TArray< TWeakObjectPtr<AActor> >    LastSentActors;
    TArray< TWeakObjectPtr<AActor> >    LastNonRelevantActors;
 
    void                        PrintDebugRelevantActors();
#endif // NET_DEBUG_RELEVANT_ACTORS
    
    TMap<FNetworkGUID, TUniquePtr<FActorDestructionInfo>>   DestroyedStartupOrDormantActors;
 
private:
 
    TMap<FName, TSet<FNetworkGUID>> DestroyedStartupOrDormantActorsByLevel;
 
    TMap<FString, FString> CachedNetAnalyticsAttributes;
 
    TMap<FObjectKey, TSharedPtr<FReplicationChangelistMgr>> ReplicationChangeListMap;
 
public:
 
    const TSet<FNetworkGUID>& GetDestroyedStartupOrDormantActors(const FName& LevelName)
    {
        return DestroyedStartupOrDormantActorsByLevel.FindOrAdd(LevelName);
    }
 
    void SetNetAnalyticsAttributes(const FString& AttributeKey, const FString& AttributeValue) { CachedNetAnalyticsAttributes.Add(AttributeKey, AttributeValue); }
 
    TMap<FName, FName>  RenamedStartupActors;
 
    uint32 ReplicationFrame;
 
    TMap<TWeakObjectPtr<UObject>, TSharedPtr<FRepLayout>, FDefaultSetAllocator, TWeakObjectPtrMapKeyFuncs<TWeakObjectPtr<UObject>, TSharedPtr<FRepLayout> > >   RepLayoutMap;
 
    TSharedPtr< FRepLayout >    GetObjectClassRepLayout( UClass * InClass );
 
    ENGINE_API TSharedPtr<FRepLayout> GetFunctionRepLayout( UFunction * Function );
 
    ENGINE_API TSharedPtr<FRepLayout> GetStructRepLayout( UStruct * Struct );
 
    TSharedPtr< FReplicationChangelistMgr > GetReplicationChangeListMgr( UObject* Object );
 
    TMap< FNetworkGUID, TSet< FObjectReplicator* > >    GuidToReplicatorMap;
    int32                                               TotalTrackedGuidMemoryBytes;
    TSet< FObjectReplicator* >                          UnmappedReplicators;
    TSet< FObjectReplicator* >                          AllOwnedReplicators;
 
    FDelegateHandle TickDispatchDelegateHandle;
    FDelegateHandle PostTickDispatchDelegateHandle;
    FDelegateHandle TickFlushDelegateHandle;
    FDelegateHandle PostTickFlushDelegateHandle;
 
#if !UE_BUILD_SHIPPING
    FOnSendRPC  SendRPCDel;
 
    FShouldSkipRepNotifies SkipRepNotifiesDel;
#endif
 
    float ProcessQueuedBunchesCurrentFrameMilliseconds;
 
    FDDoSDetection DDoS;
 
    TSharedPtr<FInternetAddr> LocalAddr;
 
    void UpdateStandbyCheatStatus(void);
 
    ENGINE_API virtual void SetAnalyticsProvider(TSharedPtr<IAnalyticsProvider> InProvider);
 
#if DO_ENABLE_NET_TEST
    FPacketSimulationSettings   PacketSimulationSettings;
 
    ENGINE_API void SetPacketSimulationSettings(const FPacketSimulationSettings& NewSettings);
 
    ENGINE_API void OnPacketSimulationSettingsChanged();
#endif
 
    // Constructors.
    ENGINE_API UNetDriver(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    ENGINE_API UNetDriver(FVTableHelper& Helper);
 
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostReloadConfig(FProperty* PropertyToLoad) override;
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual void Serialize( FArchive& Ar ) override;
    ENGINE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    //~ End UObject Interface.
 
    //~ Begin FExec Interface
protected:
    ENGINE_API virtual bool Exec_Dev(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar=*GLog) override;
//~ End FExec Interface.
 
public:
 
    ENGINE_API void EnableExecuteRPCFunctions(bool bEnable);
    ENGINE_API bool IsExecuteRPCFunctionsEnabled() const;
 
    ENGINE_API void EnablePreReplication(bool bEnable);
    ENGINE_API bool IsPreReplicationEnabled() const;
 
    ENGINE_API void ReplicateAutonomousAsSimulated(bool bEnabled);
    ENGINE_API bool IsReplicatingAutonomousAsSimulated() const;
 
    virtual bool CanDowngradeActorRole(UNetConnection* Connection, AActor* Actor) const { return true; };
 
private:
 
    bool bExecuteRPCFunctions = true;
    bool bCallPreReplication = true;
    bool bReplicatingAutonomousAsSimulated = false;
 
    TSet< FObjectReplicator* > ReplicatorsWithPendingTransactions;
 
public:
 
    ENGINE_API ENetMode GetNetMode() const;
 
    virtual bool IsAvailable() const PURE_VIRTUAL( UNetDriver::IsAvailable, return false;)
 
    ENGINE_API virtual bool InitBase(bool bInitAsClient, FNetworkNotify* InNotify, const FURL& URL, bool bReuseAddressAndPort, FString& Error);
 
    virtual bool InitConnect(class FNetworkNotify* InNotify, const FURL& ConnectURL, FString& Error ) PURE_VIRTUAL( UNetDriver::InitConnect, return true;);
 
    virtual bool InitListen(class FNetworkNotify* InNotify, FURL& ListenURL, bool bReuseAddressAndPort, FString& Error) PURE_VIRTUAL( UNetDriver::InitListen, return true;);
 
    ENGINE_API virtual void InitDestroyedStartupActors();
 
    ENGINE_API virtual void InitConnectionlessHandler();
 
    ENGINE_API virtual void FlushHandler();
 
    ENGINE_API virtual bool InitConnectionClass(void);
 
    ENGINE_API virtual bool InitReplicationDriverClass();
 
    ENGINE_API virtual bool InitReplicationBridgeClass();
    ENGINE_API virtual void Shutdown();
 
    /* Close socket and Free the memory the OS allocated for this socket */
    ENGINE_API virtual void LowLevelDestroy();
 
    /* @return network number */
    ENGINE_API virtual FString LowLevelGetNetworkNumber();
 
    /* @return local addr of this machine if set */
    virtual TSharedPtr<const FInternetAddr> GetLocalAddr() { return LocalAddr; }
 
    ENGINE_API virtual void AssertValid();
 
    ENGINE_API virtual int32 ServerReplicateActors(float DeltaSeconds);
 
    ENGINE_API virtual void ProcessRemoteFunction(class AActor* Actor, class UFunction* Function, void* Parms, struct FOutParmRec* OutParms, struct FFrame* Stack, class UObject* SubObject = nullptr );
 
    TObjectPtr<UNetworkMetricsDatabase> GetMetrics() { return NetworkMetricsDatabase; };
 
    enum class ERemoteFunctionSendPolicy
    {       
        Default, 
 
        ForceSend,
 
        ForceQueue,
    };
    UE_DEPRECATED(5.4, "Use fully scoped enum class value UNetDriver::ERemoteFunctionSendPolicy::Default")
    static constexpr ERemoteFunctionSendPolicy Default = ERemoteFunctionSendPolicy::Default;
    UE_DEPRECATED(5.4, "Use fully scoped enum class value UNetDriver::ERemoteFunctionSendPolicy::ForceSend")
    static constexpr ERemoteFunctionSendPolicy ForceSend = ERemoteFunctionSendPolicy::ForceSend;
    UE_DEPRECATED(5.4, "Use fully scoped enum class value UNetDriver::ERemoteFunctionSendPolicy::ForceQueue")
    static constexpr ERemoteFunctionSendPolicy ForceQueue = ERemoteFunctionSendPolicy::ForceQueue;
 
    ENGINE_API void ProcessRemoteFunctionForChannel(
        UActorChannel* Ch,
        const class FClassNetCache* ClassCache,
        const FFieldNetCache* FieldCache,
        UObject* TargetObj,
        UNetConnection* Connection,
        UFunction* Function,
        void* Parms,
        FOutParmRec* OutParms,
        FFrame* Stack,
        const bool IsServer,
        const ERemoteFunctionSendPolicy SendPolicy = ERemoteFunctionSendPolicy::Default);
 
    ENGINE_API void ProcessRemoteFunctionForChannel(
        UActorChannel* Ch,
        const class FClassNetCache* ClassCache,
        const FFieldNetCache* FieldCache,
        UObject* TargetObj,
        UNetConnection* Connection,
        UFunction* Function,
        void* Parms,
        FOutParmRec* OutParms,
        FFrame* Stack,
        const bool IsServer,
        const ERemoteFunctionSendPolicy SendPolicy,
        EProcessRemoteFunctionFlags& RemoteFunctionFlags);
 
private:
 
    void ProcessRemoteFunctionForChannelPrivate(
        UActorChannel* Ch,
        const class FClassNetCache* ClassCache,
        const FFieldNetCache* FieldCache,
        UObject* TargetObj,
        UNetConnection* Connection,
        UFunction* Function,
        void* Parms,
        FOutParmRec* OutParms,
        FFrame* Stack,
        const bool bIsServer,
        const ERemoteFunctionSendPolicy SendPolicy,
        EProcessRemoteFunctionFlags& RemoteFunctionFlags);
 
public:
 
    ENGINE_API virtual void TickDispatch( float DeltaTime );
 
    ENGINE_API virtual void PostTickDispatch();
 
    ENGINE_API virtual void TickFlush(float DeltaSeconds);
 
    ENGINE_API virtual void PostTickFlush();
 
    virtual void LowLevelSend(TSharedPtr<const FInternetAddr> Address, void* Data, int32 CountBits, FOutPacketTraits& Traits)
        PURE_VIRTUAL(UNetDriver::LowLevelSend,);
 
    ENGINE_API virtual void ProcessLocalServerPackets();
 
    ENGINE_API virtual void ProcessLocalClientPackets();
 
    ENGINE_API virtual void UpdateNetworkLagState();
 
    ENGINE_API virtual void ReplicateVoicePacket(TSharedPtr<class FVoicePacket> VoicePacket, class UNetConnection* CameFromConn);
 
#if !UE_BUILD_SHIPPING
    bool HandleSocketsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandlePackageMapCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleNetFloodCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleNetDebugTextCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleNetDisconnectCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleNetDumpServerRPCCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleNetDumpDormancy(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleDumpSubObjectsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleDumpRepLayoutFlagsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandlePushModelMemCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandlePropertyConditionsMemCommand(const TCHAR* Cmd, FOutputDevice& Ar);
#endif
 
    ENGINE_API void HandlePacketLossBurstCommand( int32 DurationInMilliseconds );
 
    // ---------------------------------------------------------------
    //  Game code API for updating server Actor Replication State
    // ---------------------------------------------------------------
 
    ENGINE_API virtual void ForceNetUpdate(AActor* Actor);
 
    ENGINE_API void ForceAllActorsNetUpdateTime(float NetUpdateTimeOffset, TFunctionRef<bool(const AActor* const)> ValidActorTestFunc);
 
    ENGINE_API void FlushActorDormancy(AActor *Actor, bool bWasDormInitial=false);
 
    //~ This probably doesn't need to be exported, since it's only called by AActor::SetNetDormancy.
 
    ENGINE_API void NotifyActorDormancyChange(AActor* Actor, ENetDormancy OldDormancyState);
 
    ENGINE_API virtual void NotifyActorClientDormancyChanged(AActor* Actor, ENetDormancy OldDormancyState);
 
    ENGINE_API void ForcePropertyCompare( AActor* Actor );
 
    ENGINE_API void ForceActorRelevantNextUpdate(AActor* Actor);
 
    ENGINE_API virtual void AddNetworkActor(AActor* Actor);
 
    ENGINE_API virtual void NotifyActorDestroyed(AActor* Actor, bool IsSeamlessTravel = false, EChannelCloseReason CloseReason = EChannelCloseReason::Destroyed);
 
    void NotifySubObjectDestroyed(UObject* SubObject);
 
    UE_DEPRECATED(5.4, "Replaced by overload that takes the PreviousOuter")
    ENGINE_API virtual void NotifyActorRenamed(AActor* Actor, FName PreviousName);
    
    ENGINE_API virtual void NotifyActorRenamed(AActor* Actor, UObject* PreviousOuter, FName PreviousName);
 
    ENGINE_API virtual void RemoveNetworkActor(AActor* Actor);
 
    void DeleteSubObjectOnClients(AActor* Actor, UObject* SubObject);
 
    void TearOffSubObjectOnClients(AActor* Actor, UObject* SubObject);
 
    ENGINE_API virtual void NotifyActorLevelUnloaded( AActor* Actor );
 
    ENGINE_API virtual void NotifyActorTearOff(AActor* Actor);
 
    ENGINE_API void NotifyActorIsTraveling(AActor* TravelingActor);
 
    ENGINE_API void SetRoleSwapOnReplicate(AActor* Actor, bool bSwapRoles);
 
    // ---------------------------------------------------------------
    //
    // ---------------------------------------------------------------  
 
    ENGINE_API virtual void NotifyStreamingLevelUnload( ULevel* );
 
    ENGINE_API virtual class UChildConnection* CreateChild(UNetConnection* Parent);
 
    FString GetDescription() const
    { 
        return FString::Printf(TEXT("Name:%s Def:%s %s%s"), *NetDriverName.ToString(), *NetDriverDefinition.ToString(), *GetName(), bIsPeer ? TEXT("(PEER)") : TEXT(""));
    }
 
    ENGINE_API virtual bool IsServer() const;
 
    ENGINE_API virtual void CleanPackageMaps();
 
    void RemoveClassRepLayoutReferences(UClass* Class);
 
    ENGINE_API void CleanupWorldForSeamlessTravel();
 
    ENGINE_API void PreSeamlessTravelGarbageCollect();
 
    ENGINE_API void PostSeamlessTravelGarbageCollect();
 
    virtual class ISocketSubsystem* GetSocketSubsystem() PURE_VIRTUAL(UNetDriver::GetSocketSubsystem, return NULL;);
 
    ENGINE_API virtual void SetWorld(class UWorld* InWorld);
 
    virtual class UWorld* GetWorld() const override final { return World; }
 
    class UPackage* GetWorldPackage() const { return WorldPackage; }
 
    ENGINE_API virtual void ResetGameWorldState();
 
    virtual bool IsNetResourceValid(void) PURE_VIRTUAL(UNetDriver::IsNetResourceValid, return false;);
 
    bool NetObjectIsDynamic(const UObject *Object) const;
 
    void DrawNetDriverDebug();
 
    TSharedPtr<FRepChangedPropertyTracker> FindOrCreateRepChangedPropertyTracker(UObject *Obj);
 
    TSharedPtr<FRepChangedPropertyTracker> FindRepChangedPropertyTracker(UObject* Obj);
 
    virtual bool ShouldClientDestroyTearOffActors() const { return false; }
 
    ENGINE_API virtual bool ShouldSkipRepNotifies() const;
 
    virtual bool ShouldQueueBunchesForActorGUID(FNetworkGUID InGUID) const { return false; }
 
    virtual bool ShouldIgnoreRPCs() const { return false; }
 
    virtual FNetworkGUID GetGUIDForActor(const AActor* InActor) const { return FNetworkGUID(); }
 
    virtual AActor* GetActorForGUID(FNetworkGUID InGUID) const { return nullptr; }
 
    virtual bool ShouldReceiveRepNotifiesForObject(UObject* Object) const { return true; }
 
    FNetworkObjectList& GetNetworkObjectList() { return *NetworkObjects; }
 
    const FNetworkObjectList& GetNetworkObjectList() const { return *NetworkObjects; }
 
    UE_DEPRECATED(5.3, "Will be made private in a future release")
    ENGINE_API FNetworkObjectInfo* FindOrAddNetworkObjectInfo(const AActor* InActor);
 
    UE_DEPRECATED(5.3, "Will be made private in a future release")
    ENGINE_API FNetworkObjectInfo* FindNetworkObjectInfo(const AActor* InActor);
 
    UE_DEPRECATED(5.3, "Will be made private in a future release")
    const FNetworkObjectInfo* FindNetworkObjectInfo(const AActor* InActor) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return const_cast<UNetDriver*>(this)->FindNetworkObjectInfo(InActor);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    ENGINE_API static bool IsAdaptiveNetUpdateFrequencyEnabled();
 
    ENGINE_API bool IsNetworkActorUpdateFrequencyThrottled(const AActor* InActor) const;
 
    UE_DEPRECATED(5.3, "Will be made private in a future release, please use version that takes an actor")
    ENGINE_API bool IsNetworkActorUpdateFrequencyThrottled(const FNetworkObjectInfo& InNetworkActor) const;
 
    UE_DEPRECATED(5.3, "Will be made private in a future release, please use version that takes an actor")
    ENGINE_API void CancelAdaptiveReplication(FNetworkObjectInfo& InNetworkActor);
 
    ENGINE_API void CancelAdaptiveReplication(const AActor* InActor);
 
    ENGINE_API bool IsPendingNetUpdate(const AActor* InActor) const;
 
    int32 GetDuplicateLevelID() const { return DuplicateLevelID; }
 
    void SetDuplicateLevelID(const int32 InDuplicateLevelID) { DuplicateLevelID = InDuplicateLevelID; }
 
    ENGINE_API void SetReplicationDriver(UReplicationDriver* NewReplicationManager);
 
    UReplicationDriver* GetReplicationDriver() const { return ReplicationDriver; }
 
    inline bool IsUsingIrisReplication() const
    {
        return bIsUsingIris;
    }
 
    ENGINE_API EEngineNetworkRuntimeFeatures GetNetworkRuntimeFeatures() const;
 
    ENGINE_API void RestartIrisSystem();
 
    ENGINE_API void DestroyIrisSystem();
 
    ENGINE_API void RecreateIrisSystem();
 
    template<class T>
    T* GetReplicationDriver() const { return Cast<T>(ReplicationDriver); }
 
    inline UReplicationSystem* GetReplicationSystem() { return ReplicationSystem; }
    inline UReplicationSystem* GetReplicationSystem() const { return ReplicationSystem; }
 
    void UpdateGroupFilterStatusForLevel(const ULevel* Level, UE::Net::FNetObjectGroupHandle LevelGroupHandle);
    void DisallowReplicationOfAllLevelGroupsForConnection(UE::Net::FConnectionHandle Handle);
    void UpdateGroupFilterStatusForAllLevelsForConnection(UE::Net::FConnectionHandle Handle);
    void UpdateGroupFilterStatusForAllLevelsForAllConnections();
 
    const UE::Net::FNetTokenStore* GetNetTokenStore() const { return NetTokenStore.Get(); }
    UE::Net::FNetTokenStore* GetNetTokenStore() { return NetTokenStore.Get(); }
    
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnNetTokenStoreReady, UNetDriver*);
 
protected:
    ENGINE_API virtual bool ShouldUpdateStats() const;
 
    ENGINE_API virtual bool ShouldRegisterMetricsDatabaseListeners() const;
 
private:
    FOnNetTokenStoreReady OnNetTokenStoreReadyDelegate;
public:
    FOnNetTokenStoreReady::RegistrationType& OnNetTokenStoreReady()
    {
        return OnNetTokenStoreReadyDelegate;
    }
 
 
 
    ENGINE_API void RemoveClientConnection(UNetConnection* ClientConnectionToRemove);
 
    ENGINE_API void AddClientConnection(UNetConnection * NewConnection);
 
    ENGINE_API void ForEachClientConnection(TFunction<bool(TObjectPtr<UNetConnection>)> Func);
 
    //~ This method should only be called by internal networking systems.
    ENGINE_API void NotifyActorFullyDormantForConnection(AActor* Actor, UNetConnection* Connection);
 
    ENGINE_API virtual bool IsLevelInitializedForActor( const AActor* InActor, const UNetConnection* InConnection ) const;
 
    void NotifyRPCProcessed(UFunction* Function, UNetConnection* Connection, double ElapsedTimeSeconds);
 
    ENGINE_API virtual bool ShouldReplicateFunction(AActor* Actor, UFunction* Function) const;
 
    ENGINE_API virtual bool ShouldForwardFunction(AActor* Actor, UFunction* Function, void* Parms) const;
 
    ENGINE_API virtual bool ShouldReplicateActor(AActor* Actor) const;
 
    ENGINE_API virtual bool ShouldCallRemoteFunction(UObject* Object, UFunction* Function, const FReplicationFlags& RepFlags) const;
 
    ENGINE_API virtual bool ShouldClientDestroyActor(AActor* Actor, EChannelCloseReason CloseReason = EChannelCloseReason::Destroyed) const;
 
    ENGINE_API virtual void NotifyActorChannelOpen(UActorChannel* Channel, AActor* Actor);
    
    ENGINE_API virtual void NotifyActorChannelCleanedUp(UActorChannel* Channel, EChannelCloseReason CloseReason);
 
    ENGINE_API virtual void NotifyActorTornOff(AActor* Actor);
 
    ENGINE_API virtual void ClientSetActorDormant(AActor* Actor);
 
    ENGINE_API virtual void ClientSetActorTornOff(AActor* Actor);
 
    ENGINE_API void ConsumeAsyncLoadDelinquencyAnalytics(FNetAsyncLoadDelinquencyAnalytics& Out);
 
    ENGINE_API const FNetAsyncLoadDelinquencyAnalytics& GetAsyncLoadDelinquencyAnalytics() const;
 
    ENGINE_API void ResetAsyncLoadDelinquencyAnalytics();
 
    inline uint32 AllocateConnectionId() { return ConnectionIdHandler.Allocate(); }
    inline void FreeConnectionId(uint32 Id) { return ConnectionIdHandler.Free(Id); };
 
    UE_DEPRECATED(5.6, "Use GetConnectionByHandle()")
    ENGINE_API UNetConnection* GetConnectionById(uint32 ParentConnectionId) const;
 
    ENGINE_API UNetConnection* GetConnectionByHandle(UE::Net::FConnectionHandle ConnectionHandle) const;
 
    inline uint32 GetNetTraceId() const { return NetTraceId; }
 
    ENGINE_API bool CanCreateDestructionInfo() const;
 
    ENGINE_API int64 SendDestructionInfo(UNetConnection* Connection, FActorDestructionInfo* DestructionInfo);
 
    bool SendDestructionInfoForLevelUnloadIfDormant(AActor* ThisActor, UNetConnection* Connection);
 
    ENGINE_API UE::Net::FNetIDVariant CreateNetIDForObject(UObject* Object);
 
    ENGINE_API void AssignNetIDToObject(UE::Net::FNetIDVariant NetID, const UObject* Object);
 
protected:
 
    void SetIsInTick(bool bIsInTick) { bInTick = bIsInTick; }
 
    ENGINE_API void RegisterTickEvents(class UWorld* InWorld);
    ENGINE_API void UnregisterTickEvents(class UWorld* InWorld);
 
private:
    void InternalTickDispatch(float DeltaSeconds);
    void InternalTickFlush(float DeltaSeconds);
 
protected:
    ENGINE_API virtual UChannel* InternalCreateChannelByName(const FName& ChName);
 
    void UpdateNetworkStats();
 
private:
    void ResetNetConnectionStats();
 
protected:
 
#if WITH_SERVER_CODE
    int32 ServerReplicateActors_PrepConnections( const float DeltaSeconds );
    void ServerReplicateActors_BuildConsiderList( TArray<FNetworkObjectInfo*>& OutConsiderList, const float ServerTickTime );
 
    // Actor prioritization
    ENGINE_API int32 ServerReplicateActors_PrioritizeActors( UNetConnection* Connection, const TArray<FNetViewer>& ConnectionViewers, const TArray<FNetworkObjectInfo*>& ConsiderList, const bool bCPUSaturated, FActorPriority*& OutPriorityList, FActorPriority**& OutPriorityActors );
    
    UE_DEPRECATED(5.3, "This function has been deprecated. Please use ServerReplicateActors_ProcessPrioritizedActorsRange instead")
    int32 ServerReplicateActors_ProcessPrioritizedActors( UNetConnection* Connection, const TArray<FNetViewer>& ConnectionViewers, FActorPriority** PriorityActors, const int32 FinalSortedCount, int32& OutUpdated );
    
    // Actor relevancy processing within specified range
    ENGINE_API int32 ServerReplicateActors_ProcessPrioritizedActorsRange( UNetConnection* Connection, const TArray<FNetViewer>& ConnectionViewers, FActorPriority** PriorityActors, const TInterval<int32>& ActorsIndexRange, int32& OutUpdated, bool bIgnoreSaturation = false );
    
    // Relevant actors that could not be processed this frame are marked to be considered for next frame
    ENGINE_API void ServerReplicateActors_MarkRelevantActors( UNetConnection* Connection, const TArray<FNetViewer>& ConnectionViewers, int32 StartActorIndex, int32 EndActorIndex, FActorPriority** PriorityActors );
    
    FOnConsiderListUpdate OnPreConsiderListUpdateOverride;
 
    FOnConsiderListUpdate OnPostConsiderListUpdateOverride;
 
    FOnConsiderListUpdate OnProcessConsiderListOverride;
#endif
 
    ENGINE_API virtual void OnLevelRemovedFromWorld(class ULevel* Level, class UWorld* World);
 
    ENGINE_API virtual void OnLevelAddedToWorld(class ULevel* Level, class UWorld* World);
 
    FDelegateHandle OnLevelRemovedFromWorldHandle;
    FDelegateHandle OnLevelAddedToWorldHandle;
 
 
public:
 
    const bool MaySendProperties() const
    {
        return bMaySendProperties;
    }
 
    uint32 GetOutTotalNotifiedPackets() const { return OutTotalNotifiedPackets; }
 
    inline void IncreaseOutTotalNotifiedPackets() { ++OutTotalNotifiedPackets; }
 
    int32 GetTotalOutOfOrderPackets() const
    {
        return TotalOutOfOrderPacketsLost + TotalOutOfOrderPacketsRecovered + TotalOutOfOrderPacketsDuplicate;
    }
 
    int32 GetTotalOutOfOrderPacketsLost() const
    {
        return TotalOutOfOrderPacketsLost;
    }
 
    void IncreaseTotalOutOfOrderPacketsLost(int32 Count=1)
    {
        TotalOutOfOrderPacketsLost += Count;
    }
 
    int32 GetTotalOutOfOrderPacketsRecovered() const
    {
        return TotalOutOfOrderPacketsRecovered;
    }
 
    void IncreaseTotalOutOfOrderPacketsRecovered(int32 Count=1)
    {
        TotalOutOfOrderPacketsRecovered += Count;
    }
 
    int32 GetTotalOutOfOrderPacketsDuplicate() const
    {
        return TotalOutOfOrderPacketsDuplicate;
    }
 
    void IncreaseTotalOutOfOrderPacketsDuplicate(int32 Count=1)
    {
        TotalOutOfOrderPacketsDuplicate += Count;
    }
 
    uint32 GetCachedGlobalNetTravelCount() const
    {
        return CachedGlobalNetTravelCount;
    }
 
    bool DidHitchLastFrame() const;
 
    static bool IsDormInitialStartupActor(AActor* Actor);
 
    void MoveMappedObjectToUnmapped(const UObject* Object);
 
    bool HasReplayConnection() const { return bHasReplayConnection; }
 
    virtual bool DoesSupportEncryption() const
    {
        return true;
    }
 
    ENGINE_API virtual bool IsEncryptionRequired() const;
 
    ENGINE_API float GetIncomingBunchFrameProcessingTimeLimit() const;
 
    ENGINE_API bool HasExceededIncomingBunchFrameProcessingTime() const;
 
    void AddBunchProcessingFrameTimeMS(float Milliseconds) { IncomingBunchProcessingElapsedFrameTimeMS += Milliseconds; }
 
    void AddQueuedBunchFailsafeChannel() { ++QueuedBunchFailsafeNumChannels; }
 
    void SetReplicateTransactionally(bool bInReplicateTransactionally)
    {
        bReplicateTransactionally = bInReplicateTransactionally;
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    bool ShouldReplicateTransactionally() const
    {
        return bReplicateTransactionally;
    }
#else
    constexpr bool ShouldReplicateTransactionally() const
    {
        return false;
    }
#endif
 
    void SetDeferTransactionalSend(bool bInDeferTransactionalSend)
    {
        bDeferTransactionalSend = bInDeferTransactionalSend;
    }
 
    bool ShouldDeferTransactionalSend() const
    {
        return bDeferTransactionalSend;
    }
 
    bool IsUsingRemoteObjectReferences() const { return bUseRemoteObjectRefs; }
 
    void SetUsingRemoteObjectReferences(bool bValue)
    {
        bUseRemoteObjectRefs = bValue;
    }
 
    void SetSupportForNoPawnConnection(bool bInSupportNoPawnConnection)
    {
        bSupportNoPawnConnection = bInSupportNoPawnConnection;
    }
 
    bool HasSupportForNoPawnConnection();
 
    TObjectPtr<UNetConnection> FindConnection(struct FUniqueNetIdRepl& PlayerId);
 
    bool IsSendingImmediateAcks() const
    {
        return bSendImmediateAcks;
    }
 
protected:
    
    FRandomStream UpdateDelayRandomStream;
 
    void NotifyGameInstanceUpdated();
 
    bool bTickingThrottleEnabled = true;
private:
    // Only for ForwardRemoteFunction
    friend FObjectReplicator;
 
    ENGINE_API virtual ECreateReplicationChangelistMgrFlags GetCreateReplicationChangelistMgrFlags() const;
 
    FDelegateHandle PostGarbageCollectHandle;
    void PostGarbageCollect();
 
    FActorDestructionInfo* CreateDestructionInfo(AActor* ThisActor, FActorDestructionInfo *DestructionInfo);
 
    void CreateReplicatedStaticActorDestructionInfo(ULevel* Level, const FReplicatedStaticActorDestructionInfo& Info);
 
    void FlushActorDormancyInternal(AActor *Actor);
 
    void LoadChannelDefinitions();
 
    void ReportSyncLoad(const FNetSyncLoadReport& Report);
 
    enum class ECrashContextUpdate
    {
        Default,
        UpdateRepModel,
        ClearRepModel,
    };
    void UpdateCrashContext(ECrashContextUpdate UpdateType=ECrashContextUpdate::Default);
 
    void RemoveDestroyedGuidsByLevel(const ULevel* Level, const TArray<FNetworkGUID>& RemovedGUIDs);
 
    void ServerReplicateActors_ForConnection(UE::Net::FServerReplicateActors_ForConnectionParams& Params);
 
    FDelegateHandle ReportSyncLoadDelegateHandle;
 
    void InitIrisSettings(FName NewDriverName);
    void SetReplicationSystem(UReplicationSystem* ReplicationSystem);
    void CreateReplicationSystem(bool bInitAsClient);
    void UpdateIrisReplicationViews() const;
    void SendClientMoveAdjustments();
    void PostDispatchSendUpdate();
 
    void SendNetAnalytics();
 
    FString GetReplicationModelName() const;
 
    void InitNetTraceId();
 
protected:
    ENGINE_API virtual void ForwardRemoteFunction(UObject* RootObject, UObject* SubObject, UFunction* Function, void* Parms);
 
    void EvaluateNoTimeouts();
 
private:
    void UpdateUnmappedObjects();
 
    void CleanupStaleDormantReplicators();
 
private:
 
    UPROPERTY(transient)
    TObjectPtr<UReplicationDriver> ReplicationDriver;
 
    TUniquePtr<UE::Net::FNetTokenStore> NetTokenStore;
 
    UReplicationSystem* ReplicationSystem = nullptr;
 
    bool bSkipStartReplicatingWorldForIris = false;
 
    bool bIsUsingIris = false;
 
    // For FindOrAddNetworkObjectInfo
    TPimplPtr<FNetworkObjectInfo> DummyNetworkObjectInfo;
 
    TSharedPtr<FNetworkObjectList> NetworkObjects;
 
    TArray<FNetworkObjectInfo*> CurrentConsiderList;
 
    ENetworkLagState::Type LagState;
 
    int32 DuplicateLevelID;
 
    double PacketLossBurstEndTime;
 
    uint32 OutTotalNotifiedPackets;
 
    FNetConnectionIdHandler ConnectionIdHandler;
 
    uint32 NetTraceId;
 
    int32 TotalOutOfOrderPacketsLost = 0;
 
    int32 TotalOutOfOrderPacketsRecovered = 0;
 
    int32 TotalOutOfOrderPacketsDuplicate = 0;
 
    uint32 CachedGlobalNetTravelCount = 0;
    
    uint32 StatUpdateFrames = 0;
 
    float IncomingBunchProcessingElapsedFrameTimeMS = 0.0f;
    
    uint32 NumFramesOverIncomingBunchTimeLimit = 0;
 
    uint32 QueuedBunchFailsafeNumChannels = 0;
 
    bool bReplicateTransactionally = true;
 
    bool bUseRemoteObjectRefs = false;
    
    bool bDeferTransactionalSend = true;
 
    bool bSupportNoPawnConnection = false;
 
    UPROPERTY(Config)
    bool bSendImmediateAcks = true;
};