edgegap.comCommunity DiscordDashboard

Matchmaking

Commencez rapidement avec le matchmaking et explorez des scénarios d'exemple pour divers genres.

Le matchmaking dans les jeux basés sur des parties vise généralement à :

  • trouver d'autres joueurs en fonction de critères tels que la région, la latence, le niveau ou les paramètres du jeu ;

  • rechercher des serveurs rejoindre en fonction de la capacité disponible [ou du ping, de la région, du niveau, de la carte, du mode] ;

  • démarrer un nouveau serveur si les serveurs existants sont pleins ou ne satisfont pas les critères des joueurs.

L'expérience du joueur passe en premier, définissant nos objectifs principaux :

  • taux de remplissage des parties élevé et intégration des fonctionnalités sociales (jouer avec des amis en groupe),

  • parties rapides avec une qualité de match contrôlée (faible latence, préférences partagées),

  • processus de matchmaking fiable et prévisible avec une disponibilité mondiale.

Suivez cette vidéo pour commencer avec notre service de Matchmaker :

✔️ Préparation

Tester ce service est entièrement gratuit, aucune carte de crédit requise.

Le niveau gratuit permet jusqu'à 3 heures d'exécution sur notre cluster de test partagé, après chaque redémarrage.

Ce tutoriel suppose que vous avez déjà :

Architecture du Matchmaking

Ce guide se concentrera sur API de Matchmaking et API de Backfill.

Il y a quatre (4) flux de données importants lorsque le matchmaking est impliqué :

  1. API de Matchmaking est utilisée par les clients de jeu pour communiquer avec le Matchmaker :

    1. pour la gestion des groupes, l'attribution de serveurs et la surveillance,

    2. pour la mesure du ping avec Balises de ping.

  2. Déploiements L'API est utilisée pour déployer, mettre à l'échelle et gérer vos serveurs dédiés par le Matchmaker.

  3. Transports Netcode sont utilisés pour communiquer entre les clients de jeu et les serveurs dédiés.

  4. Analyse approfondie pour remplacer ou ajouter plus de joueurs depuis le serveur.

Après la sortie, votre matchmaker devra fonctionner 24/7 pour s'assurer que les joueurs du monde entier peuvent rejoindre des serveurs.

🍀 Exemple simple

Commencez par un exemple simple et testez le flux de base des joueurs pour le matchmaking :

1. Configuration sur le niveau gratuit

☑️ Inscrivez-vous pour votre compte Edgegap gratuit et ouvrez le page du tableau de bord Matchmaker.

☑️ Cliquez sur Créer un Matchmaker d'abord, puis saisissez :

  • nom du matchmaker - pour votre référence, par ex. quickstart-dev ,

  • téléversez notre configuration JSON Simple Example.

🍀 Exemple simple (configuration minimale recommandée) :

Assurez-vous de changer l'application nom et version pour correspondre à votre Applications et versions.

Dépannage et FAQ :

La configuration de l'application n'est pas valide pour le profil XYZ.
L'image Docker pour '2024.01.30-16.23.00-UTC' n'est pas mise en cache.

🌟 Passez au niveau Pay as You Go pour débloquer déploiements instantanés avec mise en cache.

  • Les images non mises en cache de plus de 4 Go peuvent prendre plus de temps à être déployées, entraînant Déploiements. Envisagez d'optimiser la taille de votre image serveur (Unreal Engine / Unity).

  • Vous pouvez poursuivre quand même, bien que nous recommandions de tester le temps de déploiement.

☑️ Si aucune erreur de validation n'apparaît, cliquez sur Créer et Démarrer et attendez que le processus se termine. Cela aboutira au démarrage d'un nouveau cluster gratuit, avec votre matchmaker Simple Example.

✅ Vous pouvez maintenant passer à l'étape suivante.

2. Explorer la configuration

