NetConnection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
//
// A network connection.
//
 
#pragma once
 
#include "UObject/ObjectKey.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "Serialization/BitWriter.h"
#include "Serialization/CustomVersion.h"
#include "Misc/EngineVersion.h"
#include "Misc/NetworkGuid.h"
#include "GameFramework/OnlineReplStructs.h"
#include "GameFramework/UpdateLevelVisibilityLevelInfo.h"
#include "Engine/NetDriver.h"
#include "Net/DataBunch.h"
#include "Net/NetPacketNotify.h"
#include "Engine/Player.h"
#include "Engine/Channel.h"
#include "ProfilingDebugging/Histogram.h"
#include "Containers/ArrayView.h"
#include "Containers/CircularBuffer.h"
#include "Net/Core/Trace/NetTraceConfig.h"
#include "ReplicationDriver.h"
#include "Analytics/EngineNetAnalytics.h"
#include "Net/Common/Packets/PacketTraits.h"
#include "Net/Core/Misc/ResizableCircularQueue.h"
#include "Net/NetAnalyticsTypes.h"
#include "Net/Core/Connection/ConnectionHandle.h"
#include "Net/Core/Connection/NetCloseResult.h"
#include "Net/TrafficControl.h"
#include "Net/NetDormantHolder.h"
#include "HAL/LowLevelMemTracker.h"
#include "GameFramework/Actor.h"
 
#include "NetConnection.generated.h"
 
#define NETCONNECTION_HAS_SETENCRYPTIONKEY 1
 
LLM_DECLARE_TAG_API(NetConnection, ENGINE_API);
 
class FInternetAddr;
class FObjectReplicator;
class StatelessConnectHandlerComponent;
class UActorChannel;
class UChildConnection;
class ULevelStreaming;
struct FEncryptionKeyResponse;
class PacketHandler;
class FRPCDoSDetection;
enum class EEngineNetworkRuntimeFeatures : uint16;
 
namespace UE::Net
{
    class FNetPing;
    class FNetConnectionFaultRecovery;
    struct FStatelessHandshakeFailureInfo;
 
} // end namespace UE::Net
 
typedef TMap<TWeakObjectPtr<AActor>, UActorChannel*, FDefaultSetAllocator, TWeakObjectPtrMapKeyFuncs<TWeakObjectPtr<AActor>, UActorChannel*>> FActorChannelMap;
 
namespace NetConnectionHelper
{
    inline constexpr int32 NumBitsForJitterClockTimeInHeader = 10;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API bool HasDisabledBandwidthThrottling();
#endif
}
 
extern ENGINE_API TAutoConsoleVariable<int32> CVarNetEnableCongestionControl;
 
/*-----------------------------------------------------------------------------
    Types.
-----------------------------------------------------------------------------*/
enum { RELIABLE_BUFFER = 512 }; // Power of 2 >= 1.
enum { MAX_PACKETID = FNetPacketNotify::SequenceNumberT::SeqNumberCount };  // Power of 2 >= 1, covering guaranteed loss/misorder time.
enum { MAX_CHSEQUENCE = 1024 }; // Power of 2 >RELIABLE_BUFFER, covering loss/misorder time.
enum { MAX_BUNCH_HEADER_BITS = 256 };
enum { MAX_PACKET_RELIABLE_SEQUENCE_HEADER_BITS = 32 /*PackedHeader*/ + FNetPacketNotify::SequenceHistoryT::MaxSizeInBits };
enum { MAX_PACKET_INFO_HEADER_BITS = 1 /*bHasPacketInfo*/ + NetConnectionHelper::NumBitsForJitterClockTimeInHeader + 1 /*bHasServerFrameTime*/ + 8 /*ServerFrameTime*/};
enum { MAX_PACKET_HEADER_BITS = MAX_PACKET_RELIABLE_SEQUENCE_HEADER_BITS + MAX_PACKET_INFO_HEADER_BITS  };
enum { MAX_PACKET_TRAILER_BITS = 1 };
 
// 
// State of a connection.
//
enum EConnectionState
{
    USOCK_Invalid   = 0, // Connection is invalid, possibly uninitialized.
    USOCK_Closed    = 1, // Connection permanently closed.
    USOCK_Pending   = 2, // Connection is awaiting connection.
    USOCK_Open      = 3, // Connection is open.
    USOCK_Closing   = 4, // Connection is closing and waiting for all reliable data to be acked. No new data will be sent.
};
ENGINE_API const TCHAR* LexToString(const EConnectionState Value);
 
namespace UE::Net
{
    enum class ENetUpgradeSource : uint8
    {
        ControlChannel,         // The upgrade message came from the control channel
        StatelessHandshake      // The upgrade message came from the stateless handshake
    };
}
 
 
namespace EClientLoginState
{
    enum Type
    {
        Invalid     = 0,        // This must be a client (which doesn't use this state) or uninitialized.
        LoggingIn   = 1,        // The client is currently logging in.
        Welcomed    = 2,        // Told client to load map and will respond with SendJoin
        ReceivedJoin = 3,       // NMT_Join received and a player controller has been created
        CleanedUp   = 4         // Cleanup has been called at least once, the connection is considered abandoned/terminated/gone
    };
 
    inline const TCHAR* ToString( const EClientLoginState::Type EnumVal )
    {
        switch (EnumVal)
        {
            case Invalid:
            {
                return TEXT("Invalid");
            }
            case LoggingIn:
            {
                return TEXT("LoggingIn");
            }
            case Welcomed:
            {
                return TEXT("Welcomed");
            }
            case ReceivedJoin:
            {
                return TEXT("ReceivedJoin");
            }
            case CleanedUp:
            {
                return TEXT("CleanedUp");
            }
        }
        return TEXT("");
    }
};
 
 enum class EResendAllDataState : uint8
 {
     None,
     SinceOpen,
     SinceCheckpoint
 };
 
// Delegates
#if !UE_BUILD_SHIPPING
DECLARE_DELEGATE_ThreeParams(FOnReceivedRawPacket, void* /*Data*/, int32 /*Count*/, bool& /*bBlockReceive*/);
 
DECLARE_DELEGATE_ThreeParams(FOnLowLevelSend, void* /*Data*/, int32 /*Count*/, bool& /*bBlockSend*/);
#endif
 
 
#if DO_ENABLE_NET_TEST
struct FDelayedPacket
{
    TArray<uint8> Data;
 
    int32 SizeBits;
 
    FOutPacketTraits Traits;
 
    double SendTime = 0.0;
 
    uint32 DelayFrameCount = 0;
 
    bool bSent = false;
 
public:
 
