Integre a Amazon GameLift em um projeto Unreal Engine

Clone a fonte do Unreal Engine em seu ambiente de desenvolvimento em uma ramificação de sua escolha.

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

Confira a tag da versão que você está usando para desenvolver seu jogo. Por exemplo, o exemplo a seguir confere a versão 5.1.1 do Unreal Engine:

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

Navegue até a pasta raiz do repositório local. Quando você estiver na pasta raiz, execute o seguinte arquivo: Setup.bat.

Enquanto estiver na pasta raiz, execute também o arquivo: GenerateProjectFiles.bat.

Depois de executar os arquivos das etapas anteriores, um arquivo de solução do Unreal Engine, UE5.sln, é criado. Abra o Visual Studio e, no editor do Visual Studio, abra o arquivo UE5.sln.

No Visual Studio, abra o menu Exibir e escolha a opção Gerenciador de Soluções. Isso abre o menu de contexto do nó do projeto Unreal. Na janela Gerenciador de Soluções, clique com o botão direito do mouse no arquivo UE5.sln (ele pode ser listado apenas como UE5) e escolha Compilação para criar o projeto do Unreal com o destino Win64 do Editor de Desenvolvimento.

Com o Visual Studio aberto, navegue até o painel Gerenciador de Soluções e escolha o arquivo UE5 para abrir o menu de contexto do projeto do Unreal. No menu de contexto, escolha a opção Definir como projeto de Startup.

Na parte superior da janela do Visual Studio, escolha Iniciar depuração (seta verde).

Essa ação inicia sua nova instância de código-fonte do Unreal Editor. Para obter mais informações sobre o uso do Unreal Editor, consulte Interface do Unreal Editor no site de documentação do Unreal Engine.

Feche a janela do Visual Studio que você abriu, pois o Unreal Editor abre outra janela do Visual Studio que contém o projeto do Unreal e seu projeto de jogo.

No editor do Unreal, siga um destes procedimentos:

• Escolha um projeto Unreal existente que você deseja integrar com a Amazon GameLift.

• Criar um novo projeto da . Para experimentar o GameLift plug-in da Amazon para Unreal, tente usar o modelo de terceira pessoa do motor Unreal. Para obter mais informações sobre esse modelo, consulte Modelo de terceira pessoa no site de documentação do Unreal Engine.

  Como alternativa, configure um novo projeto com as seguintes configurações:

  • C++

  • Com conteúdo inicial

  • Área de Trabalho

  • Um nome de projeto. Nos exemplos deste tópico, nomeamos nosso projeto GameLiftUnrealApp.

No Gerenciador de Soluções do Visual Studio, navegue até o local do seu projeto do Unreal. Na pasta Source do Unreal, encontre um arquivo chamado Your-application-name.Target.cs.

Por exemplo: GameLiftUnrealApp.Target.cs.

Faça uma cópia deste arquivo e nomeie a cópia: Your-application-nameServer.Target.cs.

Abra o novo arquivo e faça as seguintes alterações:

Baixe o plug-in Amazon GameLift C++ Server SDK para Unreal.

Faça download do OpenSSL e instale-o. Para obter mais informações sobre como baixar o OpenSSL, leia a documentação de compilação e instalação do OpenSSL do Github.

Para obter mais informações, leia a documentação do OpenSSL Notas para plataformas Windows.

Com as bibliotecas baixadas, crie as bibliotecas do SDK do servidor C++ para Unreal Engine.

No diretório GameLift-Cpp-ServerSDK-<version> do SDK baixado, compile com o parâmetro -DBUILD_FOR_UNREAL=1 e crie o SDK do servidor. Os exemplos a seguir mostram como compilar usando cmake.

Execute os seguintes comandos em seu terminal:

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

A compilação do Windows cria os seguintes arquivos binários na pasta out\gamelift-server-sdk\Release:

Copie os dois arquivos da biblioteca para a ThirdParty\GameLiftServerSDK\Win64 pasta no pacote de plug-ins Amazon GameLift Unreal Engine.

Localize a GameLiftServerSDK pasta que você extraiu do plug-in no procedimento anterior.

Localize o Plugins na pasta raiz do seu projeto de jogo. (Se a pasta não existir, crie-a lá.)

Copie a GameLiftServerSDK pasta para Plugins o.

Isso permitirá que o projeto Unreal veja o plug-in.

