Integration eines Game-Clients für Realtime Server

In diesem Thema wird beschrieben, wie Sie Ihren Spielclient darauf vorbereiten, an von Amazon GameLift gehosteten Spielesitzungen teilnehmen und daran teilnehmen zu können.

Es gibt zwei Gruppen von Aufgaben, die zur Vorbereitung Ihres Spiele-Clients erforderlich sind:

• Einrichten Ihres Spiele-Clients zum Erfassen von Informationen zu bestehenden Spielen, zur Anforderung von Zuordnungen, zum Starten neuer Spielesitzungen und zur Reservierung von Spielesitzungsplätzen für einen Spieler.

• Ermöglichen Sie Ihrem Spielclient, an einer Spielsitzung teilzunehmen, die auf einem Realtime-Server gehostet wird, und Nachrichten auszutauschen.

Finde oder erstelle Spielsitzungen und Spielersitzungen

Richten Sie Ihren Spiel-Client so ein, dass er Spielesitzungen suchen oder starten, FlexMatch-Zuordnungen anfragen und Platz für Spieler in einem Spiel durch die Erstellung von Spielersitzungen reservieren kann. Es hat sich bewährt, einen Backend-Service zu erstellen und ihn zu verwenden, um die direkten Anfragen an den GameLift Amazon-Dienst zu stellen, wenn er durch eine Spiele-Client-Aktion ausgelöst wird. Der Backend-Service leitet dann die relevanten Antworten an den Spielclient zurück.

1. Füge das AWS SDK zu deinem Spielclient hinzu, initialisiere einen GameLift Amazon-Client und konfiguriere ihn so, dass er die Hosting-Ressourcen in deinen Flotten und Warteschlangen nutzt. Das AWS SDK ist in mehreren Sprachen verfügbar. Weitere Informationen finden Sie in den Amazon GameLift SDKsFür Spieleclient-Dienste.

2. Fügen Sie Ihrem Backend-Service GameLift Funktionen hinzu. Eine detailliertere Anleitung findest du unter Füge Amazon GameLift zu deinem Spielclient hinzu und FlexMatchMatchmaking hinzufügen. Die beste Vorgehensweise ist es, die Platzierung von Spielsitzungen zu nutzen, um neue Spielsitzungen zu erstellen. Mit dieser Methode kannst du alle Vorteile der GameLift Fähigkeit nutzen, schnell und intelligent neue Spielsitzungen zu platzieren und die Latenzdaten der Spieler zu verwenden, um Spielverzögerungen zu minimieren. Ihr Backend-Service muss mindestens in der Lage sein, neue Spielsitzungen anzufordern und daraufhin Spielsitzungsdaten zu verarbeiten. Sie können außerdem Funktionen zur Suche nach und zum Erhalten von Informationen über bestehende Spielsitzungen hinzufügen und Spielersitzungen anfordern, die effektiv einen Spielerplatz in einer bestehenden Spielsitzung reservieren.

3. Übermitteln Sie Verbindungsinformationen zurück an den Spiel-Client. Der Backend-Service empfängt Objekte für Spielsitzungen und Spielersitzungen als Antwort auf Anfragen an den GameLift Amazon-Dienst. Diese Objekte enthalten Informationen, insbesondere Verbindungsdetails (IP-Adresse und Port) und Spielersitzungs-ID, die der Spiel-Client benötigt, um sich mit der Spielsitzung auf einem Echtzeit-Server zu verbinden.

Stellen Sie eine Verbindung zu Spielen auf Echtzeitservern her

Ermöglichen Sie Ihrem Spielclient, sich direkt mit einer gehosteten Spielsitzung auf einem Echtzeitserver zu verbinden und Nachrichten mit dem Server und anderen Spielern auszutauschen.

1. Hol dir das Realtime Client SDK, erstelle es und füge es zu deinem Game-Client-Projekt hinzu. In der README-Datei finden Sie weitere Informationen zu den SDK-Anforderungen und Anweisungen zum Erstellen der Client-Bibliotheken.

2. Rufen Sie Client() mit einer Client-Konfiguration auf, die den zu verwendenden Client/Server-Verbindungstyp angibt.

   Anmerkung

   Wenn Sie eine Verbindung zu einem Echtzeitserver herstellen, der auf einer gesicherten Flotte mit einem TLS-Zertifikat ausgeführt wird, müssen Sie einen gesicherten Verbindungstyp angeben.

