Integrazione di un client di gioco per server in tempo reale

Questo argomento descrive come preparare il client di gioco a partecipare e partecipare a sessioni di gioco GameLift ospitate da Amazon.

Sono disponibili due set di attività necessarie per preparare il client di gioco:

• Configurare il client di gioco per acquisire informazioni su giochi esistenti, richiedere l'abbinamento, avviare nuove sessioni di gioco e prenotare slot delle sessioni di gioco per un giocatore.

• Consenti al tuo client di gioco di partecipare a una sessione di gioco ospitata su un server in tempo reale e di scambiare messaggi.

Trova o crea sessioni di gioco e sessioni per i giocatori

Configurare il client di gioco per trovare o avviare le sessioni di gioco, richiedere l'abbinamento FlexMatch prenotare spazi per giocatori in un gioco mediante la creazione di sessioni giocatore. Come best practice, crea un servizio di backend e utilizzalo per inviare richieste dirette al GameLift servizio Amazon quando vengono attivate da un'azione del client di gioco. Il servizio di backend trasmette quindi le risposte pertinenti al client di gioco.

1. Aggiungi l'AWSSDK al tuo client di gioco, inizializza un GameLift client Amazon e configuralo per utilizzare le risorse di hosting delle tue flotte e delle tue code. L'AWSSDK è disponibile in diverse lingue; consulta gli GameLift SDK Per i servizi client di gioco Amazon.

2. Aggiungi GameLift funzionalità al tuo servizio di backend. Per istruzioni più dettagliate, vedi Aggiungi Amazon GameLift al tuo client di gioco e Aggiungere il FlexMatch matchmaking. La best practice è utilizzare posizionamenti delle sessioni di gioco per creare nuove sessioni di gioco. Questo metodo ti consente di sfruttare appieno la capacità GameLift di inserire nuove sessioni di gioco in modo rapido e intelligente, oltre a utilizzare i dati sulla latenza dei giocatori per ridurre al minimo il ritardo di gioco. Come minimo, il tuo servizio di backend deve essere in grado di richiedere nuove sessioni di gioco e gestire i dati delle sessioni di gioco in risposta. È anche possibile aggiungere funzionalità per cercare e ottenere informazioni su sessioni di gioco esistenti e richiedere sessioni dei giocatori che effettivamente prenotano uno slot del giocatore in una sessione di gioco esistente.

3. Trasmettere le informazioni di connessione al client di gioco. Il servizio backend riceve gli oggetti della sessione di gioco e della sessione del giocatore in risposta alle richieste al GameLift servizio Amazon. Questi oggetti contengono informazioni, in particolare i dettagli di connessione (indirizzo IP e porta) e l'ID della sessione del giocatore, di cui il client di gioco ha bisogno per connettersi alla sessione di gioco in esecuzione su un server Realtime.

Connettiti ai giochi su server in tempo reale

Consenti al tuo client di gioco di connettersi direttamente a una sessione di gioco ospitata su un server in tempo reale e di scambiare messaggi con il server e con altri giocatori.

1. Scarica Realtime Client SDK, crealo e aggiungilo al tuo progetto client di gioco. Vedi il file README per ulteriori informazioni sui requisiti dell'SDK e sulle istruzioni su come creare librerie client.

2. Chiama Client() con una configurazione client che specifichi il tipo di connessione client/server da utilizzare.

   Nota

   Per la connessione a un server Realtime in esecuzione su un parco istanze protetto con un certificato TLS, devi specificare un tipo di connessione protetta.

3. Aggiungere le seguenti funzionalità al client di gioco. Per ulteriori informazioni, consulta Riferimento all'API client (C#) di Realtime Servers.

   • Connettersi e disconnettersi da un gioco

     • Connect()

     • Disconnect()

   • Inviare messaggi a destinatari target

     • SendMessage()

   • Ricevere ed elaborare messaggi

     • OnDataReceived()

   • Entrare a far parte di gruppi e lasciare gruppi di giocatori

     • JoinGroup()

     • RequestGroupMembership()

     • LeaveGroup()

4. Configurare gestori di eventi per le chiamate del client in base alle esigenze. Consultare Riferimento API client (C#) di Realtime Servers: callback asincroni.

Quando si utilizzano parchi istanze Realtime con la generazione di certificati TLS abilitata, il server viene automaticamente autenticato utilizzando il certificato TLS. Il traffico TCP e UDP viene crittografato in transito per fornire sicurezza a livello di trasporto. Il traffico TCP viene crittografato con TLS 1.2 e il traffico UDP viene crittografato con DTLS 1.2.

Esempi di client di gioco

Client in tempo reale di base (C#)

Questo esempio illustra un'integrazione di base del client di gioco con Realtime Client SDK (C#). Come illustrato, l'esempio inizializza un oggetto client in tempo reale, configura i gestori di eventi e implementa i callback lato client, si connette a un server in tempo reale, invia un messaggio e si disconnette.

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