GameLift and FlexMatch

Server module dependencies: AWSIKGameLiftServers, BetideCore, Engine. This module supports Editor and Server targets only; keep these calls out of client modules.

// GameLiftServerGameInstance.h
#pragma once

#include "Engine/GameInstance.h"
#include "Subsystems/AWSIKGameLiftServersSubsystem.h"
#include "GameLiftServerGameInstance.generated.h"

UCLASS()
class UGameLiftServerGameInstance : public UGameInstance
{
    GENERATED_BODY()

  public:
    UFUNCTION(BlueprintCallable)
    void StartManagedServer();

    UFUNCTION(BlueprintCallable)
    void EndManagedServer();

  private:
    UPROPERTY(Transient)
    TObjectPtr<UAWSIKGameLiftServersSubsystem> Server;

    bool bStartupRequested = false;
    bool bStopping = false;

    UFUNCTION()
    void OnAssignedSession(const FAWSIKGameLiftServerGameSession &GameSession);

    void ReleaseGameLiftSdkAndExit();
};

// GameLiftServerGameInstance.cpp
#include "GameLiftServerGameInstance.h"
#include "AWSIKGameLiftServers.h"
#include "Libraries/AWSIKGameLiftServersLibrary.h"

void UGameLiftServerGameInstance::StartManagedServer()
{
    if (!IsRunningDedicatedServer() || bStartupRequested)
    {
        return;
    }
    bStartupRequested = true;
    Server = GetSubsystem<UAWSIKGameLiftServersSubsystem>();
    if (!Server)
    {
        UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("GameLift server subsystem unavailable"));
        UAWSIKGameLiftServersLibrary::RequestServerExit(false);
        return;
    }
    FAWSIKGameLiftServerError Error;
    if (!Server->InitSdk(Error))
    {
        UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("%s"), *Error.Common.Message);
        ReleaseGameLiftSdkAndExit();
        return;
    }
    Server->OnStartGameSession.AddUniqueDynamic(this, &ThisClass::OnAssignedSession);
    Server->OnProcessTerminate.AddUniqueDynamic(this, &ThisClass::EndManagedServer);
    Server->SetHealthy(true);

    FAWSIKGameLiftServerProcessParameters Parameters;
    FString Address;
    UAWSIKGameLiftServersLibrary::GetServerBindAddressAndPort(Address, Parameters.Port);
    Parameters.LogPaths.Add(UAWSIKGameLiftServersLibrary::GetLogFilePath());
    if (!Server->ProcessReady(Parameters, Error))
    {
        UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("%s"), *Error.Common.Message);
        EndManagedServer();
        return;
    }
    UE_LOG(LogAWSIKGameLiftServers, Log, TEXT("GameLift process ready; waiting for a session"));
}

void UGameLiftServerGameInstance::OnAssignedSession(
    const FAWSIKGameLiftServerGameSession &GameSession)
{
    UE_LOG(LogAWSIKGameLiftServers, Log, TEXT("%s"), *GameSession.GameSessionId);
    FAWSIKGameLiftServerError Error;
    if (!Server->ActivateGameSession(Error))
    {
        UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("%s"), *Error.Common.Message);
        EndManagedServer();
        return;
    }
    UE_LOG(LogAWSIKGameLiftServers, Log, TEXT("GameLift session active"));
}

void UGameLiftServerGameInstance::EndManagedServer()
{
    if (bStopping || !Server)
    {
        return;
    }
    bStopping = true;
    Server->SetHealthy(false);
    FAWSIKGameLiftServerError Error;
    if (!Server->ProcessEnding(Error))
    {
        UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("%s"), *Error.Common.Message);
    }
    ReleaseGameLiftSdkAndExit();
}

void UGameLiftServerGameInstance::ReleaseGameLiftSdkAndExit()
{
    FAWSIKGameLiftServerError Error;
    if (!Server->Destroy(Error))
    {
        UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("%s"), *Error.Common.Message);
    }
    UAWSIKGameLiftServersLibrary::RequestServerExit(false);
}

Dependencies: UCIKCore, BetideCore, AWSIKGameLift, Engine.

// GameLiftPlacementGameInstance.h
#pragma once

#include "Engine/GameInstance.h"
#include "Hosting/UCIKHostingSubsystem.h"
#include "TimerManager.h"
#include "GameLiftPlacementGameInstance.generated.h"

UCLASS()
class UGameLiftPlacementGameInstance : public UGameInstance
{
    GENERATED_BODY()
  public:
    UFUNCTION(BlueprintCallable)
    void PlaceGameLiftForPlayer(const FUCIK_PlayerHandle &Player, const FString &PlacementKey);

    UFUNCTION(BlueprintCallable)
    void EndAllocatedMatch();

    UPROPERTY(BlueprintReadOnly)
    FUCIK_ServerHandle AllocatedServer;

