Intégration d'un client de jeu pour les serveurs en temps réel

Cette rubrique explique comment préparer votre client de jeu pour pouvoir rejoindre et participer à des sessions de jeu GameLift hébergées sur Amazon.

Il existe deux ensembles de tâches nécessaires pour préparer votre client de jeu :

• Configurer votre client de jeu pour obtenir plus d'informations sur des jeux existants, demander la mise en relation, démarrer de nouvelles sessions de jeu et réserver des emplacements de session de jeu pour un joueur.

• Permettez à votre client de jeu de rejoindre une session de jeu hébergée sur un serveur en temps réel et d'échanger des messages.

Trouvez ou créez des sessions de jeu et des sessions pour les joueurs

Configurez votre client de jeu pour trouver ou démarrer des sessions de jeu, demander des mises en relation FlexMatch et réserver de l'espace pour les joueurs dans un jeu en créant des sessions de joueur. La meilleure pratique consiste à créer un service principal et à l'utiliser pour envoyer des requêtes directes au GameLift service Amazon lorsqu'il est déclenché par une action du client du jeu. Le service principal transmet ensuite les réponses pertinentes au client du jeu.

1. Ajoutez le AWS SDK à votre client de jeu, initialisez un GameLift client Amazon et configurez-le pour utiliser les ressources d'hébergement de vos flottes et de vos files d'attente. Le AWS SDK est disponible en plusieurs langues ; consultez les GameLift kits SDK Pour les services clients liés aux jeux Amazon.

2. Ajoutez des GameLift fonctionnalités à votre service principal. Pour des instructions plus détaillées, voir Ajoutez Amazon GameLift à votre client de jeu et Ajouter un FlexMatch matchmaking. Une bonne pratique consiste à utiliser des placements de session de jeu pour créer de nouvelles sessions de jeu. Cette méthode vous permet de tirer pleinement parti GameLift de la capacité d'of à placer rapidement et intelligemment de nouvelles sessions de jeu, ainsi qu'à utiliser les données de latence des joueurs pour minimiser le décalage de jeu. Au minimum, votre service principal doit être en mesure de demander de nouvelles sessions de jeu et de gérer les données de session de jeu en réponse. Vous pouvez également ajouter des fonctionnalités pour rechercher et obtenir des informations sur les sessions de jeu existantes, et demander des sessions de joueur qui réservent de façon efficace un emplacement de joueur dans une session de jeu existante.

3. Renvoyer des informations de connexion vers le client de jeu. Le service principal reçoit des objets de session de jeu et de session de joueur en réponse aux demandes adressées au GameLift service Amazon. Ces objets contiennent des informations, notamment les détails de connexion (adresse IP et port) et l'ID de session du joueur, dont le client de jeu a besoin pour se connecter à la session de jeu en cours sur un serveur en temps réel.

Connectez-vous à des jeux sur des serveurs en temps réel

Permettez à votre client de jeu de se connecter directement à une session de jeu hébergée sur un serveur en temps réel et d'échanger des messages avec le serveur et avec d'autres joueurs.

1. Téléchargez le SDK Realtime Client, créez-le et ajoutez-le à votre projet de client de jeu. Consultez le fichier README pour plus d'informations sur les exigences du kit SDK et des instructions sur la façon de créer les bibliothèques client.

2. Appelez Client() avec une configuration client qui spécifie le type de connexion client/serveur à utiliser.

   Note

   Si vous vous connectez à un serveur en temps réel qui s'exécute sur une flotte sécurisée avec un certificat TLS, vous devez spécifier un type de connexion sécurisé.

3. Ajoutez les fonctionnalités suivantes à votre client de jeu. Consultez la Référence de l'API client (C#) de Realtime Servers pour plus d'informations.

   • Se connecter et se déconnecter d'un jeu

     • Connect()

     • Disconnect()

   • Envoyer des messages à des destinataires cibles

     • SendMessage()

   • Recevoir et traiter des messages

     • OnDataReceived()

   • Rejoindre des groupes et quitter des groupes de joueurs

     • JoinGroup()

     • RequestGroupMembership()

     • LeaveGroup()

4. Configuration des gestionnaires d'événements pour les rappels de client en fonction de vos besoins. Consultez Référence de l'API client (C#) de Realtime Servers : rappels asynchrones.

Lorsque vous travaillez avec des flottes en temps réel pour lesquelles la génération de certificats TLS est activée, le serveur est automatiquement authentifié à l'aide du certificat TLS. Le trafic TCP et UDP est chiffré en transit pour assurer la sécurité de la couche de transport. Le trafic TCP est chiffré avec TLS 1.2 et le trafic UDP avec DTLS 1.2.

Exemples de clients de jeu

Client en temps réel de base (C#)

Cet exemple illustre une intégration de base du client de jeu avec le SDK Realtime Client (C#). Comme indiqué, l'exemple initialise un objet client en temps réel, configure des gestionnaires d'événements et implémente les rappels côté client, se connecte à un serveur en temps réel, envoie un message et se déconnecte.

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