    inline FDelayedPacket(uint8* InData, int32 InSizeBits, FOutPacketTraits& InTraits)
        : Data()
        , SizeBits(InSizeBits)
        , Traits(InTraits)
    {
        int32 SizeBytes = FMath::DivideAndRoundUp(SizeBits, 8);
 
        Data.AddUninitialized(SizeBytes);
        FMemory::Memcpy(Data.GetData(), InData, SizeBytes);
    }
 
    void CountBytes(FArchive& Ar) const
    {
        Data.CountBytes(Ar);
    }
};
 
struct FDelayedIncomingPacket
{
    TUniquePtr<FBitReader> PacketData;
 
    double ReinjectionTime = 0.0;
 
    uint32 ReinjectionFrameCount = 0;
 
    void CountBytes(FArchive& Ar) const
    {
        if (PacketData.IsValid())
        {
            PacketData->CountMemory(Ar);
        }
        Ar.CountBytes(sizeof(ReinjectionTime), sizeof(ReinjectionTime));
    }
};
 
#endif //#if DO_ENABLE_NET_TEST
 
struct FChannelCloseInfo
{
    uint32 Id;
    EChannelCloseReason CloseReason;
};
typedef TArray<FChannelCloseInfo, TInlineAllocator<8>> FChannelsToClose;
 
struct FWrittenChannelsRecord
{
    enum { DefaultInitialSize = 1024 };
 
    struct FChannelRecordEntry
    {
        uint32 Value : 31;
        uint32 IsSequence : 1;
    };
 
    typedef TResizableCircularQueue<FChannelRecordEntry> FChannelRecordEntryQueue;
 
    FChannelRecordEntryQueue ChannelRecord;
    int32 LastPacketId;
 
public:
    FWrittenChannelsRecord(size_t InitialSize = DefaultInitialSize)
        : ChannelRecord(InitialSize)
        , LastPacketId(-1)
    {
    }
};
 
UCLASS(customConstructor, Abstract, MinimalAPI, transient, config=Engine)
class UNetConnection : public UPlayer
{
    using FNetResult = UE::Net::FNetResult;
    using FNetCloseResult = UE::Net::FNetCloseResult;
 
    GENERATED_BODY()
 
public:
    UPROPERTY(transient)
    TArray<TObjectPtr<class UChildConnection>> Children;
 
    UPROPERTY()
    TObjectPtr<class UNetDriver> Driver;    
 
    UPROPERTY()
    TSubclassOf<UPackageMap> PackageMapClass;
 
    UPROPERTY()
    TObjectPtr<class UPackageMap> PackageMap;
 
    UPROPERTY()
    TArray<TObjectPtr<class UChannel>> OpenChannels;
     
    UPROPERTY()
    TArray<TObjectPtr<class AActor>> SentTemporaries;
 
    UPROPERTY()
    TObjectPtr<class AActor> ViewTarget;
 
    UPROPERTY()
    TObjectPtr<class AActor> OwningActor;
 
    UPROPERTY()
    int32   MaxPacket;                      // Maximum packet size.
 
private:
    UPROPERTY()
    uint32 InternalAck:1;                   // Internally ack all packets, for 100% reliable connections.
 
    UPROPERTY(transient)
    TMap<int32, TObjectPtr<class UChildConnection>> ChildrenLookup;
 