    UPROPERTY(BlueprintReadOnly)
    FUCIK_PlayerHandle ReservedPlayer;

    UPROPERTY(BlueprintReadOnly)
    FUCIK_ConnectInfo PlayerConnection;

  private:
    UPROPERTY(Transient)
    TObjectPtr<UUCIKHostingSubsystem> Hosting;
    bool bPlacementBusy = false;
    bool bHasAllocatedServer = false;
    int32 PlacementPolls = 0;
    FTimerHandle PollTimer;
    void PollGameLiftPlacement();
    void ReservePlayer();
    void ReleaseAllocatedGameLiftServer();
};

// GameLiftPlacementGameInstance.cpp
#include "GameLiftPlacementGameInstance.h"
#include "Providers/AWSIKGameLiftProviderIds.h"
#include "UCIKCore.h"

void UGameLiftPlacementGameInstance::PlaceGameLiftForPlayer(const FUCIK_PlayerHandle &Player,
                                                            const FString &PlacementKey)
{
    if (bPlacementBusy || bHasAllocatedServer)
    {
        UE_LOG(LogUCIK, Warning, TEXT("Finish or release the current allocation first"));
        return;
    }
    Hosting = GetSubsystem<UUCIKHostingSubsystem>();
    if (!Hosting || !Player.IsValid())
    {
        UE_LOG(LogUCIK, Error, TEXT("Hosting subsystem and a valid player handle are required"));
        return;
    }
    bPlacementBusy = true;
    ReservedPlayer = Player;
    PlacementPolls = 0;
    FUCIK_ServerRequest Request;
    Request.Provider = BetideProviderIds::GameLift;
    Request.MaxPlayers = 8;
    Request.IdempotencyKey = PlacementKey;
    Hosting->RequestServer(Request,
                           FBetideCallback<FUCIK_ServerHandle>::CreateWeakLambda(
                               this, [this](const TBetideResult<FUCIK_ServerHandle> &Result) {
                                   if (!Result.bOk)
                                   {
                                       UE_LOG(LogUCIK, Error, TEXT("%s"), *Result.Error.Message);
                                       bPlacementBusy = false;
                                       return;
                                   }
                                   AllocatedServer = Result.GetValue();
                                   bHasAllocatedServer = true;
                                   PollGameLiftPlacement();
                               }));
}

void UGameLiftPlacementGameInstance::PollGameLiftPlacement()
{
    if (PlacementPolls >= 60)
    {
        UE_LOG(LogUCIK, Warning, TEXT("Readiness poll limit reached; releasing the allocation"));
        ReleaseAllocatedGameLiftServer();
        return;
    }
    ++PlacementPolls;
    Hosting->GetServerStatus(
        AllocatedServer, FBetideCallback<FUCIK_ServerStatus>::CreateWeakLambda(
                             this, [this](const TBetideResult<FUCIK_ServerStatus> &Result) {
                                 if (!Result.bOk)
                                 {
                                     UE_LOG(LogUCIK, Error, TEXT("%s"), *Result.Error.Message);
                                     ReleaseAllocatedGameLiftServer();
                                     return;
                                 }
                                 const FUCIK_ServerStatus &Status = Result.GetValue();
                                 switch (Status.Phase)
                                 {
                                 case EUCIK_ServerPhase::Ready:
                                     ReservePlayer();
                                     return;
                                 case EUCIK_ServerPhase::Unknown:
                                 case EUCIK_ServerPhase::Requested:
                                 case EUCIK_ServerPhase::Provisioning:
                                     GetTimerManager().SetTimer(PollTimer, this,
                                                                &ThisClass::PollGameLiftPlacement,
                                                                2.0f, false);
                                     return;
                                 default:
                                     UE_LOG(LogUCIK, Error, TEXT("%s"), *Status.RawStatus);
                                     ReleaseAllocatedGameLiftServer();
                                     return;
                                 }
                             }));
}

void UGameLiftPlacementGameInstance::ReservePlayer()
{
    Hosting->RequestPlayerSlots(
        AllocatedServer, {ReservedPlayer},
        FBetideCallback<TArray<FUCIK_ConnectInfo>>::CreateWeakLambda(
            this, [this](const TBetideResult<TArray<FUCIK_ConnectInfo>> &Result) {
                if (!Result.bOk)
                {
                    UE_LOG(LogUCIK, Error, TEXT("%s"), *Result.Error.Message);
                    ReleaseAllocatedGameLiftServer();
                    return;
                }
                if (Result.GetValue().Num() != 1)
                {
                    UE_LOG(LogUCIK, Error, TEXT("Expected exactly one player reservation"));
                    ReleaseAllocatedGameLiftServer();
                    return;
                }
                PlayerConnection = Result.GetValue()[0];
                bPlacementBusy = false;
                UE_LOG(LogUCIK, Log,
                       TEXT("Player reservation ready; deliver PlayerConnection to this player"));
            }));
}

