Requisitos previos Compilación de Unreal Engine a partir del código fuente Configura tu proyecto para el SDK del servidor Adición del código de servidor a su proyecto Pasos a seguir a continuación

Integrar Amazon GameLift Servers en un proyecto de Unreal Engine

En este tema se explica cómo configurar el Amazon GameLift Servers El SDK del servidor C++ para Unreal Engine e integrarlo en tus proyectos de juegos.

Sugerencia

Comience a implementar su servidor de juegos en Amazon GameLift Servers para hospedaje. Con el Amazon GameLift Servers complemento independiente para Unreal Engine, puedes integrar el código de tu juego, implementar soluciones de alojamiento simples pero completas y probar los componentes de tu juego en acción. Consulte Amazon GameLift Servers plugin para Unreal Engine.

Recursos adicionales:

Requisitos previos

Antes de continuar, asegúrate de cumplir los siguientes requisitos previos:

Requisitos previos

Un ordenador con capacidad para ejecutar Unreal Engine. Para obtener más información sobre los requisitos de Unreal Engine, consulte la documentación Especificaciones de hardware y software de Unreal Engine.
Microsoft Visual Studio 2019 o una versión posterior.
CMake versión 3.1 o posterior.
Versión 3.6 o posterior de Python.
Un cliente Git disponible en PATH.
Una cuenta de Epic Games. Cree una cuenta en el sitio web oficial de Unreal Engine.
Una GitHub cuenta asociada a tu cuenta de Unreal Engine. Para obtener más información, consulta Cómo acceder al código fuente de Unreal Engine en el GitHub sitio web de Unreal Engine.

Compilación de Unreal Engine a partir del código fuente

Las versiones estándar del editor de Unreal Engine, descargadas a través del lanzador de Epic solo permiten compilar aplicaciones cliente de Unreal. Para compilar una aplicación de servidor de Unreal, debe descargar y compilar Unreal Engine a partir del código fuente mediante el repositorio de Github de Unreal Engine. Para obtener más información, consulte el tutorial https://docs.unrealengine.com/5.1/building-unreal-engine-from-source/ en el sitio web de documentación de Unreal Engine.

nota

Si aún no lo has hecho, sigue las instrucciones que aparecen en Acceder al código fuente de Unreal Engine GitHub para vincular tu GitHub cuenta a tu cuenta de Epic Games.

Clonación del código fuente de Unreal Engine en su entorno de desarrollo

Clone el código fuente de Unreal Engine en su entorno de desarrollo en la ramificación que elija.
```
git clone https://github.com/EpicGames/UnrealEngine.git
```
Obtén la versión de Unreal Engine compatible con Amazon GameLift Servers el complemento. Consulte Para servidores de juegos para obtener información sobre el soporte de la versión Unreal.

Consulte la etiqueta de la versión que está utilizando para desarrollar el juego. Por ejemplo, en el siguiente ejemplo se muestra la versión 5.1.1 de Unreal Engine:
```
git checkout tags/5.1.1-release -b 5.1.1-release
```
Diríjase a la carpeta raíz del repositorio local. Cuando esté en la carpeta raíz, ejecute el siguiente archivo:Setup.bat.
Mientras esté en la carpeta raíz, ejecute también el archivo: GenerateProjectFiles.bat.
Después de ejecutar los archivos de los pasos anteriores, se creará un archivo de solución de Unreal Engine, UE5.sln. Abra Visual Studio y, en el editor de Visual Studio, abra el archivo UE5.sln.
En Visual Studio, abra el menú Ver y elija la opción Explorador de soluciones. De esa forma, se abrirá el menú contextual del nodo del proyecto de Unreal. En la ventana del Explorador de soluciones, haga clic con el botón derecho en el archivo UE5.sln (puede aparecer como UE5) y, a continuación, seleccione Compilar para compilar el proyecto de Unreal con el objetivo Win64 del editor de desarrollo.

