Équilibrer les équipes multijoueur

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 :

1. Ajoutez un point d'apparition de joueur au niveau.

2. Sélectionnez le point d’apparition dans l’organiseur pour ouvrir le panneau Détails correspondant.

3. 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.

4. Dupliquez la plaque d'apparition et placez-la à côté de la première plaque d'apparition.

5. 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.

6. 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.

7. 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.

8. 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.

1. Ouvrez l’explorateur Verse et double-cliquez sur team_multiplayer_balancing.verse pour ouvrir le script dans Visual Studio Code.

2. Dans la définition de classe team_multiplayer_balancing, ajoutez une matrice d’équipes variable nommée Teams qui stockera les références à chaque équipe à laquelle les joueurs appartiennent.

   Verse

        team_multiplayer_balance := class(creative_device):
            # Holds the teams found with GetTeams() 
            var Teams : []team = array{}
   

   Copy full snippet(3 lines long)

3. Dans la fonction OnBegin(), mettez à jour la matrice Teams pour la faire correspondre aux équipes configurées précédemment dans les paramètres de l'île. Appelez la fonction GetTeams() de l'API fort_team_collection pour obtenir toutes les équipes de l'espace de jeu.

   Verse

        OnBegin<override>()<suspends>:void=
            Print("Verse Device Started!")
            set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()

   Copy full snippet(3 lines long)

4. Recherchez tous les joueurs du jeu en appelant la fonction GetPlayers() et enregistrez-les dans une matrice de joueurs nommée AllPlayers.

   Verse

        OnBegin<override>()<suspends>:void=
            Print("Verse Device Started!")
            set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()
            AllPlayers := GetPlayspace().GetPlayers()

   Copy full snippet(4 lines long)

5. 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 que GetTeam[] 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.

   Verse

        AllPlayers := GetPlayspace().GetPlayers()
        for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
            # Assign Players to a new team if teams are unbalanced
   

   Copy full snippet(3 lines long)

   Dans 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.

6. 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 boucle for. 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ée CurrentTeam.

   • Créez une nouvelle variable entière TeamSize et 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.

     Verse

       for (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}")
     

     Copy full snippet(5 lines long)

   • Créez une méthode nommée FindSmallestTeam(). Celle-ci renvoie une équipe facultative (?team) lorsque TeamSize est 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ée SmallestTeam dans FindSmallestTeam(). 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 de FindSmallestTeam().

   • Étant donné que votre option SmallestTeam est définie par défaut sur false, elle reste définie sur false si aucune équipe plus petite n'est trouvée. Si FindSmallestTeam() renvoie false, cela indique définitivement que le joueur donné se trouvait déjà dans la plus petite équipe. Vous devez également initialiser une variable int CurrentTeamSize à la valeur de TeamSize. Il est nécessaire que CurrentTeamSize soit une variable pour pouvoir la mettre à jour en fonction de la taille de toute autre équipe comportant moins de joueurs.

     Verse

                               FindSmallestTeam(CurrentTeamSize : int) : ?team=
                                   var SmallestTeam : ?team = false     
                                   var TeamSize : int = CurrentTeamSize
     

     Copy full snippet(3 lines long)

   • Étant donné que TeamSize suit la taille de SmallestTeam, vous devez la comparer à la taille de chaque équipe. Parcourez chaque équipe et obtenez leur taille dans un entier local CandidateTeamSize. Si CandidateTeamSize est inférieure à TeamSize, définissez SmallestTeam sur cette équipe et TeamSize sur la taille de cette équipe.

     La condition TeamSize > CandidateTeamSize est 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 que SmallestTeam est 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, SmallestTeam reste définie sur false.

     Enfin, renvoyez SmallestTeam une fois que toutes les équipes ont été vérifiées.

     Verse

      for(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 SmallestTeam
     

     Copy full snippet(5 lines long)

   • Dans OnBegin(), créez une nouvelle option d'équipe nommée SmallestTeam à l'intérieur de la boucle for et initialisez-la à la valeur de FindSmallestTeam() lorsque TeamSize est transmise en tant qu’argument.

     Verse

       SmallestTeam : ?team = FindSmallestTeam(TeamSize)
     

     Copy full snippet(1 line long)

   • 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 locale TeamToAssign. Vous pouvez tenter d’assigner un joueur à cette équipe à l’aide de AddToTeam[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 boucle for passe simplement au joueur suivant et laisse le premier dans son équipe d'origine.

     Verse

       if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
           Print("Attempting to assign player to a new team")
     

     Copy full snippet(2 lines long)

7. OnBegin() doit être similaire au bloc de code ci-dessous.

   Verse

        OnBegin<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}")
   
   Expand code Copy full snippet(13 lines long)

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.

1. Créez une méthode nommée BalanceTeams() et déplacez tout le code après avoir défini la variable Teams à l'aide de GetTeams(). Celle-ci est appelée dans la méthode OnBegin() afin que les équipes soient équilibrées au début du jeu. La fonction BalanceTeams() devrait être similaire à ceci.

   Verse

        BalanceTeams() : 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")
   

   Copy full snippet(9 lines long)

2. Créez une autre méthode nommée OnPlayerAdded() qui contient un appel à BalanceTeams(). Bien que vous n'utilisiez pas la variable player, 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.

   Verse

                                OnPlayerAdded(InPlayer : player) : void =
                                Print("A new Player joined, assigning them to a team!")
                                BalanceTeams()      
   

   Copy full snippet(3 lines long)

3. Dans OnBegin(), abonnez-vous à PlayerAddedEvent() à l’aide de OnPlayerAdded. Désormais, lorsqu’un joueur rejoint la partie, OnPlayerAdded appelle BalanceTeams() pour équilibrer automatiquement les équipes.

   Verse

        OnBegin<override>()<suspends> : void =
                GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
                Print("Beginning to balance teams")
                BalanceTeams()

   Copy full snippet(4 lines long)

4. Enregistrez le script dans Visual Studio Code et cliquez sur Générer le code Verse pour compiler votre script.

5. 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.