Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun FlexMatch aturan ditetapkan
Setiap FlexMatch mak comblang harus memiliki aturan yang ditetapkan. Set aturan menentukan dua elemen kunci kecocokan: struktur dan ukuran tim game Anda, dan cara mengelompokkan pemain untuk mendapatkan kecocokan terbaik.
Misalnya, set aturan mungkin menggambarkan kecocokan seperti ini: Buat kecocokan dengan dua tim yang masing-masing terdiri dari lima pemain, satu tim adalah bertahan dan tim lainnya adalah penyerang. Sebuah tim dapat memiliki pemain pemula dan berpengalaman, tetapi keterampilan rata-rata kedua tim harus berada dalam jarak 10 poin satu sama lain. Jika tidak ada kecocokan yang dibuat setelah 30 detik, secara bertahap kendurkan persyaratan keterampilan.
Topik di bagian ini menjelaskan cara merancang dan membangun set aturan pencocokan. Saat membuat set aturan, Anda dapat menggunakan salah satu Amazon GameLift Servers konsol atau AWS CLI.
**Topics**
+ [Desain set FlexMatch aturan](match-design-ruleset.md)
+ [Rancang set aturan FlexMatch kecocokan besar](match-design-rulesets-large.md)
+ [Tutorial: Buat set aturan perjodohan](match-create-ruleset.md)
+ [FlexMatchcontoh set aturan](match-examples.md)
# Desain set FlexMatch aturan
Topik ini mencakup struktur dasar dari aturan yang ditetapkan dan bagaimana membangun aturan yang ditetapkan untuk pertandingan kecil hingga 40 pemain. Aturan perjodohan melakukan dua hal: menyusun struktur dan ukuran tim pertandingan dan memberi tahu mak comblang bagaimana memilih pemain untuk membentuk pertandingan terbaik.
Tapi aturan perjodohan Anda bisa berbuat lebih banyak. Sebagai contoh, Anda dapat:
+ Optimalkan algoritma perjodohan untuk game Anda.
+ Siapkan persyaratan latensi pemain minimum untuk melindungi kualitas gameplay.
+ Secara bertahap rileks persyaratan tim dan aturan pertandingan dari waktu ke waktu sehingga semua pemain aktif dapat menemukan pertandingan yang dapat diterima ketika mereka menginginkannya.
+ Tentukan penanganan untuk permintaan perjodohan grup menggunakan agregasi pihak.
+ Memproses pertandingan besar dari 40 pemain atau lebih. Untuk informasi selengkapnya tentang membangun korek api besar, lihat[Rancang set aturan FlexMatch kecocokan besar](match-design-rulesets-large.md).
Saat membuat set aturan perjodohan, pertimbangkan tugas opsional dan wajib berikut ini:
+ [Jelaskan set aturan (wajib)](match-rulesets-components-set.md)
+ [Menyesuaikan algoritme pencocokan](match-rulesets-components-algorithm.md)
+ [Menyatakan atribut pemain](match-rulesets-components-attributes.md)
+ [Menentukan tim kecocokan](match-rulesets-components-teams.md)
+ [Mengatur aturan untuk pencocokan pemain](match-rulesets-components-rules.md)
+ [Memungkinkan persyaratan untuk melonggar dari waktu ke waktu](match-rulesets-components-expansion.md)
Anda dapat membuat set aturan menggunakan Amazon GameLift Servers konsol atau `[CreateMatchmakingRuleSet](https://docs.aws.amazon.com/gameliftservers/latest/apireference/API_CreateMatchmakingRuleSet.html)` operasi.
# Jelaskan set aturan (wajib)
Berikan rincian untuk set aturan.
+ *nama* (opsional) — Label deskriptif untuk Anda gunakan sendiri. Nilai ini tidak terkait dengan nama kumpulan aturan yang Anda tentukan saat membuat aturan yang ditetapkanAmazon GameLift Servers.
+ *ruleLanguageVersion*— Versi bahasa ekspresi properti yang digunakan untuk membuat FlexMatch aturan. Nilainya harus`1.0`.
# Menyesuaikan algoritme pencocokan
FlexMatchmengoptimalkan algoritme default untuk sebagian besar game untuk membuat pemain masuk ke pertandingan yang dapat diterima dengan waktu tunggu minimal. Anda dapat menyesuaikan algoritme dan menyesuaikan perjodohan untuk gim Anda.
Berikut ini adalah algoritma FlexMatch perjodohan default:
1. FlexMatchmenempatkan semua tiket perjodohan terbuka dan tiket isi ulang di kolam tiket.
1. FlexMatchmengelompokkan tiket secara acak di kolam menjadi satu atau lebih batch. Saat kumpulan tiket semakin besar, FlexMatch bentuk batch tambahan untuk mempertahankan ukuran batch yang optimal.
1. FlexMatchmengurutkan tiket berdasarkan usia, dalam setiap batch.
1. FlexMatchmembangun kecocokan berdasarkan tiket tertua dari setiap batch.
Untuk menyesuaikan algoritme pencocokan, tambahkan komponen `algorithm` ke skema set aturan Anda. Lihat [FlexMatch skema set aturan](match-ruleset-schema.md) untuk informasi selengkapnya.
Gunakan penyesuaian opsional berikut untuk memengaruhi berbagai tahapan proses perjodohan Anda.
+ [Menambahkan penyortiran pra-batch](#match-rulesets-components-algorithm-presort)
+ [Formulir batch berdasarkan atribut batchDistance](https://docs.aws.amazon.com//gameliftservers/latest/flexmatchguide/match-rules-reference-ruletype.html#match-rules-reference-ruletype-batchdistance)
+ [Memprioritaskan tiket backfill](#match-rulesets-components-algorithm-backfill)
+ [Mendukung tiket lama dengan ekspansi](#match-rulesets-components-algorithm-expansion)
## Menambahkan penyortiran pra-batch
Anda dapat mengurutkan kumpulan tiket sebelum membentuk batch. Jenis kustomisasi ini paling efektif dengan game dengan kolam tiket besar. Penyortiran pra-batch dapat membantu mempercepat proses perjodohan dan meningkatkan keseragaman pemain dalam karakteristik yang ditentukan.
Tentukan metode penyortiran pra-batch menggunakan properti `batchingPreference` algoritma. Pengaturan default-nya adalah `random`.
Opsi untuk menyesuaikan penyortiran pra-batch meliputi:
+ **Urutkan berdasarkan atribut pemain.** Berikan daftar atribut pemain untuk mengurutkan kumpulan tiket.
Untuk mengurutkan berdasarkan atribut pemain, atur `batchingPreference` ke`sorted`, dan tentukan daftar atribut pemain Anda`sortByAttributes`. Untuk menggunakan atribut, pertama-tama deklarasikan atribut dalam `playerAttributes` komponen kumpulan aturan.
Dalam contoh berikut, FlexMatch urutkan kumpulan tiket berdasarkan peta permainan pilihan pemain dan kemudian berdasarkan keterampilan pemain. Batch yang dihasilkan lebih cenderung berisi pemain dengan keterampilan serupa yang ingin menggunakan peta yang sama.
```
"algorithm": {
"batchingPreference": "sorted",
"sortByAttributes": ["map", "player_skill"],
"strategy": "exhaustiveSearch"
},
```
+ **Urutkan berdasarkan latensi.** Buat kecocokan dengan latensi terendah yang tersedia atau buat kecocokan dengan cepat dengan latensi yang dapat diterima. Kustomisasi ini berguna untuk set aturan yang membentuk pertandingan besar lebih dari 40 pemain.
Atur properti algoritma `strategy` ke`balanced`. Strategi seimbang membatasi jenis pernyataan aturan yang tersedia. Untuk informasi selengkapnya, lihat [Rancang set aturan FlexMatch kecocokan besar](match-design-rulesets-large.md).
FlexMatchmengurutkan tiket berdasarkan data latensi yang dilaporkan pemain dengan salah satu cara berikut:
+ *Lokasi latensi terendah.* Kumpulan tiket diurutkan berdasarkan lokasi di mana pemain melaporkan nilai latensi terendah mereka. FlexMatchkemudian mengumpulkan tiket dengan latensi rendah di lokasi yang sama, menciptakan pengalaman bermain game yang lebih baik. Ini juga mengurangi jumlah tiket di setiap batch, sehingga perjodohan bisa memakan waktu lebih lama. Untuk menggunakan kustomisasi ini, atur `batchingPreference` ke`fastestRegion`, seperti yang ditunjukkan pada contoh berikut.
```
"algorithm": {
"batchingPreference": "fastestRegion",
"strategy": "balanced"
},
```
+ *Latensi yang dapat diterima cocok dengan cepat.* Kumpulan tiket diurutkan berdasarkan lokasi di mana pemain melaporkan nilai latensi yang dapat diterima. Ini membentuk lebih sedikit batch yang berisi lebih banyak tiket. Dengan lebih banyak tiket di setiap batch, menemukan pertandingan yang dapat diterima lebih cepat. Untuk menggunakan kustomisasi ini, atur properti `batchingPreference` ke` largestPopulation`, seperti yang ditunjukkan pada contoh berikut.
```
"algorithm": {
"batchingPreference": "largestPopulation",
"strategy": "balanced"
},
```
**catatan**
Nilai default untuk strategi seimbang adalah`largestPopulation`.
## Memprioritaskan tiket backfill
Jika game Anda menerapkan pengisian ulang otomatis atau pengisian ulang manual, Anda dapat menyesuaikan cara FlexMatch memproses tiket perjodohan berdasarkan jenis permintaan. Jenis permintaan dapat berupa permintaan kecocokan atau pengisian ulang baru. Secara default, FlexMatch memperlakukan kedua jenis permintaan dengan cara yang sama.
Prioritas pengisian ulang berdampak pada cara FlexMatch menangani tiket setelah menggabungkannya. Prioritas pengisian ulang memerlukan set aturan untuk menggunakan strategi pencarian lengkap.
FlexMatchtidak cocok dengan beberapa tiket isi ulang bersama-sama.
Untuk mengubah prioritas tiket isi ulang, atur properti. `backfillPriority`
+ **Cocokkan tiket isi ulang terlebih dahulu.** Opsi ini mencoba mencocokkan tiket isi ulang sebelum membuat pertandingan baru. Ini berarti bahwa pemain yang masuk memiliki peluang lebih tinggi untuk bergabung dengan game yang ada.
Cara terbaik untuk menggunakan ini jika game Anda menggunakan auto-backfill. Auto-backfill sering digunakan dalam game dengan sesi permainan pendek dan perputaran pemain tinggi. Auto-backfill membantu game-game ini membentuk pertandingan minimum yang layak dan memulainya saat FlexMatch mencari lebih banyak pemain untuk mengisi slot terbuka.
Atur `backfillPriority` ke `high` .
```
"algorithm": {
"backfillPriority": "high",
"strategy": "exhaustiveSearch"
},
```
+ **Match backfill tiket terakhir.** Opsi ini mengabaikan tiket isi ulang sampai mengevaluasi semua tiket lainnya. Ini berarti bahwa FlexMatch mengisi kembali pemain yang masuk ke dalam game yang ada ketika tidak dapat mencocokkan mereka ke dalam game baru.
Opsi ini berguna ketika Anda ingin menggunakan backfill sebagai opsi kesempatan terakhir untuk memasukkan pemain ke dalam permainan, seperti ketika tidak ada cukup pemain untuk membentuk pertandingan baru.
Atur `backfillPriority` ke `low`.
```
"algorithm": {
"backfillPriority": "low",
"strategy": "exhaustiveSearch"
},
```
## Mendukung tiket lama dengan ekspansi
Aturan ekspansi mengendurkan kriteria kecocokan saat pertandingan sulit diselesaikan. Amazon GameLift Serversberlaku aturan ekspansi ketika tiket dalam pertandingan yang diselesaikan sebagian mencapai usia tertentu. Stempel waktu pembuatan tiket menentukan kapan Amazon GameLift Servers menerapkan aturan; secara default, FlexMatch melacak stempel waktu tiket yang paling cocok.
Untuk mengubah saat FlexMatch menerapkan aturan ekspansi, tetapkan properti `expansionAgeSelection` sebagai berikut:
+ **Perluas berdasarkan tiket terbaru.** Opsi ini menerapkan aturan perluasan berdasarkan tiket terbaru yang ditambahkan ke kecocokan potensial. Setiap kali FlexMatch cocok dengan tiket baru, jam waktu diatur ulang. Dengan opsi ini, kecocokan yang dihasilkan cenderung memiliki kualitas yang lebih tinggi tetapi membutuhkan waktu lebih lama untuk dicocokkan; permintaan pertandingan mungkin habis sebelum diselesaikan jika terlalu lama untuk dicocokkan. Setel `expansionAgeSelection` ke`newest`. `newest`adalah default.
+ **Perluas berdasarkan tiket tertua.** Opsi ini menerapkan aturan ekspansi berdasarkan tiket tertua dalam pertandingan potensial. Dengan opsi ini, FlexMatch menerapkan ekspansi lebih cepat, yang meningkatkan waktu tunggu untuk pemain paling awal yang cocok, tetapi menurunkan kualitas pertandingan untuk semua pemain. Atur `expansionAgeSelection` ke `oldest`.
```
"algorithm": {
"expansionAgeSelection": "oldest",
"strategy": "exhaustiveSearch"
},
```
# Menyatakan atribut pemain
Di bagian ini, daftar atribut pemain individu untuk disertakan dalam permintaan perjodohan. Ada dua alasan Anda mungkin mendeklarasikan atribut pemain dalam set aturan:
+ Ketika set aturan berisi aturan yang bergantung pada atribut pemain.
+ Bila Anda ingin meneruskan atribut pemain ke sesi permainan melalui permintaan pertandingan. Misalnya, Anda mungkin ingin meneruskan pilihan karakter pemain ke sesi permainan sebelum setiap pemain terhubung.
Saat menyatakan atribut pemain, sertakan informasi berikut:
+ *name *(diperlukan) – Nilai ini harus unik untuk set aturan.
+ *type* (required) — Tipe data dari nilai atribut. Tipe data yang valid adalah nomor, string, daftar string, atau peta string.
+ *default* (opsional) - Masukkan nilai default untuk digunakan jika permintaan perjodohan tidak memberikan nilai atribut. Jika tidak ada default yang dideklarasikan dan permintaan tidak menyertakan nilai, tidak FlexMatch dapat memenuhi permintaan.
# Menentukan tim kecocokan
Menjelaskan struktur dan ukuran tim untuk kecocokan. Setiap kecocokan harus memiliki setidaknya satu tim, dan Anda dapat menentukan tim sebanyak yang Anda inginkan. Tim Anda dapat memiliki jumlah pemain yang sama atau asimetris. Misalnya, Anda dapat menentukan tim monster pemain tunggal dan tim pemburu dengan 10 pemain.
FlexMatchproses mencocokkan permintaan sebagai kecocokan kecil atau kecocokan besar, berdasarkan cara kumpulan aturan menentukan ukuran tim. Potensi pertandingan hingga 40 pemain adalah pertandingan kecil, pertandingan dengan lebih dari 40 pemain adalah pertandingan besar. Untuk menentukan ukuran kecocokan potensial set aturan, tambahkan pengaturan *maxPlayer* untuk semua tim yang ditentukan dalam set aturan.
+ *name * (diperlukan) – Tetapkan nama yang unik untuk setiap tim. Anda menggunakan nama ini dalam aturan dan ekspansi, dan FlexMatch referensi untuk data perjodohan dalam sesi permainan.
+ *MaxPlayers* (wajib) — Tentukan jumlah maksimum pemain yang akan ditetapkan ke tim.
+ *MinPlayers* (wajib) — Tentukan jumlah minimum pemain yang akan ditetapkan ke tim.
+ *kuantitas* (opsional) - Tentukan jumlah tim yang akan dibuat dengan definisi ini. Saat FlexMatch membuat pertandingan, ini memberi tim ini nama yang disediakan dengan nomor yang ditambahkan. Misalnya`Red-Team1`,`Red-Team2`, dan`Red-Team3`.
FlexMatchmencoba untuk mengisi tim dengan ukuran pemain maksimum tetapi membuat tim dengan lebih sedikit pemain. Jika Anda ingin semua tim dalam kecocokan memiliki ukuran yang sama, Anda dapat membuat aturan untuk itu. Lihat [FlexMatchcontoh set aturan](match-examples.md) topik untuk contoh `EqualTeamSizes` aturan.
# Mengatur aturan untuk pencocokan pemain
Buat seperangkat pernyataan aturan yang mengevaluasi pemain untuk diterima dalam pertandingan. Aturan mungkin menetapkan persyaratan yang berlaku untuk pemain individu, tim, atau seluruh kecocokan. Ketika Amazon GameLift Servers memproses permintaan pertandingan, itu dimulai dengan pemain tertua di kumpulan pemain yang tersedia dan membangun pertandingan di sekitar pemain itu. Untuk bantuan mendetail tentang membuat FlexMatch aturan, lihat[FlexMatchjenis aturan](match-rules-reference-ruletype.md).
+ *name* (required) - Nama bermakna yang secara unik mengidentifikasi aturan dalam set aturan. Nama aturan juga dirujuk dalam log peristiwa dan metrik yang melacak aktivitas yang terkait dengan aturan ini.
+ *description* (opsional) – Gunakan elemen ini untuk melampirkan deskripsi teks bentuk bebas.
+ *type* (diperlukan) – Elemen jenis mengidentifikasi operasi yang akan digunakan saat memproses aturan. Setiap jenis aturan memerlukan satu set properti tambahan. Lihat daftar jenis aturan dan properti yang valid di [FlexMatch aturan bahasa](match-rules-reference.md).
+ Properti tipe aturan (mungkin diperlukan) - Bergantung pada jenis aturan yang ditentukan, Anda mungkin perlu menetapkan properti aturan tertentu. Pelajari lebih lanjut tentang properti dan cara menggunakan bahasa ekspresi FlexMatch properti di[FlexMatch aturan bahasa](match-rules-reference.md).
# Memungkinkan persyaratan untuk melonggar dari waktu ke waktu
Ekspansi memungkinkan Anda untuk melonggarkan kriteria aturan dari waktu ke waktu ketika tidak FlexMatch dapat menemukan kecocokan. Fitur ini memastikan bahwa FlexMatch membuat yang terbaik tersedia ketika tidak dapat membuat pasangan yang sempurna. Dengan melonggarkan aturan Anda dengan ekspansi, Anda secara bertahap memperluas kolam pemain yang merupakan kecocokan yang dapat diterima.
Ekspansi dimulai ketika usia tiket terbaru dalam pertandingan yang tidak lengkap cocok dengan waktu tunggu ekspansi. Saat FlexMatch menambahkan tiket baru ke pertandingan, jam waktu tunggu ekspansi mungkin diatur ulang. Anda dapat menyesuaikan bagaimana ekspansi dimulai di `algorithm` bagian set aturan.
Berikut adalah contoh perluasan yang secara bertahap meningkatkan level keterampilan minimum yang diperlukan untuk kecocokan. Set aturan menggunakan pernyataan aturan jarak, dinamai *SkillDelta*untuk mengharuskan semua pemain dalam pertandingan berada dalam 5 tingkat keterampilan satu sama lain. Jika tidak ada pertandingan baru yang dibuat selama lima belas detik, ekspansi ini mencari perbedaan tingkat keterampilan 10, dan kemudian sepuluh detik kemudian mencari perbedaan 20.
```
"expansions": [{
"target": "rules[SkillDelta].maxDistance",
"steps": [{
"waitTimeSeconds": 15,
"value": 10
}, {
"waitTimeSeconds": 25,
"value": 20
}]
}]
```
Dengan pembuat kecocokan yang mengaktifkan backfill otomatis, jangan terlalu cepat melonggarkan persyaratan jumlah pemain Anda. Diperlukan beberapa detik untuk memulai sesi game baru dan memulai backfill otomatis. Pendekatan yang lebih baik adalah memulai ekspansi Anda setelah pengisian ulang otomatis cenderung dimulai untuk game Anda. Waktu ekspansi bervariasi tergantung pada komposisi tim Anda, jadi lakukan pengujian untuk menemukan strategi ekspansi terbaik untuk game Anda.
# Rancang set aturan FlexMatch kecocokan besar
Jika set aturan Anda membuat kecocokan yang memungkinkan 41 hingga 200 pemain, Anda perlu melakukan beberapa penyesuaian pada konfigurasi set aturan Anda. Penyesuaian ini mengoptimalkan algoritme kecocokan sehingga dapat membangun kecocokan besar yang layak sambil juga mempersingkat waktu tunggu pemain. Akibatnya, set aturan pencocokan besar menggantikan aturan khusus yang memakan waktu dengan solusi standar yang dioptimalkan untuk prioritas pencocokan umum.
Berikut cara menentukan apakah Anda perlu mengoptimalkan set aturan untuk kecocokan besar:
1. Untuk setiap tim yang ditentukan dalam set aturan Anda, dapatkan nilai dari *maxPlayer*,
1. Tambahkan semua nilai *maxPlayer*. Jika totalnya melebihi 40, Anda memiliki set aturan kecocokan yang besar.
Untuk mengoptimalkan set aturan Anda untuk kecocokan besar, buat penyesuaian yang dijelaskan sebagai berikut. Lihat skema untuk aturan kecocokan besar yang diatur di [Skema kumpulan aturan untuk kecocokan besar](match-ruleset-schema-large.md) dan contoh set aturan di [Contoh: Buat kecocokan besar](match-examples-7.md).
# Sesuaikan algoritme kecocokan untuk kecocokan besar
Tambahkan komponen algoritme ke set aturan, jika belum ada. Mengatur properti berikut.
+ `strategy` (diperlukan) – Atur properti `strategy` ke “seimbang”. Pengaturan ini memicu FlexMatch untuk melakukan pemeriksaan pasca-pertandingan tambahan untuk menemukan keseimbangan tim yang optimal berdasarkan atribut pemain tertentu, yang didefinisikan dalam properti. `balancedAttribute` Strategi seimbang menggantikan kebutuhan akan aturan khusus untuk membangun tim yang seimbang.
+ `balancedAttribute` (diperlukan) – Identifikasi atribut pemain untuk digunakan saat menyeimbangkan tim dalam kecocokan. Atribut ini harus memiliki jenis data numerik (ganda atau bilangan bulat). Misalnya, jika Anda memilih untuk menyeimbangkan keterampilan pemainFlexMatch, cobalah untuk menetapkan pemain sehingga semua tim memiliki tingkat keterampilan agregat yang sama rata mungkin. Atribut penyeimbang harus dinyatakan dalam atribut pemain set aturan.
+ `batchingPreference` (opsional) – Tentukan seberapa besar penekanan yang ingin Anda berikan untuk membentuk kecocokan dengan latensi serendah mungkin untuk pemain Anda. Pengaturan ini memengaruhi cara tiket kecocokan diurutkan sebelum membuat kecocokan. Opsi termasuk:
+ Populasi terbesar. FlexMatchmemungkinkan kecocokan menggunakan semua tiket di kolam yang memiliki nilai latensi yang dapat diterima di setidaknya satu lokasi yang sama. Akibatnya, kolam tiket potensial cenderung berukuran besar, sehingga membuatnya lebih mudah untuk mengisi kecocokan dengan lebih cepat. Pemain dapat ditempatkan dalam game dengan latensi yang dapat diterima, tetapi tidak selalu optimal. Jika `batchingPreference` properti tidak disetel, ini adalah perilaku default saat `strategy` disetel ke “balanced”.
+ Lokasi tercepat. FlexMatchpra-urutkan semua tiket di kolam berdasarkan di mana mereka melaporkan nilai latensi terendah. Akibatnya, pertandingan cenderung dibentuk dengan pemain yang melaporkan latensi rendah di lokasi yang sama. Pada saat yang sama, kolam tiket potensial untuk setiap kecocokan lebih kecil, yang dapat meningkatkan waktu yang dibutuhkan untuk mengisi kecocokan. Selain itu, karena prioritas yang lebih tinggi ditempatkan pada latensi, pemain dalam pertandingan dapat bervariasi lebih luas sehubungan dengan atribut penyeimbangan.
Contoh berikut mengonfigurasi algoritme pencocokan untuk berperilaku sebagai berikut: (1) Pra-urutkan kumpulan tiket untuk mengelompokkan tiket berdasarkan lokasi di mana mereka memiliki nilai latensi yang dapat diterima; (2) Bentuk kumpulan tiket yang diurutkan untuk pencocokan; (3) Buat pertandingan dengan tiket dalam satu batch dan seimbangkan tim untuk meratakan keterampilan pemain rata-rata.
```
"algorithm": {
"strategy": "balanced",
"balancedAttribute": "player_skill",
"batchingPreference": "largestPopulation"
},
```
# Menyatakan atribut pemain
Pastikan Anda menyatakan atribut pemain yang digunakan sebagai atribut penyeimbang dalam algoritme set aturan. Atribut ini harus dimasukkan untuk setiap pemain dalam permintaan pencocokan. Anda dapat memberikan nilai default untuk atribut pemain, tetapi penyeimbangan atribut berfungsi paling baik saat nilai khusus pemain diberikan.
# Menentukan tim
Proses mendefinisikan ukuran dan struktur tim sama dengan pertandingan kecil, tetapi cara FlexMatch mengisi tim berbeda. Hal ini memengaruhi tampilan kecocokan jika hanya diisi sebagian. Anda mungkin ingin menyesuaikan ukuran tim minimum Anda sebagai tanggapan.
FlexMatchmenggunakan aturan berikut saat menugaskan pemain ke tim. Pertama: cari tim yang belum mencapai persyaratan minimum pemain. Kedua: dari tim-tim tersebut, temukan salah satu tim yang slotnya paling terbuka.
Untuk kecocokan yang menentukan beberapa tim berukuran sama, pemain ditambahkan secara berurutan ke setiap tim hingga penuh. Akibatnya, tim dalam kecocokan selalu memiliki jumlah pemain yang hampir sama, bahkan saat pertandingan tidak penuh. Saat ini, tidak ada cara untuk memaksa tim berukuran sama dalam kecocokan besar. Untuk kecocokan dengan tim berukuran asimetris, prosesnya sedikit lebih rumit. Dalam skenario ini, pemain awalnya ditetapkan ke tim terbesar yang memiliki slot paling terbuka. Karena jumlah slot terbuka menjadi lebih merata di semua tim, pemain ditempatkan ke tim yang lebih kecil.
Misalnya, Anda memiliki aturan yang ditetapkan dengan tiga tim. Tim Merah dan Biru, keduanya diatur ke `maxPlayers`=10, `minPlayers`=5. Tim Hijau diatur ke `maxPlayers`=3, `minPlayers`=2. Berikut adalah urutan pengisiannya:
1. Tidak ada tim yang mencapai `minPlayers`. Tim Merah dan Biru memiliki 10 slot terbuka, sedangkan Hijau memiliki 3. 10 pemain pertama ditugaskan (5 masing-masing) ke tim Merah dan Biru. Kedua tim kini telah mencapai `minPlayers`.
1. Tim hijau belum mencapai `minPlayers`. 2 pemain berikutnya ditetapkan ke tim Hijau. Tim Hijau sekarang telah mencapai `minPlayers`.
1. Dengan semua tim di`minPlayers`, pemain tambahan sekarang ditugaskan berdasarkan jumlah slot terbuka. Tim Merah dan Biru masing-masing memiliki 5 slot terbuka, sedangkan tim Green memiliki 1. 8 pemain berikutnya ditetapkan (masing-masing 4) ke tim Merah dan Biru. Semua tim sekarang memiliki 1 slot terbuka.
1. 3 slot pemain yang tersisa ditetapkan (masing-masing 1) ke tim tanpa urutan tertentu.
# Tetapkan aturan untuk pertandingan besar
Pencocoka untuk kecocokan besar bergantung terutama pada strategi penyeimbangan dan pengoptimalan batching latensi. Sebagian besar aturan kustom tidak tersedia. Namun, Anda dapat memasukkan jenis aturan berikut:
+ Aturan yang menetapkan batas keras pada latensi pemain. Gunakan tipe `latency` aturan dengan properti`maxLatency`. Lihat [Latensi aturan](match-rules-reference-ruletype.md#match-rules-reference-ruletype-latency) referensi. Berikut adalah contoh yang menyetel latensi pemain maksimum ke 200 milidetik:
```
"rules": [{
"name": "player-latency",
"type": "latency",
"maxLatency": 200
}],
```
+ Aturan untuk batch pemain berdasarkan kedekatan dalam atribut pemain tertentu. Ini berbeda dengan mendefinisikan atribut balancing sebagai bagian dari algoritma pertandingan besar, yang berfokus pada membangun tim yang cocok secara merata. Aturan ini mengumpulkan tiket perjodohan berdasarkan kesamaan dalam nilai atribut yang ditentukan, seperti keterampilan pemula atau ahli, yang cenderung mengarah ke pemain pertandingan yang selaras erat pada atribut yang ditentukan. Gunakan tipe `batchDistance` aturan, identifikasi atribut berbasis numerik, dan tentukan rentang terluas untuk mengizinkan. Lihat [Aturan jarak Batch](match-rules-reference-ruletype.md#match-rules-reference-ruletype-batchdistance) referensi. Berikut adalah contoh yang meminta pemain pertandingan berada dalam satu tingkat keterampilan satu sama lain:
```
"rules": [{
"name": "batch-skill",
"type": "batchDistance",
"batchAttribute": "skill",
"maxDistance": 1
```
# Melonggarkan persyaratan kecocokan besar
Seperti halnya kecocokan kecil, Anda dapat menggunakan perluasan untuk melonggarkan persyaratan kecocokan dari waktu ke waktu ketika tidak ada kecocokan valid yang memungkinkan. Dengan kecocokan besar, Anda memiliki opsi untuk melonggarkan aturan latensi atau jumlah pemain tim.
Jika Anda menggunakan pengisian ulang pertandingan otomatis untuk pertandingan besar, hindari merilekskan jumlah pemain tim Anda terlalu cepat. FlexMatchmulai menghasilkan permintaan pengisian ulang hanya setelah sesi permainan dimulai, yang mungkin tidak terjadi selama beberapa detik setelah pertandingan dibuat. Selama waktu itu, FlexMatch dapat membuat beberapa sesi permainan baru yang terisi sebagian, terutama ketika aturan hitungan pemain diturunkan. Akibatnya, Anda mendapatkan dengan lebih banyak sesi game daripada yang Anda butuhkan dan persebaran pemain terlalu tipis. Praktik terbaik adalah memberikan langkah pertama dalam perluasan jumlah pemain Anda waktu tunggu yang lebih lama, cukup lama untuk memulai sesi game Anda. Karena permintaan backfill diberi prioritas lebih tinggi untuk kecocokan besar, pemain yang masuk akan ditempatkan ke dalam game yang ada sebelum game baru dimulai. Anda mungkin perlu bereksperimen untuk menemukan waktu tunggu yang ideal untuk game Anda.
Berikut adalah contoh yang secara bertahap menurunkan jumlah pemain tim Kuning, dengan waktu tunggu awal yang lebih lama. Perlu diingat bahwa waktu tunggu dalam perluasan set aturan adalah mutlak, tidak ditambah. Jadi perluasan pertama terjadi pada lima detik, dan perluasan kedua terjadi lima detik kemudian, yaitu pada sepuluh detik.
```
"expansions": [{
"target": "teams[Yellow].minPlayers",
"steps": [{
"waitTimeSeconds": 5,
"value": 8
}, {
"waitTimeSeconds": 10,
"value": 5
}]
}]
```
# Tutorial: Buat set aturan perjodohan
[Sebelum Anda membuat aturan perjodohan yang ditetapkan untuk mak Amazon GameLift ServersFlexMatch comblang Anda, kami sarankan untuk memeriksa sintaks set aturan.](match-rules-reference.md) Setelah Anda membuat set aturan menggunakan Amazon GameLift Servers konsol atau AWS Command Line Interface (AWS CLI), Anda tidak dapat mengubahnya.
Perhatikan bahwa ada [kuota layanan](https://console.aws.amazon.com/servicequotas/home/services/gamelift/quotas/) untuk jumlah maksimum set aturan yang dapat Anda miliki di AWS Wilayah, jadi sebaiknya hapus kumpulan aturan yang tidak digunakan.
**Topics**
------
#### [ Console ]
**Buat set aturan**
1. Buka konsol Amazon GameLift Servers di [https://console.aws.amazon.com/gamelift/](https://console.aws.amazon.com/gamelift/).
1. Beralih ke AWS Wilayah tempat Anda ingin membuat set aturan. Tentukan kumpulan aturan di Wilayah yang sama dengan konfigurasi perjodohan yang menggunakannya.
1. Di panel navigasi, pilih **FlexMatch**, **set aturan Matchmaking**.
1. Pada halaman **Matchmaking rule sets**, pilih **Create rule** set.
1. Pada halaman **set aturan Create matchmaking**, lakukan hal berikut:
1. Di bawah **Setelan aturan**, untuk **Nama**, masukkan nama deskriptif unik yang dapat Anda gunakan untuk mengidentifikasinya dalam daftar atau dalam tabel peristiwa dan metrik.
1. Untuk **set Aturan**, masukkan aturan yang ditetapkan di JSON. Untuk informasi tentang mendesain set aturan, lihat[Desain set FlexMatch aturan](match-design-ruleset.md). Anda juga dapat menggunakan salah satu set aturan contoh dari[FlexMatchcontoh set aturan](match-examples.md).
1. Pilih **Validasi** untuk memverifikasi bahwa sintaks kumpulan aturan Anda sudah benar. Anda tidak dapat mengedit kumpulan aturan setelah dibuat, jadi sebaiknya validasi terlebih dahulu.
1. (Opsional) Di bawah **Tag**, tambahkan tag untuk membantu Anda mengelola dan melacak AWS sumber daya Anda.
1. Pilih **Buat**. Jika pembuatan berhasil, Anda dapat menggunakan aturan yang ditetapkan dengan mak comblang.
------
#### [ AWS CLI ]
**Buat set aturan**
Buka jendela baris perintah dan gunakan perintah [create-matchmaking-rule-set](https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-matchmaking-rule-set.html).
Perintah contoh ini membuat aturan perjodohan sederhana yang mengatur satu tim. Pastikan untuk membuat aturan yang ditetapkan di AWS Wilayah yang sama dengan konfigurasi perjodohan yang menggunakannya.
```
aws gamelift create-matchmaking-rule-set \
--name "SampleRuleSet123" \
--rule-set-body '{"name": "aliens_vs_cowboys", "ruleLanguageVersion": "1.0", "teams": [{"name": "cowboys", "maxPlayers": 8, "minPlayers": 4}]}'
```
Jika permintaan pembuatan berhasil, Amazon GameLift Servers mengembalikan [MatchmakingRuleSet](https://docs.aws.amazon.com/gameliftservers/latest/apireference/API_MatchmakingRuleSet.html)objek yang menyertakan pengaturan yang Anda tentukan. Seorang mak comblang sekarang dapat menggunakan set aturan baru.
------
------
#### [ Console ]
**Hapus satu set aturan**
1. Buka konsol Amazon GameLift Servers di [https://console.aws.amazon.com/gamelift/](https://console.aws.amazon.com/gamelift/).
1. Beralih ke Wilayah tempat Anda membuat aturan yang ditetapkan.
1. Di panel navigasi, pilih **FlexMatch**, **set aturan Matchmaking**.
1. **Pada halaman **Matchmaking rule sets**, pilih set aturan yang ingin Anda hapus, lalu pilih Delete.**
1. Dalam kotak dialog **Hapus aturan set**, pilih **Hapus** untuk mengonfirmasi penghapusan.
**catatan**
Jika konfigurasi perjodohan menggunakan kumpulan aturan, akan Amazon GameLift Servers menampilkan pesan kesalahan (**Tidak dapat menghapus kumpulan aturan**). Jika ini terjadi, ubah konfigurasi perjodohan untuk menggunakan kumpulan aturan yang berbeda, lalu coba lagi. Untuk mengetahui konfigurasi perjodohan mana yang menggunakan kumpulan aturan, pilih nama set aturan untuk melihat halaman detailnya.
------
#### [ AWS CLI ]
**Hapus satu set aturan**
Buka jendela baris perintah dan gunakan perintah [delete-matchmaking-rule-set](https://docs.aws.amazon.com/cli/latest/reference/gamelift/delete-matchmaking-rule-set.html)untuk menghapus set aturan perjodohan.
Jika konfigurasi perjodohan menggunakan set aturan, Amazon GameLift Servers mengembalikan pesan kesalahan. Jika ini terjadi, ubah konfigurasi perjodohan untuk menggunakan kumpulan aturan yang berbeda, lalu coba lagi. Untuk mendapatkan daftar konfigurasi perjodohan mana yang menggunakan kumpulan aturan, gunakan perintah [describe-matchmaking-configurations](https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-matchmaking-configurations.html)dan tentukan nama kumpulan aturan.
Perintah contoh ini memeriksa penggunaan set aturan perjodohan dan kemudian menghapus kumpulan aturan.
```
aws gamelift describe-matchmaking-rule-sets \
--rule-set-name "SampleRuleSet123" \
--limit 10
aws gamelift delete-matchmaking-rule-set \
--name "SampleRuleSet123"
```
------
# FlexMatchcontoh set aturan
FlexMatchset aturan dapat mencakup berbagai skenario perjodohan. Contoh berikut sesuai dengan struktur FlexMatch konfigurasi dan bahasa ekspresi properti. Salin set aturan ini secara keseluruhan atau pilih komponen sesuai kebutuhan.
Untuk informasi selengkapnya tentang penggunaan FlexMatch aturan dan kumpulan aturan, lihat topik berikut:
**catatan**
Saat mengevaluasi tiket perjodohan yang mencakup beberapa pemain, semua pemain dalam permintaan harus memenuhi persyaratan pertandingan.
**Topics**
+ [Contoh: Buat dua tim dengan pemain yang serasi](match-examples-1.md)
+ [Contoh: Buat tim yang tidak rata (Hunters vs Monster)](match-examples-2.md)
+ [Contoh: Tetapkan persyaratan tingkat tim dan batas latensi](match-examples-3.md)
+ [Contoh: Gunakan pengurutan eksplisit untuk menemukan kecocokan terbaik](match-examples-4.md)
+ [Contoh: Temukan persimpangan di beberapa atribut pemain](match-examples-5.md)
+ [Contoh: Bandingkan atribut di semua pemain](match-examples-6.md)
+ [Contoh: Buat kecocokan besar](match-examples-7.md)
+ [Contoh: Buat pertandingan besar multi-tim](match-examples-8.md)
+ [Contoh: Buat pertandingan besar dengan pemain dengan atribut serupa](match-examples-9.md)
+ [Contoh: Gunakan aturan gabungan untuk membuat pertandingan dengan pemain dengan atribut serupa atau pilihan serupa](match-examples-10.md)
+ [Contoh: Buat aturan yang menggunakan daftar blokir pemain](match-examples-11.md)
# Contoh: Buat dua tim dengan pemain yang serasi
Contoh ini menggambarkan cara mengatur dua tim pemain yang sama-sama cocok dengan instruksi berikut.
+ Buat dua tim pemain.
+ Sertakan antara empat dan delapan pemain di setiap tim.
+ Tim final harus memiliki jumlah pemain yang sama.
+ Sertakan tingkat keterampilan pemain (jika tidak disediakan, default untuk 10).
+ Pilih pemain berdasarkan kemiripan tingkat keterampilan mereka dengan pemain lain. Pastikan kedua tim memiliki keterampilan pemain rata-rata dalam jarak 10 poin satu sama lain.
+ Jika pertandingan tidak diisi dengan cepat, longgarkan persyaratan keterampilan pemain untuk menyelesaikan pertandingan dalam waktu yang wajar.
+ Setelah 5 detik, perluas pencarian untuk memungkinkan tim dengan keterampilan pemain rata-rata dalam 50 poin.
+ Setelah 15 detik, perluas pencarian untuk memungkinkan tim dengan keterampilan pemain rata-rata dalam 100 poin.
Catatan tentang penggunaan set aturan ini:
+ Contoh ini memungkinkan tim memiliki ukuran antara empat dan delapan pemain (walaupun ukurannya harus sama). Untuk tim dengan berbagai ukuran yang valid, pembuat kecocokan melakukan upaya terbaik untuk mencocokkan jumlah maksimum pemain yang diizinkan.
+ Aturan `FairTeamSkill` aturan memastikan bahwa tim dicocokkan secara merata berdasarkan keterampilan pemain. Untuk mengevaluasi aturan ini untuk setiap calon pemain baru, FlexMatch sementara menambahkan pemain ke tim dan menghitung rata-rata. Jika aturan gagal, calon pemain tidak ditambahkan ke kecocokan.
+ Karena kedua tim memiliki struktur yang identik, Anda dapat memilih untuk membuat hanya satu definisi tim dan mengatur jumlah tim ke "2". Dalam skenario ini, jika Anda menamai tim "alien", maka tim Anda akan diberi nama "alien\$11" dan "alien\$12".
```
{
"name": "aliens_vs_cowboys",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "skill",
"type": "number",
"default": 10
}],
"teams": [{
"name": "cowboys",
"maxPlayers": 8,
"minPlayers": 4
}, {
"name": "aliens",
"maxPlayers": 8,
"minPlayers": 4
}],
"rules": [{
"name": "FairTeamSkill",
"description": "The average skill of players in each team is within 10 points from the average skill of all players in the match",
"type": "distance",
// get skill values for players in each team and average separately to produce list of two numbers
"measurements": [ "avg(teams[*].players.attributes[skill])" ],
// get skill values for players in each team, flatten into a single list, and average to produce an overall average
"referenceValue": "avg(flatten(teams[*].players.attributes[skill]))",
"maxDistance": 10 // minDistance would achieve the opposite result
}, {
"name": "EqualTeamSizes",
"description": "Only launch a game when the number of players in each team matches, e.g. 4v4, 5v5, 6v6, 7v7, 8v8",
"type": "comparison",
"measurements": [ "count(teams[cowboys].players)" ],
"referenceValue": "count(teams[aliens].players)",
"operation": "=" // other operations: !=, <, <=, >, >=
}],
"expansions": [{
"target": "rules[FairTeamSkill].maxDistance",
"steps": [{
"waitTimeSeconds": 5,
"value": 50
}, {
"waitTimeSeconds": 15,
"value": 100
}]
}]
}
```
# Contoh: Buat tim yang tidak rata (Hunters vs Monster)
Contoh ini menjelaskan mode game di mana sekelompok pemain berburu monster tunggal. Orang-orang memilih peran pemburu atau monster. Pemburu menentukan tingkat keterampilan minimum untuk monster yang ingin mereka hadapi. Ukuran minimum tim pemburu dapat dilonggarkan dari waktu ke waktu untuk menyelesaikan pertandingan. Skenario ini menetapkan petunjuk berikut:
+ Buat satu tim yang terdiri dari lima pemburu.
+ Buat tim terpisah yang terdiri dari tepat satu monster.
+ Sertakan atribut pemain berikut:
+ Tingkat keterampilan pemain (jika tidak disediakan, default ke 10).
+ Tingkat keterampilan monster pilihan pemain (jika tidak disediakan, default ke 10).
+ Apakah pemain ingin menjadi monster (jika tidak disediakan, default ke 0 atau salah).
+ Pilih pemain untuk menjadi monster berdasarkan kriteria berikut:
+ Pemain harus meminta peran monster.
+ Pemain harus memenuhi atau melampaui tingkat keterampilan tertinggi yang disukai oleh pemain yang sudah ditambahkan ke tim pemburu.
+ Pilih pemain untuk tim pemburu berdasarkan kriteria berikut:
+ Pemain yang meminta peran monster tidak dapat bergabung dengan tim pemburu.
+ Jika peran monster sudah terisi, pemain pasti menginginkan level keterampilan monster yang lebih rendah dari keterampilan monster yang diajukan.
+ Jika kecocokan tidak cepat terisi, longgarkan ukuran minimum tim pemburu sebagai berikut:
+ Setelah 30 detik, biarkan game dimulai dengan hanya empat pemain di tim pemburu.
+ Setelah 60 detik, biarkan game dimulai dengan hanya tiga orang dalam tim pemburu.
Catatan tentang penggunaan set aturan ini:
+ Dengan menggunakan dua tim terpisah untuk pemburu dan monster, Anda dapat mengevaluasi keanggotaan berdasarkan serangkaian kriteria yang berbeda.
```
{
"name": "players_vs_monster_5_vs_1",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "skill",
"type": "number",
"default": 10
},{
"name": "desiredSkillOfMonster",
"type": "number",
"default": 10
},{
"name": "wantsToBeMonster",
"type": "number",
"default": 0
}],
"teams": [{
"name": "players",
"maxPlayers": 5,
"minPlayers": 5
}, {
"name": "monster",
"maxPlayers": 1,
"minPlayers": 1
}],
"rules": [{
"name": "MonsterSelection",
"description": "Only users that request playing as monster are assigned to the monster team",
"type": "comparison",
"measurements": ["teams[monster].players.attributes[wantsToBeMonster]"],
"referenceValue": 1,
"operation": "="
},{
"name": "PlayerSelection",
"description": "Do not place people who want to be monsters in the players team",
"type": "comparison",
"measurements": ["teams[players].players.attributes[wantsToBeMonster]"],
"referenceValue": 0,
"operation": "="
},{
"name": "MonsterSkill",
"description": "Monsters must meet the skill requested by all players",
"type": "comparison",
"measurements": ["avg(teams[monster].players.attributes[skill])"],
"referenceValue": "max(teams[players].players.attributes[desiredSkillOfMonster])",
"operation": ">="
}],
"expansions": [{
"target": "teams[players].minPlayers",
"steps": [{
"waitTimeSeconds": 30,
"value": 4
},{
"waitTimeSeconds": 60,
"value": 3
}]
}]
}
```
# Contoh: Tetapkan persyaratan tingkat tim dan batas latensi
Contoh ini menggambarkan cara mengatur tim pemain dan menerapkan seperangkat aturan untuk setiap tim, bukan setiap pemain individu. Contoh ini menggunakan definisi tunggal untuk membuat tiga tim yang sama-sama cocok. Ini juga menetapkan latensi maksimum untuk semua pemain. Latensi maksimum dapat dilonggarkan dari waktu ke waktu untuk menyelesaikan kecocokan. Contoh ini menetapkan instruksi berikut:
+ Buat tiga tim pemain.
+ Sertakan antara tiga hingga lima pemain di setiap tim.
+ Tim final harus berisi jumlah pemain yang sama atau hampir sama (dalam satu tim).
+ Sertakan atribut pemain berikut:
+ Tingkat keterampilan pemain (jika tidak disediakan, default ke 10).
+ Peran karakter pemain (jika tidak disediakan, defaultnya adalah "petani").
+ Pilih pemain berdasarkan kemiripan tingkat keahlian mereka dengan pemain lain dalam kecocokan.
+ Pastikan bahwa setiap tim memiliki keterampilan pemain rata-rata dalam 10 poin satu sama lain.
+ Batasi tim dengan jumlah karakter “medis” berikut:
+ Seluruh pertandingan dapat memiliki maksimum lima petugas medis.
+ Hanya cocokkan pemain yang melaporkan latensi 50 milidetik atau kurang.
+ Jika pertandingan tidak diisi dengan cepat, longgarkan persyaratan latensi pemain sebagai berikut:
+ Setelah 10 detik, izinkan nilai latensi pemain hingga 100 md.
+ Setelah 20 detik, izinkan nilai latensi pemain hingga 150 md.
Catatan tentang penggunaan set aturan ini:
+ Set aturan memastikan bahwa tim dicocokkan secara merata berdasarkan keterampilan pemain. Untuk mengevaluasi `FairTeamSkill` aturan, FlexMatch secara tentatif menambahkan calon pemain ke tim dan menghitung keterampilan rata-rata pemain dalam tim. Kemudian FlexMatch membandingkannya dengan keterampilan rata-rata pemain di kedua tim. Jika aturan gagal, calon pemain tidak ditambahkan ke kecocokan.
+ Persyaratan level tim dan kecocokan (jumlah total petugas medis) dicapai melalui aturan pengumpulan. Jenis aturan ini mengambil daftar atribut karakter untuk semua pemain dan memeriksanya terhadap jumlah maksimum. Gunakan `flatten` untuk membuat daftar semua pemain di semua tim.
+ Saat mengevaluasi berdasarkan latensi, perhatikan hal berikut:
+ Data latensi disediakan dalam permintaan pencocokan sebagai bagian dari objek Pemain. Ini bukan atribut pemain, jadi tidak perlu dicantumkan sebagai satu. Untuk mendapatkan pengukuran latensi yang akurat, gunakan ping Amazon GameLift Servers beacon UDP. Titik akhir ini memungkinkan Anda mengukur latensi jaringan UDP aktual antara perangkat pemain dan masing-masing lokasi hosting potensial, menghasilkan keputusan penempatan yang lebih akurat daripada menggunakan ping ICMP. [Untuk informasi lebih lanjut tentang penggunaan suar ping UDP untuk mengukur latensi, lihat suar ping UDP.](https://docs.aws.amazon.com/gameliftservers/latest/developerguide/reference-udp-ping-beacons.html)
+ Pembuat kecocokan mengevaluasi latensi berdasarkan wilayah. Setiap wilayah dengan latensi lebih tinggi dari maksimum akan diabaikan. Agar dapat diterima untuk kecocokan, pemain harus memiliki setidaknya satu wilayah dengan latensi di bawah maksimum.
+ Jika permintaan pencocokan menghilangkan data latensi satu atau beberapa pemain, permintaan tersebut ditolak untuk semua kecocokan.
```
{
"name": "three_team_game",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "skill",
"type": "number",
"default": 10
},{
"name": "character",
"type": "string_list",
"default": [ "peasant" ]
}],
"teams": [{
"name": "trio",
"minPlayers": 3,
"maxPlayers": 5,
"quantity": 3
}],
"rules": [{
"name": "FairTeamSkill",
"description": "The average skill of players in each team is within 10 points from the average skill of players in the match",
"type": "distance",
// get players for each team, and average separately to produce list of 3
"measurements": [ "avg(teams[*].players.attributes[skill])" ],
// get players for each team, flatten into a single list, and average to produce overall average
"referenceValue": "avg(flatten(teams[*].players.attributes[skill]))",
"maxDistance": 10 // minDistance would achieve the opposite result
}, {
"name": "CloseTeamSizes",
"description": "Only launch a game when the team sizes are within 1 of each other. e.g. 3 v 3 v 4 is okay, but not 3 v 5 v 5",
"type": "distance",
"measurements": [ "max(count(teams[*].players))"],
"referenceValue": "min(count(teams[*].players))",
"maxDistance": 1
}, {
"name": "OverallMedicLimit",
"description": "Don't allow more than 5 medics in the game",
"type": "collection",
// This is similar to above, but the flatten flattens everything into a single
// list of characters in the game.
"measurements": [ "flatten(teams[*].players.attributes[character])"],
"operation": "contains",
"referenceValue": "medic",
"maxCount": 5
}, {
"name": "FastConnection",
"description": "Prefer matches with fast player connections first",
"type": "latency",
"maxLatency": 50
}],
"expansions": [{
"target": "rules[FastConnection].maxLatency",
"steps": [{
"waitTimeSeconds": 10,
"value": 100
}, {
"waitTimeSeconds": 20,
"value": 150
}]
}]
}
```
# Contoh: Gunakan pengurutan eksplisit untuk menemukan kecocokan terbaik
Contoh ini mengatur kecocokan sederhana dengan dua tim yang terdiri dari tiga pemain. Ini menggambarkan cara menggunakan aturan penyortiran eksplisit untuk membantu menemukan kecocokan terbaik secepat mungkin. Aturan ini menyortir semua tiket pencocokan aktif untuk membuat kecocokan terbaik berdasarkan persyaratan utama tertentu. Contoh ini diimplementasikan dengan instruksi berikut:
+ Buat dua tim pemain.
+ Sertakan tepat tiga pemain di setiap tim.
+ Sertakan atribut pemain berikut:
+ Level pengalaman (jika tidak disediakan, default ke 50).
+ Mode game pilihan (dapat mencantumkan beberapa nilai) (jika tidak disediakan, default ke "coop" dan "deathmatch").
+ Peta game pilihan, termasuk nama peta dan bobot preferensi (jika tidak disediakan, default ke `"defaultMap"` dengan bobot 100).
+ Menyiapkan penyortiran:
+ Urutkan pemain berdasarkan preferensi mereka untuk peta game yang sama dengan pemain jangkar. Pemain dapat memiliki beberapa peta game favorit, jadi contoh ini menggunakan nilai preferensi.
+ Urutkan pemain berdasarkan seberapa dekat level pengalaman mereka dengan pemain jangkar. Dengan penyortiran ini, semua pemain di semua tim akan memiliki level pengalaman yang sedekat mungkin.
+ Semua pemain di semua tim harus memilih setidaknya satu mode game yang sama.
+ Semua pemain di semua tim harus memilih setidaknya satu peta game yang sama.
Catatan tentang penggunaan set aturan ini:
+ Penyortiran peta game menggunakan penyortiran absolut yang membandingkan nilai atribut mapPreference. Karena penyortiran tersebut merupakan yang pertama dalam kumpulan aturan, penyortiran ini dilakukan terlebih dahulu.
+ Penyortira pengalaman menggunakan penyortiran jarak untuk membandingkan level keterampilan calon pemain dengan keterampilan pemain jangkar.
+ Penyortiran dilakukan sesuai urutan yang tercantum dalam set aturan. Dalam skenario ini, pemain disortir berdasarkan preferensi peta game, dan kemudian berdasarkan level pengalaman.
```
{
"name": "multi_map_game",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "experience",
"type": "number",
"default": 50
}, {
"name": "gameMode",
"type": "string_list",
"default": [ "deathmatch", "coop" ]
}, {
"name": "mapPreference",
"type": "string_number_map",
"default": { "defaultMap": 100 }
}, {
"name": "acceptableMaps",
"type": "string_list",
"default": [ "defaultMap" ]
}],
"teams": [{
"name": "red",
"maxPlayers": 3,
"minPlayers": 3
}, {
"name": "blue",
"maxPlayers": 3,
"minPlayers": 3
}],
"rules": [{
// We placed this rule first since we want to prioritize players preferring the same map
"name": "MapPreference",
"description": "Favor grouping players that have the highest map preference aligned with the anchor's favorite",
// This rule is just for sorting potential matches. We sort by the absolute value of a field.
"type": "absoluteSort",
// Highest values go first
"sortDirection": "descending",
// Sort is based on the mapPreference attribute.
"sortAttribute": "mapPreference",
// We find the key in the anchor's mapPreference attribute that has the highest value.
// That's the key that we use for all players when sorting.
"mapKey": "maxValue"
}, {
// This rule is second because any tie-breakers should be ordered by similar experience values
"name": "ExperienceAffinity",
"description": "Favor players with similar experience",
// This rule is just for sorting potential matches. We sort by the distance from the anchor.
"type": "distanceSort",
// Lowest distance goes first
"sortDirection": "ascending",
"sortAttribute": "experience"
}, {
"name": "SharedMode",
"description": "The players must have at least one game mode in common",
"type": "collection",
"operation": "intersection",
"measurements": [ "flatten(teams[*].players.attributes[gameMode])"],
"minCount": 1
}, {
"name": "MapOverlap",
"description": "The players must have at least one map in common",
"type": "collection",
"operation": "intersection",
"measurements": [ "flatten(teams[*].players.attributes[acceptableMaps])"],
"minCount": 1
}]
}
```
# Contoh: Temukan persimpangan di beberapa atribut pemain
Contoh ini menggambarkan cara menggunakan aturan kumpulan untuk menemukan persimpangan dalam dua atribut pemain atau lebih. Saat bekerja dengan koleksi, Anda dapat menggunakan operasi `intersection` untuk atribut tunggal, dan operasi `reference_intersection_count` untuk beberapa atribut.
Untuk menggambarkan pendekatan ini, contoh ini mengevaluasi pemain dalam kecocokan berdasarkan preferensi karakter mereka. Contoh permainan adalah gaya "free-for-all" di mana semua pemain dalam pertandingan adalah lawan. Setiap pemain diminta untuk (1) memilih karakter untuk diri mereka sendiri, dan (2) memilih karakter yang ingin mereka lawan. Kita membutuhkan aturan yang memastikan bahwa setiap pemain dalam kecocokan menggunakan karakter yang ada di daftar lawan pilihan semua pemain lain.
Set aturan contoh menjelaskan kecocokan dengan karakteristik berikut:
+ Struktur tim: Satu tim terdiri dari lima pemain
+ Atribut pemain:
+ *myCharacter*: Karakter yang dipilih pemain.
+ *preferredOpponents*: Daftar karakter yang ingin dimainkan oleh pemain.
+ Aturan kecocokan: Kecocokan potensial dapat diterima jika setiap karakter yang digunakan ada di daftar lawan pilihan setiap pemain.
Untuk menerapkan aturan kecocokan, contoh ini menggunakan aturan kumpulan dengan nilai properti berikut:
+ Operasi – Menggunakan operasi `reference_intersection_count` operasi untuk mengevaluasi bagaimana setiap daftar string dalam nilai pengukuran bersimpangan dengan daftar string dalam nilai referensi.
+ Pengukuran – Menggunakan ekspresi properti `flatten` untuk membuat daftar daftar string, dengan setiap daftar string berisi nilai atribut *myCharacter* satu pemain.
+ Nilai referensi – Menggunakan ekspresi properti `set_intersection` untuk membuat daftar string dari semua nilai atribut *preferredOpponents* yang umum untuk setiap pemain dalam kecocokan.
+ Pembatasan – `minCount` diatur ke 1 untuk memastikan bahwa karakter yang dipilih setiap pemain (daftar string dalam pengukuran) cocok dengan setidaknya salah satu lawan pilihan yang umum untuk semua pemain. (string dalam nilai referensi).
+ Perluasan — Jika pertandingan tidak diisi dalam waktu 15 detik, longgarkan persyaratan persimpangan minimum.
Alur proses untuk aturan ini adalah sebagai berikut:
1. Seorang pemain ditambahkan ke kecocokan prospektif. Nilai referensi (daftar string) dihitung ulang untuk menyertakan perpotongan dengan daftar lawan pilihan pemain baru. Nilai pengukuran (daftar daftar string) dihitung ulang untuk menambahkan karakter yang dipilih pemain baru sebagai daftar string baru.
1. Amazon GameLift Serversmemverifikasi bahwa setiap daftar string dalam nilai pengukuran (karakter yang dipilih pemain) berpotongan dengan setidaknya satu string dalam nilai referensi (lawan pilihan pemain). Karena dalam contoh ini setiap daftar string dalam pengukuran hanya berisi satu nilai, simpangannya adalah 0 atau 1.
1. Jika ada daftar string dalam pengukuran yang tidak besimpangan dengan daftar string nilai referensi, aturan gagal dan pemain baru dikeluarkan dari kecocokan prospektif.
1. Jika kecocokan tidak terisi dalam waktu 15 detik, batalkan persyaratan kecocokan lawan untuk mengisi slot pemain yang tersisa dalam kecocokan.
```
{
"name": "preferred_characters",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "myCharacter",
"type": "string_list"
}, {
"name": "preferredOpponents",
"type": "string_list"
}],
"teams": [{
"name": "red",
"minPlayers": 5,
"maxPlayers": 5
}],
"rules": [{
"description": "Make sure that all players in the match are using a character that is on all other players' preferred opponents list.",
"name": "OpponentMatch",
"type": "collection",
"operation": "reference_intersection_count",
"measurements": ["flatten(teams[*].players.attributes[myCharacter])"],
"referenceValue": "set_intersection(flatten(teams[*].players.attributes[preferredOpponents]))",
"minCount":1
}],
"expansions": [{
"target": "rules[OpponentMatch].minCount",
"steps": [{
"waitTimeSeconds": 15,
"value": 0
}]
}]
}
```
# Contoh: Bandingkan atribut di semua pemain
Contoh ini menggambarkan cara membandingkan atribut pemain di seluruh grup pemain.
Set aturan contoh menjelaskan kecocokan dengan karakteristik berikut:
+ Struktur tim: Dua tim pemain tunggal
+ Atribut pemain:
+ *gameMode*: Jenis game yang dipilih oleh pemain (jika tidak disediakan, default ke "berbasis giliran").
+ *gameMap*: Dunia game yang dipilih oleh pemain (jika tidak disediakan, default ke 1).
+ *character*: Karakter yang dipilih oleh pemain (tidak ada nilai default berarti pemain harus menentukan karakter).
+ Aturan kecocokan: Pemain yang cocok harus memenuhi persyaratan berikut:
+ Pemain harus memilih mode game yang sama.
+ Pemain harus memilih peta game yang sama.
+ Pemain banyak memilih karakter yang berbeda.
Catatan tentang penggunaan set aturan ini:
+ Untuk menerapkan aturan kecocokan, contoh ini menggunakan aturan perbandingan untuk memeriksa nilai atribut semua pemain. Untuk mode game dan peta, aturan memverifikasi bahwa nilainya sama. Untuk karakter, aturan memverifikasi bahwa nilai-nilai yang berbeda.
+ Contoh ini menggunakan definisi satu pemain dengan properti kuantitas untuk membuat kedua tim pemain. Tim diberi nama berikut: "player\$11" dan "player\$12".
```
{
"name": "",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "gameMode",
"type": "string",
"default": "turn-based"
}, {
"name": "gameMap",
"type": "number",
"default": 1
}, {
"name": "character",
"type": "number"
}],
"teams": [{
"name": "player",
"minPlayers": 1,
"maxPlayers": 1,
"quantity": 2
}],
"rules": [{
"name": "SameGameMode",
"description": "Only match players when they choose the same game type",
"type": "comparison",
"operation": "=",
"measurements": ["flatten(teams[*].players.attributes[gameMode])"]
}, {
"name": "SameGameMap",
"description": "Only match players when they're in the same map",
"type": "comparison",
"operation": "=",
"measurements": ["flatten(teams[*].players.attributes[gameMap])"]
}, {
"name": "DifferentCharacter",
"description": "Only match players when they're using different characters",
"type": "comparison",
"operation": "!=",
"measurements": ["flatten(teams[*].players.attributes[character])"]
}]
}
```
# Contoh: Buat kecocokan besar
Contoh ini menggambarkan cara menyiapkan set aturan untuk pertandingan yang dapat melebihi 40 pemain. Ketika satu set aturan menjelaskan tim dengan jumlah maxPlayer total lebih besar dari 40, maka aturan itu akan diproses sebagai kecocokan besar. Pelajari selengkapnya di [Rancang set aturan FlexMatch kecocokan besar](match-design-rulesets-large.md).
Set aturan contoh membuat kecocokan menggunakan petunjuk berikut:
+ Buat satu tim dengan maksimal 200 pemain, dengan persyaratan minimal 175 pemain.
+ Kriteria penyeimbangan: Pilih pemain berdasarkan level keterampilan yang sama. Semua pemain harus melaporkan level keterampilan mereka untuk dicocokkan.
+ Preferensi batching: Mengelompokkan pemain dengan kriteria penyeimbangan yang sama saat membuat kecocokan.
+ Aturan latensi: Setel latensi pemain maksimum yang dapat diterima 150 milidetik.
+ Jika kecocokan tidak diisi dengan cepat, longgarkan persyaratan untuk menyelesaikan kecocokan dalam waktu yang wajar.
+ Setelah 10 detik, terima tim dengan 150 pemain.
+ Setelah 12 detik, naikkan latensi maksimum yang dapat diterima menjadi 200 milidetik.
+ Setelah 15 detik, terima tim dengan 100 pemain.
Catatan tentang penggunaan set aturan ini:
+ Karena algoritme menggunakan preferensi batching "populasi terbesar", pemain pertama-tama diurutkan berdasarkan kriteria penyeimbangan. Akibatnya, kecocokan cenderung lebih penuh dan berisi pemain yang lebih mirip dalam keterampilan. Semua pemain memenuhi persyaratan latensi yang dapat diterima, tetapi mereka mungkin tidak mendapatkan latensi terbaik untuk lokasi mereka.
+ Strategi algoritme yang digunakan dalam set aturan ini, "populasi terbesar", adalah pengaturan default. Untuk menggunakan default, Anda dapat memilih untuk menghilangkan pengaturan.
+ Jika Anda telah mengaktifkan backfill kecocokan, jangan terlalu cepat melonggarkan persyaratan jumlah pemain, atau Anda mungkin mendapatkan terlalu banyak sesi game yang terisi sebagian. Pelajari selengkapnya di [Melonggarkan persyaratan kecocokan besar](match-design-rulesets-large-relax.md).
```
{
"name": "free-for-all",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "skill",
"type": "number"
}],
"algorithm": {
"balancedAttribute": "skill",
"strategy": "balanced",
"batchingPreference": "largestPopulation"
},
"teams": [{
"name": "Marauders",
"maxPlayers": 200,
"minPlayers": 175
}],
"rules": [{
"name": "low-latency",
"description": "Sets maximum acceptable latency",
"type": "latency",
"maxLatency": 150
}],
"expansions": [{
"target": "rules[low-latency].maxLatency",
"steps": [{
"waitTimeSeconds": 12,
"value": 200
}],
}, {
"target": "teams[Marauders].minPlayers",
"steps": [{
"waitTimeSeconds": 10,
"value": 150
}, {
"waitTimeSeconds": 15,
"value": 100
}]
}]
}
```
# Contoh: Buat pertandingan besar multi-tim
Contoh ini menggambarkan cara menyiapkan kumpulan aturan untuk kecocokan dengan beberapa tim yang dapat melebihi 40 pemain. Contoh ini menggambarkan cara membuat beberapa tim identik dengan satu definisi dan bagaimana tim berukuran asimetris diisi selama pembuatan kecocokan.
Set aturan contoh membuat kecocokan menggunakan petunjuk berikut:
+ Buat sepuluh tim "pemburu" identik dengan maksimal 15 pemain, dan satu tim "monster" dengan tepat 5 pemain.
+ Kriteria penyeimbangan: Pilih pemain berdasarkan jumlah membunuh monster. Jika pemain tidak melaporkan jumlah membunuh mereka, gunakan nilai default 5.
+ Preferensi batching: Kelompok pemain berdasarkan wilayah di mana mereka melaporkan latensi pemain tercepat.
+ Aturan latensi: Menetapkan latensi pemain maksimum yang dapat diterima sebesar 200 milidetik.
+ Jika kecocokan tidak diisi dengan cepat, longgarkan persyaratan untuk menyelesaikan kecocokan dalam waktu yang wajar.
+ Setelah 15 detik, terima tim dengan 10 pemain.
+ Setelah 20 detik, terima tim dengan 8 pemain.
Catatan tentang penggunaan set aturan ini:
+ Set aturan ini mendefinisikan tim yang berpotensi dapat menampung hingga 155 pemain, yang menjadikannya kecocokan besar. (10 x 15 pemburu \$1 5 monster = 155)
+ Karena algoritme menggunakan preferensi batching "wilayah tercepat", pemain cenderung ditempatkan di wilayah yang melaporkan latensi lebih cepat dan bukan di wilayah yang melaporkan latensi tinggi (tetapi dapat diterima). Pada saat yang sama, kecocokan cenderung memiliki lebih sedikit pemain, dan kriteria penyeimbangan (jumlah keterampilan monster) mungkin lebih bervariasi.
+ Saat perluasan didefinisikan untuk definisi multi-tim (kuantitas > 1), perluasan berlaku untuk semua tim yang dibuat dengan definisi tersebut. Jadi dengan melonggarkan pengaturan pemain minimum tim pemburu, kesepuluh tim pemburu dapat terpengaruh secara merata.
+ Karena aturan ini dioptimalkan untuk meminimalkan latensi pemain, aturan latensi bertindak sebagai catch-all untuk mengecualikan pemain yang tidak memiliki opsi koneksi yang dapat diterima. Kita tidak perlu melonggarkan persyaratan ini.
+ Berikut cara FlexMatch mengisi kecocokan untuk aturan ini yang ditetapkan sebelum ekspansi apa pun berlaku:
+ Belum ada tim yang mencapai jumlah minPlayers. Tim Pemburu memiliki 15 slot terbuka, sedangkan tim Monster memiliki 5 slot terbuka.
+ 100 pemain pertama ditugaskan (10 masing-masing) ke sepuluh tim pemburu.
+ 22 pemain berikutnya ditugaskan secara berurutan (masing-masing 2) ke tim pemburu dan tim monster.
+ Tim Pemburu telah mencapai jumlah minPlayers masing-masing 12 pemain. Tim Monster memiliki 2 pemain dan belum mencapai jumlah minPlayers.
+ Tiga pemain berikutnya ditugaskan ke tim monster.
+ Semua tim telah mencapai jumlah minPlayers. Tim pemburu masing-masing memiliki tiga slot terbuka. Tim Monster sudah penuh.
+ 30 pemain terakhir ditugaskan secara berurutan ke tim pemburu, sehingga memastikan bahwa semua tim pemburu memiliki ukuran yang hampir sama (plus atau minus satu pemain).
+ Jika Anda telah mengaktifkan pengisian ulang untuk pertandingan yang dibuat dengan kumpulan aturan ini, jangan terlalu cepat melonggarkan persyaratan jumlah pemain, atau Anda mungkin berakhir dengan terlalu banyak sesi game yang terisi sebagian. Pelajari selengkapnya di [Melonggarkan persyaratan kecocokan besar](match-design-rulesets-large-relax.md).
```
{
"name": "monster-hunters",
"ruleLanguageVersion": "1.0",
"playerAttributes": [{
"name": "monster-kills",
"type": "number",
"default": 5
}],
"algorithm": {
"balancedAttribute": "monster-kills",
"strategy": "balanced",
"batchingPreference": "fastestRegion"
},
"teams": [{
"name": "Monsters",
"maxPlayers": 5,
"minPlayers": 5
}, {
"name": "Hunters",
"maxPlayers": 15,
"minPlayers": 12,
"quantity": 10
}],
"rules": [{
"name": "latency-catchall",
"description": "Sets maximum acceptable latency",
"type": "latency",
"maxLatency": 150
}],
"expansions": [{
"target": "teams[Hunters].minPlayers",
"steps": [{
"waitTimeSeconds": 15,
"value": 10
}, {
"waitTimeSeconds": 20,
"value": 8
}]
}]
}
```
# Contoh: Buat pertandingan besar dengan pemain dengan atribut serupa
Contoh ini menggambarkan cara menyiapkan set aturan untuk kecocokan dengan dua tim menggunakan `batchDistance`. Contohnya:
+ Aturan `SimilarLeague` memastikan semua pemain dalam kecocokan memiliki `league` dalam 2 pemain lainnya.
+ Aturan `SimilarSkill` memastikan semua pemain dalam kecocokan memiliki `skill` dalam 10 pemain lainnya. Jika seorang pemain telah menunggu 10 detik, jaraknya diperluas menjadi 20. Jika seorang pemain telah menunggu 20 detik, jaraknya diperluas menjadi 40.
+ Aturan `SameMap` memastikan semua pemain dalam kecocokan telah meminta hal yang sama `map`.
+ Aturan`SameMode` memastikan semua pemain dalam kecocokan telah meminta hal yang sama `mode`.
```
{
"ruleLanguageVersion": "1.0",
"teams": [{
"name": "red",
"minPlayers": 100,
"maxPlayers": 100
}, {
"name": "blue",
"minPlayers": 100,
"maxPlayers": 100
}],
"algorithm": {
"strategy":"balanced",
"balancedAttribute": "skill",
"batchingPreference":"fastestRegion"
},
"playerAttributes": [{
"name": "league",
"type": "number"
},{
"name": "skill",
"type": "number"
},{
"name": "map",
"type": "string"
},{
"name": "mode",
"type": "string"
}],
"rules": [{
"name": "SimilarLeague",
"type": "batchDistance",
"batchAttribute": "league",
"maxDistance": 2
}, {
"name": "SimilarSkill",
"type": "batchDistance",
"batchAttribute": "skill",
"maxDistance": 10
}, {
"name": "SameMap",
"type": "batchDistance",
"batchAttribute": "map"
}, {
"name": "SameMode",
"type": "batchDistance",
"batchAttribute": "mode"
}],
"expansions": [{
"target": "rules[SimilarSkill].maxDistance",
"steps": [{
"waitTimeSeconds": 10,
"value": 20
}, {
"waitTimeSeconds": 20,
"value": 40
}]
}]
}
```
# Contoh: Gunakan aturan gabungan untuk membuat pertandingan dengan pemain dengan atribut serupa atau pilihan serupa
Contoh ini menggambarkan cara menyiapkan set aturan untuk kecocokan dengan dua tim menggunakan `compound`. Contohnya:
+ Aturan `SimilarLeagueDistance` memastikan semua pemain dalam kecocokan memiliki `league` dalam 2 pemain lainnya.
+ Aturan `SimilarSkillDistance` memastikan semua pemain dalam kecocokan memiliki `skill` dalam 10 pemain lainnya. Jika seorang pemain telah menunggu 10 detik, jaraknya diperluas menjadi 20. Jika seorang pemain telah menunggu 20 detik, jaraknya diperluas menjadi 40.
+ Aturan `SameMapComparison` memastikan semua pemain dalam kecocokan telah meminta hal yang sama `map`.
+ Aturan`SameModeComparison` memastikan semua pemain dalam kecocokan telah meminta hal yang sama `mode`.
+ `CompoundRuleMatchmaker`Aturan memastikan kecocokan jika setidaknya salah satu dari kondisi berikut benar:
+ Pemain dalam pertandingan telah meminta hal yang sama `map` dan sama`mode`.
+ Pemain dalam pertandingan memiliki `league` atribut `skill` dan atribut yang sebanding.
```
{
"ruleLanguageVersion": "1.0",
"teams": [{
"name": "red",
"minPlayers": 10,
"maxPlayers": 20
}, {
"name": "blue",
"minPlayers": 10,
"maxPlayers": 20
}],
"algorithm": {
"strategy":"balanced",
"balancedAttribute": "skill",
"batchingPreference":"fastestRegion"
},
"playerAttributes": [{
"name": "league",
"type": "number"
},{
"name": "skill",
"type": "number"
},{
"name": "map",
"type": "string"
},{
"name": "mode",
"type": "string"
}],
"rules": [{
"name": "SimilarLeagueDistance",
"type": "distance",
"measurements": ["max(flatten(teams[*].players.attributes[league]))"],
"referenceValue": "min(flatten(teams[*].players.attributes[league]))",
"maxDistance": 2
}, {
"name": "SimilarSkillDistance",
"type": "distance",
"measurements": ["max(flatten(teams[*].players.attributes[skill]))"],
"referenceValue": "min(flatten(teams[*].players.attributes[skill]))",
"maxDistance": 10
}, {
"name": "SameMapComparison",
"type": "comparison",
"operation": "=",
"measurements": ["flatten(teams[*].players.attributes[map])"]
}, {
"name": "SameModeComparison",
"type": "comparison",
"operation": "=",
"measurements": ["flatten(teams[*].players.attributes[mode])"]
}, {
"name": "CompoundRuleMatchmaker",
"type": "compound",
"statement": "or(and(SameMapComparison, SameModeComparison), and(SimilarSkillDistance, SimilarLeagueDistance))"
}],
"expansions": [{
"target": "rules[SimilarSkillDistance].maxDistance",
"steps": [{
"waitTimeSeconds": 10,
"value": 20
}, {
"waitTimeSeconds": 20,
"value": 40
}]
}]
}
```
# Contoh: Buat aturan yang menggunakan daftar blokir pemain
Contoh ini menggambarkan aturan yang memungkinkan pemain menghindari kecocokan dengan pemain tertentu lainnya. Pemain dapat membuat daftar blok, yang dievaluasi oleh mak comblang selama pemilihan pemain untuk pertandingan. Untuk panduan lebih lanjut tentang menambahkan daftar blokir atau menghindari fitur daftar, lihat [AWS untuk Blog Game](https://aws.amazon.com/blogs/gametech/category/game-development/amazon-gamelift/).
Contoh ini menetapkan instruksi berikut:
+ Buat dua tim yang terdiri dari lima pemain.
+ Masukkan daftar blok pemain, yang merupakan daftar pemain IDs (hingga 100).
+ Bandingkan semua pemain dengan daftar blok masing-masing pemain dan tolak pertandingan yang diusulkan jika ada pemain IDs yang diblokir ditemukan.
Catatan tentang penggunaan set aturan ini:
+ Saat mengevaluasi pemain baru untuk ditambahkan ke pertandingan yang diusulkan (atau untuk mengisi kembali tempat dalam pertandingan yang ada), pemain mungkin ditolak karena salah satu alasan berikut:
+ Jika pemain baru ada di daftar blok untuk setiap pemain yang sudah dipilih untuk pertandingan.
+ Jika ada pemain yang sudah dipilih untuk pertandingan ada di daftar blok pemain baru.
+ Seperti yang ditunjukkan, set aturan ini mencegah pencocokan pemain dengan pemain mana pun di daftar bloknya. Anda dapat mengubah persyaratan ini ke preferensi (juga disebut daftar “hindari”) dengan menambahkan perluasan aturan dan meningkatkan `maxCount` nilainya.
```
{
"name": "Player Block List",
"ruleLanguageVersion": "1.0",
"teams": [{
"maxPlayers": 5,
"minPlayers": 5,
"name": "red"
}, {
"maxPlayers": 5,
"minPlayers": 5,
"name": "blue"
}],
"playerAttributes": [{
"name": "BlockList",
"type": "string_list",
"default": []
}],
"rules": [{
"name": "PlayerIdNotInBlockList",
"type": "collection",
"operation": "reference_intersection_count",
"measurements": "flatten(teams[*].players.attributes[BlockList])",
"referenceValue": "flatten(teams[*].players[playerId])",
"maxCount": 0
}]
}
```