À mesure que nous publions des mises à jour du Matchmaker, chaque nouvelle version utilise versionnage sémantique pour communiquer clairement l'impact des modifications en interprétant le format major.minor.patch:

  • 🔥 majeure les versions incluent des changements incompatibles et nécessitent une revue d'intégration,

  • 🌟 mineure les versions incluent des améliorations importantes compatibles avec les versions précédentes,

  • 🩹 correction les versions incluent des corrections de bugs et des améliorations mineures.

Inspecter les tickets pour mieux comprendre et déboguer les flux de matchmaking possibles pendant le développement. Nous recommandons de désactiver l'API inspect pour votre matchmaker en production.

Certaines déploiements peuvent entraîner des erreurs. Nous tentons de résoudre cela en réessayant le déploiement jusqu'à max_deployment_retry_count fois automatiquement (sans confirmation du client).

Pour s'assurer que des plantages inattendus du client ou des tickets abandonnés ne persistent pas et n'occupent pas les ressources de votre matchmaker, les tickets seront annulés après ticket_expiration_period faisant passer leur statut à ANNULÉ puis supprimés définitivement après ticket_removal_period .

Le cœur de notre logique de matchmaking est configuré dans Profils (Files d'attente). Chaque profil est une file de matchmaking complètement isolée, pointant vers Applications et versions avec une quantité pré-définie de ressources CPU et mémoire (RAM) requises.

Règles dans l'ensemble de règles initial doit être satisfait pour que les joueurs soient regroupés, chaque règle étant définie par trois propriétés :

  • nom de votre choix, par ex. - taille du match,

  • type de règle, également appelé opérateur, par ex. - player_count,

  • et enfin les attributs de l'opérateur, par ex. team_count ou max_team_size.

Règle du nombre de joueurs

Ceci est une règle spéciale définissant combien de joueurs doivent correspondre pour initier l'attribution :

  • team_count fait référence au nombre d'équipes, 1 équipe peut être utilisée pour les modes coopératifs ou tous contre tous,

  • min_team_size fait référence au nombre minimum de joueurs par équipe.

  • max_team_size fait référence au nombre maximum de joueurs par équipe.

Notre exemple simple démontre un jeu coopératif avec 2 joueurs.

La règle Player Count est requise et ne peut être définie qu'une seule fois dans vos règles de configuration initiales.

Règle des latences

latences est une règle spéciale optimisant le ping des matchs de joueurs :

  • réduire la latence client-serveur en supprimant les régions à haute latence (au-dessus du seuil),

  • améliorer l'équité des matchs en regroupant les joueurs ayant une latence similaire (en dessous de la différence).

Exemple de règle : balises

balises règle configurée avec "difference": 100, "max_latency": 200 construira des matchs :

✅ Alice et Bob peuvent être appariés :

  • Tokyo est ignorée (>200 ms),

  • latence pour Chicago avec une différence absolue de 100 ms.

Ville de la balise
Match
abs(A - B) [ms]
Alice [ms]
Bob [ms]

Chicago

✅

75.0

12.3

87.3

Los Angeles

❌

113.2 ❌

145.6

32.4

Tokyo

n/a

n/a

233.2 ❌

253.2 ❌

❌ Alice et Charlie ne seront jamais appariés :

  • aucune balise n'a une latence < 200 ms pour les deux joueurs,

  • Alice vit en Amérique du Nord - Illinois,

  • Charlie vit en Asie - Japon.

Ville de la balise
Match
abs(A - B) [ms]
Alice [ms]
Charlie [ms]

Chicago

n/a

n/a

12.3

215.6 ❌

Los Angeles

n/a

n/a

145.6

238.3 ❌

Tokyo

n/a

n/a

233.2 ❌

24.2

Règle latences est optionnelle et ne peut être définie qu'une seule fois dans votre configuration initiale règles.

✅ Vous pouvez maintenant passer à l'étape suivante.

3. Examiner les détails de l'instance

☑️ Examinez les détails de votre nouveau matchmaker dans notre tableau de bord une fois qu'il est initialisé :

  • Statut indique la santé du service, peut être ONLINE, OFFLINE ou ERROR.

  • Identifiant aide le personnel d'Edgegap à trouver rapidement votre matchmaker si vous avez besoin d'aide pour le dépannage.

  • Démarré le peut être utile pour retracer l'heure de la dernière mise à jour.

  • Taille correspond à l'un de nos niveaux de tarification.

  • URL de l'API sera utilisée par les clients de jeu et les serveurs de jeu pour communiquer avec votre matchmaker.

  • URL Swagger est une interface pratique de spécification OpenAPI que nous fournissons pour explorer le schéma de l'API.

  • Jeton d'authentification est un jeton secret unique utilisé par les clients de jeu et les serveurs de jeu pour l'authentification.

Le personnel d'Edgegap ne vous demandera jamais vos jetons. Régénérez votre jeton si vous suspectez une faille de sécurité.

Pour tester votre nouveau matchmaker, vous aurez besoin de l'URL Swagger, de l'URL de l'API et du jeton d'authentification.

✅ Vous pouvez maintenant passer à l'étape suivante.

Pour mettre à jour vos règles de matchmaker en développement, modifiez votre configuration et redémarrez-le.

Voir ⏩ Mises à jour progressives pour les jeux en direct et les mises à jour sans temps d'arrêt.

4. Tester l'API des tickets

Veuillez attendre jusqu'à 5 minutes après avoir démarré votre matchmaker pour permettre à la propagation DNS de se terminer.

☑️ D'abord, ouvrez votre URL Swagger pour inspecter votre schéma OpenAPI dans l'interface Swagger :

☑️ Cliquez sur Autoriser 🔒, collez votre Jeton d'authentification, et confirmez en cliquant sur Autoriser.

☑️ Faites défiler jusqu'à API Ticket - POST /tickets, développez et cliquez sur Essayer.

☑️ Prévisualisez votre requête :

  • remarquez player_ip défini sur null - cela fera que le Matchmaker utilise automatiquement l'adresse IP ajoutée à votre requête (voir Serveur vers Serveur pour des alternatives),

  • profil fait référence à votre Profils (Files d'attente),

  • attributs incluent des valeurs pour vos règles de matchmaker, dans ce cas pour la latences règle,

    • règle player_count est la seule règle qui ne requiert aucun attribut dans les tickets des joueurs.

☑️ Cliquez sur Exécuter et examinez la réponse à votre requête de ticket joueur :

☑️ Créez un second ticket en cliquant sur Exécuter à nouveau, afin que nos deux joueurs correspondent et qu'un serveur soit démarré.

☑️ Réduire POST /tickets et ouvrir GET /tickets/{ticketId}, puis cliquer Essayer.

☑️ Saisir l'ID du ticket à partir de la réponse de l'étape précédente et cliquer Exécuter.

☑️ Examiner l'affectation mise à jour pour votre ticket joueur :

  • statut changé en MATCH_FOUND d'abord, tout en gardant attribution défini sur null pour indiquer que les joueurs ont été appariés et qu'un serveur est en cours d'attribution,

☑️ Cliquez sur Exécuter à nouveau pour vérifier votre ticket, et examiner l'affectation mise à jour pour votre ticket :

  • statut changé en HOST_ASSIGNED avec attribution contenant les détails du serveur attribué.

Dépannage et FAQ

Mon ticket est bloqué dans EN RECHERCHE .

  • Veuillez vérifier que vous avez créé suffisamment de tickets avec des critères qui se chevauchent conformément à votre configuration.

Mon ticket reste bloqué en alternant entre MATCH_FOUND et TEAM_FOUND à plusieurs reprises.

  • Les comptes Free Tier sont limités à 1 déploiement à la fois. Veuillez envisager de passer à une offre payante ou d'arrêter votre déploiement actuel pour en démarrer un nouveau.

Mon ticket passe directement à ANNULÉ.

  • Votre ticket a atteint son expiration. Recréez un nouveau ticket ou augmentez la période d'expiration dans votre configuration à des fins de test.

Je reçois HTTP 404 Not Found lors de la vérification de mon ticket.

  • Votre ticket a été supprimé soit par une requête DELETE, soit en atteignant sa période de suppression (commence après l'expiration du ticket, définie dans votre configuration). Recréez un nouveau ticket ou augmentez les périodes d'expiration/suppression dans votre configuration à des fins de test.

☑️ Inspectez votre nouveau déploiement dans notre tableau de bord:

  • remarquez que chaque déploiement est étiqueté avec tous les IDs de tickets et le profil pour une traçabilité accrue.

Quelques secondes après avoir trouvé une partie, les adhésions procèdent à statut:HOST_ASSIGNED indiquant que votre déploiement est maintenant prêt et que votre serveur de jeu s'initialise.

Chaque joueur lit son ticket_id et réelle et tente la connexion en utilisant le FQDN (URL de déploiement) et le Port externe. Votre serveur de jeu peut encore être en cours d'initialisation à ce moment, donc les joueurs doivent réessayer la connexion plusieurs fois, jusqu'à dépasser votre temps d'initialisation habituel du serveur :

Pour se connecter depuis PIE (Éditeur) pendant le développement et les tests, appuyez sur la touche tilde ~ et tapez open {URL}:{port} et attendez que votre éditeur charge la carte.

Pour se connecter depuis une build cliente du jeu (et dans un environnement de production en direct) essayez

En cas d'échecs de connexion ou d'écran noir consultez notre guide de dépannage.

Nous ne demandons pas aux joueurs de confirmer la partie, car nous visons à fournir le temps le plus court possible jusqu'au jeu, un taux de remplissage des parties élevé, et à minimiser les abandons de file d'attente et les annulations de parties.

Les joueurs devraient conserver leur ID d'affectation de manière persistante entre les redémarrages du jeu, afin que, en cas de plantage du client de jeu, ils puissent récupérer les détails de connexion et tenter de se reconnecter.

Voir Matchmaking et nos SDK avec fonction de reconnexion automatique et plus encore.

☑️ Essayez de vous connecter depuis votre client de jeu au serveur attribué.

Si vous constatez une latence élevée, votre intégration netcode peut être configurée pour simuler la latence réseau. Désactivez le VPN lors des tests pour des conditions plus réalistes et recevez un déploiement à faible latence.

☑️ Une fois que vous avez vérifié que vous pouvez vous connecter à votre déploiement sans problème et que vous avez terminé les tests, Arrêter votre déploiement pour libérer des capacités dans votre compte pour la prochaine build.

✅ Vous pouvez maintenant passer à l'étape suivante.

Trouvez la spécification openAPI pour les tests à {matchmaker-url}/swagger/v1/swagger.json.

5. Intégration au jeu

Le matchmaker s'intègre avec :

☑️ Dans Client de jeu, nous recommandons de fournir des mises à jour du statut des tickets aux joueurs via l'interface du jeu pour une meilleure expérience joueur. Voir :

☑️ Dans Client de jeu, assurez-vous de gérer les 429 Too Many Requests erreurs réessayables avec un backoff exponentiel et une nouvelle tentative, donnant au matchmaker le temps de récupérer lors de pics de trafic soudains.

☑️ Dans Client de jeu, assurez-vous de gérer les erreurs non réessayables :

  • 404 Not Found - le ticket a été supprimé,

  • 500 Internal Server Error - panne temporaire du service.

☑️ Dans Serveur de jeu, lire les préférences des joueurs et le contexte initial du serveur :

  1. Variables injectées (Matchmaker) pour récupérer les données de matchmaking initiales des joueurs.

  2. Variables injectées (Versions de l'application) pour les paramètres de version, les réglages et les secrets.

  3. Variables injectées (Déploiement) pour les informations de déploiement, IP, emplacement, etc...

Utilisez GetEnvironmentVariable en C# ou GetEnvironmentVariable en C++ pour obtenir les valeurs des variables.

☑️ Une fois que les joueurs sont connectés, Serveur de jeu et clients de jeu démarrent une scène de chargement - scène 3D, UI sociale de type lobby, ou un écran de chargement avec une barre de progression, pour indiquer que l'initialisation progresse.

☑️ Assurez-vous que votre déploiement sera arrêté correctement une fois le match terminé.

🙌 Félicitations, vous avez complété l'intégration du matchmaking ! Pour en savoir plus, continuez la lecture.

🏁 Exemple avancé

Une configuration complète utilisant toutes les fonctionnalités de matchmaking incluant Profils (Files d'attente), Règles, et Analyse approfondie peut ressembler à ceci :

🏁 Exemple avancé (Configuration d'exemple complète)
{
  "version": "3.2.1",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "allowed_cors_origins": [
    "https://*.my-game-server.com"
  ],
  "profiles": {
    "advanced-example": {
      "ticket_expiration_period": "5m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m"
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 1,
              "min_team_size": 4,
              "max_team_size": 4
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 125,
              "max_latency": 125
            }
          },
          "elo_rating": {
            "type": "number_difference",
            "attributes": {
              "max_difference": 50
            }
          },
          "selected_game_mode": {
            "type": "string_equality"
          },
          "selected_map": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          },
          "backfill_group_size": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {
          "30": {
            "elo_rating": {
              "max_difference": 150
            },
            "beacons": {
              "difference": 125,
              "max_latency": 250
            }
          },
          "60": {
            "elo_rating": {
              "max_difference": 200
            }
          },
          "180": {
            "match_size": {
              "team_count": 1,
              "min_team_size": 1,
              "max_team_size": 4
            },
            "beacons": {
              "difference": 99999,
              "max_latency": 99999
            }
          }
        }
      }
    }
  }
}

🎾 Lobby personnalisé

Les lobbies personnalisés (lobbies privés, niveaux sandbox) sont une option très populaire pour le multijoueur sur canapé et pour tester de nouvelles fonctionnalités dans les jeux avant qu'elles n'entrent dans les modes de jeu principaux. Ils nécessitent généralement le moins de restrictions, mais veillez à ce que les joueurs puissent Analyse approfondie.

🎾 Exemple de salon personnalisé
{
  "version": "3.2.1",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "profiles": {
    "custom-lobby-example": {
      "ticket_expiration_period": "3m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m"
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 1,
              "min_team_size": 4,
              "max_team_size": 4
            }
          },
          "lobby_id": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {
          "10": {
            "match_size": {
              "team_count": 1,
              "min_team_size": 1,
              "max_team_size": 4
            }
          }
        }
      }
    }
  }
}