nota
Para completar la compilación se precisa más de una hora.

Una vez completada la compilación, estará listo para abrir el editor de desarrollo de Unreal y crear o importar un proyecto.

Configura tu proyecto de Unreal para el SDK del servidor

Siga estos pasos para obtener el SDK de servidor para Amazon GameLift Servers para que Unreal Engine esté listo para tus proyectos de servidores de juegos.

Para configurar tu proyecto para el SDK del servidor

Con Visual Studio abierto, diríjase al panel del Explorador de soluciones y elija el archivo UE5 para abrir el menú contextual del proyecto de Unreal. En el menú contextual, elija la opción Establecer como proyecto de inicio.
En la parte superior de la ventana de Visual Studio, elija Iniciar la depuración (flecha verde).

Esta acción inicia la nueva instancia de Unreal Editor creada en código fuente. Para obtener más información sobre el uso del editor de Unreal, consulte Interfaz del editor de Unreal en el sitio web de documentación de Unreal Engine.
Cierre la ventana de Visual Studio que ha abierto, ya que el editor de Unreal abre otra ventana de Visual Studio que contiene el proyecto de Unreal y el proyecto de juego.
En el editor de Unreal, realice uno de los siguientes procedimientos:
- Elige un proyecto de Unreal existente con el que quieras integrarte Amazon GameLift Servers.
- Cree un nuevo proyecto de . Para experimentar con el SDK del servidor Amazon GameLift Servers, intenta usar la plantilla en tercera persona de Unreal Engine. Para obtener más información sobre esta plantilla, consulte la plantilla Tercera persona en el sitio web de documentación de Unreal Engine.
  
  También puede configurar un nuevo proyecto con la siguiente configuración:
  - C++
  - Con contenido inicial
  - Escritorio
  - Un nombre de proyecto. En los ejemplos de este tema, asignamos un nombre a nuestro proyecto GameLiftUnrealApp.
En el Explorador de soluciones de Visual Studio, diríjase a la ubicación de su proyecto de Unreal. En la carpeta Source de Unreal, busque un archivo denominado Your-application-name.Target.cs.

Por ejemplo: GameLiftUnrealApp.Target.cs.
Realice una copia del archivo y asígnele el nombre Your-application-nameServer.Target.cs.

Abra el archivo nuevo y realice los cambios siguientes:

Cambie los valores class y constructor para que coincidan con el nombre del archivo.
Cambie el valor Type de TargetType.Game a TargetType.Server.

El archivo final tendrá un aspecto semejante al siguiente:


   public class GameLiftUnrealAppServerTarget : TargetRules
    {  
        public GameLiftUnrealAppServerTarget(TargetInfo Target) : base(Target)
        {
            Type = TargetType.Server;
            DefaultBuildSettings = BuildSettingsVersion.V2;
            IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_1;
            ExtraModuleNames.Add("GameLiftUnrealApp");
        }
    }

Tu proyecto ahora está configurado para usar el SDK del servidor para Amazon GameLift Servers.

La siguiente tarea consiste en compilar las bibliotecas del SDK del servidor C++ para Unreal de forma que pueda importarlas en su proyecto.

Para compilar las bibliotecas del SDK del servidor C++ para Unreal, realice el siguiente procedimiento:

Descargar Amazon GameLift Servers SDK de servidor C++ para Unreal.

nota
Colocar el SDK en el directorio de descargas predeterminado puede provocar un error de compilación debido a que la ruta supera el límite de 260 caracteres. Por ejemplo: C:\Users\Administrator\Downloads\GameLift-SDK-Release-06_15_2023\GameLift-Cpp-ServerSDK-5.0.4.
Le recomendamos que traslade el SDK a otro directorio, por ejemplo C:\GameLift-Cpp-ServerSDK-5.0.4.
Descargue e instale OpenSSL. Para obtener más información sobre la descarga de OpenSSL, lea la documentación de compilación e instalación de OpenSSL de Github.

