Dans les jeux multijoueur, des équipes de joueurs s'affrontent ou collaborent pour atteindre un objectif. Le nombre de joueurs dans chaque équipe peut avoir une incidence considérable sur le jeu, et de nombreux développeurs choisissent le nombre de joueurs dans chaque équipe pour créer des expériences agréables.
L'équilibrage des équipes répartit les joueurs en équipes selon une proportion déterminée. La plupart des jeux multijoueur équilibrent les équipes de manière à ce qu'aucune d'entre elles ne soit avantagée. Certains jeux créent intentionnellement des déséquilibres, par exemple en opposant quatre joueurs à un joueur surpuissant. Quelle que soit la configuration choisie, l'équilibre des équipes est essentiel pour créer des expériences intéressantes dans les jeux multijoueur.
Dans ce guide, vous apprendrez à équilibrer dynamiquement les équipes de joueurs à l’exécution du jeu et chaque fois qu'un nouveau joueur rejoint la partie. Le script complet est fourni à la fin de ce guide pour référence.
Fonctionnalités du langage Verse utilisées
matrice : Cet appareil utilise des matrices pour stocker une référence à chaque équipe.
option: Cet appareil utilise des options pour déterminer s'il existe une équipe avec moins de joueurs que celle dans laquelle un joueur se trouve actuellement.
for: Avec l'expression for, vous pouvez parcourir les matrices utilisées par l’appareil.
if: L’expression if est utilisée pour vérifier si les joueurs doivent changer d'équipe en fonction de la taille des équipes.
échec: Les contextes d'échec permettent d’accéder aux matrices et de contrôler le flux du programme.
API Verse utilisées
Abonnement possible : vous vous abonnerez à
PlayerAddedEvent()pour rééquilibrer dynamiquement les équipes lorsqu'un nouveau joueur rejoint une partie en cours.Équipes : La classe d’équipe ajoute, supprime et récupère des joueurs des équipes. Dans ce tutoriel, vous utiliserez la classe team pour manipuler directement les joueurs et leur affectation à une équipe.
Espace de jeu : l'espace de jeu suit les événements auxquels les joueurs peuvent s'abonner et qui sont liés à l'arrivée et au départ des joueurs. Il permet également de récupérer des listes de joueurs et d'équipes et de trouver l'équipe d'un joueur donné. Dans ce tutoriel, vous vous abonnerez à plusieurs événements de l'espace de jeu, et récupérerez des joueurs et des équipes à l'aide des méthodes de l'espace de jeu afin de pouvoir les manipuler directement.
Configurer le niveau
Dans cet exemple, nous utilisons l'appareil suivant.
4 x appareils Point d'apparition de joueur : Cet appareil définit l'emplacement d'apparition du joueur au début du jeu.
Procédez comme suit pour configurer votre niveau :
Ajoutez un point d'apparition de joueur au niveau.
Sélectionnez le point d’apparition dans l’organiseur pour ouvrir le panneau Détails correspondant.
Dans le panneau Détails, sous Options utilisateur :
Définissez l'équipe de joueurs sur l'index d'équipe avec une valeur de 1
Activez l’option Visible pendant le jeu
Cliquez sur l'image pour l'agrandir.
Dupliquez la plaque d'apparition et placez-la à côté de la première plaque d'apparition.
Dupliquez les deux plaques d'apparition et placez-les à l’écart du premier groupe de plaques d'apparition. C'est là que les joueurs de l'équipe 2 apparaîtront.
Sélectionnez les points d’apparition dupliqués et, dans le panneau Détails sous Options utilisateur, modifiez la valeur de l’index d’équipe sur 2 pour les deux.
Dans l’organiseur, sélectionnez l'appareil Paramètres de l’île pour ouvrir le panneau Détails correspondant. Sous Options utilisateur - Règles du jeu :
Définissez Équipes sur l'index d'équipe avec une valeur de 2. Dans cet exemple, nous utilisons deux équipes, mais vous pouvez sélectionner le nombre d’équipes de votre choix.
Définissez le paramètre Taille d'équipe sur Dynamique. Cela signifie que votre code Verse peut prendre en charge l'équilibrage des équipes.
Définissez le paramètre Rejoindre un jeu en cours en tant que sur Faire apparaître afin que les nouveaux joueurs puissent rejoindre une partie en cours.
Cliquez sur l'image pour l'agrandir.
Créez un nouvel appareil Verse nommé team_multiplayer_balancing à l'aide de l'explorateur Verse, puis faites-le glisser dans le niveau. (Pour apprendre à créer un nouvel appareil dans Verse, consultez la rubrique Créer votre propre appareil à l'aide de Verse.)
Votre niveau doit ressembler à ceci :
Équilibrer les équipes
Équilibrer les équipes au début du jeu
Dans cette étape, nous vous expliquons comment répartir les joueurs en équipes équitables au début d'une partie et lorsqu'un nouveau joueur rejoint la partie.
Ouvrez l’explorateur Verse et double-cliquez sur team_multiplayer_balancing.verse pour ouvrir le script dans Visual Studio Code.
Dans la définition de classe
team_multiplayer_balancing, ajoutez une matrice d’équipesvariablenomméeTeamsqui stockera les références à chaque équipe à laquelle les joueurs appartiennent.Verseteam_multiplayer_balance := class(creative_device): # Holds the teams found with GetTeams() var Teams : []team = array{}Dans la
fonctionOnBegin(), mettez à jour la matriceTeamspour la faire correspondre aux équipes configurées précédemment dans les paramètres de l'île. Appelez la fonctionGetTeams()de l'APIfort_team_collectionpour obtenir toutes les équipes de l'espace de jeu.VerseOnBegin<override>()<suspends>:void= Print("Verse Device Started!") set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()Recherchez tous les joueurs du jeu en appelant la fonction
GetPlayers()et enregistrez-les dans une matrice de joueurs nomméeAllPlayers.VerseOnBegin<override>()<suspends>:void= Print("Verse Device Started!") set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams() AllPlayers := GetPlayspace().GetPlayers()Parcourez la liste des joueurs et créez des équipes avec le même nombre de joueurs. Vous comparerez l'équipe dans laquelle un joueur se trouve actuellement à toute autre équipe et déterminerez si elle est la mieux adaptée à ce joueur. Dans ce cas, vous pouvez utiliser l'équipe à laquelle un joueur est automatiquement assigné au démarrage du jeu en utilisant
GetTeam[](car les joueurs doivent faire partie d’une équipe dans les modes de jeu à plusieurs équipes). Notez queGetTeam[]nécessite un paramètre de type agent, mais comme joueur est une sous-classe d'agent, vous pouvez transmettre un joueur sans conversion de type.VerseAllPlayers := GetPlayspace().GetPlayers() for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]): # Assign Players to a new team if teams are unbalancedDans la mesure où `team` est une classe interne, il n’est possible de l’initialiser et de l’utiliser que comme référence à un objet d’équipe existant.
Vous souhaitez affecter des joueurs à l'équipe qui en a le moins jusqu'à ce que toutes les équipes soient équilibrées. Pour ce faire, vous devez vérifier chaque joueur, puis chaque équipe à l'aide d'une
bouclefor. Vous pourriez utiliser deux boucles for, l'une pour parcourir les joueurs et l'autre pour parcourir les équipes, mais dans cet exemple, vous allez extraire la boucle for de l'équipe dans sa propre méthode. Configurez le joueur pour la boucle for en obtenant une référence à chaque joueur, puis une référence à chaque équipe dans laquelle ils se trouvent dans une constante nomméeCurrentTeam.Créez une nouvelle variable entière
TeamSizeet initialisez-la à0, puis définissez-la sur la taille d'équipe dans laquelle le joueur se trouve actuellement. Dans la mesure oùGetAgents[]est une expression faillible, vous devez inclure cet ensemble dans une instruction if.Versefor (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]): # Assign Players to a new team if teams are unbalanced var TeamSize : int = 0 if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length): Print("Size of this player's starting team is {TeamSize}")Créez une méthode nommée
FindSmallestTeam(). Celle-ci renvoie une équipe facultative (?team) lorsqueTeamSizeest transmis en tant qu’argument, et permet de rechercher et de renvoyer l'équipe comportant le moins de joueurs. Initialisez une nouvelle option d'équipe nomméeSmallestTeamdansFindSmallestTeam(). Nous utilisons une option ici, car il est possible qu’un joueur se trouve déjà dans la plus petite équipe lors de l’appel deFindSmallestTeam().Étant donné que votre option
SmallestTeamest définie par défaut sur false, elle reste définie surfalsesi aucune équipe plus petite n'est trouvée. SiFindSmallestTeam()renvoiefalse, cela indique définitivement que le joueur donné se trouvait déjà dans la plus petite équipe. Vous devez également initialiser une variable intCurrentTeamSizeà la valeur deTeamSize. Il est nécessaire queCurrentTeamSizesoit une variable pour pouvoir la mettre à jour en fonction de la taille de toute autre équipe comportant moins de joueurs.VerseFindSmallestTeam(CurrentTeamSize : int) : ?team= var SmallestTeam : ?team = false var TeamSize : int = CurrentTeamSizeÉtant donné que
TeamSizesuit la taille deSmallestTeam, vous devez la comparer à la taille de chaque équipe. Parcourez chaque équipe et obtenez leur taille dans un entier localCandidateTeamSize. SiCandidateTeamSizeest inférieure àTeamSize, définissezSmallestTeamsur cette équipe etTeamSizesur la taille de cette équipe.La condition
TeamSize > CandidateTeamSizeest une condition de filtre, car elle est vérifiée entre les parenthèses de la boucle for. L'utilisation d'une condition de filtre garantit que le code à l'intérieur de votre boucle ne s'exécute que si la condition de filtre est remplie. Vous vous assurez ainsi queSmallestTeamest définie sur l'équipe comportant le moins de joueurs si une équipe est trouvée. Si aucune équipe avec un nombre inférieur de joueurs n'est trouvée,SmallestTeamreste définie sur false.Enfin, renvoyez
SmallestTeamune fois que toutes les équipes ont été vérifiées.Versefor(Team : Teams, CandidateTeamSize := GetPlayspace().GetTeamCollection().GetAgents[Team].Length, TeamSize > CandidateTeamSize): set SmallestTeam = option{Team} set TeamSize = CandidateTeamSize Print("Found a team with less players: {CandidateTeamSize}") return SmallestTeamDans
OnBegin(), créez une nouvelle option d'équipe nomméeSmallestTeamà l'intérieur de la boucleforet initialisez-la à la valeur deFindSmallestTeam()lorsqueTeamSizeest transmise en tant qu’argument.VerseSmallestTeam : ?team = FindSmallestTeam(TeamSize)Ensuite, essayez d'accéder à la valeur de la variable facultative
SmallestTeam. Si la valeur est définie sur false, le joueur faisait déjà partie de la plus petite équipe et aucune affectation n'est nécessaire. Dans le cas contraire, vous devez affecter le joueur à sa nouvelle équipe. Étant donné que de nombreuses méthodes ne nous permettent pas de transmettre directement une option en tant qu'argument, vous devez extraire la valeur dans une variable localeTeamToAssign. Vous pouvez tenter d’assigner un joueur à cette équipe à l’aide deAddToTeam[player, team]. Notez que cette assignation échoue si l’on essaie d’assigner un joueur à une équipe dont ils font déjà partie. Cela n'a cependant aucune incidence négative, car la boucleforpasse simplement au joueur suivant et laisse le premier dans son équipe d'origine.Verseif (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]): Print("Attempting to assign player to a new team")
OnBegin()doit être similaire au bloc de code ci-dessous.VerseOnBegin<override>()<suspends> : void = Print("Verse Device Started!") set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams() Print("Beginning to Assign Players") Playspace := GetPlayspace() AllPlayers := Playspace.GetPlayers() for (TeamPlayer : AllPlayers, CurrentTeam := Playspace.GetTeamCollection().GetTeam[TeamPlayer]): var TeamSize : int = 0 if(set TeamSize = Playspace.GetTeamCollection().GetAgents[CurrentTeam].Length): Print("Size of this player's starting team is {TeamSize}")
Gérer un joueur rejoignant une partie en cours
Si vous souhaitez également équilibrer automatiquement les équipes lors d'une partie en cours, vous devez vous abonner à l'événement qui se déclenche lorsqu'un nouveau joueur rejoint l'équipe. Comme vous ne souhaitez pas répéter tout le code que vous venez d'écrire, vous pouvez le convertir en méthode commune.
Créez une méthode nommée
BalanceTeams()et déplacez tout le code après avoir défini la variableTeamsà l'aide deGetTeams(). Celle-ci est appelée dans la méthodeOnBegin()afin que les équipes soient équilibrées au début du jeu. La fonctionBalanceTeams()devrait être similaire à ceci.VerseBalanceTeams() : void = AllPlayers := GetPlayspace().GetPlayers() for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]): var TeamSize : int = 0 if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length): Print("Size of this player's starting team is {TeamSize}") SmallestTeam : ?team = FindSmallestTeam(TeamSize) if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]): Print("Attempting to assign player to a new team")Créez une autre méthode nommée
OnPlayerAdded()qui contient un appel àBalanceTeams(). Bien que vous n'utilisiez pas la variableplayer, la définition de la méthode l'exige puisque vous vous abonnez àPlayerAddedEvent()à l'aide de cette méthode. Consultez la page Interactions avec les appareils de codage pour plus de détails sur les événements auxquels il est possible de s'abonner.VerseOnPlayerAdded(InPlayer : player) : void = Print("A new Player joined, assigning them to a team!") BalanceTeams()Dans
OnBegin(), abonnez-vous àPlayerAddedEvent()à l’aide deOnPlayerAdded. Désormais, lorsqu’un joueur rejoint la partie,OnPlayerAddedappelleBalanceTeams()pour équilibrer automatiquement les équipes.VerseOnBegin<override>()<suspends> : void = GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded) Print("Beginning to balance teams") BalanceTeams()Enregistrez le script dans Visual Studio Code et cliquez sur Générer le code Verse pour compiler votre script.
Cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester le niveau.
Lorsque vous testez votre niveau, la taille de chaque équipe, ainsi que toute équipe plus petite trouvée par le script, doivent s’afficher dans le journal de sortie. Les joueurs doivent être répartis de manière équitable entre les équipes, et tout nouveau joueur qui rejoint le jeu doit maintenir cet équilibre.
Script complet
Le code suivant est le script complet d'un appareil qui équilibre automatiquement les équipes de joueurs.
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
team_multiplayer_balance := class(creative_device):
# Holds the teams found with GetTeams()
var Teams : []team = array{}
OnBegin<override>()<suspends> : void =
Print("Verse Device Started!")
À vous de jouer
Au cours de ce tutoriel, vous avez appris à créer un appareil avec Verse qui équilibre automatiquement les équipes de joueurs.
Utilisez vos connaissances pour créer des équipes volontairement déséquilibrées pour les modes de jeu asymétriques, par exemple un jeu à un contre quatre.