Personnalisez l'algorithme de correspondance pour les correspondances importantes Déclarer les attributs du joueur Définissez les équipes Établissez des règles pour les grands matchs Assouplir les exigences relatives aux matchs

Concevez un ensemble FlexMatch de règles pour les matchs importants

Si votre ensemble de règles crée des matchs pouvant accueillir 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 des matchs de grande envergure viables tout en réduisant les temps d'attente des joueurs. Par conséquent, les ensembles de règles de correspondance volumineux 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 importantes :

Pour chaque équipe définie dans votre ensemble de règles, obtenez la valeur de MaxPlayer,
Additionnez toutes les valeurs de MaxPlayer. Si le total est supérieur à 40, vous disposez d'un ensemble de règles de correspondance volumineux.

Pour optimiser votre ensemble de règles pour les matchs importants, effectuez les ajustements décrits ci-dessous. Consultez le schéma d'un ensemble de règles de correspondance volumineux dans Schéma d'ensemble de règles pour les matchs importants et des exemples d'ensembles de règles dansExemple 7 : créer une grande correspondance.

Personnalisez l'algorithme de correspondance pour les correspondances importantes

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 pour trouver l'équilibre optimal de l'équipe en fonction d'un attribut de joueur spécifié, qui est défini dans la balancedAttribute propriété. La stratégie équilibrée remplace le besoin de règles personnalisées pour créer des équipes équilibrées.
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 de mettre l'accent sur les compétences des joueurs, FlexMatch essayez de répartir les 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 formation de matchs avec la plus faible latence possible pour vos joueurs. Ce paramètre affecte la façon dont les tickets de match sont triés avant de créer des matchs. Les options incluent :
- 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 billets 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 à se former 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 remplir un match. De plus, étant donné que la priorité est accordée à la latence, les joueurs peuvent varier plus largement en ce qui concerne l'attribut d'équilibrage lors des matchs.

L'exemple suivant configure l'algorithme de match pour qu'il se comporte comme suit : (1) Triez à l'avance le pool de tickets pour regrouper les tickets par emplacement où ils présentent des valeurs de latence acceptables ; (2) Formez des lots de tickets triés pour les faire correspondre ; (3) Créez des matchs avec des tickets par lots et équilibrez les équipes pour égaliser les compétences moyennes des joueurs.


"algorithm": {
    "strategy": "balanced",
    "balancedAttribute": "player_skill",
    "batchingPreference": "largestPopulation"
},

Déclarer les attributs du joueur

Assurez-vous de déclarer l'attribut du joueur qui est utilisé comme attribut d'équilibrage dans l'algorithme de l'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 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 participant à 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 équipes les plus importantes ayant le plus de places libres. 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 équipes les plus petites.

Supposons, par exemple, que vous ayez un ensemble de règles avec trois équipes. Les équipes rouge et bleue sont toutes deux réglées sur maxPlayers =10, minPlayers =5. L'équipe verte est réglée sur maxPlayers =3, minPlayers =2. Voici la séquence de remplissage :

Aucune équipe n'y est parvenueminPlayers. 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 butminPlayers.
L'équipe verte n'est pas encore arrivéeminPlayers. Les 2 prochains joueurs sont attribués à l'équipe verte. L'équipe des Verts est maintenant arrivéeminPlayers.
Toutes les équipes étant présentesminPlayers, des joueurs supplémentaires sont désormais affecté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.
Les emplacements de 3 joueurs restants sont attribués (1 par équipe) sans ordre particulier.

Établissez des règles pour les grands matchs

Le matchmaking pour les matchs importants 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 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 consistant à regrouper les joueurs en fonction de leur proximité dans 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 de grande correspondance, qui vise à créer des équipes équilibrées. Cette règle regroupe les tickets de matchmaking en fonction de la similitude des valeurs des attributs spécifiés, telles que le niveau de débutant ou d'expert, ce qui a tendance à conduire à des matchs entre joueurs étroitement liés à 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 référence. Voici un exemple qui demande que les joueurs d'un match se situent à moins d'un niveau de compétence l'un de l'autre :
```
"rules": [{
        "name": "batch-skill",
        "type": "batchDistance",
        "batchAttribute": "skill",
        "maxDistance": 1
```

Assouplir les exigences relatives aux 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. Pour les matchs de grande envergure, vous avez la possibilité d'assouplir les règles de latence ou le nombre de joueurs de l'équipe.

Si vous utilisez le remblayage automatique pour les matchs importants, évitez de relâcher le nombre de joueurs de votre équipe trop rapidement. FlexMatchcommence à générer des demandes de remplissage uniquement après le début d'une session de jeu, ce qui peut ne pas se produire plusieurs secondes après la création d'un match. 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
        }]
    }]

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Conception d'un ensemble de règles

Création d'ensembles de règles