Schritt 1: Lege dein Profil fest Schritt 2: Richte deinen Spielcode ein Schritt 3: Connect zu einer Anywhere-Flotte her Schritt 4: Registrieren Sie Ihre Workstation Schritt 5: Authentifizierungstoken generieren Schritt 6: Spiel starten

Plugin für Unreal: Lokales Testen mit Amazon einrichten GameLift Anywhere

In diesem Workflow fügen Sie Client- und Server-Spielcode für GameLift Amazon-Funktionen hinzu und verwenden das Plug-in, um Ihre lokale Workstation als Testspielserver-Host zu bestimmen. Wenn Sie die Integrationsaufgaben abgeschlossen haben, verwenden Sie das Plugin, um Ihre Spielclient- und Serverkomponenten zu erstellen.

So starten Sie den Amazon GameLift Anywhere-Workflow:

Wählen Sie in der Hauptsymbolleiste des Unreal-Editors das GameLift Amazon-Menü und dann Host with Anywhere aus. Diese Aktion öffnet die Plugin-Seite Deploy Anywhere, auf der ein sechsstufiger Prozess zum Integrieren, Erstellen und Starten deiner Spielkomponenten vorgestellt wird.

Schritt 1: Lege dein Profil fest

Wählen Sie das Profil aus, das Sie verwenden möchten, wenn Sie diesem Workflow folgen. Das von Ihnen ausgewählte Profil wirkt sich auf alle Schritte im Workflow aus. Alle Ressourcen, die Sie erstellen, sind mit dem AWS Konto des Profils verknüpft und werden in der AWS Standardregion des Profils platziert. Die Berechtigungen des Profilbenutzers bestimmen Ihren Zugriff auf AWS Ressourcen und Aktionen.

Wählen Sie ein Profil aus der Dropdownliste der verfügbaren Profile aus. Wenn Sie noch kein Profil haben oder ein neues erstellen möchten, gehen Sie zum GameLift Amazon-Menü und wählen Sie AWS Benutzerprofile einrichten.
Wenn der Bootstrap-Status nicht „Aktiv“ lautet, wählen Sie das Bootstrap-Profil und warten Sie, bis sich der Status auf „Aktiv“ ändert.

Schritt 2: Richte deinen Spielcode ein

In diesem Schritt nehmen Sie eine Reihe von Aktualisierungen an Ihrem Client- und Servercode vor, um Hosting-Funktionen hinzuzufügen. Wenn du noch keine Quellversion des Unreal-Editors eingerichtet hast, bietet das Plugin Links zu Anweisungen und Quellcode.

Mit dem Plugin können Sie einige Annehmlichkeiten bei der Integration Ihres Spielcodes nutzen. Sie können eine minimale Integration durchführen, um grundlegende Hosting-Funktionen einzurichten. Sie können auch eine umfassendere benutzerdefinierte Integration durchführen. Die Informationen in diesem Abschnitt beschreiben die minimale Integrationsoption. Verwenden Sie die im Plugin enthaltenen Testkarten, um Ihrem Spielprojekt GameLift Client-Amazon-Funktionen hinzuzufügen. Verwenden Sie für die Serverintegration das bereitgestellte Codebeispiel, um den Spielmodus Ihres Projekts zu aktualisieren.

Integrieren Sie Ihren Server-Spielmodus

Füge deinem Spiel einen Servercode hinzu, der die Kommunikation zwischen deinem Spieleserver und dem GameLift Amazon-Service ermöglicht. Ihr Spieleserver muss in der Lage sein, auf Anfragen von Amazon zu antworten GameLift, z. B. um eine neue Spielsitzung zu starten, und auch den Status des Spieleservers und der Spielerverbindungen melden können.

Öffnen Sie in Ihrem Code-Editor die Lösungsdatei (.sln) für Ihr Spielprojekt, die sich normalerweise im Stammordner des Projekts befindet. Zum Beispiel: GameLiftUnrealApp.sln.
Suchen Sie bei geöffneter Lösung die Header-Datei für den Spielmodus des Projekts: [project-name]GameMode.h file. Zum Beispiel: GameLiftUnrealAppGameMode.h.

Ändern Sie die Header-Datei so, dass sie dem folgenden Beispielcode entspricht. Achten Sie darauf, "GameLiftServer" durch Ihren eigenen Projektnamen zu ersetzen. Diese Updates sind spezifisch für den Spieleserver. Wir empfehlen dir, eine Sicherungskopie der ursprünglichen Spielmodusdateien für deinen Client zu erstellen.


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

Öffnen Sie die zugehörige [project-name]GameMode.cpp Quelldatei (zum BeispielGameLiftUnrealAppGameMode.cpp). Ändern Sie den Code so, dass er dem folgenden Beispielcode entspricht. Achten Sie darauf, "GameLiftUnrealApp" durch Ihren eigenen Projektnamen zu ersetzen. Diese Updates sind spezifisch für den Spieleserver. Wir empfehlen dir, eine Sicherungskopie der Originaldatei zur Verwendung mit deinem Client zu erstellen.

