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.
# Concevez un ensemble FlexMatch de règles de correspondance important
Si votre ensemble de règles crée des matchs qui accueillent de 41 à 200 joueurs, vous devez apporter quelques modifications à la configuration de votre ensemble de règles. Ces ajustements optimisent l'algorithme de match afin qu'il puisse créer de grands matchs viables tout en réduisant les temps d'attente des joueurs. Par conséquent, les grands ensembles de règles de match remplacent les règles personnalisées fastidieuses par des solutions standard optimisées pour les priorités de matchmaking courantes.
Voici comment déterminer si vous devez optimiser votre ensemble de règles pour les correspondances de grande taille :
1. Pour chaque équipe définie dans votre ensemble de règles, obtenez la valeur de *MaxPlayer*,
1. Additionnez toutes les valeurs de *MaxPlayer.* Si le total est supérieur à 40, vous disposez d'un ensemble de règles de correspondance important.
Pour optimiser votre ensemble de règles pour les grandes correspondances, effectuez les ajustements décrits ci-dessous. Consultez le schéma pour une règle de correspondance étendue définie dans [Schéma d'ensemble de règles pour les matchs de grande taille](match-ruleset-schema-large.md) et des exemples d'ensembles de règles dans[Exemple : créer une correspondance de grande taille](match-examples-7.md).
# Personnalisez l'algorithme de correspondance pour les grandes correspondances
Ajoutez un composant d'algorithme à l'ensemble de règles, s'il n'en existe pas déjà un. Définissez les propriétés suivantes.
+ `strategy`(obligatoire) — Définissez la `strategy` propriété sur « équilibré ». Ce paramètre déclenche FlexMatch des vérifications supplémentaires après le match afin de trouver l'équilibre optimal de l'équipe en fonction d'un attribut de joueur spécifié, défini dans la `balancedAttribute` propriété. La stratégie équilibrée remplace le besoin de règles personnalisées pour constituer des équipes égales.
+ `balancedAttribute`(obligatoire) — Identifiez un attribut de joueur à utiliser pour équilibrer les équipes lors d'un match. Cet attribut doit avoir un type de données numérique (double ou entier). Par exemple, si vous choisissez d'équilibrer les compétences des joueurs, essayez FlexMatch d'attribuer des joueurs de manière à ce que toutes les équipes aient des niveaux de compétence agrégés aussi égaux que possible. L'attribut d'équilibrage doit être déclaré dans les attributs du joueur de l'ensemble de règles.
+ `batchingPreference`(facultatif) — Choisissez dans quelle mesure vous souhaitez mettre l'accent sur la création de matchs avec le moins de latence possible pour vos joueurs. Ce paramètre affecte la manière dont les tickets de match sont triés avant la création des matchs. Voici les options :
+ La plus grande population. FlexMatchautorise les matchs en utilisant tous les tickets du pool présentant des valeurs de latence acceptables à au moins un endroit en commun. Par conséquent, le pool de tickets potentiel a tendance à être important, ce qui permet de remplir les matchs plus rapidement. Les joueurs peuvent être placés dans des jeux avec une latence acceptable, mais pas toujours optimale. Si la `batchingPreference` propriété n'est pas définie, il s'agit du comportement par défaut lorsqu'elle `strategy` est définie sur « équilibré ».
+ Emplacement le plus rapide. FlexMatchtrie à l'avance tous les tickets du pool en fonction de l'endroit où ils indiquent les valeurs de latence les plus faibles. Par conséquent, les matchs ont tendance à être organisés avec des joueurs qui signalent une faible latence aux mêmes endroits. Dans le même temps, le nombre de tickets potentiels pour chaque match est réduit, ce qui peut augmenter le temps nécessaire pour terminer un match. En outre, étant donné qu'une priorité plus élevée est accordée à la latence, les joueurs participant aux matchs peuvent varier davantage en ce qui concerne l'attribut d'équilibrage.
L'exemple suivant configure l'algorithme de match pour qu'il se comporte comme suit : (1) Pré-triez le pool de tickets pour regrouper les tickets par lieu où les valeurs de latence sont acceptables ; (2) Formez des lots de tickets triés pour les faire correspondre ; (3) Créez des matchs avec des tickets par lot et équilibrez les équipes pour égaliser les compétences moyennes des joueurs.
```
"algorithm": {
"strategy": "balanced",
"balancedAttribute": "player_skill",
"batchingPreference": "largestPopulation"
},
```
# Déclarer les attributs des joueurs
Assurez-vous de déclarer l'attribut de joueur utilisé comme attribut d'équilibrage dans l'algorithme d'ensemble de règles. Cet attribut doit être inclus pour chaque joueur dans une demande de matchmaking. Vous pouvez fournir une valeur par défaut pour l'attribut du joueur, mais l'équilibrage des attributs fonctionne mieux lorsque des valeurs spécifiques au joueur sont fournies.
# Définissez les équipes
Le processus de définition de la taille et de la structure des équipes est le même que pour les parties de petite envergure, mais la façon dont FlexMatch remplit les équipes est différente. Cela affecte l'apparence probable des correspondances lorsqu'elles ne sont que partiellement remplies. Vous souhaiterez peut-être ajuster la taille minimale de votre équipe en conséquence.
FlexMatch utilise les règles suivantes lors de l'affectation d'un joueur à une équipe. Premièrement, il recherche les équipes qui ne comptent pas encore le nombre minimal de joueurs requis. Deuxièmement, parmi ces équipes, il identifie celle qui a le moins de joueurs.
Pour les parties définissant des équipes de taille égale, les joueurs sont ajoutés de manière séquentielle pour chaque équipe jusqu'à ce qu’elles soient pleines. Par conséquent, les équipes d'un match ont toujours un nombre presque égal de joueurs, même lorsque le match n'est pas complet. Actuellement, il n'est pas possible d’imposer des équipes de taille égale dans les partie à grande échelle. Pour les parties dont les tailles d’équipes sont asymétriques, le processus est un peu plus complexe. Dans ce scénario, les joueurs sont initialement affectés aux plus grandes équipes qui ont le plus de places ouvertes. Au fur et à mesure que le nombre de places libres est réparti de manière plus uniforme entre toutes les équipes, les joueurs sont répartis dans les plus petites équipes.
Supposons, par exemple, que vous ayez un ensemble de règles composé de trois équipes. Les équipes rouge et bleue sont toutes deux réglées à `maxPlayers` =10, `minPlayers` =5. L'équipe verte est définie sur `maxPlayers` =3, `minPlayers` =2. Voici la séquence de remplissage :
1. Aucune équipe n'est arrivée`minPlayers`. Les équipes rouge et bleue ont 10 emplacements ouverts, tandis que l’équipe verte en compte 3. Les 10 premiers joueurs sont affectés aux équipes rouge et bleue, à hauteur de 5 joeurs par équipe. Les deux équipes ont désormais atteint le score`minPlayers`.
1. L'équipe verte n'est pas encore arrivée`minPlayers`. Les 2 prochains joueurs sont attribués à l'équipe verte. L'équipe verte est maintenant arrivée`minPlayers`.
1. Toutes les équipes étant réunies`minPlayers`, des joueurs supplémentaires sont désormais assignés en fonction du nombre de places disponibles. Les équipes rouge et bleue ont chacune 5 places libres, tandis que l'équipe verte en a une. Les 8 joueurs suivants sont affectés (4 chacun) aux équipes rouge et bleue. Toutes les équipes ont désormais 1 place libre.
1. Les 3 places restantes sont attribuées (1 chacune) aux équipes sans ordre particulier.
# Établissez des règles pour les matchs de grande envergure
Le matchmaking pour les matchs de grande envergure repose principalement sur la stratégie d'équilibrage et les optimisations du traitement par lots de latence. la plupart des règles personnalisées ne sont pas disponibles. Vous pouvez toutefois intégrer les types de règles suivants :
+ Règle qui fixe une limite stricte à la latence des joueurs. Utilisez le type de `latency` règle avec la propriété`maxLatency`. Voir la [Règle de latence](match-rules-reference-ruletype.md#match-rules-reference-ruletype-latency) référence. Voici un exemple qui définit une latence maximum de 200 millisecondes pour les joeurs :
```
"rules": [{
"name": "player-latency",
"type": "latency",
"maxLatency": 200
}],
```
+ Règle permettant de regrouper les joueurs en fonction de la proximité d'un attribut de joueur spécifié. Cela est différent de la définition d'un attribut d'équilibrage dans le cadre de l'algorithme des matchs importants, qui met l'accent sur la constitution d'équipes égales. Cette règle regroupe les tickets de matchmaking en fonction de la similitude des valeurs d'attribut spécifiées, telles que les compétences de débutant ou d'expert, ce qui a tendance à conduire à des matchs entre des joueurs étroitement alignés sur l'attribut spécifié. Utilisez le type de `batchDistance` règle, identifiez un attribut numérique et spécifiez la plage la plus large à autoriser. Voir la [Règle de distance par lots](match-rules-reference-ruletype.md#match-rules-reference-ruletype-batchdistance) référence. Voici un exemple qui demande aux joueurs d'un match de se situer à un niveau de compétence les uns des autres :
```
"rules": [{
"name": "batch-skill",
"type": "batchDistance",
"batchAttribute": "skill",
"maxDistance": 1
```
# Assoudez les exigences relatives aux gros matchs
Comme pour les parties de petite envergure, vous pouvez utiliser des extensions pour assouplir progressivement les exigences de mise en relation lorsqu’aucune partie ne correspond. Lors de matchs de grande envergure, vous avez la possibilité d'assouplir les règles de latence ou d'assouplir le nombre de joueurs de l'équipe.
Si vous utilisez le remplissage automatique des parties à grande échelle, patientez un peu avant d'assouplir le nombre de joueurs requis. FlexMatch ne commence à générer les demandes de remplissage qu’après le démarrage d’une session de jeu, ce qui peut ne pas se produire pendant plusieurs secondes après la création d’une partie. Parallèlement, FlexMatch permet de créer plusieurs sessions de jeu partiellement remplies, notamment lorsque les règles liées au nombre de joueurs sont abaissées. Dans ce cas, vous pouvez vous retrouver avec plus de sessions de jeu que nécessaire et une trop faible répartition des joueurs entre eux. Une bonne pratique consiste ici à attribuer à la première étape de l’extension du nombre de joueurs un délai d'attente suffisamment long pour que la session de jeu puisse démarrer. Dans la mesure où les demandes de remplissage sont prioritaires dans les parties à grande échelle, les joueurs entrants sont placés dans les jeux existants avant le démarrage de nouveaux jeux. Vous devrez peut-être effectuer plusieurs tests afin de déterminer le temps d'attente idéal pour votre jeu.
Voici un exemple qui réduit progressivement le nombre de joueurs de l'équipe jaune, avec un temps d'attente initial plus long. Gardez à l'esprit que les délais d'attente des extensions dans les ensembles de règles sont des valeurs absolues, et non composées. Par conséquent, la première extension se produit à cinq secondes, tandis que la seconde extension se produit cinq secondes plus tard, à savoir au bout de dix secondes.
```
"expansions": [{
"target": "teams[Yellow].minPlayers",
"steps": [{
"waitTimeSeconds": 5,
"value": 8
}, {
"waitTimeSeconds": 10,
"value": 5
}]
}]
```