Integra Amazon GameLift in un progetto Unreal Engine

Clona il codice sorgente di Unreal Engine nel tuo ambiente di sviluppo in un ramo a tua scelta.

git clone https://github.com/EpicGames/UnrealEngine.git

Dai un'occhiata al tag della versione che stai usando per sviluppare il gioco. Ad esempio, l'esempio seguente verifica la versione 5.1.1 di Unreal Engine:

git checkout tags/5.1.1-release -b 5.1.1-release

Passa alla cartella principale del repository locale. Quando ti trovi nella cartella principale, esegui il seguente file:Setup.bat.

Mentre sei nella cartella principale, esegui anche il file:GenerateProjectFiles.bat.

Dopo aver eseguito i file dei passaggi precedenti, viene creato un file di soluzione Unreal EngineUE5.sln,,. Apri Visual Studio e nell'editor di Visual Studio apri il UE5.sln file.

In Visual Studio, apri il menu Visualizza e scegli l'opzione Solution Explorer. Si apre il menu contestuale del nodo del progetto Unreal. Nella finestra Solution Explorer, fai clic con il pulsante destro del mouse sul UE5.sln file (può essere elencato come sempliceUE5), quindi scegli Build per creare il progetto Unreal con il target Development Editor Win64.

Con Visual Studio aperto, vai al riquadro Solution Explorer e scegli il UE5 file per aprire il menu contestuale del progetto Unreal. Nel menu contestuale, scegli l'opzione Imposta come progetto di avvio.

Nella parte superiore della finestra di Visual Studio, scegli Avvia debug (freccia verde).

Questa azione avvia la tua nuova istanza di Unreal Editor creata dal codice sorgente. Per ulteriori informazioni sull'utilizzo di Unreal Editor, consulta Unreal Editor Interface sul sito Web di documentazione di Unreal Engine.

Chiudi la finestra di Visual Studio che hai aperto, poiché Unreal Editor apre un'altra finestra di Visual Studio che contiene il progetto Unreal e il tuo progetto di gioco.

Nell'editor Unreal, esegui una delle seguenti operazioni:

• Scegli un progetto Unreal esistente che desideri integrare con Amazon GameLift.

• Crea un nuovo progetto. Per sperimentare con il GameLift plug-in Amazon per Unreal, prova a utilizzare il modello in terza persona del motore Unreal. Per ulteriori informazioni su questo modello, consulta il modello in terza persona sul sito Web di documentazione di Unreal Engine.

  In alternativa, configura un nuovo progetto con le seguenti impostazioni:

  • C++

  • Con contenuto iniziale

  • Desktop

  • Un nome di progetto. Negli esempi di questo argomento, abbiamo dato un nome al nostro progettoGameLiftUnrealApp.

In Solution Explorer di Visual Studio, vai alla posizione del tuo progetto Unreal. Nella Source cartella Unreal, trova un file denominato. Your-application-name.Target.cs

Ad esempio: GameLiftUnrealApp.Target.cs.

Crea una copia di questo file e assegna un nome alla copia:Your-application-nameServer.Target.cs.

Apri il nuovo file e apporta le seguenti modifiche:

Scarica il SDKplug-in del server Amazon GameLift C++ per Unreal.

Scarica e installa OpenSSL. Per ulteriori informazioni su come scaricare OpenSSL, leggi la documentazione relativa alla SSLbuild e all'installazione di Github Open.

Per ulteriori informazioni, leggi la documentazione di Open SSL Notes per le piattaforme Windows.

Una volta scaricate le librerie, create le SDK librerie del server C++ per Unreal Engine.

Nella GameLift-Cpp-ServerSDK-<version> directory scaricataSDK, compila con il -DBUILD_FOR_UNREAL=1 parametro e crea il server. SDK I seguenti esempi mostrano come compilare utilizzando. cmake

Esegui i seguenti comandi nel tuo terminale:

mkdir cmake-build
cmake.exe -G "Visual Studio 17 2022" -DCMAKE_BUILD_TYPE=Release -S . -B ./cmake-build -DBUILD_FOR_UNREAL=1 -A x64
cmake.exe --build ./cmake-build --target ALL_BUILD --config Release

La build di Windows crea i seguenti file binari nella out\gamelift-server-sdk\Release cartella:

Copia i due file della libreria nella ThirdParty\GameLiftServerSDK\Win64 cartella del pacchetto del plug-in Amazon GameLift Unreal Engine.

Individua la GameLiftServerSDK cartella che hai estratto dal plugin nella procedura precedente.

Individuala Plugins nella cartella principale del progetto di gioco. (Se la cartella non esiste, creala lì.)

Copiare la GameLiftServerSDK cartella inPlugins.

Ciò consentirà al progetto Unreal di vedere il plugin.

Aggiungi il SDK plug-in GameLift del server Amazon al .uproject file del gioco.

Nell'esempio, l'app viene chiamataGameLiftUnrealApp, quindi il file saràGameLiftUnrealApp.uproject.

Modifica il .uproject file per aggiungere il plugin al tuo progetto di gioco.

"Plugins": [
    {
        "Name": "GameLiftServerSDK",
        "Enabled": true
    }
]

Assicurati che il ModuleRules gioco dipenda dal plugin. Apri il .Build.cs file e aggiungi la GameLiftServer SDK dipendenza Amazon. Questo file si trova sottoYour-application-name/Source//Your-application-name/.

Ad esempio, il percorso del file del tutorial è../GameLiftUnrealApp/Source/GameLiftUnrealApp/GameLiftUnrealApp.Build.cs.

Aggiungi "GameLiftServerSDK" alla fine dell'elenco diPublicDependencyModuleNames.

using UnrealBuildTool;
using System.Collections.Generic;
public class GameLiftUnrealApp : ModuleRules  
  {
    public GameLiftUnrealApp(TargetInfo Target)
    {
      PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "GameLiftServerSDK" });
      bEnableExceptions = true;
    }
  }

In Visual Studio, apri il .sln file dell'applicazione. Nel nostro esempio, il file si GameLiftUnrealApp.sln trova nella cartella principale.

Con la soluzione aperta, individuate il Your-application-nameGameMode.h file dell'applicazione. Esempio: GameLiftUnrealAppGameMode.h.

Modificate il file di intestazione per allinearlo al codice di esempio seguente. Assicurati di sostituire "GameLiftUnrealApp" con il nome della tua applicazione.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "GameLiftServerSDK.h"
#include "GameLiftUnrealAppGameMode.generated.h"

DECLARE_LOG_CATEGORY_EXTERN(GameServerLog, Log, All);

UCLASS(minimalapi)
class AGameLiftUnrealAppGameMode : public AGameModeBase
{
    GENERATED_BODY()

public:
    AGameLiftUnrealAppGameMode();

protected:
    virtual void BeginPlay() override;

private:
    // Process Parameters needs to remain in scope for the lifetime of the app
    FProcessParameters m_params;

    void InitGameLift();
};

Aprire il Your-application-nameGameMode.cpp file sorgente correlato. Nel nostro esempio:GameLiftUnrealAppGameMode.cpp. e modifica il codice per allinearlo al seguente codice di esempio. Assicurati di sostituire "GameLiftUnrealApp" con il nome della tua applicazione.

Questo esempio mostra come aggiungere tutti gli elementi necessari per l'integrazione con Amazon GameLift, come descritto in Aggiungi Amazon GameLift al tuo server di gioco. Questo include:

#include "GameLiftUnrealAppGameMode.h"
#include "GameLiftUnrealAppCharacter.h"

#include "UObject/ConstructorHelpers.h"

DEFINE_LOG_CATEGORY(GameServerLog);