Para obtener más información, lea la documentación de Notas de para plataformas Windows de OpenSSL.

nota
La versión de OpenSSL que se utiliza para crear el SDK del servidor Amazon GameLift Servers debe coincidir con la versión de OpenSSL utilizada por Unreal para empaquetar tu servidor de juegos. Encontrará información sobre las versiones en el directorio de instalación de Unreal (...Engine\Source\ThirdParty\OpenSSL).
Con las bibliotecas descargadas, cree las bibliotecas del SDK del servidor C++ para Unreal Engine.

Navega hasta el GameLift-Cpp-ServerSDK-<version> directorio del SDK descargado y, a continuación, sigue los pasos correspondientes a tu plataforma:
Linux
Para obtener una compilación automática rápida y sencilla de binarios compatibles con Amazon Linux, OpenSSL OpenCrypto y sus dependencias, consulte el SDK de creación del servidor para Amazon GameLift Servers para Unreal Engine 5 en Amazon Linux.

Si prefieres hacerlo manualmente, sigue los pasos que se indican aquí. Este método espera que la versión de OpenSSL correcta que coincida con su Unreal Engine esté configurada en su entorno Linux y que OpenSSL OpenCrypto y las bibliotecas se hayan copiado a la compilación de su servidor.
Ejecute los siguientes comandos :

mkdir out cd out cmake -DBUILD_FOR_UNREAL=1 .. make

Esto crea el archivo:

prefix/lib/aws-cpp-sdk-gamelift-server.so

Copia el archivo que se creó en esta ubicación de la carpeta del plugin Unreal:

GameLiftPlugin/Source/GameLiftServer/ThirdParty/GameLiftServerSDK/Linux/x86_64-unknown-linux-gnu/

Una vez completado, comprueba que tienes una ruta de archivo similar a la de este ejemplo:

GameLiftPlugin/Source/GameLiftServer/ThirdParty/GameLiftServerSDK/Linux/x86_64-unknown-linux-gnu/aws-cpp-sdk-gamelift-server.so
Windows
Ejecute los siguientes comandos :

mkdir out cd out cmake -G "Visual Studio 17 2022" -DBUILD_FOR_UNREAL=1 .. msbuild ALL_BUILD.vcxproj /p:Configuration=Release

Esto produce los siguientes archivos binarios necesarios para el SDK del servidor:

prefix\bin\aws-cpp-sdk-gamelift-server.dll prefix\lib\aws-cpp-sdk-gamelift-server.lib

Copia los archivos que se crearon en esta ubicación de la carpeta del complemento Unreal:

GameLiftPlugin\Source\GameLiftServer\ThirdParty\GameLiftServerSDK\Win64\

Una vez completado, comprueba que tienes dos rutas de archivo similares a las de este ejemplo:

GameLiftPlugin\Source\GameLiftServer\ThirdParty\GameLiftServerSDK\Win64\aws-cpp-sdk-gamelift-server.dll GameLiftPlugin\Source\GameLiftServer\ThirdParty\GameLiftServerSDK\Win64\aws-cpp-sdk-gamelift-server.lib
Cross Compile from Windows to Linux
Siga los pasos que se indican en Cómo crear el SDK del servidor para Amazon GameLift Servers para Unreal Engine 5 en Amazon Linux para descargar una versión para Linux del SDK libaws-cpp-sdk-gamelift-server.so de C++ Server. El paquete de descarga también incluye los archivoslibcrypto.so-.1.1, libssl.so.1.1 que se utilizarán en pasos posteriores después de empaquetar el Unreal Project.

Copia el archivo libaws-cpp-sdk-gamelift-server.so a la amazon-gamelift-plugin-unreal/GameLiftPlugin/Source/GameliftServer/ThirdParty/GameLiftServerSDK/Linux/x86_64-unknown-linux-gnu/ carpeta que se encuentra dentro del Amazon GameLift Servers Carpeta de complementos Unreal en tu proyecto.
Para obtener instrucciones más detalladas sobre cómo crear el SDK de C++, consulta el archivo README.md que se encuentra en el directorio del SDK de C++.