    int32 NextServerNetPlayerIndex = 1;
 
public:
    bool IsInternalAck() const { return bInternalAck; }
    void SetInternalAck(bool bValue) 
    { 
        bInternalAck = bValue; 
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        InternalAck = bValue;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    bool IsReplay() const { return bReplay; }
    void SetReplay(bool bValue)
    {
        bReplay = bValue;
    }
 
    virtual bool IsReplayReady() const { return false; }
 
    bool IsForceInitialDirty() const { return bForceInitialDirty; }
    void SetForceInitialDirty(bool bValue)
    {
        bForceInitialDirty = bValue;
    }
 
    bool IsUnlimitedBunchSizeAllowed() const { return bUnlimitedBunchSizeAllowed; }
    void SetUnlimitedBunchSizeAllowed(bool bValue)
    {
        bUnlimitedBunchSizeAllowed = bValue;
    }
 
    ENGINE_API virtual ~UNetConnection();
 
private:
    uint32 bInternalAck : 1;                // Internally ack all packets, for 100% reliable connections.
    uint32 bReplay : 1;                     // Flag to indicate a replay connection, independent of reliability
    uint32 bForceInitialDirty : 1;          // Force all properties dirty on initial replication
    uint32 bUnlimitedBunchSizeAllowed : 1;  // Ignore the value of net.MaxConstructedPartialBunchSizeBytes
 
public:
    struct FURL         URL;                // URL of the other side.
    
    TSharedPtr<FInternetAddr>   RemoteAddr;
 
    // Track each type of bit used per-packet for bandwidth profiling
 
    int NumPacketIdBits;
 
    int NumBunchBits;
 
    int NumAckBits;
 
    int NumPaddingBits;
 
    int32 MaxPacketHandlerBits;
 
    void ResetPacketBitCounts();
 
    enum class EWriteBitsDataType
    {
        Unknown,
        Bunch,
        Ack
    };
 
    TMap<FString, TArray<float>>& GetActorsStarvedByClassTimeMap() { return ActorsStarvedByClassTimeMap; }
    
    void ResetActorsStarvedByClassTimeMap() { ActorsStarvedByClassTimeMap.Empty(); }
 
    ENGINE_API uint32 GetClientHandshakeId() const;
 
    ENGINE_API void SetClientHandshakeId(uint32 InClientHandshakeId);
 
private:
    // Connection information.
    EConnectionState    State;                  // State this connection is in.
 
    uint32 ClientHandshakeId = 0;
 
public:
    ENGINE_API const EConnectionState GetConnectionState() const;
    ENGINE_API void SetConnectionState(EConnectionState ConnectionState);
    
    ENGINE_API bool IsClosingOrClosed() const;
 
    uint32 bPendingDestroy:1;    // when true, playercontroller or beaconclient is being destroyed
 
 
    TUniquePtr<PacketHandler> Handler;
 
    TWeakPtr<StatelessConnectHandlerComponent> StatelessConnectComponent;
 
 
    bool            bNeedsByteSwapping;
    UPROPERTY()
    FUniqueNetIdRepl PlayerId;
 
    // Negotiated parameters.
    int32           PacketOverhead;         // Bytes overhead per packet sent.
    FString         Challenge;              // Server-generated challenge.
    FString         ClientResponse;         // Client-generated response.
    FString         RequestURL;             // URL requested by client
 
    UE_DEPRECATED(5.5, "Variable is deprecated and unassigned")
    int32           ResponseId;             // Id assigned by the server for linking responses to connections upon authentication
 
    // Login state tracking
    EClientLoginState::Type ClientLoginState;
    uint8                   ExpectedClientLoginMsgType; // Used to determine what the next expected control channel msg type should be from a connecting client
 
    // Internal.
    UPROPERTY()
    double          LastReceiveTime;        // Last time a packet was received, for timeout checking.
    double          LastReceiveRealtime;    // Last time a packet was received, using real time seconds (FPlatformTime::Seconds)
    double          LastGoodPacketRealtime; // Last real time a packet was considered valid
    double          LastSendTime;           // Last time a packet was sent, for keepalives.
    double          LastTickTime;           // Last time of polling.
 
    int32           QueuedBits;
 
    int32           TickCount;
 
    uint32          LastProcessedFrame;
 
    double GetLastRecvAckTime() const { return LastRecvAckTimestamp; }
    double GetConnectTime() const { return ConnectTimestamp; }
 
private:
    double          LastRecvAckTimestamp;
 
    double          ConnectTimestamp;
 
    FPacketTimestamp    LastOSReceiveTime;      // Last time a packet was received at the OS/NIC layer
    bool                bIsOSReceiveTimeLocal;  // Whether LastOSReceiveTime uses the same clock as the game, or needs translating
 
    bool bSendBufferHasDummyPacketInfo = false;
 
    FBitWriterMark HeaderMarkForPacketInfo;
 
    int32 PreviousJitterTimeDelta;
 
    double PreviousPacketSendTimeInS;
 
public:
    // Merge info.
    FBitWriterMark  LastStart;              // Most recently sent bunch start.
    FBitWriterMark  LastEnd;                // Most recently sent bunch end.
    bool            AllowMerge;             // Whether to allow merging.
    bool            TimeSensitive;          // Whether contents are time-sensitive.
    FOutBunch*      LastOutBunch;           // Most recent outgoing bunch.
    FOutBunch       LastOut;
    FBitWriter      SendBunchHeader;
 
    // Stat display.
    double          StatUpdateTime;
    float           StatPeriod;
 
    float           AvgLag;
 
    double          LagAcc;
    int32           LagCount;
    
    double          LastTime, FrameTime;
 
    double          CumulativeTime;
    
    double          AverageFrameTime;
 
    double          RawPingInSeconds = 0.0;
 
    float           GetAverageJitterInMS() const { return AverageJitterInMS; }
 
    int32           CountedFrames;
 
    int32 InBytes, OutBytes;
    int32 InTotalBytes, OutTotalBytes;
    int32 InPackets, OutPackets;
    int32 InPacketsThisFrame = 0;
    int32 OutPacketsThisFrame = 0;
    int32 InTotalPackets, OutTotalPackets;
    int32 InBytesPerSecond, OutBytesPerSecond;
    int32 InPacketsPerSecond, OutPacketsPerSecond;
    int32 InPacketsLost, OutPacketsLost;
    int32 InTotalPacketsLost, OutTotalPacketsLost;
    int32 OutTotalAcks;
    int32 TotalDelayedRPCs = 0;
    int32 TotalDelayedRPCsFrameCount = 0;
 
private:
    int32 InTotalHandlerPackets;
 
    double GracefulCloseTimeoutDeadline = 0.0;
 
public:
    int32 GetInTotalHandlerPackets() const
    {
        return InTotalHandlerPackets;
    }
 
    using FNetConnectionPacketLoss = TPacketLossData<3>;
    const FNetConnectionPacketLoss& GetInLossPercentage() const  { return InPacketsLossPercentage; }
    const FNetConnectionPacketLoss& GetOutLossPercentage() const { return OutPacketsLossPercentage;  }
 
 
private:
 
    FNetConnectionPacketLoss InPacketsLossPercentage;
    FNetConnectionPacketLoss OutPacketsLossPercentage;
 
    int32 StatPeriodCount;
 
    float AverageJitterInMS;
 
public:
 
    FNetConnAnalyticsVars                           AnalyticsVars;
 
    TNetAnalyticsDataPtr<FNetConnAnalyticsData>     NetAnalyticsData;
 
    // Packet.
    FBitWriter      SendBuffer;                     // Queued up bits waiting to send
    double          OutLagTime[256];                // The sent time of a packetId to calculate RTT from
    int32           OutLagPacketId[256];            // Keep track of the packedId we stored the sent time for
    uint8           OutBytesPerSecondHistory[256];  // For saturation measuring.
    int32           InPacketId;                     // Full incoming packet index.
    int32           OutPacketId;                    // Most recently sent packet.
    int32           OutAckPacketId;                 // The id of the last ACK included in the current packet
 
private:
    int32           OutFirstAckPacketId = -1;       // The id of the first ACK included in the current packet
 
public:
 
    bool            bLastHasServerFrameTime;
 
    // Channel table.
 
    UPROPERTY(config)
    int32 DefaultMaxChannelSize;
 
    TArray<TObjectPtr<UChannel>>    Channels;
    TArray<int32>       OutReliable;
    TArray<int32>       InReliable;
    TArray<int32>       PendingOutRec;  // Outgoing reliable unacked data from previous (now destroyed) channel in this slot.  This contains the first chsequence not acked
    int32               InitOutReliable;
    int32               InitInReliable;
 
    uint32 GetNetworkCustomVersion(const FGuid& VersionGuid) const;
    void SetNetworkCustomVersions(const FCustomVersionContainer& CustomVersions);
 
private:
    FCustomVersionContainer NetworkCustomVersions;
 
public:
 
    // Log tracking
    double          LogCallLastTime;
    int32           LogCallCount;
    int32           LogSustainedCount;
 
    UE::Net::FConnectionHandle GetConnectionHandle() const
    {
        return ConnectionHandle;
    }
 
    UE_DEPRECATED(5.6, "Use GetConnectionHandle() instead")
    uint32 GetConnectionId() const
    { 
        return ConnectionHandle.IsParentConnection() ? ConnectionHandle.GetParentConnectionId() : UE::Net::FConnectionHandle().GetParentConnectionId();
    }
 
    UE_DEPRECATED(5.6, "External code should not be setting connection IDs. For valid use cases SetConnectionHandle() should be used instead.")
    void SetConnectionId(uint32 InConnectionId)
    {
        // Using this deprecated method will result in previous behavior which didn't support child connections in a meaningful way. We assume this is a parent connection.
        ConnectionHandle = UE::Net::FConnectionHandle(InConnectionId);
    }
    
    UE_DEPRECATED(5.6, "Use GetConnectionHandle instead")
    ENGINE_API uint32 GetParentConnectionId() const;
 
    FNetTraceCollector* GetInTraceCollector() const;
    FNetTraceCollector* GetOutTraceCollector() const;
 
    AActor* GetConnectionViewTarget() const;
 
    // ----------------------------------------------
    // Actor Channel Accessors
    // ----------------------------------------------
 
    void RemoveActorChannel(AActor* Actor)
    {
        ActorChannels.Remove(Actor);
        if (ReplicationConnectionDriver)
        {
            ReplicationConnectionDriver->NotifyActorChannelRemoved(Actor);
        }
    }
 
    void AddActorChannel(AActor* Actor, UActorChannel* Channel)
    {
        ActorChannels.Add(Actor, Channel);
        if (ReplicationConnectionDriver)
        {
            ReplicationConnectionDriver->NotifyActorChannelAdded(Actor, Channel);
        }
    }
 
    UActorChannel* FindActorChannelRef(const TWeakObjectPtr<AActor>& Actor)
    {
        return ActorChannels.FindRef(Actor);
    }
 
    UActorChannel** FindActorChannel(const TWeakObjectPtr<AActor>& Actor)
    {
        return ActorChannels.Find(Actor);
    }
 
    bool ContainsActorChannel(const TWeakObjectPtr<AActor>& Actor)
    {
        return ActorChannels.Contains(Actor);
    }
 
    int32 ActorChannelsNum() const
    {
        return ActorChannels.Num();
    }
 
    FActorChannelMap::TConstIterator ActorChannelConstIterator() const
    {
        return ActorChannels.CreateConstIterator();
    }
 
    const FActorChannelMap& ActorChannelMap() const
    {
        return ActorChannels;
    }
 
    UReplicationConnectionDriver* GetReplicationConnectionDriver()
    {
        return ReplicationConnectionDriver;
    }
 
    void SetReplicationConnectionDriver(UReplicationConnectionDriver* NewReplicationConnectionDriver)
    {
        ReplicationConnectionDriver = NewReplicationConnectionDriver;
    }
 
    void TearDownReplicationConnectionDriver()
    {
        if (ReplicationConnectionDriver)
        {
            ReplicationConnectionDriver->TearDown();
            ReplicationConnectionDriver = nullptr;
        }
    }
 
private:
    FActorChannelMap ActorChannels;
 
    UReplicationConnectionDriver* ReplicationConnectionDriver;
 
    FPackageFileVersion PackageVersionUE;
 
    int32 PackageVersionLicenseeUE;
 
    FEngineVersion EngineVersion;
 
public:
    void SetPackageVersionUE(FPackageFileVersion InPackageVersionUE) { PackageVersionUE = InPackageVersionUE; }
    
    void SetPackageVersionLicenseeUE(int32 InPackageVersionLicenseeUE) { PackageVersionLicenseeUE = InPackageVersionLicenseeUE; }
 
    void SetEngineVersion(const FEngineVersion& InEngineVersion) { EngineVersion = InEngineVersion; }
 
    void SetNetVersionsOnArchive(FArchive& Ar) const;
 
    void AddDestructionInfo(FActorDestructionInfo* DestructionInfo)
    {
        if (Driver && Driver->GetReplicationSystem())
        {
            return;
        }
        if (ReplicationConnectionDriver)
        {
            ReplicationConnectionDriver->NotifyAddDestructionInfo(DestructionInfo);
        }
        else
        {
            DestroyedStartupOrDormantActorGUIDs.Add(DestructionInfo->NetGUID);
        }
    }
 
    void RemoveDestructionInfo(FActorDestructionInfo* DestructionInfo)
    {
        if (Driver && Driver->GetReplicationSystem())
        {
            return;
        }
        if (ReplicationConnectionDriver)
        {
            ReplicationConnectionDriver->NotifyRemoveDestructionInfo(DestructionInfo);
        }
        else
        {
            DestroyedStartupOrDormantActorGUIDs.Remove(DestructionInfo->NetGUID);
        }
    }
    
    void ResetDestructionInfos()
    {
        if (Driver && Driver->GetReplicationSystem())
        {
            return;
        }
        if (ReplicationConnectionDriver)
        {
            ReplicationConnectionDriver->NotifyResetDestructionInfo();
        }
        else
        {
            DestroyedStartupOrDormantActorGUIDs.Reset(); 
        }
    }
 
    TSet<FNetworkGUID>& GetDestroyedStartupOrDormantActorGUIDs() { return DestroyedStartupOrDormantActorGUIDs; }
 
private:
 
    TSet<FNetworkGUID>  DestroyedStartupOrDormantActorGUIDs;
 
    TSet<FName> ClientMakingVisibleLevelNames;
 
public:
 
    TMap<FNetworkGUID, TArray<TObjectPtr<class UActorChannel>>> KeepProcessingActorChannelBunchesMap;
 
private:
 
    UE::Net::Private::FDormantReplicatorHolder DormantReplicatorSet;
 
public:
 
    FName GetClientWorldPackageName() const { return ClientWorldPackageName; }
 
    ENGINE_API void SetClientWorldPackageName(FName NewClientWorldPackageName);
 
    TSet<FName> ClientVisibleLevelNames;
 
    ENGINE_API void UpdateLevelVisibility(const struct FUpdateLevelVisibilityLevelInfo& LevelVisibility);
 
    const TSet<FName>& GetClientMakingVisibleLevelNames() const { return ClientMakingVisibleLevelNames; }
    
#if DO_ENABLE_NET_TEST
 
    FPacketSimulationSettings PacketSimulationSettings;
 
    void UpdatePacketSimulationSettings();
 
private:
 
    TArray<FDelayedPacket> Delayed;
 
    TArray<FDelayedIncomingPacket> DelayedIncomingPackets;
 
    bool bSendDelayedPacketsOutofOrder = false;
 
    bool bIsReinjectingDelayedPackets = false;
 
    double NextBufferBloatFlushOut = 0.0;
    double NextBufferBloatFlushIn = 0.0;
    
    double NextBufferBloatActiveTimeOut = 0.0;
    double NextBufferBloatActiveTimeIn = 0.0;
 
    void ReinjectDelayedPackets();
 
    void UpdateDelayedPackets(const double CurrentRealtimeSeconds);
 
#endif //#if DO_ENABLE_NET_TEST
 
public:
 
    EResendAllDataState ResendAllDataState;
 
#if !UE_BUILD_SHIPPING
    FOnReceivedRawPacket    ReceivedRawPacketDel;
 
    FOnLowLevelSend         LowLevelSendDel;
#endif
 
    ENGINE_API void SetLocalPlayerFunction(TFunction<class ULocalPlayer*(UNetConnection*, APlayerController*)> GetPlayerFunction);
    ENGINE_API TFunction<class ULocalPlayer*(UNetConnection*, APlayerController*)> GetLocalPlayerFunction();
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnConnectionOpened, 
                                           UNetConnection*      /* ChildGameServerConnection */, 
                                           APlayerController*   /* PlayerController */, 
                                           UNetConnection*      /* ParentGameServerConnection */);
    FOnConnectionOpened& GetOnConnectionOpened() { return OnConnectionOpened; };
 
private:
 