Der folgende Beispielcode zeigt, wie Sie die mindestens erforderlichen Elemente für die Serverintegration mit Amazon hinzufügen GameLift:

Initialisieren Sie einen Amazon GameLift API-Client. Der InitSDK() Aufruf mit Serverparametern ist für eine Amazon GameLift Anywhere-Flotte erforderlich. Wenn Sie eine Verbindung zu einer Anywhere-Flotte herstellen, speichert das Plugin die Serverparameter als Konsolenargumente. Der Beispielcode kann zur Laufzeit auf die Werte zugreifen.
Implementieren Sie die erforderlichen Rückruffunktionen, um auf Anfragen des GameLift Amazon-Service zu antworten, einschließlich OnStartGameSessionOnProcessTerminate, undonHealthCheck.
Rufen Sie ProcessReady() über einen bestimmten Port an, um den GameLift Amazon-Service zu benachrichtigen, wenn Sie bereit sind, Spielsitzungen abzuhalten.


// 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(">>>> Web Socket 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
}

Integrieren Sie Ihre Client-Spielkarte

Die Startkarte des Spiels enthält eine Entwurfslogik und Elemente der Benutzeroberfläche, die bereits Basiscode enthalten, mit dem Spielsitzungen angefordert und Verbindungsinformationen verwendet werden können, um eine Verbindung zu einer Spielsitzung herzustellen. Du kannst die Map unverändert verwenden oder sie nach Bedarf ändern. Verwenden Sie die Startkarte des Spiels zusammen mit anderen Spielressourcen, z. B. dem von Unreal Engine bereitgestellten Third-Person-Vorlagenprojekt. Diese Elemente sind im Inhaltsbrowser verfügbar. Sie können sie verwenden, um die Bereitstellungsworkflows des Plugins zu testen oder als Leitfaden für die Erstellung eines benutzerdefinierten Backend-Service für Ihr Spiel.

Die Startup-Map weist die folgenden Eigenschaften auf:

Sie beinhaltet Logik sowohl für eine Anywhere-Flotte als auch für eine verwaltete EC2-Flotte. Wenn Sie Ihren Client ausführen, können Sie wählen, ob Sie eine Verbindung zu einer der beiden Flotten herstellen möchten.
Zu den Client-Funktionen gehören das Suchen nach einer Spielsitzung SearchGameSessions (()), das Erstellen einer neuen Spielsitzung (CreateGameSession()) und das direkte Beitreten zu einer Spielsitzung.
Es erhält eine eindeutige Spieler-ID aus dem Amazon Cognito Cognito-Benutzerpool Ihres Projekts (dies ist Teil einer bereitgestellten Anywhere-Lösung).

Um die Karte des Startspiels zu verwenden

Öffnen Sie im UE-Editor die Seite Projekteinstellungen, Karten und Modi und erweitern Sie den Bereich Standardkarten.
Wählen Sie für Editor Startup Map die Option "StartupMap" aus der Dropdownliste aus. Möglicherweise müssen Sie nach der Datei suchen, die sich in ... > Unreal Projects/[project-name]/Plugins/Amazon GameLift Plugin Content/Maps befindet.
Wählen Sie für Game Default Map dieselbe "StartupMap" aus der Drop-down-Liste aus.
Wählen Sie für die Serverstandardkarte "ThirdPersonMap“ aus. Dies ist eine Standardkarte, die in Ihrem Spielprojekt enthalten ist. Diese Karte ist für zwei Spieler im Spiel konzipiert.
Öffne das Detailfenster für die Standardkarte des Servers. Stellen Sie GameMode Override auf „Keine“ ein.
Erweitere den Bereich Standardmodi und setze den globalen Standard-Server-Spielmodus auf den Spielmodus, den du für deine Serverintegration aktualisiert hast.

Nachdem Sie diese Änderungen an Ihrem Projekt vorgenommen haben, können Sie Ihre Spielkomponenten erstellen.

Erstellen Sie Ihre Spielkomponenten

Erstelle neue Server- und Client-Zieldateien

Gehe in deinem Spielprojektordner zum Quellordner und suche nach den Target.cs Dateien.
Kopiere die Datei [project-name]Editor.Target.cs in zwei neue Dateien mit dem Namen [project-name]Client.Target.cs und[project-name]Server.Target.cs.
Bearbeiten Sie jede der neuen Dateien, um die Werte für den Klassennamen und den Zieltyp zu aktualisieren, wie hier gezeigt:


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

Aktualisieren Sie die .Build.cs Datei.

Öffnen Sie die .Build.cs Datei für Ihr Projekt. Diese Datei befindet sich unter UnrealProjects/[project name]/Source/[project name]/[project name].Build.cs.

Aktualisieren Sie die ModuleRules Klasse wie im folgenden Codebeispiel gezeigt.


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