Utilice el siguiente procedimiento para importar el SDK del servidor para Amazon GameLift Servers a su proyecto de ejemplo.

Importe el SDK del servidor para Amazon GameLift Servers

Busque la GameLiftServerSDK carpeta que extrajo de la descarga en el procedimiento anterior.
Busque los Plugins en la carpeta raíz del proyecto del juego (si la carpeta no existe, créela allí).
Copie la carpeta GameLiftServerSDK en los Plugins.

Esto permitirá que el proyecto Unreal vea el SDK del servidor.
Añada el SDK del servidor para Amazon GameLift Servers al .uproject archivo del juego.

En el ejemplo, la aplicación se llama GameLiftUnrealApp, por lo que el archivo será GameLiftUnrealApp.uproject

Edita el .uproject archivo para añadir el SDK del servidor a tu proyecto de juego.


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

Asegúrate de que el juego ModuleRules dependa del SDK del servidor. Abre el .Build.cs archivo y añade el Amazon GameLift ServersDependencia de ServerSDK. El archivo se encuentra en Your-application-name/Source//Your-application-name/.

Por ejemplo, la ruta del archivo del tutorial es ../GameLiftUnrealApp/Source/GameLiftUnrealApp/GameLiftUnrealApp.Build.cs.

Añada "GameLiftServerSDK" al final de la 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;
    }
  }

El SDK del servidor debería funcionar ahora para su aplicación. Continúe con la siguiente sección para realizar la integración Amazon GameLift Servers funcionalidad en tu juego.

Add (Suma) Amazon GameLift Servers código de servidor para tu proyecto Unreal

Has configurado y configurado tu entorno de Unreal Engine y ahora puedes integrar un servidor de juegos con Amazon GameLift Servers. El código que se presenta en este tema hace las llamadas obligatorias al Amazon GameLift Servers servicio. También implementa un conjunto de funciones de devolución de llamada que responden a las solicitudes del Amazon GameLift Servers servicio. Para obtener más información sobre cada función y lo que hace el código, consulte Inicialización del proceso del servidor. Para obtener más información sobre las acciones del SDK y los tipos de datos que se utilizan en este código, consulteSDK 5.x de servidor C++ (Unreal) para Amazon GameLift Servers -- Acciones.

Para inicializar un servidor de juegos con Amazon GameLift Servers, utilice el siguiente procedimiento.

nota

La Amazon GameLift Servers-el código específico que se proporciona en la siguiente sección depende del uso de un indicador de WITH_GAMELIFT preprocesador. Este indicador solo es válido cuando se cumplen estas dos condiciones:

Target.Type == TargetRules.TargetType.Server
El proyecto del juego reconoce el SDK del servidor para Amazon GameLift Servers binarios.

Esto asegura que solo las compilaciones del servidor Unreal invoquen Amazon GameLift Serverses la API de backend. También le permitirá escribir código que se ejecutará correctamente para todos los destinos diferentes de Unreal que pueda producir el juego.

Integre un servidor de juegos con Amazon GameLift Servers

En Visual Studio, abra el archivo .sln de su aplicación. En nuestro ejemplo, el archivo GameLiftUnrealApp.sln se encuentra en la carpeta raíz.
Con la solución abierta, localice el archivo Your-application-nameGameMode.h de su aplicación. Ejemplo: GameLiftUnrealAppGameMode.h.

Cambie el archivo de encabezado para alinearlo con el siguiente código de ejemplo. Asegúrese de sustituir "GameLiftUnrealApp" por el nombre de su propia aplicación.


#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 el archivo Your-application-nameGameMode.cpp del archivo de origen relacionado. En nuestro ejemplo: GameLiftUnrealAppGameMode.cpp, y cambie el código para que se alinee con el siguiente código de ejemplo. Asegúrese de sustituir "GameLiftUnrealApp" por el nombre de su propia aplicación.