    FOnConnectionOpened OnConnectionOpened;
    TFunction<class ULocalPlayer*(UNetConnection*, APlayerController*)> PlayerConnectionFunction;
 
public:
 
    ENGINE_API bool ShouldReplicateVoicePacketFrom(const FUniqueNetId& Sender);
    
    static class UNetConnection* GNetConnectionBeingCleanedUp;
 
    // Constructors and destructors.
    ENGINE_API UNetConnection(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    ENGINE_API UNetConnection(FVTableHelper& Helper);
 
    //~ Begin UObject Interface.
 
    ENGINE_API virtual void Serialize( FArchive& Ar ) override;
 
    ENGINE_API virtual void FinishDestroy() override;
 
    ENGINE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    ENGINE_API virtual UWorld* GetWorld() const override;
 
    //~ End UObject Interface.
 
 
    //~ Begin FExec Interface.
#if UE_ALLOW_EXEC_COMMANDS
    ENGINE_API virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar=*GLog ) override;
#endif
    //~ End FExec Interface.
 
    void ReadInput( float DeltaSeconds );
 
    virtual UChildConnection* GetUChildConnection()
    {
        return NULL;
    }
 
    virtual FString LowLevelGetRemoteAddress(bool bAppendPort=false) PURE_VIRTUAL(UNetConnection::LowLevelGetRemoteAddress,return TEXT(""););
 
