NetworkDelegates.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/Object.h"
#include "Engine/EngineBaseTypes.h"
#include "UObject/CoreNet.h"
 
class UPendingNetGame;
class UNetDriver;
 
namespace EAcceptConnection
{
    enum Type
    {
        Reject,
        Accept,
        Ignore
    };
 
    inline const TCHAR* ToString(EAcceptConnection::Type EnumVal)
    {
        switch (EnumVal)
        {
            case Reject:
            {
                return TEXT("Reject");
            }
            case Accept:
            {
                return TEXT("Accept");
            }
            case Ignore:
            {
                return TEXT("Ignore");
            }
        }
        return TEXT("");
    }
};
 
class FNetworkNotify
{
public:
    virtual EAcceptConnection::Type NotifyAcceptingConnection() PURE_VIRTUAL(FNetworkNotify::NotifyAcceptedConnection, return EAcceptConnection::Ignore;);
 
    virtual void NotifyAcceptedConnection(class UNetConnection* Connection) PURE_VIRTUAL(FNetworkNotify::NotifyAcceptedConnection, );
 
    virtual bool NotifyAcceptingChannel(class UChannel* Channel) PURE_VIRTUAL(FNetworkNotify::NotifyAcceptingChannel, return false;);
 
    virtual void NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, class FInBunch& Bunch) PURE_VIRTUAL(FNetworkNotify::NotifyReceivedText, );
};
 
enum class EEncryptionResponse : uint8
{
    Failure,
    Success,
    InvalidToken,
    NoKey,
    SessionIdMismatch,
    InvalidParams
};
 
inline const TCHAR* const LexToString(const EEncryptionResponse Response)
{
    switch (Response)
    {
        case EEncryptionResponse::Failure:
            return TEXT("Failure");
        case EEncryptionResponse::Success:
            return TEXT("Success");
        case EEncryptionResponse::InvalidToken:
            return TEXT("InvalidToken");
        case EEncryptionResponse::NoKey:
            return TEXT("NoKey");
        case EEncryptionResponse::SessionIdMismatch:
            return TEXT("SessionIdMismatch");
        case EEncryptionResponse::InvalidParams:
            return TEXT("InvalidParams");
        default:
            break;
    }
 
    checkf(false, TEXT("Missing EncryptionResponse Type: %d"), static_cast<const int32>(Response));
    return TEXT("");
}
 
struct FEncryptionKeyResponse
{
    EEncryptionResponse Response;
    FString ErrorMsg;
    FEncryptionData EncryptionData;
 
    FEncryptionKeyResponse()
        : Response(EEncryptionResponse::Failure)
    {
    }
 
    FEncryptionKeyResponse(EEncryptionResponse InResponse, const FString& InErrorMsg)
        : Response(InResponse)
        , ErrorMsg(InErrorMsg)
    {
    }
};
 
enum class EEncryptionFailureAction : uint8
{
    Default,
    RejectConnection,
    AllowConnection
};
 
enum class ECheatPunishType : uint8
{
    /* Unknown type of cheat punishment */
    Unknown,
    KickClient,
    KickMatch,
    PunishInfo
};
 
inline const TCHAR* const LexToString(const ECheatPunishType Response)
{
    switch (Response)
    {
        case ECheatPunishType::Unknown:
            return TEXT("Unknown");
        case ECheatPunishType::KickClient:
            return TEXT("KickClient");
        case ECheatPunishType::KickMatch:
            return TEXT("KickMatch");
        case ECheatPunishType::PunishInfo:
            return TEXT("PunishInfo");
        default:
            break;
    }
 
    checkf(false, TEXT("Missing ECheatPunishType Type: %d"), static_cast<const int32>(Response));
    return TEXT("");
}
 
DECLARE_DELEGATE_OneParam(FOnEncryptionKeyResponse, const FEncryptionKeyResponse& );
 
enum class ENetSyncLoadType : int32
{
    Unknown,
    PropertyReference,
    ActorSpawn
};
 
struct FNetSyncLoadReport
{
    FNetSyncLoadReport()
        : Type(ENetSyncLoadType::Unknown)
        , NetDriver(nullptr)
        , OwningObject(nullptr)
        , Property(nullptr)
        , LoadedObject(nullptr) {}
 
    ENetSyncLoadType Type;
 
    const UNetDriver* NetDriver;
 
    const UObject* OwningObject;
 
    const FProperty* Property;
 
    const UObject* LoadedObject;
};
 
class FNetDelegates
{
 
public:
 
    DECLARE_DELEGATE_TwoParams(FReceivedNetworkEncryptionToken, const FString& /*EncryptionToken*/, const FOnEncryptionKeyResponse& /*Delegate*/);
    static ENGINE_API FReceivedNetworkEncryptionToken OnReceivedNetworkEncryptionToken;
 
    DECLARE_DELEGATE_OneParam(FReceivedNetworkEncryptionAck, const FOnEncryptionKeyResponse& /*Delegate*/);
    static ENGINE_API FReceivedNetworkEncryptionAck OnReceivedNetworkEncryptionAck;
 
    DECLARE_DELEGATE_RetVal_OneParam(EEncryptionFailureAction, FReceivedNetworkEncryptionFailure, UNetConnection* /* Connection */);
    static ENGINE_API FReceivedNetworkEncryptionFailure OnReceivedNetworkEncryptionFailure;
 
 
    DECLARE_DELEGATE_FourParams(FNetworkCheatDetected, const class FUniqueNetId& /*PlayerId*/, ECheatPunishType /*PunishType*/, const FString& /*ReasonStr*/, const FString& /*InfoStr*/);
    static ENGINE_API FNetworkCheatDetected OnNetworkCheatDetected;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPendingNetGameConnectionCreated, UPendingNetGame* /*PendingNetGame*/);
    static ENGINE_API FOnPendingNetGameConnectionCreated OnPendingNetGameConnectionCreated;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnSyncLoadDetected, const FNetSyncLoadReport& /* SyncLoadReport */);
    static ENGINE_API FOnSyncLoadDetected OnSyncLoadDetected;
};