En este ejemplo se muestra cómo añadir todos los elementos necesarios para la integración con Amazon GameLift Servers, tal y como se describe en Agregar Amazon GameLift Servers a tu servidor de juegos. Esto incluye:

Inicializando un Amazon GameLift Servers Cliente de API.
Implementación de funciones de devolución de llamada para responder a las solicitudes del Amazon GameLift Servers servicio, que incluye OnStartGameSessionOnProcessTerminate, y. onHealthCheck
Llamar a ProcessReady () con un puerto designado para notificar al Amazon GameLift Serversservicio cuando esté listo para organizar sesiones de juego.


#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 an Amazon GameLift Servers Anywhere fleet. These are not needed for an Amazon GameLift Servers 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)
    }

    if (FParse::Value(FCommandLine::Get(), TEXT("-awsregion="), serverParameters.m_awsRegion))
    {
        UE_LOG(GameServerLog, Log, TEXT("AWS_REGION: %s"), *serverParameters.m_awsRegion)
    }


    if (FParse::Value(FCommandLine::Get(), TEXT("-accesskey="), serverParameters.m_accessKey))
    {
        UE_LOG(GameServerLog, Log, TEXT("ACCESS_KEY: %s"), *serverParameters.m_accessKey)
    }
    if (FParse::Value(FCommandLine::Get(), TEXT("-secretkey="), serverParameters.m_secretKey))
    {
        UE_LOG(GameServerLog, Log, TEXT("SECRET_KEY: % s"), *serverParameters.m_secretKey)
    }
    if (FParse::Value(FCommandLine::Get(), TEXT("-sessiontoken="), serverParameters.m_sessionToken))
    {
        UE_LOG(GameServerLog, Log, TEXT("SESSION_TOKEN: %s"), *serverParameters.m_sessionToken)
    }

    //The Host/compute-name of the Amazon GameLift Servers 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)
    }



    FString glProcessId = "";
    if (FParse::Value(FCommandLine::Get(), TEXT("-processId="), glProcessId))
    {
        serverParameters.m_processId = TCHAR_TO_UTF8(*glProcessId);
    }
    else
    {
        // If no ProcessId is passed as a command line argument, generate a randomized unique string.
        FString TimeString = FString::FromInt(std::time(nullptr));
        FString ProcessId = "ProcessId_" + TimeString;
        serverParameters.m_processId = TCHAR_TO_UTF8(*ProcessId);
    }

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

    //InitSDK establishes a local connection with the Amazon GameLift Servers Agent to enable further communication.
    //Use InitSDK(serverParameters) for an Amazon GameLift Servers Anywhere fleet. 
    //Use InitSDK() for Amazon GameLift Servers managed EC2 fleet.
    gameLiftSdkModule->InitSDK(serverParameters);

    //Implement callback function onStartGameSession
    //Amazon GameLift Servers 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
    //Amazon GameLift Servers 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 Amazon GameLift Servers 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
    //Amazon GameLift Servers 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 Amazon GameLift Servers 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 Amazon GameLift Servers where to find game session log files.
    //At the end of a game session, Amazon GameLift Servers 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 Amazon GameLift Servers it's ready to host game sessions.
    UE_LOG(GameServerLog, Log, TEXT("Calling Process Ready"));
    gameLiftSdkModule->ProcessReady(m_params);
}

Compile un proyecto de juego para los dos tipos de destino siguientes: Editor de desarrollo y Servidor de desarrollo.