Pour les lobbies privés sans accès public, définissez "team_size": 1 et faites en sorte que le propriétaire du groupe démarre le jeu seul. Le propriétaire peut partager les détails du groupe et de l'affectation de l'hôte à n'importe quel nombre de membres pour qu'ils rejoignent.

Ajouter custom-lobby-example profil dans votre matchmaker existant pour prendre en charge les lobbies personnalisés.

🥛 Démonstration de backfill

En s'appuyant sur Matchmaking, cette configuration présente Backfill avec Groupes.

🥛 Exemple de configuration de remplissage rétroactif
{
  "version": "3.2.1",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "profiles": {
    "backfill-example": {
      "ticket_expiration_period": "5m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m",
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 1,
              "min_team_size": 4,
              "max_team_size": 4
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 100,
              "max_latency": 200
            }
          },
          "backfill_group_size": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {}
      }
    }
  }
}

Optionnellement, certains jeux peuvent avoir des besoins particuliers en matière de matchmaking, tels que :

  • permettre aux nouveaux joueurs de rejoindre des parties en cours (amis ou « randoms »),

  • remplacer les joueurs qui abandonnent (leavers) après le démarrage du serveur pour éviter de redémarrer la partie,

  • autoriser des spectateurs à rejoindre et observer des tournois ou des matchs d'amis (e-sports),

  • centraliser les joueurs dans des serveurs plus grands pour offrir davantage d'interactions sociales (MMO).