    virtual FString LowLevelDescribe() PURE_VIRTUAL(UNetConnection::LowLevelDescribe,return TEXT(""););
 
    ENGINE_API virtual FString Describe();
 
    // @todo: Traits should be passed within bit readers/writers, eventually
    virtual void LowLevelSend(void* Data, int32 CountBits, FOutPacketTraits& Traits)
        PURE_VIRTUAL(UNetConnection::LowLevelSend,);
 
    ENGINE_API virtual void ValidateSendBuffer();
 
    ENGINE_API virtual void InitSendBuffer();
 
    ENGINE_API virtual void AssertValid();
 
    ENGINE_API virtual void FlushNet(bool bIgnoreSimulation = false);
 
    ENGINE_API virtual void Tick(float DeltaSeconds);
 
    UE_DEPRECATED(5.6, "Replaced with a version that doesn't have a saturate option. Call Saturate() directly if passing true before." )
    ENGINE_API virtual int32 IsNetReady( bool bSaturate);
 
    ENGINE_API virtual bool IsNetReady() const;
 
    ENGINE_API bool IsPacketSequenceWindowFull(uint32 SafetyMargin=0U);
 
    ENGINE_API virtual void HandleClientPlayer( class APlayerController* PC, class UNetConnection* NetConnection );
 
    virtual int32 GetAddrPort(void)
    {
        if (RemoteAddr.IsValid())
        {
            return RemoteAddr->GetPort();
        }
        return 0;
    }
 
    ENGINE_API UChildConnection* GetChildConnectionWithNetPlayerIndex(const int32 NetPlayerIndex);
 
    ENGINE_API bool GetNetPlayerIndex(UChildConnection* ChildConnection, int32* OutNetPlayerIndex);
 
    ENGINE_API UChildConnection* CreateChild(int32* OutNetPlayerIndex);
 
    ENGINE_API UChildConnection* CreateChildWithNetPlayerIndex(int32 NetPlayerIndex);
 
    ENGINE_API void RemoveChild(UChildConnection* ChildConnection);
 
    virtual TSharedPtr<const FInternetAddr> GetRemoteAddr() { return RemoteAddr; }
 
    void Close()
    {
        Close(FNetCloseResult());
    }
 
    void Close(FNetCloseResult&& CloseReason)
    {
        Close(static_cast<FNetResult&&>(MoveTemp(CloseReason)));
    }
 
    ENGINE_API void Close(FNetResult&& CloseReason);
 
 
    ENGINE_API void GracefulClose(FNetResult&& CloseReason);
 
    virtual void GracefulClose(FNetCloseResult&& CloseReason)
    {
        GracefulClose(static_cast<FNetResult&&>(MoveTemp(CloseReason)));
    }
 
    ENGINE_API virtual void CleanUp();
 
    ENGINE_API virtual void InitBase(UNetDriver* InDriver, class FSocket* InSocket, const FURL& InURL, EConnectionState InState, int32 InMaxPacket = 0, int32 InPacketOverhead = 0);
 
    virtual void InitRemoteConnection(UNetDriver* InDriver, class FSocket* InSocket, const FURL& InURL, const class FInternetAddr& InRemoteAddr, EConnectionState InState, int32 InMaxPacket = 0, int32 InPacketOverhead = 0) PURE_VIRTUAL(UNetConnection::InitRemoteConnection, );
    
    virtual void InitLocalConnection(UNetDriver* InDriver, class FSocket* InSocket, const FURL& InURL, EConnectionState InState, int32 InMaxPacket = 0, int32 InPacketOverhead = 0) PURE_VIRTUAL(UNetConnection::InitLocalConnection, );
    
    ENGINE_API virtual void InitConnection(UNetDriver* InDriver, EConnectionState InState, const FURL& InURL, int32 InConnectionSpeed=0, int32 InMaxPacket=0);
 
    ENGINE_API virtual void InitHandler();
 
    ENGINE_API virtual void InitSequence(int32 IncomingSequence, int32 OutgoingSequence);
 
    ENGINE_API virtual void NotifyAnalyticsProvider();
 
    ENGINE_API void EnableEncryption(const FEncryptionData& EncryptionData);
 
    ENGINE_API void EnableEncryptionServer(const FEncryptionData& EncryptionData);
 
    ENGINE_API void SetEncryptionData(const FEncryptionData& EncryptionData);
 
    ENGINE_API void SendClientEncryptionAck();
 
    ENGINE_API void EnableEncryption();
 
    ENGINE_API virtual bool IsEncryptionEnabled() const;
 
    virtual FString RemoteAddressToString()
    {
        if (RemoteAddr.IsValid())
        {
            return RemoteAddr->ToString(true);
        }
        return TEXT("Invalid");
    }
    
    
    ENGINE_API virtual TSharedPtr<FObjectReplicator> CreateReplicatorForNewActorChannel(UObject* Object);
 
    // Functions.
 
    int32 WriteBitsToSendBuffer( 
        const uint8 *   Bits, 
        const int32     SizeInBits, 
        const uint8 *   ExtraBits = NULL, 
        const int32     ExtraSizeInBits = 0,
        EWriteBitsDataType DataType =  EWriteBitsDataType::Unknown);
 
    int64 GetFreeSendBufferBits();
 
    void PopLastStart();
 
    ENGINE_API virtual bool ClientHasInitializedLevel(const ULevel* TestLevel) const;
 
    UE_DEPRECATED(5.4, "ClientHasInitializedLevelFor is deprecated. Use ClientHasInitializedLevel and pass the actor's level (Actor->GetLevel()) instead.")
    ENGINE_API virtual bool ClientHasInitializedLevelFor(const AActor* TestActor) const;
 
