MultiplayerManagerComponent.cpp

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#include "MultiplayerManagerComponent.h"
#include "PVROnlineSession.h"
#include "PVROSubsystem.h"
 
DEFINE_LOG_CATEGORY_STATIC(LogMultiplayerManagerComponent, Verbose, All);
 
#define Verbose(pmt, ...) UE_LOG(LogMultiplayerManagerComponent, Verbose, TEXT(pmt), ##__VA_ARGS__)
#define Log(pmt, ...) UE_LOG(LogMultiplayerManagerComponent, Log, TEXT(pmt), ##__VA_ARGS__)
#define Warn(pmt, ...) UE_LOG(LogMultiplayerManagerComponent, Warning, TEXT(pmt), ##__VA_ARGS__)
#define Error(pmt, ...) UE_LOG(LogMultiplayerManagerComponent, Error, TEXT(pmt), ##__VA_ARGS__)
#define Fatal(pmt, ...) UE_LOG(LogMultiplayerManagerComponent, Fatal, TEXT(pmt), ##__VA_ARGS__)
 
// Sets default values for this component's properties
UMultiplayerManagerComponent::UMultiplayerManagerComponent()
{
    // Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
    // off to improve performance if you don't need them.
    PrimaryComponentTick.bCanEverTick = true;
 
    Log("Multiplayer Manager Component has been created.");
 
    // ...
#if UE_SERVER
    AgonesSDK = CreateDefaultSubobject<UAgonesComponent>(TEXT("AgonesSDK"));
#endif
}
 
 
// Called when the game starts
void UMultiplayerManagerComponent::BeginPlay()
{
    Super::BeginPlay();
 
    Log("Are we a server?");
#if UE_SERVER
    Log("We are! Start Playing with Server.");
 
    check(AgonesSDK);
    bWasMetaDataSet = false;
    AgonesSDK->Connect();
    if (IOnlineSubsystem* const OnlineSubsystem = IOnlineSubsystem::Get())
    {
        Log("Get the online subsystem.");
        FPVROnlineSessionPtr SessionInt = StaticCastSharedPtr<FPVROnlineSession>(OnlineSubsystem->GetSessionInterface());
        if (SessionInt.IsValid())
        {
            auto NamedSession = SessionInt->GetFirstNamedSession();
            Log("Found first named session.");
            if (NamedSession)
            {
                FSetLabelDelegate SetLabelSuccessDelegate;
                SetLabelSuccessDelegate.BindDynamic(this, &UMultiplayerManagerComponent::OnSetLabelSuccess);
                FAgonesErrorDelegate SetLabelFailDelegate;
                SetLabelFailDelegate.BindDynamic(this, &UMultiplayerManagerComponent::OnSetLabelFail);
                Log("Online Session was already created!");
                FString MapName;
                NamedSession->SessionSettings.Get(SETTING_MAPNAME, MapName);
                AgonesSDK->SetLabel("SessionID", NamedSession->GetSessionIdStr(), SetLabelSuccessDelegate, SetLabelFailDelegate);
                AgonesSDK->SetLabel("MapName", MapName, SetLabelSuccessDelegate, SetLabelFailDelegate);
                AgonesSDK->SetLabel("OwningUserName", NamedSession->OwningUserName, SetLabelSuccessDelegate, SetLabelFailDelegate);
                AgonesSDK->SetLabel("SessionName", NamedSession->SessionName.ToString(), SetLabelSuccessDelegate, SetLabelFailDelegate);
            }
            else
            {
                SessionInt->OnCreateSessionCompleteDelegates.AddUObject(this, &UMultiplayerManagerComponent::OnSessionCreated);
            }
        }
    }
    GameServerDelegate.BindDynamic(this, &UMultiplayerManagerComponent::OnGameServerChanged);
    AgonesSDK->WatchGameServer(GameServerDelegate);
#endif
}
 
void UMultiplayerManagerComponent::OnSetLabelSuccess(const FEmptyResponse& Response)
{
    Verbose("Set label success.");
}
 
void UMultiplayerManagerComponent::OnSetLabelFail(const FAgonesError& Error)
{
    Verbose("Set label error: %s", *Error.ErrorMessage);
}
 
// Called every frame
void UMultiplayerManagerComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
 
    // ...
}
 