Le backfill est un ticket appartenant au serveur représentant les joueurs actuellement connectés au serveur. Cela garantit que les joueurs nouvellement ajoutés respecteront vos règles de matchmaking lorsqu'ils seront appariés avec des joueurs actuels.

Analyse approfondie pour remplacer les sessions Seat/Match. Le matchmaker ne prend en charge que la session Default.

Scénarios de backfill visualisés

Les backfills ignorent player_count la règle, et appairent toujours exactement un groupe. backfill_group_size contrôle la capacité de l'équipe avec une stratégie round-robin, remplissant les équipes de manière uniforme et contrôlée.

Les étapes pour compléter un backfill réussi sont :

    • Affectation réelle données récupérées depuis Variables injectées (déploiement).

    • Les tickets des joueurs actuellement connectés:

      • depuis Analyse approfondie (matchmaker), les backfills précédents assigned_ticket réponse, ou données factices manipulées pour correspondre à des joueurs spécifiques,

      • remplacer backfill_group_size valeurs par des tailles de groupe possibles jusqu'à la capacité disponible,

    • "1" si le joueur fait du matchmaking seul.

    • "2" si le joueur fait partie d'un groupe de matchmaking de 2 membres au total.

    • "nouveau" si les joueurs ont activé le démarrage de nouvelles parties en plus de rejoindre des parties en cours.

  3. Les clients de jeu procèdent à Analyse approfondie et associent les joueurs au backfill correspondant.

  4. Si le groupe backfillé n'a pas complètement rempli l'équipe, le serveur peut répéter ce processus avec les tickets des joueurs nouvellement backfillés, pour ajouter plus de joueurs et atteindre la taille d'équipe souhaitée.

