Plugin per Unreal: configura i test locali con Amazon GameLift Anywhere

Per avviare il flusso di lavoro Amazon GameLift Anywhere:

• Nella barra degli strumenti principale dell'editor Unreal, scegli il GameLift menu Amazon e seleziona Host with Anywhere. Questa azione apre la pagina del plugin Deploy Anywhere, che presenta un processo in sei fasi per integrare, creare e avviare i componenti del gioco.

Per impostare un profilo utente

1. Seleziona un profilo dall'elenco a discesa dei profili disponibili. Se non hai ancora un profilo o desideri crearne uno nuovo, vai al GameLift menu Amazon e scegli Imposta profili AWS utente.

2. Se lo stato di bootstrap non è «Attivo», scegli il profilo Bootstrap e attendi che lo stato passi a «Attivo».

Per aggiungere il codice del server per Amazon GameLift

1. Nel tuo editor di codice, apri il file solution (.sln) per il tuo progetto di gioco, che di solito si trova nella cartella principale del progetto. Ad esempio: GameLiftUnrealApp.sln.

2. Con la soluzione aperta, individua il file di intestazione della modalità gioco del progetto: [project-name]GameMode.h file. Ad esempio: GameLiftUnrealAppGameMode.h.

3. Modifica il file di intestazione per allinearlo al seguente codice di esempio. Assicurati di sostituire "GameLiftServer" con il nome del tuo progetto. Questi aggiornamenti sono specifici per il server di gioco; ti consigliamo di creare una copia di backup dei file delle modalità di gioco originali da utilizzare con il tuo client.

   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
    
   #pragma once
    
   #include "CoreMinimal.h"
   #include "GameFramework/GameModeBase.h"
   #include "GameLiftServerGameMode.generated.h"
    
   struct FProcessParameters;
    
   DECLARE_LOG_CATEGORY_EXTERN(GameServerLog, Log, All);
    
   UCLASS(minimalapi)
   class AGameLiftServerGameMode : public AGameModeBase
   {
       GENERATED_BODY()
    
   public:
       AGameLiftServerGameMode();
    
   protected:
       virtual void BeginPlay() override;
    
   private:
       void InitGameLift();
   
   private:
       TSharedPtr<FProcessParameters> ProcessParameters;
   };

