Mengintegrasikan klien game untuk Server Realtime

Topik ini menjelaskan bagaimana mempersiapkan klien game Anda untuk dapat bergabung dan berpartisipasi dalam sesi game yang GameLift di-host Amazon.

Ada dua set tugas yang diperlukan untuk mempersiapkan klien game Anda:

• Siapkan klien game Anda untuk memperoleh informasi tentang game yang tersedia, meminta matchmaking, memulai sesi game baru, dan menyimpan slot sesi game untuk pemain.

• Aktifkan klien game Anda untuk bergabung dengan sesi game yang di-host di server Realtime dan bertukar pesan.

Menemukan atau membuat sesi permainan dan sesi pemain

Siapkan klien game Anda untuk menemukan atau memulai sesi permainan, meminta FlexMatch perjodohan, dan cadangan ruang untuk pemain dalam permainan dengan membuat sesi pemain. Sebagai praktik terbaik, buat layanan backend dan gunakan untuk membuat permintaan langsung ke GameLift layanan Amazon saat dipicu oleh aksi klien game. Layanan backend kemudian menyampaikan respons yang relevan kembali ke klien game.

1. Tambahkan AWS SDK ke klien game Anda, inisialisasi GameLift klien Amazon, dan konfigurasikan untuk menggunakan sumber daya hosting di armada dan antrean Anda. AWSSDK tersedia dalam beberapa bahasa; lihat Amazon GameLift SDKUntuk layanan klien khusus.

2. Tambahkan GameLift fungsionalitas ke layanan backend Anda. Untuk petunjuk lebih rinci, lihat Tambahkan Amazon GameLift ke klien game Anda dan Menambahkan FlexMatch perjodohan. Praktik terbaik adalah menggunakan penempatan sesi game untuk membuat sesi game baru. Metode ini memungkinkan Anda memanfaatkan sepenuhnya kemampuan untuk menempatkan sesi permainan baru dengan cepat dan cerdas, serta menggunakan data latensi pemain untuk meminimalkan jeda permainan. GameLift Minimal, layanan backend Anda harus dapat meminta sesi game baru dan menangani data sesi game sebagai tanggapan. Anda mungkin juga ingin menambahkan fungsionalitas untuk mencari dan mendapatkan informasi tentang sesi game yang ada, dan meminta sesi pemain, yang secara efektif menyimpan slot pemain di sesi game yang ada.

3. Menyampaikan informasi koneksi kembali ke klien game. Layanan backend menerima sesi game dan objek sesi pemain sebagai respons terhadap permintaan ke GameLift layanan Amazon. Objek ini berisi informasi, khususnya detail koneksi (alamat IP dan port) dan ID sesi pemain, yang harus connect oleh klien game ke sesi game yang berjalan di Server Realtime.

Terhubung ke game di Server Realtime

Aktifkan klien game Anda untuk connect langsung dengan sesi game yang di-host di server Realtime dan bertukar pesan dengan server dan dengan pemain lain.

1. Dapatkan SDK Klien Realtime, buat, dan tambahkan ke proyek klien game Anda. Lihat file README Untuk informasi lebih lanjut tentang persyaratan SDK dan instruksi tentang cara membangun pustaka klien.

2. Panggilan Client() dengan konfigurasi klien yang menentukan jenis koneksi klien/server untuk digunakan.

   catatan

   Jika Anda menyambung ke server Realtime yang berjalan di armada aman dengan sertifikat TLS, Anda harus menentukan jenis sambungan yang aman.

3. Tambahkan fungsionalitas berikut untuk klien game Anda. Untuk informasi lebih lanjut, lihat Referensi API klien Server Realtime (C #).

   • Connect ke dan putuskan sambungan dari game

     • Connect()

     • Disconnect()

   • Mengirim pesan ke penerima target

     • SendMessage()

   • Menerima dan memproses pesan

     • OnDataReceived()

   • Bergabung dengan grup dan tinggalkan grup pemain

     • JoinGroup()

     • RequestGroupMembership()

     • LeaveGroup()

4. Mengatur event handler untuk callback klien yang diperlukan. Lihat Referensi API klien Server Realtime (C #): Callback asinkron.

Ketika bekerja dengan armada Realtime yang memiliki generasi sertifikat TLS diaktifkan, server secara otomatis dikonfirmasi menggunakan sertifikat TLS. Lalu lintas TCP dan UDP dienkripsi dalam penerbangan untuk menyediakan keamanan lapisan pengangkutan. Lalu lintas TCP dienkripsi menggunakan TLS 1.2, dan lalu lintas UDP dienkripsi menggunakan DTLS 1.2.

Contoh klien game

Klien realtime dasar (C #)

Contoh ini menggambarkan integrasi klien game basic dengan Klien Basic Realtime (C#). Seperti yang ditunjukkan, contoh menginisialisasi objek klien Realtime, menyiapkan event handler dan mengimplementasikan callback sisi klien, menghubungkan ke server Realtime, mengirim pesan, dan memutusnya.

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