Pour créer un profil Backfill-only, définissez min_team_size à 999 999 et désactivez les correspondances ticket + ticket.

🥛 Exemple de backfill (Vitrine Backfill)
🥛 Exemple d'affectation de backfill (Vitrine Backfill)

Voir Gestion des sièges Mirror et Gestion des sièges FishNet pour la surveillance de la connexion des joueurs.

⚔️ Jeux compétitifs

Les jeux compétitifs se concentrent sur la compétition entre joueurs pour obtenir la victoire, que ce soit en tant qu'individus (free for all) ou en équipes. Assurez des matchs justes et équilibrés en appariant des joueurs ou des équipes de niveaux de compétence similaires, et maintenez le rythme du jeu en trouvant rapidement une concurrence équitable.

⚔️ Exemple de jeu compétitif
{
  "version": "3.2.1",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "profiles": {
    "casual-example": {
      "ticket_expiration_period": "5m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m",
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 2,
              "min_team_size": 5,
              "max_team_size": 5
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 125,
              "max_latency": 150
            }
          },
          "selected_maps": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          },
          "backfill_group_size": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {
          "30": {
            "beacons": {
              "difference": 125,
              "max_latency": 250
            }
          },
          "180": {
            "beacons": {
              "difference": 99999,
              "max_latency": 99999
            }
          }
        }
      }
    },
    "competitive-example": {
      "ticket_expiration_period": "5m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m"
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 2,
              "min_team_size": 5,
              "max_team_size": 5
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 125,
              "max_latency": 150
            }
          },
          "versus_ranks": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {
          "120": {
            "beacons": {
              "difference": 125,
              "max_latency": 250
            }
          }
        }
      }
    },
    "challenger-example": {
      "ticket_expiration_period": "5m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m"
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 2,
              "min_team_size": 5,
              "max_team_size": 5
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 125,
              "max_latency": 150
            }
          },
          "elo_rating": {
            "type": "number_difference",
            "attributes": {
              "max_difference": 50
            }
          }
        },
        "expansions": {
          "120": {
            "beacons": {
              "difference": 125,
              "max_latency": 250
            }
          }
        }
      }
    }
  }
}