AGameLiftUnrealAppGameMode::AGameLiftUnrealAppGameMode()
{
    // set default pawn class to our Blueprinted character
    static ConstructorHelpers::FClassFinder<APawn> PlayerPawnBPClass(TEXT("/Game/ThirdPerson/Blueprints/BP_ThirdPersonCharacter"));
    if (PlayerPawnBPClass.Class != NULL)
    {
        DefaultPawnClass = PlayerPawnBPClass.Class;
    }
}

void AGameLiftUnrealAppGameMode::BeginPlay()
{
#if WITH_GAMELIFT
    InitGameLift();
#endif
}

void AGameLiftUnrealAppGameMode::InitGameLift()
{
    UE_LOG(GameServerLog, Log, TEXT("Initializing the GameLift Server"));

    //Getting the module first.
    FGameLiftServerSDKModule* gameLiftSdkModule = &FModuleManager::LoadModuleChecked<FGameLiftServerSDKModule>(FName("GameLiftServerSDK"));

    //Define the server parameters for a GameLift Anywhere fleet. These are not needed for a GameLift managed EC2 fleet.
    FServerParameters serverParameters;

    //AuthToken returned from the "aws gamelift get-compute-auth-token" API. Note this will expire and require a new call to the API after 15 minutes.
    if (FParse::Value(FCommandLine::Get(), TEXT("-authtoken="), serverParameters.m_authToken))
    {
        UE_LOG(GameServerLog, Log, TEXT("AUTH_TOKEN: %s"), *serverParameters.m_authToken)
    }

    //The Host/compute-name of the GameLift Anywhere instance.
    if (FParse::Value(FCommandLine::Get(), TEXT("-hostid="), serverParameters.m_hostId))
    {
        UE_LOG(GameServerLog, Log, TEXT("HOST_ID: %s"), *serverParameters.m_hostId)
    }

    //The Anywhere Fleet ID.
    if (FParse::Value(FCommandLine::Get(), TEXT("-fleetid="), serverParameters.m_fleetId))
    {
        UE_LOG(GameServerLog, Log, TEXT("FLEET_ID: %s"), *serverParameters.m_fleetId)
    }

    //The WebSocket URL (GameLiftServiceSdkEndpoint).
    if (FParse::Value(FCommandLine::Get(), TEXT("-websocketurl="), serverParameters.m_webSocketUrl))
    {
        UE_LOG(GameServerLog, Log, TEXT("WEBSOCKET_URL: %s"), *serverParameters.m_webSocketUrl)
    }

    //The PID of the running process
    serverParameters.m_processId = FString::Printf(TEXT("%d"), GetCurrentProcessId());
    UE_LOG(GameServerLog, Log, TEXT("PID: %s"), *serverParameters.m_processId);

    //InitSDK establishes a local connection with GameLift's agent to enable further communication.
    //Use InitSDK(serverParameters) for a GameLift Anywhere fleet. 
    //Use InitSDK() for a GameLift managed EC2 fleet.
    gameLiftSdkModule->InitSDK(serverParameters);

    //Implement callback function onStartGameSession
    //GameLift sends a game session activation request to the game server
    //and passes a game session object with game properties and other settings.
    //Here is where a game server takes action based on the game session object.
    //When the game server is ready to receive incoming player connections, 
    //it invokes the server SDK call ActivateGameSession().
    auto onGameSession = [=](Aws::GameLift::Server::Model::GameSession gameSession)
    {
        FString gameSessionId = FString(gameSession.GetGameSessionId());
        UE_LOG(GameServerLog, Log, TEXT("GameSession Initializing: %s"), *gameSessionId);
        gameLiftSdkModule->ActivateGameSession();
    };

    m_params.OnStartGameSession.BindLambda(onGameSession);

    //Implement callback function OnProcessTerminate
    //GameLift invokes this callback before shutting down the instance hosting this game server.
    //It gives the game server a chance to save its state, communicate with services, etc., 
    //and initiate shut down. When the game server is ready to shut down, it invokes the 
    //server SDK call ProcessEnding() to tell GameLift it is shutting down.
    auto onProcessTerminate = [=]() 
    {
        UE_LOG(GameServerLog, Log, TEXT("Game Server Process is terminating"));
        gameLiftSdkModule->ProcessEnding();
    };

    m_params.OnTerminate.BindLambda(onProcessTerminate);

    //Implement callback function OnHealthCheck
    //GameLift invokes this callback approximately every 60 seconds.
    //A game server might want to check the health of dependencies, etc.
    //Then it returns health status true if healthy, false otherwise.
    //The game server must respond within 60 seconds, or GameLift records 'false'.
    //In this example, the game server always reports healthy.
    auto onHealthCheck = []() 
    {
        UE_LOG(GameServerLog, Log, TEXT("Performing Health Check"));
        return true;
    };

    m_params.OnHealthCheck.BindLambda(onHealthCheck);

    //The game server gets ready to report that it is ready to host game sessions
    //and that it will listen on port 7777 for incoming player connections.
    m_params.port = 7777;

    //Here, the game server tells GameLift where to find game session log files.
    //At the end of a game session, GameLift uploads everything in the specified 
    //location and stores it in the cloud for access later.
    TArray<FString> logfiles;
    logfiles.Add(TEXT("GameLift426Test/Saved/Logs/GameLift426Test.log"));
    m_params.logParameters = logfiles;

    //The game server calls ProcessReady() to tell GameLift it's ready to host game sessions.
    UE_LOG(GameServerLog, Log, TEXT("Calling Process Ready"));
    gameLiftSdkModule->ProcessReady(m_params);
}