Adicione o plug-in Amazon GameLift Server SDK ao .uproject arquivo do jogo.

No exemplo, o aplicativo é chamado GameLiftUnrealApp, então o arquivo será GameLiftUnrealApp.uproject.

Edite o arquivo .uproject para adicionar o plug-in ao seu projeto de jogo.

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

Certifique-se de que o ModuleRules jogo dependa do plug-in. Abra o .Build.cs arquivo e adicione a dependência do Amazon GameLiftServer SDK. Este arquivo pode ser encontrado no Your-application-name/Source//Your-application-name/.

Por exemplo, o caminho do arquivo do tutorial é ../GameLiftUnrealApp/Source/GameLiftUnrealApp/GameLiftUnrealApp.Build.cs.

Adicione "GameLiftServerSDK" ao final da lista de PublicDependencyModuleNames.

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

No Visual Studio, abra o arquivo .sln do aplicativo. No nosso exemplo, o arquivo GameLiftUnrealApp.sln é encontrado na pasta raiz.

Com a solução aberta, localize o arquivo Your-application-nameGameMode.h do seu aplicativo. Exemplo: GameLiftUnrealAppGameMode.h.

Altere o arquivo de cabeçalho para alinhá-lo com o código de exemplo a seguir. Certifique-se de substituir "GameLiftUnrealApp" pelo nome do seu próprio aplicativo.

#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();
};

Abra o arquivo Your-application-nameGameMode.cpp de origem relacionado. Em nosso Exemplo: GameLiftUnrealAppGameMode.cpp. e altere o código para alinhar com o código de exemplo a seguir. Certifique-se de substituir "GameLiftUnrealApp" pelo nome do seu próprio aplicativo.

Este exemplo mostra como adicionar todos os elementos necessários para a integração com a Amazon GameLift, conforme descrito em Adicionar Amazon GameLift ao seu servidor de jogos. Isso inclui:

#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);
}

Crie um projeto de jogo para os dois tipos de alvo a seguir: Editor de Desenvolvimento e Servidor de Desenvolvimento.

Quando as duas compilações estiverem concluídas, feche o Visual Studio e abra o arquivo .uproject do seu projeto para abri-lo no Unreal Editor.

No Unreal Editor, empacote a versão do servidor do seu jogo. Para escolher um destino, vá para Plataformas, Windows e selecione our-application-nameServidor Y.

Para iniciar o processo de criação do aplicativo do servidor, acesse Plataformas, Windows e selecione Projeto de pacote. Quando a compilação estiver concluída, você deverá ter um executável. No caso do nosso exemplo, o nome do arquivo é GameLiftUnrealAppServer.exe.

A criação de um aplicativo de servidor no Unreal Editor produz dois executáveis. Um está localizado na raiz da pasta de compilação do jogo e atua como um invólucro para o executável real do servidor.

Ao criar uma GameLift frota da Amazon com a construção do seu servidor, recomendamos que você transmita o executável real do servidor como o caminho de lançamento da configuração de tempo de execução. Por exemplo, na pasta de criação do jogo, você pode ter um arquivo GameLiftFPS.exe na raiz e outro em \GameLiftFPS\Binaries\Win64\GameLiftFPSServer.exe. Ao criar uma frota, recomendamos que você use C:\GameLiftFPS\Binaries\Win64\GameLiftFPSServer.exe como o caminho de inicialização da configuração de runtime.

Certifique-se de abrir as portas UDP necessárias na GameLift frota da Amazon, para que o servidor do jogo possa se comunicar com os clientes do jogo. Por padrão, o Unreal Engine usa porta 7777. Para obter mais informações, consulte o guia UpdateFleetPortSettingsde referência da API GameLift de serviços da Amazon.

Crie um arquivo install.bat para a versão do seu jogo. Esse script de instalação é executado sempre que a compilação do jogo é implantada em uma GameLift frota da Amazon. Veja um arquivo de exemplo install.bat:

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

Para algumas versões do Unreal Engine, o install.bat deveria ser

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

Agora você pode empacotar e enviar sua versão do jogo para a Amazon GameLift.

A versão do OpenSSL que você empacota com a compilação do jogo precisa corresponder à versão que o mecanismo de jogo usou ao criar o servidor do jogo. Certifique-se de empacotar a versão correta do OpenSSL com a compilação do servidor do jogo. Para o sistema operacional Windows, o formato OpenSSL é .dll.