Vous pouvez définir plusieurs équipes avec 1 joueur ou plus chacune, par exemple :

Mode de jeu
Nombre d'équipes
Taille d'équipe
Joueurs totaux

FPS 5v5

2

5

10

MOBA 5v5

2

5

10

Battle Royale 20x3

20

3

60

10p Free For All

1

10

10

Définir plusieurs Profils (Files d'attente) pour des règles et paramètres spécifiques au mode de jeu, et développer selon les besoins.

  • Pour tous les matchs :

    • restreindre latence de matchmaking pour éviter d'apparier des joueurs éloignés,

    • Analyse approfondie pour les parties préfabriquées et empêcher de dépasser la taille des équipes,

    • assouplir lentement les restrictions de latence au fil du temps pour trouver plus de joueurs,

    • allouer plus de CPU ou de mémoire avec différents Applications et versions pour des profils spécifiques,

  • Pour les matchs occasionnels :

    • omettre les restrictions de classement pour maximiser la vitesse de matchmaking et le taux de remplissage des matchs,

    • laisser les joueurs indiquer leurs préférences de carte pour trouver une carte adaptée à tous,

    • spécifier la taille du groupe de backfill pour remplacer les partants sans dépasser la taille des équipes,

    • supprimer les limitations de latence pour garantir un match après 3 minutes (180s) de temps d'attente dans la file.

  • Pour les matchs compétitifs :

    • restreindre le classement pour n'autoriser que des adversaires de niveau de compétence similaire,

    • utiliser des montées/descendes de rang pour apparier les joueurs aux extrémités de classement de la ligue.

  • Pour le top 1% des matchs de haut niveau (challengers) :

    • utiliser des évaluations de compétence numériques (ELO) pour un contrôle précis de la distribution des compétences dans les matchs,

    • attendre plus longtemps avant d'assouplir les exigences de latence en raison du nombre réduit de joueurs.

Utiliser plusieurs profils pour séparer les modes de jeu occasionnels, les modes compétitifs, et les challengers de haut niveau les joueurs vous permet de personnaliser les règles et les extensions pour chaque type de joueur séparément.

🤝 Jeux coopératifs

Les jeux coopératifs exigent que les joueurs travaillent ensemble en équipe vers un objectif commun, ou contre un adversaire IA. Alignez les joueurs ayant des préférences et des habitudes de jeu similaires. Remplacez les joueurs qui partent, et améliorez Balises de ping pour offrir une expérience joueur réactive.

🤝 Exemple de jeu coopératif
{
  "version": "3.2.1",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "profiles": {
    "cooperative-example": {
      "ticket_expiration_period": "3m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m",
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 1,
              "min_team_size": 4,
              "max_team_size": 4
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 125,
              "max_latency": 150
            }
          },
          "selected_difficulty": {
            "type": "string_equality"
          },
          "selected_map": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          },
          "player_level": {
            "type": "number_difference",
            "attributes": {
              "max_difference": 10
            }
          },
          "backfill_group_size": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          },
          "moderation_flags": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {
          "30": {
            "beacons": {
              "difference": 125,
              "max_latency": 250
            },
            "player_level": {
              "max_difference": 20
            }
          },
          "60": {
            "match_size": {
              "team_count": 1,
              "taille_min_equipe": 2,
              "max_team_size": 4
            }
          },
          "150": {
            "match_size": {
              "team_count": 1,
              "min_team_size": 1,
              "max_team_size": 4
            }
          }
        }
      }
    }
  }
}