4. Apri il [project-name]GameMode.cpp file sorgente correlato (ad esempioGameLiftUnrealAppGameMode.cpp). Modificate il codice per allinearlo al codice di esempio seguente. Assicurati di sostituire "GameLiftUnrealApp" con il nome del tuo progetto. Questi aggiornamenti sono specifici per il server di gioco; ti consigliamo di creare una copia di backup del file originale da utilizzare con il tuo client.

   Il codice di esempio seguente mostra come aggiungere gli elementi minimi richiesti per l'integrazione dei server con Amazon GameLift:

   • Inizializza un GameLift API client Amazon. La InitSDK() chiamata con i parametri del server è necessaria per una flotta Amazon GameLift Anywhere. Quando ti connetti a una flotta Anywhere, il plug-in memorizza i parametri del server come argomenti della console. Il codice di esempio può accedere ai valori in fase di esecuzione.

   • Implementa le funzioni di callback richieste per rispondere alle richieste del GameLift servizio Amazon, tra cui OnStartGameSessionOnProcessTerminate, eonHealthCheck.

   • Chiama ProcessReady() con una porta designata per avvisare il GameLift servizio Amazon quando sei pronto per ospitare sessioni di gioco.

   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
    
   #include "GameLiftServerGameMode.h"
    
   #include "UObject/ConstructorHelpers.h"
   #include "Kismet/GameplayStatics.h"
    
   #if WITH_GAMELIFT
   #include "GameLiftServerSDK.h"
   #include "GameLiftServerSDKModels.h"
   #endif
    
   #include "GenericPlatform/GenericPlatformOutputDevices.h"
    
   DEFINE_LOG_CATEGORY(GameServerLog);
    
   AGameLiftServerGameMode::AGameLiftServerGameMode() :
       ProcessParameters(nullptr)
   {
       // 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;
       }
    
       UE_LOG(GameServerLog, Log, TEXT("Initializing AGameLiftServerGameMode..."));
   }
    
   void AGameLiftServerGameMode::BeginPlay()
   {
       Super::BeginPlay();
    
   #if WITH_GAMELIFT
       InitGameLift();
   #endif
   }
    
   void AGameLiftServerGameMode::InitGameLift()
   {
   #if WITH_GAMELIFT
       UE_LOG(GameServerLog, Log, TEXT("Calling InitGameLift..."));
    
       // 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 ServerParametersForAnywhere;
    
       bool bIsAnywhereActive = false;
       if (FParse::Param(FCommandLine::Get(), TEXT("glAnywhere")))
       {
           bIsAnywhereActive = true;
       }
    
       if (bIsAnywhereActive)
       {
           UE_LOG(GameServerLog, Log, TEXT("Configuring server parameters for Anywhere..."));
    
           // If GameLift Anywhere is enabled, parse command line arguments and pass them in the ServerParameters object.
           FString glAnywhereWebSocketUrl = "";
           if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereWebSocketUrl="), glAnywhereWebSocketUrl))
           {
               ServerParametersForAnywhere.m_webSocketUrl = TCHAR_TO_UTF8(*glAnywhereWebSocketUrl);
           }
    
           FString glAnywhereFleetId = "";
           if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereFleetId="), glAnywhereFleetId))
           {
               ServerParametersForAnywhere.m_fleetId = TCHAR_TO_UTF8(*glAnywhereFleetId);
           }
    
           FString glAnywhereProcessId = "";
           if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereProcessId="), glAnywhereProcessId))
           {
               ServerParametersForAnywhere.m_processId = TCHAR_TO_UTF8(*glAnywhereProcessId);
           }
           else
           {
               // If no ProcessId is passed as a command line argument, generate a randomized unique string.
               ServerParametersForAnywhere.m_processId =
                   TCHAR_TO_UTF8(
                       *FText::Format(
                           FText::FromString("ProcessId_{0}"),
                           FText::AsNumber(std::time(nullptr))
                       ).ToString()
                   );
           }
    
           FString glAnywhereHostId = "";
           if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereHostId="), glAnywhereHostId))
           {
               ServerParametersForAnywhere.m_hostId = TCHAR_TO_UTF8(*glAnywhereHostId);
           }
    
           FString glAnywhereAuthToken = "";
           if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereAuthToken="), glAnywhereAuthToken))
           {
               ServerParametersForAnywhere.m_authToken = TCHAR_TO_UTF8(*glAnywhereAuthToken);
           }
    
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_YELLOW);
           UE_LOG(GameServerLog, Log, TEXT(">>>> WebSocket URL: %s"), *ServerParametersForAnywhere.m_webSocketUrl);
           UE_LOG(GameServerLog, Log, TEXT(">>>> Fleet ID: %s"), *ServerParametersForAnywhere.m_fleetId);
           UE_LOG(GameServerLog, Log, TEXT(">>>> Process ID: %s"), *ServerParametersForAnywhere.m_processId);
           UE_LOG(GameServerLog, Log, TEXT(">>>> Host ID (Compute Name): %s"), *ServerParametersForAnywhere.m_hostId);
           UE_LOG(GameServerLog, Log, TEXT(">>>> Auth Token: %s"), *ServerParametersForAnywhere.m_authToken);
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
       }
    
       UE_LOG(GameServerLog, Log, TEXT("Initializing the GameLift Server..."));
    
       //InitSDK will establish a local connection with GameLift's agent to enable further communication.
       FGameLiftGenericOutcome InitSdkOutcome = GameLiftSdkModule->InitSDK(ServerParametersForAnywhere);
       if (InitSdkOutcome.IsSuccess())
       {
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_GREEN);
           UE_LOG(GameServerLog, Log, TEXT("GameLift InitSDK succeeded!"));
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
       }
       else
       {
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_RED);
           UE_LOG(GameServerLog, Log, TEXT("ERROR: InitSDK failed : ("));
           FGameLiftError GameLiftError = InitSdkOutcome.GetError();
           UE_LOG(GameServerLog, Log, TEXT("ERROR: %s"), *GameLiftError.m_errorMessage);
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
           return;
       }
    
       ProcessParameters = MakeShared<FProcessParameters>();
    
       //When a game session is created, GameLift sends an activation request to the game server and passes along the game session object containing game properties and other settings.
       //Here is where a game server should take action based on the game session object.
       //Once the game server is ready to receive incoming player connections, it should invoke GameLiftServerAPI.ActivateGameSession()
       ProcessParameters->OnStartGameSession.BindLambda([=](Aws::GameLift::Server::Model::GameSession InGameSession)
       {
           FString GameSessionId = FString(InGameSession.GetGameSessionId());
           UE_LOG(GameServerLog, Log, TEXT("GameSession Initializing: %s"), *GameSessionId);
           GameLiftSdkModule->ActivateGameSession();
       });
    
       //OnProcessTerminate callback. GameLift will invoke this callback before shutting down an instance hosting this game server.
       //It gives this game server a chance to save its state, communicate with services, etc., before being shut down.
       //In this case, we simply tell GameLift we are indeed going to shutdown.
       ProcessParameters->OnTerminate.BindLambda([=]()
       {
           UE_LOG(GameServerLog, Log, TEXT("Game Server Process is terminating"));
           GameLiftSdkModule->ProcessEnding();
       });
    
       //This is the HealthCheck callback.
       //GameLift will invoke this callback every 60 seconds or so.
       //Here, a game server might want to check the health of dependencies and such.
       //Simply return true if healthy, false otherwise.
       //The game server has 60 seconds to respond with its health status. GameLift will default to 'false' if the game server doesn't respond in time.
       //In this case, we're always healthy!
       ProcessParameters->OnHealthCheck.BindLambda([]()
       {
           UE_LOG(GameServerLog, Log, TEXT("Performing Health Check"));
           return true;
       });
    
       //GameServer.exe -port=7777 LOG=server.mylog
       ProcessParameters->port = FURL::UrlConfig.DefaultPort;
       TArray<FString> CommandLineTokens;
       TArray<FString> CommandLineSwitches;
   
       FCommandLine::Parse(FCommandLine::Get(), CommandLineTokens, CommandLineSwitches);
   
       for (FString SwitchStr : CommandLineSwitches)
       {
           FString Key;
           FString Value;
   
           if (SwitchStr.Split("=", &Key, &Value))
           {
               if (Key.Equals("port"))
               {
                   ProcessParameters->port = FCString::Atoi(*Value);
               }
           }
       }
    
       //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("GameServerLog/Saved/Logs/GameServerLog.log"));
       ProcessParameters->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..."));
       FGameLiftGenericOutcome ProcessReadyOutcome = GameLiftSdkModule->ProcessReady(*ProcessParameters);
    
       if (ProcessReadyOutcome.IsSuccess())
       {
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_GREEN);
           UE_LOG(GameServerLog, Log, TEXT("Process Ready!"));
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
       }
       else
       {
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_RED);
           UE_LOG(GameServerLog, Log, TEXT("ERROR: Process Ready Failed!"));
           FGameLiftError ProcessReadyError = ProcessReadyOutcome.GetError();
           UE_LOG(GameServerLog, Log, TEXT("ERROR: %s"), *ProcessReadyError.m_errorMessage);
           UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
       }
    
       UE_LOG(GameServerLog, Log, TEXT("InitGameLift completed!"));
   #endif
   }
   
   