void UGameLiftPlacementGameInstance::EndAllocatedMatch()
{
    if (bPlacementBusy || !bHasAllocatedServer)
    {
        UE_LOG(LogUCIK, Warning,
               TEXT("Wait for the operation to finish; an allocation is required"));
        return;
    }
    ReleaseAllocatedGameLiftServer();
}

void UGameLiftPlacementGameInstance::ReleaseAllocatedGameLiftServer()
{
    bPlacementBusy = true;
    GetTimerManager().ClearTimer(PollTimer);
    Hosting->TerminateServer(
        AllocatedServer,
        FBetideCallbackVoid::CreateWeakLambda(this, [this](const TBetideResult<void> &Result) {
            bPlacementBusy = false;
            if (!Result.bOk)
            {
                UE_LOG(LogUCIK, Error, TEXT("%s; allocation retained, retry EndAllocatedMatch"),
                       *Result.Error.Message);
                return;
            }
            bHasAllocatedServer = false;
            AllocatedServer = {};
            PlayerConnection = {};
            UE_LOG(LogUCIK, Log, TEXT("Allocation released"));
        }));
}

Dependencies: AWSIKGameLiftServers, BetideCore, Engine; Editor and Server targets only.

// GameLiftReservationComponent.h
#pragma once

#include "Components/ActorComponent.h"
#include "GameLiftReservationComponent.generated.h"

UCLASS(ClassGroup = (Game), meta = (BlueprintSpawnableComponent))
class UGameLiftReservationComponent : public UActorComponent
{
    GENERATED_BODY()
  public:
    UFUNCTION(BlueprintCallable)
    void ValidatePlayerReservation(const FString &ReservationToken);

    UFUNCTION(BlueprintCallable)
    void ReleasePlayerReservation();

    UPROPERTY(BlueprintReadOnly)
    bool HasReservation = false;

    UPROPERTY(BlueprintReadOnly)
    bool LastActionSucceeded = false;

    UPROPERTY(BlueprintReadOnly)
    FString LastError;

  private:
    FString PlayerSessionId;
    bool BeginAction();
    void Fail(const FString &Message);
};

// GameLiftReservationComponent.cpp
#include "GameLiftReservationComponent.h"
#include "AWSIKGameLiftServers.h"
#include "Engine/GameInstance.h"
#include "Engine/World.h"
#include "Subsystems/AWSIKGameLiftServersSubsystem.h"

void UGameLiftReservationComponent::Fail(const FString &Message)
{
    LastError = Message;
    UE_LOG(LogAWSIKGameLiftServers, Error, TEXT("%s"), *LastError);
}

bool UGameLiftReservationComponent::BeginAction()
{
    LastActionSucceeded = false;
    LastError.Reset();
    if (!GetWorld() || GetWorld()->GetNetMode() != NM_DedicatedServer)
    {
        Fail(TEXT("Reservation calls must run on the dedicated server"));
        return false;
    }
    return true;
}

void UGameLiftReservationComponent::ValidatePlayerReservation(const FString &ReservationToken)
{
    if (!BeginAction())
        return;
    if (HasReservation)
    {
        Fail(TEXT("This connection already owns a reservation"));
        return;
    }
    const UGameInstance *GameInstance = GetWorld()->GetGameInstance();
    auto *Server =
        GameInstance ? GameInstance->GetSubsystem<UAWSIKGameLiftServersSubsystem>() : nullptr;
    if (!Server)
    {
        Fail(TEXT("GameLift server subsystem unavailable"));
        return;
    }
    FAWSIKGameLiftServerError Error;
    if (!Server->AcceptPlayerSession(ReservationToken, Error))
    {
        Fail(Error.Common.Message);
        return;
    }
    PlayerSessionId = ReservationToken;
    HasReservation = true;
    LastActionSucceeded = true;
}

void UGameLiftReservationComponent::ReleasePlayerReservation()
{
    if (!BeginAction())
        return;
    if (!HasReservation)
    {
        Fail(TEXT("This connection has no accepted reservation"));
        return;
    }
    const UGameInstance *GameInstance = GetWorld()->GetGameInstance();
    auto *Server =
        GameInstance ? GameInstance->GetSubsystem<UAWSIKGameLiftServersSubsystem>() : nullptr;
    if (!Server)
    {
        Fail(TEXT("GameLift server subsystem unavailable"));
        return;
    }
    FAWSIKGameLiftServerError Error;
    if (!Server->RemovePlayerSession(PlayerSessionId, Error))
    {
        Fail(Error.Common.Message);
        return;
    }
    HasReservation = false;
    PlayerSessionId.Reset();
    LastActionSucceeded = true;
}