NetTestHelpers.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "Engine/NetDriver.h"
 
#include "Containers/Array.h"
#include "GameFramework/PlayerController.h"
#include "Kismet/GameplayStatics.h"
 
class IConsoleVariable;
class UGameInstance;
class UReplicationSystem;
class UObjectReplicationBridge;
 
struct FGameInstancePIEParameters;
 
#if WITH_EDITOR
 
namespace UE::Net
{
 
template<class T>
int32 NumActors(UWorld* World)
{
    TArray<AActor*> Actors;
    UGameplayStatics::GetAllActorsOfClass(Cast<UObject>(World), T::StaticClass(), Actors);
    return Actors.Num();
}
 
/*
 * Used to set a cvar and restore it to it's original value when destroyed
 */
class [[nodiscard]] FScopedCVarOverrideInt
{
public:
    ENGINE_API FScopedCVarOverrideInt(const TCHAR* VariableName, int32 Value);
    ENGINE_API ~FScopedCVarOverrideInt();
 
    FScopedCVarOverrideInt(FScopedCVarOverrideInt&&) = delete;
    FScopedCVarOverrideInt(const FScopedCVarOverrideInt&) = delete;
    FScopedCVarOverrideInt& operator=(FScopedCVarOverrideInt&&) = delete;
    FScopedCVarOverrideInt& operator=(const FScopedCVarOverrideInt&) = delete;
 
private:
    IConsoleVariable* Variable = nullptr;
    int32 SavedValue = 0;
};
 
class [[nodiscard]] FScopedCVarOverrideFloat
{
public:
    ENGINE_API FScopedCVarOverrideFloat(const TCHAR* VariableName, float Value);
    ENGINE_API ~FScopedCVarOverrideFloat();
 
    FScopedCVarOverrideFloat(FScopedCVarOverrideFloat&&) = delete;
    FScopedCVarOverrideFloat(const FScopedCVarOverrideFloat&) = delete;
    FScopedCVarOverrideFloat& operator=(FScopedCVarOverrideFloat&&) = delete;
    FScopedCVarOverrideFloat& operator=(const FScopedCVarOverrideFloat&) = delete;
 
private:
    IConsoleVariable* Variable = nullptr;
    float SavedValue = 0;
};
 
class FScopedTestSettings
{
public:
    ENGINE_API FScopedTestSettings();
    ENGINE_API ~FScopedTestSettings();
 
    FScopedTestSettings(FScopedTestSettings&&) = delete;
    FScopedTestSettings(const FScopedTestSettings&) = delete;
    FScopedTestSettings& operator=(FScopedTestSettings&&) = delete;
    FScopedTestSettings& operator=(const FScopedTestSettings&) = delete;
 
private:
    FScopedCVarOverrideInt AddressResolutionDisabled;
    FScopedCVarOverrideInt BandwidthThrottlingDisabled;
    FScopedCVarOverrideInt RepGraphBandwidthThrottlingDisabled;
    FScopedCVarOverrideInt RandomNetUpdateDelayDisabled;
    FScopedCVarOverrideInt GameplayDebuggerDisabled;
};
 
class FScopedNetTestPIERestoration
{
public:
 
    ENGINE_API FScopedNetTestPIERestoration();
    ENGINE_API ~FScopedNetTestPIERestoration();
 
    FScopedNetTestPIERestoration(FScopedNetTestPIERestoration&&) = delete;
    FScopedNetTestPIERestoration(const FScopedNetTestPIERestoration&) = delete;
    FScopedNetTestPIERestoration& operator=(FScopedNetTestPIERestoration&&) = delete;
    FScopedNetTestPIERestoration& operator=(const FScopedNetTestPIERestoration&) = delete;
 
private:
 
    // Restores PIE world context
    UWorld* OldGWorld = nullptr;
    int32 OldPIEID = 0;
    bool OldGIsPlayInEditorWorld = false;
};
 
struct FTestWorldInstance
{
    struct FContext;
 
public:
    ENGINE_API static FTestWorldInstance CreateServer(const TCHAR* InURL, const EReplicationSystem ReplicationSystem = EReplicationSystem::Default);
    ENGINE_API static FTestWorldInstance CreateClient(int32 ServerPort, int32 NumLocalPlayers = 1);
    ENGINE_API static FTestWorldInstance CreateProxy();
 
    ENGINE_API ~FTestWorldInstance();
 
    FTestWorldInstance(const FTestWorldInstance&) = delete;
    FTestWorldInstance& operator=(const FTestWorldInstance&) = delete;
 
    explicit FTestWorldInstance(bool bDelayedInit) : GameInstance(nullptr) {}
    
    ENGINE_API FTestWorldInstance(FTestWorldInstance&& Other);
    ENGINE_API FTestWorldInstance& operator=(FTestWorldInstance&& Other);
 
    ENGINE_API FWorldContext* GetWorldContext() const;  
 
    ENGINE_API FContext GetTestContext() const;
 
    ENGINE_API UWorld* GetWorld() const;
    ENGINE_API UNetDriver* GetNetDriver() const;
 