Baue deine Spielprojektlösung neu auf.
Öffnen Sie Ihr Spielprojekt in einer Quellversion des Unreal Engine-Editors.
Gehen Sie sowohl für Ihren Client als auch für Ihren Server wie folgt vor:
1. Wählen Sie ein Ziel aus. Gehen Sie zu Plattformen, Windows und wählen Sie eine der folgenden Optionen aus:
  - Server: [your-application-name]Server
  - Client: [your-application-name]Client
2. Starte den Build. Gehen Sie zu Plattform, Windows, Paketprojekt.

Jeder Paketierungsprozess generiert eine ausführbare Datei: [your-application-name]Client.exe oder[your-application-name]Server.exe.

Legen Sie im Plugin die Pfade zu den ausführbaren Client- und Server-Build-Dateien auf Ihrer lokalen Workstation fest.

Schritt 3: Connect zu einer Anywhere-Flotte her

In diesem Schritt bestimmen Sie eine Anywhere-Flotte, die verwendet werden soll. Eine Anywhere-Flotte definiert eine Sammlung von Rechenressourcen, die sich überall befinden können, für das Hosting von Spieleservern.

Wenn das AWS Konto, das Sie derzeit verwenden, bereits über Anywhere-Flotten verfügt, öffnen Sie das Dropdown-Feld Flottenname und wählen Sie eine Flotte aus. In dieser Dropdownliste werden nur die Anywhere-Flotten in der AWS Region für das aktuell aktive Benutzerprofil angezeigt.
Wenn es keine vorhandenen Flotten gibt oder Sie eine neue erstellen möchten, wählen Sie Neue Anywhere-Flotte erstellen und geben Sie einen Flottennamen ein.

Nachdem Sie eine Anywhere-Flotte für Ihr Projekt ausgewählt haben, GameLift überprüft Amazon, ob der Flottenstatus aktiv ist, und zeigt die Flotten-ID an. Sie können den Fortschritt dieser Anfrage im Ausgabeprotokoll des Unreal-Editors verfolgen.

Schritt 4: Registrieren Sie Ihre Workstation

In diesem Schritt registrieren Sie Ihre lokale Workstation als Rechenressource in der neuen Anywhere-Flotte.

Geben Sie einen Rechennamen für Ihren lokalen Computer ein. Wenn Sie der Flotte mehr als einen Computer hinzufügen, müssen die Namen eindeutig sein.
Geben Sie eine IP-Adresse für Ihren lokalen Computer an. Dieses Feld ist standardmäßig auf die öffentliche IP-Adresse Ihres Computers eingestellt. Du kannst auch localhost (127.0.0.1) verwenden, solange du deinen Spielclient und Server auf demselben Computer ausführst.
Wähle Computer registrieren. Sie können den Fortschritt dieser Anfrage im Ausgabeprotokoll des Unreal-Editors verfolgen.

Als Reaktion auf diese Aktion GameLift überprüft Amazon, ob es eine Verbindung zum Computer herstellen kann, und gibt Informationen über den neu registrierten Computer zurück. Es erstellt auch die Konsolenargumente, die Ihre ausführbaren Spieldateien benötigen, um die Kommunikation mit dem Amazon-Service zu initialisieren. GameLift

Schritt 5: Authentifizierungstoken generieren

Spieleserverprozesse, die auf deinem Anywhere-Computer ausgeführt werden, benötigen ein Authentifizierungstoken, um den GameLift Dienst aufrufen zu können. Das Plugin generiert und speichert automatisch ein Authentifizierungstoken für die Anywhere-Flotte, wenn Sie den Spieleserver über das Plug-in starten. Der Wert des Authentifizierungstokens wird als Befehlszeilenargument gespeichert, das Ihr Servercode zur Laufzeit abrufen kann.

In diesem Schritt müssen Sie keine Maßnahmen ergreifen.

Schritt 6: Spiel starten

Zu diesem Zeitpunkt haben Sie alle Aufgaben erledigt, die zum Starten und Spielen Ihres Multiplayer-Spiels auf einer lokalen Workstation mit Amazon erforderlich sind GameLift.

Starte deinen Spieleserver. Der Spieleserver benachrichtigt Amazon GameLift , wenn er bereit ist, Spielsitzungen zu veranstalten.
Starte deinen Spielclient und verwende die neuen Funktionen, um eine neue Spielsitzung zu starten. Diese Anfrage wird GameLift über den neuen Backend-Service an Amazon gesendet. Als Reaktion darauf ruft Amazon GameLift den Spieleserver auf, der auf Ihrem lokalen Computer läuft, um eine neue Spielsitzung zu starten. Wenn die Spielsitzung bereit ist, Spieler aufzunehmen, GameLift stellt Amazon dem Spielclient Verbindungsinformationen zur Verfügung, damit er an der Spielsitzung teilnehmen kann.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Richten Sie ein AWS Benutzerprofil ein

Stellen Sie Ihr Spiel auf verwalteten Amazon EC2 EC2-Flotten bereit