    ENGINE_API virtual void ReceivedRawPacket(void* Data,int32 Count);
 
    ENGINE_API int32 SendRawBunch(FOutBunch& Bunch, bool InAllowMerge, const FNetTraceCollector* BunchCollector);
    inline int32 SendRawBunch( FOutBunch& Bunch, bool InAllowMerge ) { return SendRawBunch(Bunch, InAllowMerge, nullptr); }
 
    inline int32 GetMaxSingleBunchSizeBits() const
    {
        return (MaxPacket * 8) - MAX_BUNCH_HEADER_BITS - MAX_PACKET_TRAILER_BITS - MAX_PACKET_HEADER_BITS - MaxPacketHandlerBits;
    }
 
    UNetDriver* GetDriver() {return Driver;}
    const UNetDriver* GetDriver() const { return Driver; }
 
    ENGINE_API UChannel* CreateChannelByName( const FName& ChName, EChannelCreateFlags CreateFlags, int32 ChannelIndex=INDEX_NONE );
 
    ENGINE_API virtual void ReceivedPacket( FBitReader& Reader, bool bIsReinjectedPacket=false, bool bDispatchPacket=true );
    
    ENGINE_API virtual void DispatchPacket( FBitReader& Reader, int32 PacketId, bool& bOutSkipAck, bool& bOutHasBunchErrors );
 
    void ReceivedNak( int32 NakPacketId );
 
    void ResetGameWorldState();
 
    void SlowAssertValid()
    {
#if DO_GUARD_SLOW
        AssertValid();
#endif
    }
 
    ENGINE_API class UVoiceChannel* GetVoiceChannel();
 
    ENGINE_API virtual void FlushDormancy(class AActor* Actor);
 
    ENGINE_API void ForcePropertyCompare( AActor* Actor );
 
    void FlushDormancyForObject(AActor* DormantActor, UObject* ReplicatedObject);
 
    ENGINE_API virtual void SetClientLoginState( const EClientLoginState::Type NewState );
 
    ENGINE_API void SetExpectedClientLoginMsgType( const uint8 NewType );
 
    ENGINE_API bool IsClientMsgTypeValid( const uint8 ClientMsgType );
 
    ENGINE_API bool TrackLogsPerSecond();
 
    ENGINE_API virtual float GetTimeoutValue();
 
    void StartTickingChannel(UChannel* Channel) { ChannelsToTick.AddUnique(Channel); }
 
    void StopTickingChannel(UChannel* Channel) { ChannelsToTick.Remove(Channel); }
 
    int32 GetNumTickingChannels() const { return ChannelsToTick.Num(); }
 
    inline FHistogram GetNetHistogram() const { return NetConnectionHistogram; }
 
    inline bool HasReceivedClientPacket()
    {
        // The InternalAck and ServerConnection conditions, are only there to exclude demo's and clients from this check,
        // so that the check is only performed on servers.
        return IsInternalAck() || Driver->ServerConnection != nullptr || InReliable[0] != InitInReliable;
    }
 
    ENGINE_API void SetPlayerOnlinePlatformName(const FName InPlayerOnlinePlatformName);
 
    FName GetPlayerOnlinePlatformName() const { return PlayerOnlinePlatformName; }
    
    void SetAllowExistingChannelIndex(bool bAllow);
 
private:
    void RestoreRemappedChannel(const int32 ChIndex);
 
public:
 
    void SetIgnoreActorBunches(bool bInIgnoreActorBunches, TSet<FNetworkGUID>&& InIgnoredBunchGuids);
 
    void SetReserveDestroyedChannels(bool bInReserveChannels);
 
    bool IsReservingDestroyedChannels() const { return bReserveDestroyedChannels; }
 
    void AddReservedChannel(int32 ChIndex) { ReservedChannels.Add(ChIndex); }
 
    void SetIgnoreReservedChannels(bool bInIgnoreReservedChannels);
 
    TArray<FOutBunch *>& GetOutgoingBunches() { return OutgoingBunches; }
 
    void StoreDormantReplicator(AActor* OwnerActor, UObject* Object, const TSharedRef<FObjectReplicator>& ObjectReplicator);
    
    TSharedPtr<FObjectReplicator> FindAndRemoveDormantReplicator(AActor* OwnerActor, UObject* Object);
 
    void RemoveDormantReplicator(AActor* Actor, UObject* Object);
 
    void CleanupDormantReplicatorsForActor(AActor* Actor);
 
    ENGINE_API void ExecuteOnAllDormantReplicators(UE::Net::FExecuteForEachDormantReplicator ExecuteFunction);
 
    void ExecuteOnAllDormantReplicatorsOfActor(AActor* OwnerActor, UE::Net::FExecuteForEachDormantReplicator ExecuteFunction);
 
    void CleanupStaleDormantReplicators();
 
    void PreTickDispatch();
 
    void PostTickDispatch();
 
    void FlushPacketOrderCache(bool bFlushWholeCache=false);
 
    int32 GetTotalOutOfOrderPackets() const
    {
        return TotalOutOfOrderPacketsLost + TotalOutOfOrderPacketsRecovered + TotalOutOfOrderPacketsDuplicate;
    }
 
    int32 GetTotalOutOfOrderPacketsLost() const
    {
        return TotalOutOfOrderPacketsLost;
    }
 
    int32 GetTotalOutOfOrderPacketsRecovered() const
    {
        return TotalOutOfOrderPacketsRecovered;
    }
 
    int32 GetTotalOutOfOrderPacketsDuplicate() const
    {
        return TotalOutOfOrderPacketsDuplicate;
    }
 
    void SetPacketOSReceiveTime(const FPacketTimestamp& InOSReceiveTime, bool bInIsOSReceiveTimeLocal)
    {
        LastOSReceiveTime = InOSReceiveTime;
        bIsOSReceiveTimeLocal = bInIsOSReceiveTimeLocal;
    }
 
    virtual void NotifyActorNetGUID(UActorChannel* Channel) {}
 
    ENGINE_API void ConsumeQueuedActorDelinquencyAnalytics(FNetQueuedActorDelinquencyAnalytics& Out);
 
    ENGINE_API const FNetQueuedActorDelinquencyAnalytics& GetQueuedActorDelinquencyAnalytics() const;
 
    ENGINE_API void ResetQueuedActorDelinquencyAnalytics();
 
    ENGINE_API void ConsumeSaturationAnalytics(FNetConnectionSaturationAnalytics& Out);
 
    ENGINE_API const FNetConnectionSaturationAnalytics& GetSaturationAnalytics() const;
 
    ENGINE_API void ResetSaturationAnalytics();
 
    ENGINE_API void ConsumePacketAnalytics(FNetConnectionPacketAnalytics& Out);
 