3. Fügen Sie die folgenden Funktionen Ihrem Spiel-Client hinzu. Weitere Informationen finden Sie unter Referenz zur Realtime Server-Client-API (C#).

   • Herstellen und Trennen einer Verbindung zu einem Spiel

     • Connect()

     • Disconnect()

   • Senden von Nachrichten an Zielempfänger

     • SendMessage()

   • Erhalten und Verarbeiten von Nachrichten

     • OnDataReceived()

   • Beitreten zu und Verlassen von Spielergruppen

     • JoinGroup()

     • RequestGroupMembership()

     • LeaveGroup()

4. Richten Sie nach Bedarf Ereignishandler für die Client-Callbacks ein. Siehe Referenz zur Realtime Server-Client-API (C#): Asynchrone Callbacks.

Bei der Arbeit mit Echtzeit-Flotten mit aktivierter TLS-Zertifikatgenerierung wird der Server automatisch mit dem TLS-Zertifikat authentifiziert. TCP- und UDP-Datenverkehr wird während der Übertragung verschlüsselt, um Sicherheit auf Transportebene zu gewährleisten. TCP-Datenverkehr wird mit TLS 1.2 verschlüsselt und UDP-Datenverkehr wird mit DTLS 1.2 verschlüsselt.

Beispiele für Spieleclients

Einfacher Echtzeitclient (C#)

Dieses Beispiel veranschaulicht eine grundlegende Game-Client-Integration mit dem Realtime Client SDK (C#). Wie gezeigt, initialisiert das Beispiel ein Realtime-Client-Objekt, richtet Event-Handler ein und implementiert die clientseitigen Callbacks, stellt eine Verbindung zu einem Realtime-Server her, sendet eine Nachricht und trennt die Verbindung.

using System;
using System.Text;
using Aws.GameLift.Realtime;
using Aws.GameLift.Realtime.Event;
using Aws.GameLift.Realtime.Types;

namespace Example
{
    /**
     * An example client that wraps the GameLift Realtime client SDK
     * 
     * You can redirect logging from the SDK by setting up the LogHandler as such:
     * ClientLogger.LogHandler = (x) => Console.WriteLine(x);
     *
     */
    class RealTimeClient
    {
        public Aws.GameLift.Realtime.Client Client { get; private set; }
        
        // An opcode defined by client and your server script that represents a custom message type
        private const int MY_TEST_OP_CODE = 10;

        /// Initialize a client for GameLift Realtime and connect to a player session.
        /// <param name="endpoint">The DNS name that is assigned to Realtime server</param>
        /// <param name="remoteTcpPort">A TCP port for the Realtime server</param>
        /// <param name="listeningUdpPort">A local port for listening to UDP traffic</param>
        /// <param name="connectionType">Type of connection to establish between client and the Realtime server</param>
        /// <param name="playerSessionId">The player session ID that is assigned to the game client for a game session </param>
        /// <param name="connectionPayload">Developer-defined data to be used during client connection, such as for player authentication</param>
       public RealTimeClient(string endpoint, int remoteTcpPort, int listeningUdpPort, ConnectionType connectionType,
                    string playerSessionId, byte[] connectionPayload)
        {
            // Create a client configuration to specify a secure or unsecure connection type
            // Best practice is to set up a secure connection using the connection type RT_OVER_WSS_DTLS_TLS12.
            ClientConfiguration clientConfiguration = new ClientConfiguration()
	     {
                // C# notation to set the field ConnectionType in the new instance of ClientConfiguration
	         ConnectionType = connectionType
	     };

            // Create a Realtime client with the client configuration            
            Client = new Client(clientConfiguration);

            // Initialize event handlers for the Realtime client
            Client.ConnectionOpen += OnOpenEvent;
            Client.ConnectionClose += OnCloseEvent;
            Client.GroupMembershipUpdated += OnGroupMembershipUpdate;
            Client.DataReceived += OnDataReceived;

            // Create a connection token to authenticate the client with the Realtime server
            // Player session IDs can be retrieved using AWS SDK for GameLift
            ConnectionToken connectionToken = new ConnectionToken(playerSessionId, connectionPayload);

            // Initiate a connection with the Realtime server with the given connection information
            Client.Connect(endpoint, remoteTcpPort, listeningUdpPort, connectionToken);
        }

        public void Disconnect()
        {
            if (Client.Connected)
            {
                Client.Disconnect();
            }
        }

        public bool IsConnected()
        {
            return Client.Connected;
        }

        /// <summary>
        /// Example of sending to a custom message to the server.
        /// 
        /// Server could be replaced by known peer Id etc.
        /// </summary>
        /// <param name="intent">Choice of delivery intent i.e. Reliable, Fast etc. </param>
        /// <param name="payload">Custom payload to send with message</param>
        public void SendMessage(DeliveryIntent intent, string payload)
        {
            Client.SendMessage(Client.NewMessage(MY_TEST_OP_CODE)
                .WithDeliveryIntent(intent)
                .WithTargetPlayer(Constants.PLAYER_ID_SERVER)
                .WithPayload(StringToBytes(payload)));
        }

        /**
         * Handle connection open events
         */
        public void OnOpenEvent(object sender, EventArgs e)
        {
        }

        /**
         * Handle connection close events
         */
        public void OnCloseEvent(object sender, EventArgs e)
        {
        }

        /**
         * Handle Group membership update events 
         */
        public void OnGroupMembershipUpdate(object sender, GroupMembershipEventArgs e)
        {
        }

        /**
         *  Handle data received from the Realtime server 
         */
        public virtual void OnDataReceived(object sender, DataReceivedEventArgs e)
        {
            switch (e.OpCode)
            {
                // handle message based on OpCode
                default:
                    break;
            }
        }

        /**
         * Helper method to simplify task of sending/receiving payloads.
         */
        public static byte[] StringToBytes(string str)
        {
            return Encoding.UTF8.GetBytes(str);
        }

        /**
         * Helper method to simplify task of sending/receiving payloads.
         */
        public static string BytesToString(byte[] bytes)
        {
            return Encoding.UTF8.GetString(bytes);
        }
    }
}