SessionTransitionSubsystem.h

Go to the documentation of this file.

// Copyright (c) 2026 Nelaric

 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Ticker.h"
#include "Core/NetWork/NetworkEndpoint.h"
#include "Delegates/Delegate.h"
#include "Engine/EngineBaseTypes.h"
#include "Misc/Optional.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "Templates/UniquePtr.h"
#include "UObject/WeakObjectPtr.h"
 
#include "SessionTransitionSubsystem.generated.h"
 
class UWorld;
 
namespace Nelaric
{
class FGameplayRuntimeInternalAccessKey;

struct FTransitionDestination
{
    FNetworkEndpoint GameEndpoint;

    FNetworkEndpoint BeaconEndpoint;
};

DECLARE_DELEGATE_RetVal_TwoParams(bool, FStartTransitionApproval, uint64, const FTransitionDestination&);

DECLARE_DELEGATE_OneParam(FOnTransitionTerminated, uint64);

struct FTransitionHandle
{
    uint64 Id = 0;
};

enum class ETransitionError : uint8
{
    UnsupportedMode,

    NoWorld,

    MissingDestination,

    Busy,

    AuthorityRejected,

    AuthorityUnavailable,

    ConfirmationInvalid,

    TravelFailed,

    NetworkFailed,

    UnexpectedNetMode,
};

DECLARE_DELEGATE_TwoParams(FOnTransitionSucceeded, FTransitionHandle, ENetMode);

DECLARE_DELEGATE_OneParam(FOnTransitionCancelled, FTransitionHandle);

DECLARE_DELEGATE_OneParam(FOnTransitionTimedOut, FTransitionHandle);

DECLARE_DELEGATE_TwoParams(FOnTransitionFailed, FTransitionHandle, ETransitionError);

struct FTransitionCallbacks
{
    FOnTransitionSucceeded OnSucceeded;

    FOnTransitionCancelled OnCancelled;

    FOnTransitionTimedOut OnTimedOut;

    FOnTransitionFailed OnFailed;
};
} // namespace Nelaric

UCLASS(MinimalAPI)
class USessionTransitionSubsystem : public UGameInstanceSubsystem
{
    GENERATED_BODY()
 
public:
    GAMEPLAYRUNTIME_API Nelaric::FTransitionHandle RequestTransition(ENetMode TargetMode,
                                                                     const Nelaric::FTransitionDestination& Destination,
                                                                     const Nelaric::FTransitionCallbacks& Callbacks);

    GAMEPLAYRUNTIME_API bool CancelTransition(Nelaric::FTransitionHandle Handle);

    GAMEPLAYRUNTIME_API TOptional<ENetMode> GetNetMode() const;
 
public:
    GAMEPLAYRUNTIME_API void InternalConfigureApprovalTransport(const Nelaric::FGameplayRuntimeInternalAccessKey& Key,
                                                                const Nelaric::FStartTransitionApproval& Source,
                                                                const Nelaric::FStartTransitionApproval& Target,
                                                                const Nelaric::FOnTransitionTerminated& Terminated);

    GAMEPLAYRUNTIME_API void InternalClearApprovalTransport(const Nelaric::FGameplayRuntimeInternalAccessKey& Key);

    GAMEPLAYRUNTIME_API void InternalReportSourceApproval(const Nelaric::FGameplayRuntimeInternalAccessKey& Key,
                                                          uint64 RequestId, bool bApproved);

    GAMEPLAYRUNTIME_API void InternalReportTargetApproval(const Nelaric::FGameplayRuntimeInternalAccessKey& Key,
                                                          uint64 RequestId, bool bApproved);

    GAMEPLAYRUNTIME_API void InternalReportTargetUnavailable(const Nelaric::FGameplayRuntimeInternalAccessKey& Key,
                                                             uint64 RequestId);
 
protected:
    GAMEPLAYRUNTIME_API virtual void Initialize(FSubsystemCollectionBase& Collection) override;

    GAMEPLAYRUNTIME_API virtual void Deinitialize() override;
 
private:
    struct FActiveTransition
    {
        Nelaric::FTransitionHandle Handle;
        Nelaric::FTransitionCallbacks Callbacks;
        Nelaric::FTransitionDestination Destination;
        TWeakObjectPtr<UWorld> SourceWorld;
        double DeadlineSeconds = 0.0;
        bool bSourceApproved = false;
        bool bTargetApproved = false;
        bool bTravelStarted = false;
    };
 
    bool Tick(float DeltaTime);
    void TryStartTravel();
    void Fail(Nelaric::ETransitionError Error);
    void FinishSucceeded(ENetMode Mode);
    void FinishTimedOut();
    void FinishCancelled();
 
    Nelaric::FStartTransitionApproval StartSourceApproval;
    Nelaric::FStartTransitionApproval StartTargetApproval;
    Nelaric::FOnTransitionTerminated OnTerminated;
    TUniquePtr<FActiveTransition> Active;
    FTSTicker::FDelegateHandle TickHandle;
    uint64 NextRequestId = 1;
};