nota
No es necesario volver a compilar la solución. En su lugar, compile solo el proyecto en la carpeta Games que coincida con el nombre de la aplicación. De lo contrario, Visual Studio reconstruye todo el UE5 proyecto, lo que puede tardar hasta una hora.
Una vez finalizadas ambas compilaciones, cierre Visual Studio y abra el archivo .uproject del proyecto para abrirlo en el editor de Unreal.
En el editor de Unreal, empaquete la compilación del servidor de juegos. Para elegir un objetivo, vaya a Plataformas, Windows y seleccione Your-application-nameServer.
Para iniciar el proceso de compilación de la aplicación de servidor, diríjase a Plataformas, Windows y seleccione Proyecto de paquetes. Cuando se complete la compilación, debería tener un archivo ejecutable. En el caso de nuestro ejemplo, el nombre del archivo es GameLiftUnrealAppServer.exe.
Al compilar una aplicación de servidor en el editor de Unreal, se generan dos archivos ejecutables. Uno de ellos se encuentra en la raíz de la carpeta de compilación del juego y actúa como contenedor del archivo ejecutable del servidor propiamente dicho.

Al crear un Amazon GameLift Servers junto con la versión de su servidor, le recomendamos que introduzca el ejecutable del servidor propiamente dicho como ruta de inicio de la configuración en tiempo de ejecución. Por ejemplo, en la carpeta de compilación del juego, puede que tenga un archivo GameLiftFPS.exe en la raíz y otro en \GameLiftFPS\Binaries\Win64\GameLiftFPSServer.exe. Al crear una flota, le recomendamos que la utilice C:\GameLiftFPS\Binaries\Win64\GameLiftFPSServer.exe como ruta de lanzamiento de la configuración del tiempo de ejecución.
Asegúrese de abrir los puertos UDP necesarios en el Amazon GameLift Servers fleet, para que el servidor del juego pueda comunicarse con los clientes del juego. De forma predeterminada, Unreal Engine utiliza el puerto 7777. Para obtener más información, consulta UpdateFleetPortSettingsla guía de referencia de la API de servicio para Amazon GameLift Servers.
En Windows: crea un install.bat archivo para la compilación de tu juego. Este script de instalación se ejecuta cada vez que la compilación del juego se implementa en un Amazon GameLift Servers flota. A continuación, se muestra un archivo install.bat de ejemplo:
```
VC_redist.x64.exe /q
UE5PrereqSetup_x64.exe /q
```
Para algunas versiones de Unreal Engine, el install.bat debería ser lo siguiente:
```
VC_redist.x64.exe /q
UEPrereqSetup_x64.exe /q
```
nota
La ruta del archivo al archivo <>PrereqSetup_x64.exe es Engine\Extras\Redist\en-us.
Ahora puedes empaquetar y cargar tu versión de juego en Amazon GameLift Servers.

La versión de OpenSSL empaquetada con la compilación del juego debe coincidir con la versión utilizada por el motor del juego a la hora de compilar el servidor de juegos. Asegúrese de empaquetar la versión de OpenSSL correcta con la compilación del servidor de juegos. Para el SO Windows, el formato de OpenSSL es .dll.
nota
Package los archivos DLL/SO de OpenSSL en la compilación de su servidor de juegos. Debe empaquetar la misma versión de OpenSSL que haya usado al compilar el servidor de juegos.
- libssl-1_1-x64.dll(Windows) o (Linux) libssl.so.1.1
  
  libcrypto-1_1-x64.dll(Windows) o libcrypto.so.1.1 (Linux)
Empaquete las dependencias junto con el archivo ejecutable del servidor de juegos en la raíz de un archivo zip. Por ejemplo, en Windows, openssl-lib las DLL deben estar en el mismo directorio que el .exe archivo.

Pasos a seguir a continuación

Has configurado y configurado tu entorno de Unreal Engine y ahora puedes empezar a integrarlo Amazon GameLift Servers en tu juego.

Para obtener más información sobre cómo añadir Amazon GameLift Servers a tu juego, consulta lo siguiente:

Para obtener instrucciones sobre cómo probar el juego, consulte Configure las pruebas locales con Amazon GameLift Servers Anywhere .

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

O3DE: Añadir Amazon GameLift Servers a tu juego

Integración con Unity