void UMultiplayerManagerComponent::OnGameServerChanged(const FGameServerResponse& Response)
{
    Verbose("Game server %s changed with state %s at address %s and health checks are %s", *Response.ObjectMeta.Name, *Response.Status.State, *Response.Status.Address, Response.Spec.Health.bDisabled ? TEXT("Disabled") : TEXT("Enabled"));
 
#if UE_SERVER
    if (Response.Status.State.Equals("Ready", ESearchCase::Type::IgnoreCase) && !bWasMetaDataSet)
    {
        Log("Server is ready.");
        int ModuleID = 0;
        if (!FParse::Value(FCommandLine::Get(), TEXT("-PIXOVR_MODULE_ID="), ModuleID))
        {
            // OK, we failed to find the module version reading from the terminal. Let's check the ini files.
            if (GConfig && !GConfig->GetInt(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("ModuleId"), ModuleID, GEngineIni))
            {
                Fatal("No Module ID available.");
            }
        }
 
        int OrgID = 0;
        if (!FParse::Value(FCommandLine::Get(), TEXT("-PIXOVR_ORG_ID="), OrgID))
        {
            // This is likely stored already in the server data. Thanks Agones!
            Error("No Org ID available.");
        }
 
        FString ModuleVersion = TEXT("0.1.0");
        if (!FParse::Value(FCommandLine::Get(), TEXT("-PIXOVR_MODULE_VERSION="), ModuleVersion))
        {
            // OK, we failed to find the module version reading from the terminal. Let's check the ApexSDK.
            if (GConfig && !GConfig->GetString(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("ModuleVersion"), ModuleVersion, GEngineIni))
            {
                Fatal("No Module Version available.");
            }
        }
 
        // We won't include OrgID since we're now using Agones to fill that information out for the server.
        AgonesSDK->SetLabel("ModuleID", FString::FromInt(ModuleID), {}, {});
        AgonesSDK->SetLabel("ModuleVersion", ModuleVersion, {}, {});
 
        Log("Flagging that meta data was set.");
        bWasMetaDataSet = true;
    }
#endif
}
 
void UMultiplayerManagerComponent::OnSessionCreated(FName SessionName, bool bWasSuccessful)
{
    Log("Online Session was Created!");
    if (!bWasSuccessful)
    {
        Warn("No session was created successfully.");
        return;
    }
 
#if UE_SERVER
    if (IOnlineSubsystem* const OnlineSubsystem = IOnlineSubsystem::Get())
    {
        FPVROnlineSessionPtr SessionInt = StaticCastSharedPtr<FPVROnlineSession>(OnlineSubsystem->GetSessionInterface());
        if (SessionInt.IsValid())
        {
            auto NamedSession = SessionInt->GetNamedSession(SessionName);
            if (NamedSession)
            {
                AgonesSDK->SetLabel("SessionID", NamedSession->GetSessionIdStr(), {}, {});
                FString MapName;
                NamedSession->SessionSettings.Get(SETTING_MAPNAME, MapName);
                AgonesSDK->SetLabel("MapName", MapName, {}, {});
                AgonesSDK->SetLabel("OwningUserName", NamedSession->OwningUserName, {}, {});
            }
            AgonesSDK->SetLabel("SessionName", SessionName.ToString(), {}, {});
        }
    }
#endif
}
 
void UMultiplayerManagerComponent::SetUserInfo(FString InUserName, int InUserOrgId)
{
    if (IOnlineSubsystem* const OnlineSubsystem = IOnlineSubsystem::Get())
    {
        FPVROSubsystem* PVROSubsystem = (FPVROSubsystem*)OnlineSubsystem;
        if (PVROSubsystem)
        {
            PVROSubsystem->SetUserInfo(InUserName, InUserOrgId);
        }
    }
}
 
void UMultiplayerManagerComponent::SetModuleInfo(int InModuleId, FString InModuleVersion)
{
    if (IOnlineSubsystem* const OnlineSubsystem = IOnlineSubsystem::Get())
    {
        FPVROSubsystem* PVROSubsystem = (FPVROSubsystem*)OnlineSubsystem;
        if (PVROSubsystem)
        {
            PVROSubsystem->SetModuleInfo(InModuleId, InModuleVersion);
        }
    }
}
 
bool UMultiplayerManagerComponent::FindSessions(float InTimeoutInSeconds, int InOrgId, int InModuleId, FString InUserName, FString InModuleVersion)
{
    UGameInstance* GameInstance = GetWorld()->GetGameInstance();
 
    if (GameInstance)
    {
        if (IOnlineSubsystem* const OnlineSubsystem = IOnlineSubsystem::Get())
        {
            IOnlineSessionPtr Session = OnlineSubsystem->GetSessionInterface();
            if (Session.IsValid())
            {
                TSharedPtr<FOnlineSessionSearch> SearchSettings = MakeShareable(new FOnlineSessionSearch());
                SearchSettings->QuerySettings.Set(FName(TEXT("OrgID")), InOrgId, EOnlineComparisonOp::Equals);
                SearchSettings->QuerySettings.Set(FName(TEXT("ModuleID")), InModuleId, EOnlineComparisonOp::Equals);
                SearchSettings->QuerySettings.Set(FName(TEXT("UserName")), InUserName, EOnlineComparisonOp::Equals);
                SearchSettings->QuerySettings.Set(FName(TEXT("ModuleVersion")), InModuleVersion, EOnlineComparisonOp::Equals);
                SearchSettings->TimeoutInSeconds = InTimeoutInSeconds;
 
                TSharedRef<FOnlineSessionSearch> SearchSettingsRef = SearchSettings.ToSharedRef();
 
                ULocalPlayer* const Player = GameInstance->GetFirstGamePlayer();
                Session->FindSessions(*Player->GetPreferredUniqueNetId().GetUniqueNetId(), SearchSettingsRef);
            }
        }
    }
 
    Warn("No suitable Online Subsystem is available.");
    return false;
}
 
#undef Verbose
#undef Log
#undef Warn
#undef Error
#undef Fatal