Crea un progetto di gioco per entrambi i seguenti tipi di target: Development Editor e Development Server.

Una volta completate entrambe le build, chiudi Visual Studio e apri il .uproject file del progetto per aprirlo in Unreal Editor.

In Unreal Editor, impacchetta la build del server del tuo gioco. Per scegliere un bersaglio, vai su Piattaforme, Windows e seleziona Your-application-nameServer.

Per avviare il processo di creazione dell'applicazione server, vai su Piattaforme, Windows e seleziona Package Project. Una volta completata la compilazione, dovresti avere un eseguibile. Nel caso del nostro esempio, il nome del file èGameLiftUnrealAppServer.exe.

La creazione di un'applicazione server in Unreal Editor produce due eseguibili. Uno si trova nella radice della cartella build del gioco e funge da wrapper per l'effettivo eseguibile del server.

Quando crei una GameLift flotta Amazon con la build del tuo server, ti consigliamo di inserire l'eseguibile del server effettivo come percorso di avvio della configurazione di runtime. Ad esempio, nella cartella Game Build, potresti avere un GameLiftFPS.exe file nella directory principale e un altro in\GameLiftFPS\Binaries\Win64\GameLiftFPSServer.exe. Quando crei una flotta, ti consigliamo di C:\GameLiftFPS\Binaries\Win64\GameLiftFPSServer.exe utilizzarla come percorso di avvio della configurazione di runtime.

Assicurati di aprire le UDP porte necessarie sulla GameLift flotta Amazon, in modo che il server di gioco possa comunicare con i client di gioco. Per impostazione predefinita, Unreal Engine utilizza la porta7777. Per ulteriori informazioni, UpdateFleetPortSettingsconsulta la guida di API riferimento del GameLift servizio Amazon.

Crea un install.bat file per la build del tuo gioco. Questo script di installazione viene eseguito ogni volta che la build del gioco viene distribuita su una GameLift flotta Amazon. Ecco un install.bat file di esempio:

VC_redist.x64.exe /q
UE5PrereqSetup_x64.exe /q

Per alcune versioni di Unreal Engine, install.bat dovrebbe invece essere

VC_redist.x64.exe /q
UEPrereqSetup_x64.exe /q

Ora puoi impacchettare e caricare la build del tuo gioco su Amazon GameLift.

La versione di Open SSL che includi nella build del gioco deve corrispondere alla versione utilizzata dal motore di gioco per creare il server di gioco. Assicurati di includere la SSL versione Open corretta con la build del server di gioco. Per il sistema operativo Windows, il SSL formato Open è.dll.