Per utilizzare la mappa di gioco di avvio

1. Nell'editor UE, apri la pagina Impostazioni del progetto, mappe e modalità ed espandi la sezione Mappe predefinite.

2. Per Editor Startup Map, seleziona StartupMap "" dall'elenco a discesa. Potrebbe essere necessario cercare il file, che si trova in... > Unreal Projects/[project-name]/Plugins/Amazon GameLift Plugin Content/Maps.

3. Per Game Default Map, seleziona la stessa StartupMap "" dall'elenco a discesa.

4. Per Server Default Map, seleziona "ThirdPersonMap». Questa è una mappa predefinita inclusa nel tuo progetto di gioco. Questa mappa è progettata per due giocatori.

5. Apri il pannello dei dettagli per la mappa predefinita del server. Imposta GameMode Override su «Nessuno».

6. Espandi la sezione Modalità predefinite e imposta la modalità di gioco Global Default Server sulla modalità di gioco che hai aggiornato per l'integrazione del server.

Per impacchettare le build del server di gioco e del client di gioco

1. Crea nuovi file di destinazione per server e client

   1. Nella cartella del progetto di gioco, vai alla cartella Source e trova i Target.cs file.

   2. Copia il file [project-name]Editor.Target.cs in due nuovi file denominati [project-name]Client.Target.cs e[project-name]Server.Target.cs.

   3. Modifica ciascuno dei nuovi file per aggiornare i valori del nome della classe e del tipo di destinazione, come mostrato:

   UnrealProjects > MyGame > Source > MyGameClient.Target.cs
   // Copyright Epic Games, Inc. All Rights Reserved.
   
   using UnrealBuildTool;
   using System.Collections.Generic;
   
   public class MyGameClientTarget : TargetRules
   {
     public MyGameClientTarget(TargetInfo Target) : base(Target)
     {
       Type = TargetType.Client;
        DefaultBuildSettings = BuildSettingsVersion.V2;
       IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_1;
        ExtraModuleNames.Add("MyGame");
     }
   }

   UnrealProjects > MyGame > Source > MyGameServer.Target.cs
   // Copyright Epic Games, Inc. All Rights Reserved.
       
   using UnrealBuildTool;
   using System.Collections.Generic;
       
   public class MyGameServerTarget : TargetRules
   {
     public MyGameServerTarget(TargetInfo Target) : base(Target)
     {
       Type = TargetType.Server;
       DefaultBuildSettings = BuildSettingsVersion.V2;
       IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_1;
       ExtraModuleNames.Add("MyGame");
     }
   }