Avec un nombre d'équipes de 1 et une taille maximale d'équipe de 4, exiger jusqu'à 4 joueurs par match.

Définir plusieurs Profils (Files d'attente) pour les règles et paramètres spécifiques aux modes de jeu :

  • commencer avec un minimum de 4 joueurs pour garder des joueurs en file d'attente et maximiser le taux de remplissage des matchs,

  • restreindre latence de matchmaking pour éviter d'apparier des joueurs éloignés,

  • laisser les joueurs choisir une difficulté de jeu particulière pour convenir au niveau de compétence de chacun,

  • laisser les joueurs indiquer leurs préférences de carte pour trouver une carte adaptée à tous,

  • restreindre la différence de niveau des joueurs pour exiger un degré de progression de jeu similaire,

  • spécifier la taille du groupe de backfill pour remplacer les partants sans dépasser la capacité du serveur,

  • utiliser des indicateurs de modération pour séparer les joueurs à faible karma et les tricheurs de la population générale,

  • Analyse approfondie pour les parties préfabriquées et pour remplir les équipes sans dépasser la capacité du serveur,

  • allouer plus de CPU ou de mémoire en utilisant différents Applications et versions pour d'autres profils.

Commencez avec les conditions idéales, et élargir les restrictions pour garantir des matchs rapides :

  • assouplir les restrictions de latence au fil du temps pour trouver plus de joueurs,

  • augmenter la différence de niveau autorisée pour trouver plus de joueurs,

  • diminuer la taille minimale des équipes pour exiger moins de joueurs et démarrer la partie plus tôt,

    • le serveur peut remplir les emplacements vides avec des coéquipiers IA,

    • ou Analyse approfondie pour ajouter des joueurs plus tard,

  • fixer la taille minimale de l'équipe à 1 pour lancer le jeu en solo après 150s de temps d'attente en file

🎈 Jeux sociaux

Les jeux sociaux se concentrent sur la création de connexions et de relations entre les joueurs grâce à la collaboration, la communication et l'expérience partagée. Supportez un grand nombre de joueurs, maximisez le taux de remplissage des matchs et alignez les préférences des joueurs et leurs habitudes de jeu. Remplacez les joueurs qui partent, et assurez une grande Balises de ping pour offrir une expérience joueur réactive.

🎈 Exemple de jeu social
{
  "version": "3.2.1",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "profiles": {
    "social-example": {
      "ticket_expiration_period": "3m",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m",
      "application": {
        "name": "my-game-server",
        "version": "2024.01.30-16.23.00-UTC"
      },
      "rules": {
        "initial": {
          "match_size": {
            "attributes": {
              "team_count": 1,
              "min_team_size": 50,
              "max_team_size": 50
            },
            "type": "player_count"
          },
          "beacons": {
            "attributes": {
              "difference": 125,
              "max_latency": 150
            },
            "type": "latencies"
          },
          "selected_mode": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          },
          "backfill_group_size": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          },
          "moderation_flags": {
            "type": "intersection",
            "attributes": {
              "overlap": 1
            }
          }
        },
        "expansions": {
          "15": {
            "beacons": {
              "difference": 125,
              "max_latency": 250
            },
            "match_size": {
              "team_count": 1,
              "min_team_size": 20,
              "max_team_size": 50
            }
          },
          "30": {
            "match_size": {
              "team_count": 1,
              "min_team_size": 10,
              "max_team_size": 50
            }
          },
          "150": {
            "match_size": {
              "team_count": 1,
              "min_team_size": 1,
              "max_team_size": 50
            }
          }
        }
      }
    }
  }
}