    ENGINE_API int32 GetPort();
 
    ENGINE_API void Tick(float DeltaSeconds = 0.0166f);
 
    ENGINE_API void LoadStreamingLevel(FName LevelName);
    ENGINE_API void UnloadStreamingLevel(FName LevelName);
 
public:
 
    struct FContext
    {
        UWorld* World = nullptr;
        UNetDriver* NetDriver = nullptr;
        UReplicationSystem* IrisRepSystem = nullptr;
        UObjectReplicationBridge* IrisRepBridge = nullptr;
 
        bool IsValid() const
        {
            return World && NetDriver && IrisRepSystem && IrisRepBridge;
        }
    };
 
public:
 
    UGameInstance* GameInstance = nullptr;
 
private:
    explicit FTestWorldInstance(const FGameInstancePIEParameters& InstanceParams);
 
    void Shutdown();
 
    static int32 FindUnusedPIEInstance();
 
    int32 LevelStreamRequestUUID = 0;
};
 
struct FTestWorlds
{
    ENGINE_API FTestWorlds(const EReplicationSystem ReplicationSystem = EReplicationSystem::Default);
 
    ENGINE_API FTestWorlds(const FString& MapName, const FString& GameModeName, const EReplicationSystem ReplicationSystem = EReplicationSystem::Default);
 
    ENGINE_API explicit FTestWorlds(const TCHAR* ServerURL, const EReplicationSystem ReplicationSystem = EReplicationSystem::Default);
 
    ENGINE_API ~FTestWorlds();
 
    ENGINE_API void SetTickInSeconds(float TickInSeconds);
    float GetTickDeltaSeconds() const { return TickDeltaSeconds; }
    
    ENGINE_API bool CreateAndConnectClient();
 
    ENGINE_API int32 ConnectNewClient();
 
    ENGINE_API void TickAll(int32 NumTicks=1);
    ENGINE_API void TickServer();
    ENGINE_API void TickClients();
 
    ENGINE_API void TickServerAndDrop();
    ENGINE_API void TickClientsAndDrop();
 
    ENGINE_API void TickServerAndDelay(uint32 NumFramesToDelay = 1);
    ENGINE_API void TickClientsAndDelay(uint32 NumFramesToDelay = 1);
 
    template<class PredicateT>
    bool TickAllUntil(const PredicateT& Predicate, float DeltaSeconds = 0.0166f, int32 MaxTicks = 60);
 
    ENGINE_API bool WaitForClientConnect(FTestWorldInstance& Client);
 
    ENGINE_API APlayerController* GetServerPlayerControllerOfClient(uint32 ClientIndex);
 
    ENGINE_API UObject* FindReplicatedObjectOnClient(UObject* ServerObject, uint32 ClientIndex) const;
 
    template<typename T>
    T* FindReplicatedObjectOnClient(UObject* ServerObject, uint32 ClientIndex) const
    {
        return Cast<T>(FindReplicatedObjectOnClient(ServerObject, ClientIndex));
    }
 
    ENGINE_API bool DoesReplicatedObjectExistOnClient(UObject* ServerObject, uint32 ClientIndex) const;
 
    ENGINE_API bool IsServerObjectReplicated(const UObject* ServerObject) const;
 
public:
 
    DECLARE_MULTICAST_DELEGATE(FPreTickAll);
    FPreTickAll PreTickAllDelegate;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnClientConnected, const FTestWorldInstance& Client);
    FOnClientConnected OnClientConnected;
 
public:
 
    FTestWorldInstance Server;
    TArray<FTestWorldInstance> Clients;
 
private:
 
    void InitDelegates();
 
    void OnNetDriverCreated(UWorld* InWorld, UNetDriver* InNetDriver);
    FDelegateHandle NetDriverCreatedHandle;
 
private:
 
    float TickDeltaSeconds = 0.0166f;
 
    // Sets up important settings for the networking system to run optimally
    FScopedTestSettings TestSettings;
 
    // Restore GWorld and other PIE settings
    FScopedNetTestPIERestoration PIERestoration;
};
 
//------------------------------------------------------------------------
// Inline functions
//------------------------------------------------------------------------
 
template<class PredicateT>
inline bool FTestWorlds::TickAllUntil(const PredicateT& Predicate, float DeltaSeconds, int32 MaxTicks)
{
    PreTickAllDelegate.Broadcast();
 
    int32 TickCount = 0;
    bool bPredicateResult = Predicate();
        
    while (!bPredicateResult && TickCount < MaxTicks)
    {
        Server.Tick(DeltaSeconds);
        for (FTestWorldInstance& Client : Clients)
        {
            Client.Tick(DeltaSeconds);
        }
        TickCount++;
        GFrameCounter++;
        bPredicateResult = Predicate();
    }
 
    return bPredicateResult;
}
 
ENGINE_API bool IsClientConnected(FTestWorldInstance& Instance);
ENGINE_API bool IsServerConnected(FTestWorldInstance& Instance);
 
} // end namespace UE::Net
 
#endif //WITH_EDITOR