Plugin pour Unreal : configurez des tests locaux avec Amazon GameLift Anywhere

Pour démarrer le flux de travail Amazon GameLift Anywhere :

• Dans la barre d'outils principale de l'éditeur Unreal, choisissez le GameLift menu Amazon, puis sélectionnez Host with Anywhere. Cette action ouvre la page du plugin Deploy Anywhere, qui présente un processus en six étapes pour intégrer, créer et lancer les composants de votre jeu.

Pour définir un profil utilisateur

1. Sélectionnez un profil dans la liste déroulante des profils disponibles. Si vous n'avez pas encore de profil ou si vous souhaitez en créer un nouveau, rendez-vous dans le GameLift menu Amazon et choisissez Set AWS User Profiles.

2. Si le statut du bootstrap n'est pas « Actif », choisissez le profil Bootstrap et attendez que le statut passe à « Actif ».

Pour ajouter du code de serveur pour Amazon GameLift

1. Dans votre éditeur de code, ouvrez le fichier solution (.sln) pour votre projet de jeu, qui se trouve généralement dans le dossier racine du projet. olpPar exemple : GameLiftUnrealApp.sln.

2. La solution étant ouverte, localisez le fichier d'en-tête du mode jeu du projet : [project-name]GameMode.h file. olpPar exemple : GameLiftUnrealAppGameMode.h.

3. Modifiez le fichier d'en-tête pour l'aligner sur l'exemple de code suivant. Assurez-vous de remplacer « GameLiftServer » par le nom de votre propre projet. Ces mises à jour sont spécifiques au serveur de jeu ; nous vous recommandons de créer une copie de sauvegarde des fichiers du mode de jeu d'origine pour les utiliser avec votre 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. Ouvrez le [project-name]GameMode.cpp fichier source correspondant (par exempleGameLiftUnrealAppGameMode.cpp). Modifiez le code pour l'aligner sur l'exemple de code suivant. Assurez-vous de remplacer « GameLiftUnrealApp » par le nom de votre propre projet. Ces mises à jour sont spécifiques au serveur de jeu ; nous vous recommandons de créer une copie de sauvegarde du fichier original pour l'utiliser avec votre client.

   L'exemple de code suivant montre comment ajouter les éléments minimaux requis pour l'intégration du serveur à Amazon GameLift :

   • Initialisez un GameLift API client Amazon. L'InitSDK()appel avec les paramètres du serveur est obligatoire pour une flotte Amazon GameLift Anywhere. Lorsque vous vous connectez à une flotte Anywhere, le plugin stocke les paramètres du serveur sous forme d'arguments de console. L'exemple de code permet d'accéder aux valeurs lors de l'exécution.

   • Implémentez les fonctions de rappel requises pour répondre aux demandes du GameLift service Amazon, notamment OnStartGameSessionOnProcessTerminate, etonHealthCheck.

   • Appelez ProcessReady() un port désigné pour informer le GameLift service Amazon lorsque vous êtes prêt à héberger des sessions de jeu.

   // 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
   }
   
   

Pour utiliser la carte du jeu de démarrage

1. Dans l'éditeur UE, ouvrez la page Paramètres du projet, cartes et modes, puis développez la section Cartes par défaut.

2. Pour Editor Startup Map, sélectionnez StartupMap « » dans la liste déroulante. Vous devrez peut-être rechercher le fichier, qui se trouve dans... > Unreal Projects/[project-name]/Plugins/Amazon GameLift Plugin Content/Maps.

3. Pour la carte par défaut du jeu, sélectionnez le même StartupMap « » dans la liste déroulante.

4. Pour la carte par défaut du serveur, sélectionnez « ThirdPersonMap ». Il s'agit d'une carte par défaut incluse dans votre projet de jeu. Cette carte est conçue pour deux joueurs.

5. Ouvrez le panneau de détails de la carte par défaut du serveur. Définissez GameMode Override sur « Aucun ».

6. Développez la section Modes par défaut et définissez le mode de jeu par défaut global sur le mode de jeu que vous avez mis à jour pour l'intégration de votre serveur.

Pour empaqueter les versions de votre serveur de jeu et de votre client de jeu

1. Création de nouveaux fichiers cibles pour le serveur et le client

   1. Dans le dossier de votre projet de jeu, allez dans le dossier Source et recherchez les Target.cs fichiers.

   2. Copiez le fichier [project-name]Editor.Target.cs dans deux nouveaux fichiers nommés [project-name]Client.Target.cs et[project-name]Server.Target.cs.

   3. Modifiez chacun des nouveaux fichiers pour mettre à jour le nom de classe et les valeurs du type de cible, comme indiqué :

   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. Mettez à jour le .Build.cs fichier.

   1. Ouvrez le .Build.cs fichier correspondant à votre projet. Ce fichier se trouve dans le dossier UnrealProjects/[project name]/Source/[project name]/[project name].Build.cs.

   2. Mettez à jour la ModuleRules classe comme indiqué dans l'exemple de code suivant.

      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. Reconstruisez la solution de votre projet de jeu.

4. Ouvrez votre projet de jeu dans une version source de l'éditeur Unreal Engine.

5. Procédez comme suit pour votre client et votre serveur :

   1. Choisissez une cible. Accédez à Plateformes, Windows et sélectionnez l'une des options suivantes :

      • Serveur : [your-application-name]Server

      • Client :[your-application-name]Client

   2. Démarrez le build. Accédez à Platform, Windows, Package Project.

Pour enregistrer votre station de travail en tant que système de calcul n'importe où

2. Entrez un nom de calcul pour votre machine locale. Si vous ajoutez plusieurs ordinateurs dans le parc, les noms doivent être uniques.

3. Fournissez une adresse IP pour votre machine locale. Ce champ correspond par défaut à l'adresse IP publique de votre machine. Vous pouvez également utiliser localhost (127.0.0.1) tant que vous exécutez votre client de jeu et votre serveur sur la même machine.

4. Choisissez Register compute. Vous pouvez suivre la progression de cette demande dans le journal de sortie de l'éditeur Unreal.

Pour jouer à votre jeu hébergé

1. Lancez votre serveur de jeu. Le serveur de jeu informera Amazon GameLift lorsqu'il sera prêt à héberger des sessions de jeu.

2. Lancez votre client de jeu et utilisez les nouvelles fonctionnalités pour démarrer une nouvelle session de jeu. Cette demande est envoyée à Amazon GameLift via le nouveau service principal. En réponse GameLift, Amazon appelle le serveur de jeu, qui fonctionne sur votre machine locale, pour démarrer une nouvelle session de jeu. Lorsque la session de jeu est prête à accepter des joueurs, Amazon GameLift fournit les informations de connexion permettant au client du jeu de rejoindre la session de jeu.