Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# FlexMatchexemples d'ensembles de règles
Les ensembles de règles FlexMatch peuvent couvrir différents scénarios de mise en relation. Les exemples suivants sont conformes à la structure de la configuration et du langage d'expression de propriété FlexMatch. Copiez entièrement ces ensembles de règles ou choisissez des éléments en fonction de vos besoins.
Pour plus d'informations sur l'utilisation de règles et d'ensembles de règles FlexMatch, consultez les rubriques suivantes :
**Note**
Lorsque vous évaluez une demande de mise en relation incluant plusieurs joueurs, tous les joueurs de la demande doivent satisfaire aux exigences de mise en relation.
**Topics**
+ [Exemple : créer deux équipes avec des joueurs identiques](match-examples-1.md)
+ [Exemple : créer des équipes inégales (chasseurs contre monstres)](match-examples-2.md)
+ [Exemple : définir les exigences et les limites de latence au niveau de l'équipe](match-examples-3.md)
+ [Exemple : utilisez un tri explicite pour trouver les meilleures correspondances](match-examples-4.md)
+ [Exemple : trouver des intersections entre les attributs de plusieurs joueurs](match-examples-5.md)
+ [Exemple : comparez les attributs de tous les joueurs](match-examples-6.md)
+ [Exemple : créer une correspondance de grande taille](match-examples-7.md)
+ [Exemple : créer un grand match entre plusieurs équipes](match-examples-8.md)
+ [Exemple : créer un match de grande envergure avec des joueurs aux attributs similaires](match-examples-9.md)
+ [Exemple : utilisez une règle composée pour créer un match avec des joueurs ayant des attributs similaires ou des sélections similaires](match-examples-10.md)
+ [Exemple : créer une règle qui utilise la liste de blocage d'un joueur](match-examples-11.md)
# Exemple : créer deux équipes avec des joueurs identiques
Cet exemple illustre la configuration de deux équipes ayant un nombre identique de joueurs mis en relation avec les instructions suivantes.
+ Créez deux équipes de joueurs.
+ Inclure entre quatre et huit joueurs dans chaque équipe.
+ Au final, les équipes doivent avoir le même nombre de joueurs.
+ Inclure un niveau de compétence pour les joueurs (si aucune valeur n'est fournie, la valeur par défaut est 10).
+ Choisissez les joueurs en fonction de leur niveau de compétences, qui doit être similaire à celui d'autres joueurs. Assurez-vous que le niveau moyen de compétence des deux équipes diffère de 10 points maximum.
+ Si la mise en relation n'est pas effectuée rapidement, assouplissez les exigences du niveau de compétences pour que la mise en relation soit réalisée dans un délai raisonnable.
+ Après 5 secondes, étendez la recherche pour autoriser un écart moyen de compétences des joueurs de 50 points maximum.
+ Après 15 secondes, étendez la recherche pour autoriser un écart moyen de compétences des joueurs de 100 points maximum.
Remarques sur l'utilisation de cet ensemble de règles :
+ Cet exemple permet de disposer d'équipes composées de 4 à 8 joueurs (même si elles doivent être de même taille). Pour les équipes offrant plusieurs tailles valides, le matchmaker fait de son mieux pour mettre en relation le nombre maximal de joueurs autorisés.
+ La règle `FairTeamSkill` garantit que les équipes sont mises en relation de façon uniforme en fonction de la compétence des joueurs. Pour évaluer cette règle pour chaque nouveau joueur potentiel, FlexMatch ajoute provisoirement le joueur à une équipe et calcule les moyennes. Si la règle échoue, le joueur potentiel n'est pas ajouté à la mise en relation.
+ Étant donné que les deux équipes ont des structures identiques, vous pouvez choisir de créer une seule définition d'équipe et de définir la quantité de l'équipe sur « 2 ». Dans ce scénario, si vous avez nommé l'équipe « extra-terrestres », vos équipes recevront les noms « extra-terrestres\$11" et « extra-terrestres\$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
}]
}]
}
```
# Exemple : créer des équipes inégales (chasseurs contre monstres)
Cet exemple décrit un mode de jeu dans lequel un groupe de joueurs chasse un seul monstre. Les joueurs choisissent un rôle de chasseur ou un rôle de monstre. Les chasseurs spécifient le niveau minimal de compétence du monstre qu'ils souhaitent affronter. La taille minimale de l'équipe de chasseurs peut être assouplie au fil du temps pour réaliser la mise en relation. Ce scénario établit les instructions suivantes :
+ Créez une équipe comportant exactement cinq chasseurs.
+ Créez une équipe distincte comportant un seul monstre.
+ Définissez les attributs suivants pour les joueurs :
+ Un niveau de compétence pour les joueurs (si aucune valeur n'est fournie, la valeur par défaut est 10).
+ Un niveau de compétence souhaité pour le monstre (si aucune valeur n'est fournie, la valeur par défaut est 10).
+ Si le joueur souhaite être le monstre (si cette valeur n'est pas renseignée, la valeur par défaut est 0 ou false).
+ Choisissez le joueur qui sera le monstre en fonction des critères suivants :
+ Le joueur doit demander le rôle de monstre.
+ Le niveau de compétence du joueur doit correspondre ou être supérieur au niveau de compétence le plus élevé souhaité par les joueurs qui ont déjà intégré l'équipe de chasseurs.
+ Choisissez les joueurs de l'équipe de chasseurs en fonction des critères suivants :
+ Les joueurs qui demandent le rôle de monstre ne peuvent pas être intégrés à l'équipe de chasseurs.
+ Si le rôle de monstre est déjà attribué, le joueur doit vouloir un niveau de compétence pour le monstre qui soit inférieur à la compétence du monstre proposé.
+ Si la mise en relation n'est pas effectuée rapidement, assouplissez les critères de taille minimale de l'équipe des chasseurs de la manière suivante :
+ Après 30 secondes, autorisez le démarrage du jeu avec seulement quatre joueurs dans l'équipe des chasseurs.
+ Après 60 secondes, autorisez le démarrage du jeu avec seulement trois joueurs dans l'équipe des chasseurs.
Remarques sur l'utilisation de cet ensemble de règles :
+ En utilisant deux équipes distinctes pour les chasseurs et le monstre, vous pouvez évaluer les membres en fonction de différents ensembles de critères.
```
{
"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
}]
}]
}
```
# Exemple : définir les exigences et les limites de latence au niveau de l'équipe
Cet exemple illustre la configuration d’équipes de joueurs et l'application d'un ensemble de règles à chacune d’elles plutôt qu'à chaque joueur. Il utilise une seule définition pour créer trois équipes de taille égale. Il établit également une latence maximale pour tous les joueurs. Les valeurs maximales de latence peuvent être assouplies au fil du temps pour réaliser la mise en relation. Cet exemple présente les instructions suivantes :
+ Créez trois équipes de joueurs.
+ Inclure entre trois et cinq joueurs dans chaque équipe.
+ Au final, les équipes doivent avoir le même nombre de joueurs ou un joueur d'écart.
+ Définissez les attributs suivants pour les joueurs :
+ Un niveau de compétence pour les joueurs (si aucune valeur n'est fournie, la valeur par défaut est 10).
+ Un rôle pour chaque joueur (si aucune valeur n'est fournie, la valeur par défaut est « paysan »).
+ Choisissez les joueurs en fonction de leur niveau de compétences, qui doit être similaire à celui d'autres joueurs de la relation.
+ Assurez-vous que le niveau moyen de compétence de chaque équipe diffère de 10 points maximum.
+ Limitez le nombre de personnages « médecin » dans chaque équipe :
+ Le nombre maximum de médecins d'une relation complète est 5.
+ Seuls les joueurs dont la latence est de 50 millisecondes ou moins doivent être pris en compte.
+ Si la mise en relation n'est pas effectuée rapidement, assouplissez le critère de latence pour les joueurs de la manière suivante :
+ Après 10 secondes, autoriser les valeurs de latence pour les joueurs jusqu'à 100 ms.
+ Après 20 secondes, autoriser les valeurs de latence pour les joueurs jusqu'à 150 ms.
Remarques sur l'utilisation de cet ensemble de règles :
+ L'ensemble de règles garantit que les équipes sont mises en relation de façon uniforme en fonction de la compétence des joueurs. Pour évaluer la règle `FairTeamSkill`, FlexMatch ajoute provisoirement le joueur potentiel à une équipe et calcule le niveau de compétence moyen des joueurs de l'équipe. Ensuite, il le compare au niveau de compétence moyen des joueurs dans les deux équipes. Si la règle échoue, le joueur potentiel n'est pas ajouté à la mise en relation.
+ Pour respecter les exigences au niveau de l'équipe et de la mise en relation (nombre total de médecins) un ensemble de règles est utilisé. Ce type de règle vérifie la liste des attributs de personnages pour tous les joueurs par rapport au nombre maximum. Utilisez `flatten` pour créer une liste pour tous les joueurs dans toutes les équipes.
+ Lors de l'évaluation basée sur la latence, notez les éléments suivants :
+ Les données de latence sont fournies dans la demande de mise en relation dans le carte de l'objet Player (joueur). Il ne s'agit pas d'un attribut de joueur, il n'a donc pas besoin d'être répertorié en tant que tel. Pour obtenir des mesures de latence précises, utilisez Amazon GameLift Servers les balises ping UDP. Ces points de terminaison vous permettent de mesurer la latence réelle du réseau UDP entre les appareils des joueurs et chacun des sites d'hébergement potentiels, ce qui permet de prendre des décisions de placement plus précises que l'utilisation de pings ICMP. Pour plus d'informations sur l'utilisation des balises ping UDP pour mesurer la latence, reportez-vous à la section Balises ping [UDP.](https://docs.aws.amazon.com/gameliftservers/latest/developerguide/reference-udp-ping-beacons.html)
+ Le matchmaker évalue la latence par région. Toute région dont la latence est plus élevée que la latence maximale est ignorée. Pour être accepté pour une mise en relation, un joueur doit avoir au moins une région avec une latence inférieure au maximum.
+ Si une demande de mise en relation omet les données de latence pour un ou plusieurs joueurs, la demande est rejetée pour toutes les relations.
```
{
"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
}]
}]
}
```
# Exemple : utilisez un tri explicite pour trouver les meilleures correspondances
Cet exemple montre la configuration d'une mise en relation simple avec deux équipes de trois joueurs. Il montre comment utiliser les règles de tri explicite pour aider à trouver les meilleures mises en relation possibles aussi rapidement que possible. Ces règles trient tous les tickets de matchmaking actifs pour créer les meilleurs matchs en fonction de certaines exigences clés. Cet exemple est implémenté avec les instructions suivantes :
+ Créez deux équipes de joueurs.
+ Inclure exactement trois joueurs dans chaque équipe.
+ Définissez les attributs suivants pour les joueurs :
+ Niveau d'expérience (si aucune valeur n'est fournie, la valeur par défaut est 50).
+ Modes de jeu préférés (peut contenir plusieurs valeurs) (si aucune valeur n'est fournie, les valeurs par défaut sont « coop » et « deathmatch »).
+ Relations de jeu préférées, indiquant le nom de la mise en relation et la pondération des préférences (si aucune valeur n'est fournie, la valeur par défaut est `"defaultMap"` avec une pondération de 100).
+ Configurez le tri préalable :
+ Triez les joueurs en fonction de leurs préférences pour la même relation de jeu en tant que joueur d'ancrage. Les joueurs peuvent avoir plusieurs relations de jeu préférées, c'est pourquoi cet exemple utilise une valeur de préférence.
+ Triez les joueurs en fonction du degré de correspondance de leur niveau d'expérience avec celui du joueur d'ancrage. Ce tri permet de rapprocher le mieux possible les niveaux d'expérience de tous les joueurs de toutes les équipes.
+ Tous les joueurs dans toutes les équipes doivent avoir sélectionné au moins un mode de jeu en commun.
+ Tous les joueurs dans toutes les équipes doivent avoir sélectionné au moins une relation de jeu en commun.
Remarques sur l'utilisation de cet ensemble de règles :
+ Le tri de la relation de jeu utilise un tri absolu qui compare la valeur d'attribut mapPreference. Comme il s’agit de la première valeur dans l'ensemble de règles, ce tri est effectuée en premier.
+ Le tri utilise un paramètre de distance pour comparer le niveau de compétence d'un joueur potentiel par rapport à celui du joueur d'ancrage.
+ Les tris sont exécutés dans l'ordre dans lequel ils sont répertoriés dans un ensemble de règles. Dans ce scénario, les joueurs sont triés par préférence de relation de jeu, puis par niveau d'expérience.
```
{
"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
}]
}
```
# Exemple : trouver des intersections entre les attributs de plusieurs joueurs
Cet exemple illustre comment utiliser une règle de collection pour rechercher des intersections dans deux attributs de joueur ou plus. Lorsque vous utilisez des collections, vous pouvez utiliser l'opération `intersection` pour un attribut unique, et l'opération `reference_intersection_count` pour plusieurs attributs.
Pour illustrer cette approche, cet exemple évalue les joueurs d'une mise en relation en fonction de leurs préférences de personnages. L'exemple de jeu est un style free-for-all « » dans lequel tous les joueurs d'un match sont des adversaires. Chaque joueur est invité à (1) choisir un personnage pour lui-même, et (2) à choisir les personnages contre lesquels il veut jouer. Nous avons besoin d'une règle qui garantit que chaque joueur d'une mise en relation utilise un personnage figurant sur la liste des adversaires préférés de tous les autres joueurs.
L'exemple d'ensemble de règles décrit une mise en relation avec les caractéristiques suivantes :
+ Structure de l'équipe : une équipe de cinq joueurs
+ Attributs du joueur :
+ *myCharacter* : personnage choisi par le joueur.
+ *preferredOpponents* : liste des personnages contre lesquels le joueur veut jouer.
+ Règles de mise en relation : une mise en relation potentielle est acceptable si chaque personnage en cours d'utilisation figure sur la liste des adversaires préférés de chaque joueur.
Pour implémenter la règle de mise en relation, cet exemple utilise une règle de collection avec les valeurs de propriété suivantes :
+ Opération — Utilise une `reference_intersection_count` opération pour évaluer la manière dont chaque liste de chaînes de la valeur de mesure intersecte la liste de chaînes de la valeur de référence.
+ Mesure — Utilise l'expression de `flatten` propriété pour créer une liste de listes de chaînes, chaque liste de chaînes contenant la valeur d'attribut *MyCharacter* d'un joueur.
+ *Valeur de référence — Utilise l'expression de `set_intersection` propriété pour créer une liste de chaînes contenant toutes les valeurs d'attribut PreferredAdversaires communes à tous les joueurs du match.*
+ Restrictions : `minCount` est définie sur 1 pour garantir que le personnage choisi par chaque joueur (une liste de chaînes dans la mesure) correspond à au moins un des adversaires préférés communs à tous les joueurs. (une chaîne dans la valeur de référence).
+ Expansion — Si une correspondance n'est pas remplie dans les 15 secondes, assouplissez l'exigence minimale d'intersection.
Le processus pour cette règle se présente comme suit :
1. Un joueur est ajouté à la mise en relation potentielle. La valeur de référence (une liste de chaînes) est recalculée afin d'inclure les intersections avec la liste des adversaires préférés du nouveau joueur. La valeur de mesure (une liste de listes de chaînes) est recalculée pour ajouter le caractère choisi par le nouveau joueur en tant que nouvelle liste de chaînes.
1. Amazon GameLift Servers vérifie que chaque liste de chaînes de la valeur de mesure (les personnages choisis par le joueur) interagisse avec au moins une chaîne de la valeur de référence (les adversaires préférés du joueur). Comme dans cet exemple, chaque liste de chaînes de la mesure ne contient qu'une seule valeur, l'intersection est 0 ou 1.
1. Si aucune liste de chaînes de la mesure n'interagit avec la liste de chaînes de la valeur de référence, la règle échoue et le nouveau joueur est supprimé de la mise en relation potentielle.
1. Si une mise en relation n'est pas remplie dans un délai de 15 secondes, abandonnez l'exigence de mise en relation de l'adversaire afin de remplir les emplacements restants du joueur dans la mise en relation.
```
{
"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
}]
}]
}
```
# Exemple : comparez les attributs de tous les joueurs
Cet exemple illustre la façon de comparer les attributs d'un joueur à un groupe de joueurs.
L'exemple d'ensemble de règles décrit une mise en relation avec les caractéristiques suivantes :
+ Structure des équipes : deux équipes à un seul joueur
+ Attributs du joueur :
+ *gameMode* : type de jeu choisi par le joueur (si aucune valeur n'est fournie, la valeur par défaut est « turn-based »).
+ *gameMap* : monde du jeu choisi par le joueur (si aucune valeur n'est fournie, la valeur par défaut est 1).
+ *character* : personnage choisi par le joueur (l'absence de valeur par défaut signifie que les joueurs doivent indiquer un personnage).
+ Règles de mise en relation : les joueurs mis en relation doivent répondre aux exigences suivantes :
+ Les joueurs doivent choisir le même mode de jeu.
+ Les joueurs doivent choisir la même relation de jeu.
+ Les joueurs doivent choisir des personnages différents.
Remarques sur l'utilisation de cet ensemble de règles :
+ Pour implémenter la règle de mise en relation, cet exemple utilise des règles de comparaison permettant de vérifier les valeurs d'attribut de tous les joueurs. Pour le mode et la relation de jeu, la règle vérifie que les valeurs sont identiques. Pour le personnage, la règle vérifie que les valeurs sont différentes.
+ Cet exemple utilise une seule définition de joueur avec une propriété de quantité pour créer les deux équipes de joueurs. Les équipes se voient attribuer les noms suivants : « joueur\$11 » et « joueur\$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])"]
}]
}
```
# Exemple : créer une correspondance de grande taille
Cet exemple illustre comment configurer un ensemble de règles pour une partie pouvant impliquer plus de 40 joueurs. Lorsqu'un ensemble de règles décrit les équipes avec une valeur maxPlayer totale supérieure à 40, on parle de partie à grande échelle. Pour en savoir plus, voir [Concevez un ensemble FlexMatch de règles de correspondance important](match-design-rulesets-large.md).
Cet exemple d’ensemble de règles crée une partie avec les instructions suivantes :
+ Créer une équipe pouvant compter jusqu'à 200 joueurs, avec un minimum de 175 joueurs.
+ Critères d’équilibrage : sélectionner les joueurs en fonction d’un niveau de compétence similaire. Tous les joueurs doivent indiquer leur niveau de compétence pour pouvoir être mis en relation.
+ Préférence de traitement par lots : regrouper les joueurs en fonction de critères d’équilibrage similaires lors de la création des parties.
+ Règles de latence : définir une latence maximum acceptable de 150 millisecondes pour les joueurs.
+ Si la mise en relation n'est pas effectuée rapidement, assouplissez les exigences pour que la partie puisse se remplir dans un délai raisonnable.
+ Après 10 secondes, accepter une équipe avec 150 joueurs.
+ Après 12 secondes, augmenter la latence maximum acceptable en la faisant passer à 200 millisecondes.
+ Après 15 secondes, accepter une équipe avec 100 joueurs.
Remarques sur l'utilisation de cet ensemble de règles :
+ Étant donné que l'algorithme utilise la préférence de traitement par lots largestPopulation, les joueurs sont d'abord triés en fonction des critères d’équilibrage. Par conséquent, les parties ont tendance à accueillir plus de joueurs aux compétences similaires. Tous les joueurs répondent aux exigences de latence acceptables, mais n’ont pas forcément la meilleure latence possible pour leur emplacement.
+ La stratégie d'algorithme utilisée dans cet ensemble de règles, « largest population », est le paramètre par défaut. Pour utiliser la valeur par défaut, vous pouvez choisir d'omettre le paramètre.
+ Si vous avez activé le remplissage des parties, patientez un peu avant d’assouplir les exigences relatives au nombre de joueurs. Dans le cas contraire, vous risquez de vous retrouver avec un trop grand nombre de sessions de jeu partiellement remplies. Pour en savoir plus, voir [Assoudez les exigences relatives aux gros matchs](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
}]
}]
}
```
# Exemple : créer un grand match entre plusieurs équipes
Cet exemple illustre comment configurer un ensemble de règles pour une partie entre plusieurs équipes pouvant impliquer plus de 40 joueurs. Il indique comment créer plusieurs équipes identiques avec une seule définition et présente comment les équipes de taille asymétrique sont remplies au cours de la création d’une partie.
Cet exemple d’ensemble de règles crée une partie avec les instructions suivantes :
+ Créer dix équipes « chasseur » identiques avec jusqu'à 15ˆjoueurs, et une équipe « monstre » avec exactement 5 joueurs.
+ Critères d’équilibrage : sélectionner les joueurs en fonction du nombre de monstres tués. Si les joueurs ne rapportent pas leur nombre de monstres tués, utiliser la valeur par défaut 5.
+ Préférence de traitement par lots : regrouper les joueurs en fonction des régions où la latence est la plus rapide possible pour les joueurs.
+ Règle de latence : définir une latence maximum acceptable de 200 millisecondes pour les joueurs.
+ Si la mise en relation n'est pas effectuée rapidement, assouplissez les exigences pour que la partie puisse se remplir dans un délai raisonnable.
+ Après 15 secondes, accepter les équipes avec 10 joueurs.
+ Après 20 secondes, accepter les équipes avec 8 joueurs.
Remarques sur l'utilisation de cet ensemble de règles :
+ Cet ensemble de règles définit les équipes pouvant contenir jusqu'à 155 joueurs, ce qui en fait un match important. (10 x 15 chasseurs\$15 monstres = 155)
+ Étant donné que l'algorithme utilise la préférence de traitement par lots fastestRegion, les joueurs ont tendance à être placés dans les régions où ils signalent une latence plus rapide et non dans celles où ils signalent une latence élevée (mais acceptable). Parallèlement, les parties sont susceptibles d'avoir moins de joueurs, et les critères d'équilibrage (nombre de monstres tués) peuvent varier plus largement.
+ Lorsqu'une extension est spécifiée pour une définition d'équipe (quantité > 1), elle s'applique à toutes les équipes créées avec cette définition. Par conséquent, en assouplissant le paramètre lié au nombre minimum de joueurs d’une équipe de chasseurs, les dix équipes de chasseurs sont affectées de manière égale.
+ Étant donné que cet ensemble de règles est optimisé pour réduire la latence des joueurs, la règle de latence exclut tous les joueurs qui n'ont pas d'options de connexion acceptables. Il n'est pas nécessaire d'assouplir cette exigence.
+ Voici comment FlexMatch remplit les parties pour cet ensemble de règles avant l'entrée en vigueur des extensions :
+ Aucune équipe n'a encore atteint le nombre minimum de joueurs requis. Les équipes de chasseurs ont 15 emplacements ouverts, tandis que l'équipe Monstre compte 5 emplacements ouverts.
+ Les 100 premiers joueurs sont affectés aux dix équipes de chasseurs (10 joueurs pour chaque équipe).
+ Les 22 joueurs suivants seront affectés de manière séquentielle (2 joueurs pour chaque équipe) aux équipes de chasseurs et à l’équipe Monstre.
+ Les équipes de chasseurs ont chacune atteint le nombre minimum requis de 12 joueurs. L’équipe Monstre a 2 joueurs et n'a pas atteint le nombre minimum de joueurs requis.
+ Les trois joueurs suivants sont donc attribués cette équipe.
+ Toutes les équipes ont maintenant le nombre minimum de joueurs requis. Les équipes de chasseurs ont chacune trois emplacements ouverts. L’équipe Monstre est au complet.
+ Les 30 derniers joueurs sont affectés de manière séquentielle aux équipes de chasseurs, en s'assurant qu’elles ont toutes presque la même taille (à un joueur près).
+ Si vous avez activé le remplissage des parties créées avec cet ensemble de règles, patientez un peu avant d’assouplir les exigences relatives au nombre de joueurs. Dans le cas contraire, vous risquez de vous retrouver avec un trop grand nombre de sessions de jeu partiellement remplies. Pour en savoir plus, voir [Assoudez les exigences relatives aux gros matchs](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
}]
}]
}
```
# Exemple : créer un match de grande envergure avec des joueurs aux attributs similaires
Cet exemple montre comment configurer un ensemble de règles pour les matchs où deux équipes utilisent`batchDistance`. Dans l'exemple :
+ La `SimilarLeague` règle garantit que tous les joueurs d'un match ont `league` moins de 2 % des autres joueurs.
+ La `SimilarSkill` règle garantit que tous les joueurs d'un match ont `skill` moins de 10 % des autres joueurs. Si un joueur attend 10 secondes, la distance passe à 20. Si un joueur attend depuis 20 secondes, la distance passe à 40.
+ La `SameMap` règle garantit que tous les joueurs d'un match en ont fait la même demande`map`.
+ La `SameMode` règle garantit que tous les joueurs d'un match en ont fait la même demande`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
}]
}]
}
```
# Exemple : utilisez une règle composée pour créer un match avec des joueurs ayant des attributs similaires ou des sélections similaires
Cet exemple montre comment configurer un ensemble de règles pour les matchs où deux équipes utilisent`compound`. Dans l'exemple :
+ La `SimilarLeagueDistance` règle garantit que tous les joueurs d'un match ont `league` moins de 2 % des autres joueurs.
+ La `SimilarSkillDistance` règle garantit que tous les joueurs d'un match ont `skill` moins de 10 % des autres joueurs. Si un joueur attend 10 secondes, la distance passe à 20. Si un joueur attend depuis 20 secondes, la distance passe à 40.
+ La `SameMapComparison` règle garantit que tous les joueurs d'un match en ont fait la même demande`map`.
+ La `SameModeComparison` règle garantit que tous les joueurs d'un match en ont fait la même demande`mode`.
+ La `CompoundRuleMatchmaker` règle garantit une correspondance si au moins l'une des conditions suivantes est vraie :
+ Les joueurs participant à un match ont demandé la même chose `map` et la même chose`mode`.
+ Les joueurs d'un match ont des `league` attributs `skill` et des attributs comparables.
```
{
"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
}]
}]
}
```
# Exemple : créer une règle qui utilise la liste de blocage d'un joueur
Cet exemple illustre un ensemble de règles qui permet aux joueurs d'éviter d'être jumelés à certains autres joueurs. Les joueurs peuvent créer une liste de blocage, que le système de matchmaking évalue lors de la sélection des joueurs pour un match. Pour plus d'informations sur l'ajout d'une fonctionnalité de liste de blocage ou de liste à éviter, consultez [AWS le blog sur les jeux](https://aws.amazon.com/blogs/gametech/category/game-development/amazon-gamelift/).
Cet exemple présente les instructions suivantes :
+ Créez deux équipes de cinq joueurs exactement.
+ Transmettez la liste de blocage d'un joueur, qui est une liste de joueurs IDs (jusqu'à 100).
+ Comparez tous les joueurs à la liste de blocage de chaque joueur et rejetez un match proposé si un joueur IDs bloqué est trouvé.
Remarques sur l'utilisation de cet ensemble de règles :
+ Lors de l'évaluation d'un nouveau joueur à ajouter à un match proposé (ou pour remplacer une place dans un match existant), le joueur peut être rejeté pour l'une des raisons suivantes :
+ Si le nouveau joueur figure sur la liste des joueurs déjà sélectionnés pour le match.
+ Si des joueurs déjà sélectionnés pour le match figurent sur la liste de blocage du nouveau joueur.
+ Comme indiqué, cet ensemble de règles empêche de faire correspondre un joueur à un joueur figurant sur sa liste de blocage. Vous pouvez remplacer cette exigence par une préférence (également appelée liste « à éviter ») en ajoutant une extension des règles et en augmentant la `maxCount` valeur.
```
{
"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
}]
}
```