Avec un nombre d'équipes de 1 (free for all) et une taille maximale d'équipe de 50, exiger jusqu'à 50 joueurs par match.

Définir Profils (Files d'attente) pour les règles et paramètres spécifiques aux modes de jeu :

  • restreindre latence de matchmaking pour éviter d'apparier des joueurs éloignés,

  • laisser les joueurs indiquer leurs préférences de mode de jeu et trouver un mode adapté à tous,

  • spécifier la taille du groupe de backfill pour remplacer les partants sans dépasser la capacité du serveur,

  • utiliser des indicateurs de modération pour séparer les joueurs à faible karma et les tricheurs de la population générale,

  • Analyse approfondie pour les lobbies préfabriqués ou pour remplir les équipes sans dépasser la capacité du serveur,

  • allouer plus de CPU ou de mémoire en utilisant différents Applications et versions pour d'autres profils.

Commencez avec les conditions idéales, et élargir les restrictions pour garantir des matchs rapides :

  • assouplir les restrictions de latence au fil du temps pour trouver plus de joueurs,

  • diminuer lentement la taille d'équipe minimale pour exiger moins de joueurs et démarrer la partie plus tôt,

    • le serveur peut remplir les emplacements vides avec des joueurs IA,

    • ou Analyse approfondie pour ajouter des joueurs plus tard,

  • fixer la taille minimale de l'équipe à 1 pour lancer le jeu en solo après 150s de temps d'attente en file

PrécédentBalises de pingSuivantAnalyse approfondie

Mis à jour

Ce contenu vous a-t-il été utile ?