Plugin para Unreal: configure testes locais com a Amazon GameLift Anywhere

Para iniciar o fluxo de trabalho do Amazon GameLift Anywhere:

• Na barra de ferramentas principal do editor Unreal, escolha o GameLift menu Amazon e selecione Host with Anywhere. Essa ação abre a página do plug-in Implantar o Anywhere, que apresenta um processo de seis etapas para integrar, criar e iniciar os componentes do jogo.

Para definir um perfil de usuário

1. Selecione um perfil na lista suspensa de perfis disponíveis. Se você ainda não tem um perfil ou deseja criar um novo, acesse o GameLift menu Amazon e escolha Definir perfis de AWS usuário.

2. Se o status do bootstrap não for “Ativo”, escolha o perfil do Bootstrap e aguarde até que o status mude para “Ativo”.

Para adicionar o código do servidor para a Amazon GameLift

1. No editor de código, abra o arquivo de solução (.sln) do seu projeto de jogo, normalmente encontrado na pasta raiz do projeto. Por exemplo: GameLiftUnrealApp.sln.

2. Com a solução aberta, localize o arquivo de cabeçalho do modo de jogo do projeto: arquivo [project-name]GameMode.h. Por exemplo: GameLiftUnrealAppGameMode.h.

3. Altere o arquivo de cabeçalho para alinhá-lo com o código de exemplo a seguir. Certifique-se de substituir "GameLiftServer" pelo nome do seu próprio projeto. Essas atualizações são específicas para o servidor do jogo, recomendamos que você faça uma cópia de backup dos arquivos originais do modo de jogo para uso com seu cliente.

   // 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. Abra o arquivo [project-name]GameMode.cpp de origem relacionado (por exemplo GameLiftUnrealAppGameMode.cpp). Altere o código para alinhá-lo com o código de exemplo a seguir. Certifique-se de substituir "GameLiftUnrealApp" pelo nome do seu próprio projeto. Essas atualizações são específicas para o servidor do jogo, recomendamos que você faça uma cópia de backup do arquivo original para uso com seu cliente.

   O código de exemplo a seguir mostra como adicionar os elementos mínimos necessários para a integração do servidor com a Amazon GameLift:

   • Inicialize um GameLift API cliente da Amazon. A InitSDK() chamada com os parâmetros do servidor é necessária para uma frota do Amazon GameLift Anywhere. Quando você se conecta a uma frota Anywhere, o plug-in armazena os parâmetros do servidor como argumentos do console. O código de amostra pode acessar os valores em runtime.

   • Implemente as funções de retorno de chamada necessárias para responder às solicitações do GameLift serviço da AmazonOnStartGameSession, incluindoOnProcessTerminate, e. onHealthCheck

   • Ligue ProcessReady() para uma porta designada para notificar o GameLift serviço da Amazon quando estiver pronto para hospedar sessões de jogo.

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

Para usar o mapa do jogo de startup

1. No editor do UE, abra a página Configurações do projeto, mapas e modos e expanda a seção Mapas padrão.

2. Para Editor Startup Map, selecione StartupMap "" na lista suspensa. Talvez seja necessário pesquisar o arquivo, que está localizado em ... > Unreal Projects/[project-name]/Plugins/Amazon GameLift Plugin Content/Maps.

3. Para Mapa padrão do jogo, selecione o mesmo "StartupMap" na lista suspensa.

4. Para Mapa padrão do servidor, selecione "ThirdPersonMap”. Esse é um mapa padrão incluído no seu projeto de jogo. Este mapa foi projetado para dois jogadores no jogo.

5. Abra o painel de detalhes do mapa padrão do servidor. Defina GameMode Override como “Nenhum”.

6. Expanda a seção Modos padrão e defina o Modo de jogo padrão global do servidor para o modo de jogo que você atualizou para a integração do servidor.

Para empacotar suas compilações de servidor e cliente de jogo

1. Crie novos arquivos de destino do servidor e do cliente

   1. Na pasta do projeto do jogo, vá até a pasta Origem e encontre os arquivos Target.cs.

   2. Copie o arquivo [project-name]Editor.Target.cs em dois novos arquivos chamados [project-name]Client.Target.cs e [project-name]Server.Target.cs.

   3. Edite cada um dos novos arquivos para atualizar os valores do nome da classe e do tipo de destino, conforme mostrado:

   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. Atualize o arquivo .Build.cs.

   1. Abra o arquivo .Build.cs de seu projeto. Esse arquivo está localizado em UnrealProjects/[project name]/Source/[project name]/[project name].Build.cs.

   2. Atualize a classe ModuleRules conforme mostrado no exemplo de código a seguir.

      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. Crie a solução de projeto de jogo novamente.

4. Abra seu projeto de jogo em uma versão original do editor do Unreal Engine.

5. Faça o seguinte para seu cliente e servidor:

   1. Escolha um destino. Vá para Plataformas, Windows e selecione uma das seguintes opções:

      • Servidor: [your-application-name]Server

      • Cliente: [your-application-name]Client

   2. Inicie a compilação. Vá para Plataforma, Windows, Projeto de Pacote.

Para registrar sua estação de trabalho como uma computação em qualquer lugar

2. Insira um nome de computação para a sua máquina local. Se você adicionar mais de uma computação na frota, os nomes deverão ser exclusivos.

3. Forneça um endereço IP para sua máquina local. Esse campo é padronizado para o endereço IP público da sua máquina. Você também pode usar o localhost (127.0.0.1), desde que esteja executando o cliente e o servidor do jogo na mesma máquina.

4. Escolha Registrar computação. Você pode acompanhar o progresso dessa solicitação no registro de saída do editor Unreal.

Para jogar seu jogo hospedado

1. Inicie seu servidor de jogos. O servidor do jogo notificará a Amazon GameLift quando ela estiver pronta para hospedar sessões de jogo.

2. Inicie seu cliente de jogo e use a nova funcionalidade para iniciar uma nova sessão de jogo. Essa solicitação é enviada para a Amazon GameLift por meio do novo serviço de back-end. Em resposta, a Amazon GameLift liga para o servidor do jogo, executado em sua máquina local, para iniciar uma nova sessão de jogo. Quando a sessão de jogo estiver pronta para aceitar jogadores, a Amazon GameLift fornecerá informações de conexão para que o cliente do jogo participe da sessão de jogo.