    ENGINE_API const FNetConnectionPacketAnalytics& GetPacketAnalytics() const;
 
    ENGINE_API void ResetPacketAnalytics();
 
    ENGINE_API void TrackReplicationForAnalytics(const bool bWasSaturated);
 
    uint32 GetOutTotalNotifiedPackets() const { return OutTotalNotifiedPackets; }
 
    ENGINE_API void SendChallengeControlMessage();
 
    void SendChallengeControlMessage(const FEncryptionKeyResponse& Response);
 
    bool GetPendingCloseDueToReplicationFailure() const
    {
        return bConnectionPendingCloseDueToReplicationFailure;
    }
 
    ENGINE_API void SetPendingCloseDueToReplicationFailure();
 
    ENGINE_API virtual void NotifyActorDestroyed(AActor* Actor, bool IsSeamlessTravel = false);
 
    ENGINE_API virtual void NotifyActorChannelCleanedUp(UActorChannel* Channel, EChannelCloseReason CloseReason);
 
    FNetLevelVisibilityTransactionId UpdateLevelStreamStatusChangedTransactionId(const ULevelStreaming* LevelObject, const FName PackageName, bool bShouldBeVisible);
 
protected:
 
    bool GetPendingCloseDueToSocketSendFailure() const
    {
        return bConnectionPendingCloseDueToSocketSendFailure;
    }
 
    ENGINE_API void SetPendingCloseDueToSocketSendFailure();
 
    void CleanupDormantActorState();
 
    void ClearDormantReplicatorsReference();
 
    ENGINE_API virtual void DestroyOwningActor();
 
    ENGINE_API virtual void DestroyIgnoredActor(AActor* Actor);
 
    ENGINE_API virtual void HandleConnectionTimeout(const FString& Error);
 
    ENGINE_API void NotifyConnectionUpdated();
 
    ENGINE_API int32 GetLastNotifiedPacketId() const;
 
private:
    UPROPERTY()
    TArray<TObjectPtr<UChannel>> ChannelsToTick;
 
    FHistogram NetConnectionHistogram;
 
    FName PlayerOnlinePlatformName;
 
    mutable TMap<FName, bool> ClientVisibleActorOuters;
 
    TMap<FName, FUpdateLevelVisibilityLevelInfo> PendingUpdateLevelVisibility;
 
    TMap<FName, FNetLevelVisibilityTransactionId> ClientPendingStreamingStatusRequest;
 
private:
 
    void OnStatelessHandshakeFailure(UE::Net::FStatelessHandshakeFailureInfo HandshakeFailureInfo);
 
    void UpdateLevelVisibilityInternal(const struct FUpdateLevelVisibilityLevelInfo& LevelVisibility);
 
    bool UpdateCachedLevelVisibility(const FName& PackageName) const;
 
    void UpdateAllCachedLevelVisibility() const;
 
#if DO_ENABLE_NET_TEST
    bool ShouldDropOutgoingPacketForLossSimulation(int64 NumBits) const;
#endif
 
#if DO_ENABLE_NET_TEST
    bool CheckOutgoingPacketEmulation(double CurrentTimeInS, FOutPacketTraits& Traits);
    bool CheckIncomingPacketEmulation(double CurrentTimeInS, FBitReader& Reader);
#endif
 
    void WritePacketHeader(FBitWriter& Writer);
 
    void WriteDummyPacketInfo(FBitWriter& Writer);
 
    void WriteFinalPacketInfo(FBitWriter& Writer, double PacketSentTimeInS);
    
    bool ReadPacketInfo(FBitReader& Reader, bool bHasPacketInfoPayload, FEngineNetworkCustomVersion::Type EngineNetVer);
 
    void ReceivedAck(int32 AckPacketId, FChannelsToClose& OutChannelsToClose);
 
    void ProcessJitter(uint32 PacketJitterClockTimeMS);
 
    void PrepareWriteBitsToSendBuffer(const int32 SizeInBits, const int32 ExtraSizeInBits);
    
    int32 WriteBitsToSendBufferInternal( 
        const uint8 *   Bits, 
        const int32     SizeInBits, 
        const uint8 *   ExtraBits, 
        const int32     ExtraSizeInBits,
        EWriteBitsDataType DataType =  EWriteBitsDataType::Unknown);
 
    FName ClientWorldPackageName;
 
    TMap<FString, TArray<float>> ActorsStarvedByClassTimeMap;
 
    TMap<int32, FNetworkGUID> IgnoringChannels;
 
    TMap<int32, int32> ChannelIndexMap;
 
    bool bAllowExistingChannelIndex;
 
    TSet<FNetworkGUID> IgnoredBunchGuids;
 
    TSet<int32> IgnoredBunchChannels;
 
    bool bIgnoreActorBunches;
 
    TSet<int32> ReservedChannels;
 
    bool bReserveDestroyedChannels;
    bool bIgnoreReservedChannels;
 
    TArray<FOutBunch*> OutgoingBunches;
 
    FWrittenChannelsRecord ChannelRecord;
 
    FNetPacketNotify PacketNotify;
 
    int32 LastNotifiedPacketId;
 
    uint32 OutTotalNotifiedPackets;
 
    uint32 HasDirtyAcks;
    
    bool bHasWarnedAboutChannelLimit;
 
    bool bConnectionPendingCloseDueToSocketSendFailure;
 
    bool bConnectionPendingCloseDueToReplicationFailure;
 
    FNetworkGUID GetActorGUIDFromOpenBunch(FInBunch& Bunch);
 
    int32 TotalOutOfOrderPacketsLost = 0;
 
    int32 TotalOutOfOrderPacketsRecovered = 0;
 
    int32 TotalOutOfOrderPacketsDuplicate = 0;
 
    TOptional<TCircularBuffer<TUniquePtr<FBitReader>>> PacketOrderCache;
 
    int32 PacketOrderCacheStartIdx;
 
    int32 PacketOrderCacheCount;
 
    FNetConnectionSaturationAnalytics SaturationAnalytics;
    FNetConnectionPacketAnalytics PacketAnalytics;
 
    bool bFlushingPacketOrderCache;
 
    UE::Net::FConnectionHandle ConnectionHandle;
 
#if UE_NET_TRACE_ENABLED
    FNetTraceCollector* InTraceCollector = nullptr;
    FNetTraceCollector* OutTraceCollector = nullptr;
    uint32 NetTraceId = 0;
#endif
 
    bool bFlushedNetThisFrame = false;
 
    AActor* RepContextActor;
    ULevel* RepContextLevel;
 
    friend struct FScopedRepContext;
 
    bool bAutoFlush;
 
    bool bLoggedFlushNetQueuedBitsOverflow = false;
 
    TUniquePtr<FRPCDoSDetection> RPCDoS;
 
    TUniquePtr<UE::Net::FNetConnectionFaultRecovery> FaultRecovery;
 