2. Aggiorna il .Build.cs file.

   1. Apri il .Build.cs file del tuo progetto. Questo file si trova in UnrealProjects/[project name]/Source/[project name]/[project name].Build.cs.

   2. Aggiornate la ModuleRules classe come illustrato nel seguente esempio di codice.

      public class MyGame : ModuleRules
      {
        public GameLiftUnrealApp(TargetInfo Target)
        {
          PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
          bEnableExceptions = true;
          
          if (Target.Type == TargetRules.TargetType.Server)
          {
            PublicDependencyModuleNames.AddRange(new string[] { "GameLiftServerSDK" });
            PublicDefinitions.Add("WITH_GAMELIFT=1");
          }
          else
          {
            PublicDefinitions.Add("WITH_GAMELIFT=0");
          }
        }
      }

3. Ricostruisci la soluzione del tuo progetto di gioco.

4. Apri il tuo progetto di gioco in una versione originale dell'editor di Unreal Engine.

5. Fai quanto segue sia per il client che per il server:

   1. Scegli un bersaglio. Vai a Piattaforme, Windows e seleziona una delle seguenti opzioni:

      • Server: [your-application-name]Server

      • Client: [your-application-name]Client

   2. Avvia la compilazione. Vai a Platform, Windows, Package Project.

Per registrare la workstation come elaborazione Anywhere

2. Inserisci un nome di calcolo per il tuo computer locale. Se aggiungi più di un computer nel parco dati, i nomi devono essere univoci.

3. Fornisci un indirizzo IP per il tuo computer locale. L'impostazione predefinita di questo campo è l'indirizzo IP pubblico della macchina. Puoi anche usare localhost (127.0.0.1) purché utilizzi il client e il server di gioco sulla stessa macchina.

4. Scegli Register compute. Puoi tenere traccia dello stato di avanzamento di questa richiesta nel registro di output dell'editor Unreal.

Per giocare al gioco che hai ospitato

1. Avvia il tuo server di gioco. Il server di gioco avviserà Amazon GameLift quando sarà pronto per ospitare sessioni di gioco.

2. Avvia il client di gioco e usa la nuova funzionalità per iniziare una nuova sessione di gioco. Questa richiesta viene inviata ad Amazon GameLift tramite il nuovo servizio di backend. In risposta GameLift, Amazon chiama il server di gioco, in esecuzione sul tuo computer locale, per avviare una nuova sessione di gioco. Quando la sessione di gioco è pronta per accettare giocatori, Amazon GameLift fornisce le informazioni di connessione per consentire al client di gioco di partecipare alla sessione di gioco.