    bool bReceivedCloseReason = false;
 
    TPimplPtr<UE::Net::FNetResult, EPimplPtrMode::DeepCopy> PendingGracefulCloseResult;
 
    TPimplPtr<UE::Net::FNetPing> NetPing;
 
 
    int32 GetFreeChannelIndex(const FName& ChName) const;
 
public:
    AActor* GetRepContextActor() const { return RepContextActor; }
    ULevel* GetRepContextLevel() const { return RepContextLevel; }
 
    bool GetAutoFlush() const { return bAutoFlush; }
    void SetAutoFlush(bool bValue) { bAutoFlush = bValue; }
 
    FRPCDoSDetection* GetRPCDoS()
    {
        return RPCDoS.Get();
    }
 
    UE::Net::FNetConnectionFaultRecovery* GetFaultRecovery()
    {
        return FaultRecovery.Get();
    }
 
    UE::Net::FNetPing* GetNetPing()
    {
        return NetPing.Get();
    }
 
    void SendCloseReason(FNetCloseResult&& CloseReason)
    {
        SendCloseReason(static_cast<FNetResult&&>(MoveTemp(CloseReason)));
    }
 
    ENGINE_API void SendCloseReason(FNetResult&& CloseReason);
 
    ENGINE_API void HandleReceiveCloseReason(const FString& CloseReasonList);
 
    ENGINE_API bool HandleReceiveNetUpgrade(uint32 RemoteNetworkVersion, EEngineNetworkRuntimeFeatures RemoteNetworkFeatures,
                                            UE::Net::ENetUpgradeSource NetUpgradeSource=UE::Net::ENetUpgradeSource::ControlChannel);
 
private:
    void HandleNetResultOrClose(ENetCloseResult InResult);
 
    void TryClosePendingGracefulClose();
 
protected:
    TOptional<FNetworkCongestionControl> NetworkCongestionControl;
 
    void InitChannelData();
 
    void SetConnectionHandle(UE::Net::FConnectionHandle Handle)
    {
        ConnectionHandle = Handle;
    }
 
public:
    UE::Net::FDormantObjectMap* GetDormantFlushedObjectsForActor(AActor* Actor);
 
    void ClearDormantFlushedObjectsForActor(AActor* Actor);
};
 
struct FScopedRepContext
{
public:
    FScopedRepContext(UNetConnection* InConnection, AActor* InActor);
 
    FScopedRepContext(UNetConnection* InConnection, ULevel* InLevel)
        : Connection(InConnection)
    {
        if (Connection)
        {
            check(!Connection->RepContextActor);
            check(!Connection->RepContextLevel);
 
            Connection->RepContextLevel = InLevel;
        }
    }
 
    ~FScopedRepContext()
    {
        if (Connection)
        {
            Connection->RepContextActor = nullptr;
            Connection->RepContextLevel = nullptr;
        }
    }
 
    FScopedRepContext(FScopedRepContext&&) = delete;
    FScopedRepContext(const FScopedRepContext&) = delete;
    FScopedRepContext& operator=(const FScopedRepContext&) = delete;
    FScopedRepContext& operator=(FScopedRepContext&&) = delete;
 
private:
    UNetConnection* Connection;
};
 
struct FNetConnectionSettings
{
    FNetConnectionSettings( UNetConnection* InConnection )
    {
#if DO_ENABLE_NET_TEST
        PacketLag = InConnection->PacketSimulationSettings.PktLag;
        PacketLoss = InConnection->PacketSimulationSettings.PktLoss;
#else
        PacketLag = 0;
        PacketLoss = 0;
#endif
    }
 
    FNetConnectionSettings( int32 InPacketLag )
    {
        PacketLag = InPacketLag;
        PacketLoss = 0;
    }
 
    void ApplyTo(UNetConnection* Connection)
    {
#if DO_ENABLE_NET_TEST
        Connection->PacketSimulationSettings.PktLag = PacketLag;
        Connection->PacketSimulationSettings.PktLoss = PacketLoss;
#endif
    }
 
    int32 PacketLag;
    int32 PacketLoss;
};
 
struct FScopedNetConnectionSettings
{
    FScopedNetConnectionSettings(UNetConnection* InConnection, FNetConnectionSettings NewSettings, bool Apply=true) : 
        Connection(InConnection), OldSettings(InConnection), ShouldApply(Apply)
    {
        if (ShouldApply)
        {
            Connection->FlushNet();
            NewSettings.ApplyTo(Connection.Get());
        }
    }
    ~FScopedNetConnectionSettings()
    {
        UNetConnection* LocalConnection = Connection.Get();
        if (LocalConnection && ShouldApply)
        {
            LocalConnection->FlushNet();
            OldSettings.ApplyTo(LocalConnection);
        }
    }
 
    TWeakObjectPtr<UNetConnection> Connection;
    FNetConnectionSettings OldSettings;
    bool ShouldApply;
};
 
UCLASS(transient, config=Engine, MinimalAPI)
class USimulatedClientNetConnection
    : public UNetConnection
{
    GENERATED_UCLASS_BODY()
public:
 
    virtual void LowLevelSend(void* Data, int32 CountBits, FOutPacketTraits& Traits) override { }
    ENGINE_API void HandleClientPlayer( APlayerController* PC, UNetConnection* NetConnection ) override;
    virtual FString LowLevelGetRemoteAddress(bool bAppendPort=false) override { return FString(); }
    virtual bool ClientHasInitializedLevel(const ULevel* TestLevel) const override { return true; }
 
    virtual void DestroyOwningActor() override { /* Don't destroy the OwningActor since we follow a real PlayerController*/ }
 
    virtual TSharedPtr<const FInternetAddr> GetRemoteAddr() override { return nullptr; }
 
    virtual void InitRemoteConnection(UNetDriver* InDriver, class FSocket* InSocket, const FURL& InURL, const class FInternetAddr& InRemoteAddr, EConnectionState InState, int32 InMaxPacket = 0, int32 InPacketOverhead = 0) override {}
    virtual void InitLocalConnection(UNetDriver* InDriver, class FSocket* InSocket, const FURL& InURL, EConnectionState InState, int32 InMaxPacket = 0, int32 InPacketOverhead = 0) override {}
 
    virtual FString LowLevelDescribe() override { return TEXT("Simulated Client"); }
 
};
 
#if UE_NET_TRACE_ENABLED
    inline FNetTraceCollector* UNetConnection::GetInTraceCollector() const { return InTraceCollector; }
    inline FNetTraceCollector* UNetConnection::GetOutTraceCollector() const { return OutTraceCollector; }
#else
    inline FNetTraceCollector* UNetConnection::GetInTraceCollector() const { return nullptr; }
    inline FNetTraceCollector* UNetConnection::GetOutTraceCollector() const { return nullptr; }
#endif