1. Epic GamesDeveloper
  3. 3. Équilibrer les équipes de façon asymétrique

3. Équilibrer les équipes de façon asymétrique

Apprenez à équilibrer des équipes de joueurs de manière asymétrique.

3. Équilibrer les équipes de façon asymétrique
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

Comprendre l'algorithme

Il est souhaitable que les équipes soient équilibrées au début du jeu.

Contrairement aux jeux où l'équilibrage des joueurs est symétrique et où les joueurs sont répartis uniformément entre les équipes, l'équilibrage asymétrique des équipes signifie que chaque équipe doit avoir un nombre relatif de joueurs. En d'autres termes, la taille des équipes doit suivre un rapport relatif.

Par exemple, vous pourriez souhaiter qu'une équipe ait toujours deux fois plus de joueurs qu'une autre. Au fur et à mesure que les joueurs rejoignent la partie, vous devez les équilibrer de manière à préserver ce nombre relatif. Dans les modes de jeu où une équipe est plus puissante ou possède des capacités différentes de l'autre équipe, l'équilibrage asymétrique crée des expériences de jeu plus fluides en répartissant soigneusement le nombre de joueurs dans chaque équipe.

Dans cet exemple, vous devez vous assurer que les équipes ayant un nombre maximum de joueurs plus élevé (dans ce cas, les défenseurs) auront toujours plus de joueurs que les équipes ayant un maximum inférieur (comme les infiltrés).

Pour répartir les joueurs correctement, vous devrez placer chaque joueur dans l'équipe présentant la plus grande différence par rapport à son nombre maximum de joueurs.

À cet effet, pour chaque nouveau joueur, vous devez vérifier chaque équipe et stocker une référence au nombre maximal et au nombre actuel de joueurs de cette équipe, ainsi qu'à l'équipe à laquelle affecter ce joueur. Vous pouvez soustraire le nombre actuel de joueurs du maximum afin d'obtenir la différence par rapport au maximum. L'équipe qui présente la plus grande différence par rapport au maximum est logiquement celle à laquelle affecter le joueur.

En itérant sur chaque équipe, vous vous assurez de trouver l'équipe qui présente la plus grande différence.

Définir l'algorithme

Cette étape vous apprendra à équilibrer les équipes de joueurs de façon asymétrique au début du jeu.

  1. Ajoutez une nouvelle méthode appelée BalanceTeams() à la classe triad_infiltration_game. Cette méthode affecte un joueur à l'équipe présentant la plus grande différence par rapport à son nombre maximal de joueurs. 
     # Répartit les joueurs dans l'ensemble des équipes de la partie
 BalanceTeams():void=
     Logger.Print("Beginning to balance teams")
  2. Obtenir tous les joueurs de la partie et les stocker dans une matrice variable AllPlayers. Mélanger ensuite AllPlayers. Cela garantira la répartition aléatoire des joueurs dans les équipes, et non en fonction de l'ordre dans lequel ils ont initialement rejoint le jeu. 
     # Répartit les joueurs dans l'ensemble des équipes de la partie
 BalanceTeams():void=
     Logger.Print("Beginning to balance teams")
     var AllPlayers:[]player := GetPlayspace().GetPlayers()
     set AllPlayers = Shuffle(AllPlayers)
  3. Vous n'avez plus qu'à itérer sur tous les joueurs et les affecter à l'équipe présentant la plus grande différence par rapport à son nombre maximal de joueurs. Pour cela, vous allez utiliser une fonction d'assistance nommée FindTeamWithLargestDifference() que vous créerez à l'étape suivante. Avant cela, initialisez une variable d'option nommée TeamToAssignà laquelle affecter un joueur, puis définissez-la sur la valeur renvoyée par FindTeamWithLargestDifference(). 
     for(TeamPlayer:AllPlayers):
     var TeamToAssign:?team = false
     set TeamToAssign = FindTeamWithLargestDifference()
  4. Créez la fonction FindTeamWithLargestDifference() dans la définition de classe triad_infiltration_game. Cette fonction se chargera de trouver l'équipe présentant la plus grande différence entre le nombre de joueurs et son maximum et renverra éventuellement une teamen option. Afin d'empêcher la réaffectation d'un joueur lorsqu'il se trouve déjà dans l'équipe présentant la plus grande différence, il faut que la team renvoyée soit une option. 
     # Trouve l'équipe ayant la plus grande différence entre son nombre de joueurs actuels et son
 # nombre maximum de joueurs
 FindTeamWithLargestDifference():?team =
     Logger.Print("Attempting to find smallest team")
  5. Initialisez une variable d'équipe optionnelle nommée TeamToAssign qui stockera une référence à l'équipe ayant la plus grande différence de joueurs, ainsi qu'un nombre entier LargestDifferencepour suivre cette différence de joueurs. 
     # Trouve l'équipe ayant la plus grande différence entre son nombre de joueurs actuels et son
 # nombre maximum de joueurs.
 FindTeamWithLargestDifference():?team =
     Logger.Print("Attempting to find smallest team")
     var TeamToAssign:?team = false
     var LargestDifference:int = 0
  6. Maintenant, itérez sur la liste des équipes, en obtenant à la fois la taille actuelle et la taille maximale de cette équipe. 
     var TeamToAssign:?team = false
 var LargestDifference:int = 0
 for:
     CandidateTeam:Teams
     CurrentTeamSize := GetPlayspace().GetTeamCollection().GetAgents[CandidateTeam].Length
     MaximumTeamSize := TeamsAndTotals[CandidateTeam]
  7. Pour chaque équipe, calculez la DifferenceFromMaximum, qui est la différence entre la taille maximale de cette équipe et le nombre de joueurs qu'elle contient actuellement. Si l'équipe présente une différence plus grande que LargestDifference, définissez LargestDifference sur DifferenceFromMaximumet enveloppez TeamToAssign dans une option. 
     for:
     CandidateTeam:Teams
     CurrentTeamSize := GetPlayspace().GetTeamCollection().GetAgents[CandidateTeam].Length
     MaximumTeamSize := TeamsAndTotals[CandidateTeam]
 do:
     Logger.Print("Checking a team...")
     Logger.Print("Maximum size of this team is {MaximumTeamSize}")
     DifferenceFromMaximum := MaximumTeamSize - CurrentTeamSize
     Logger.Print("Difference from maximum is {DifferenceFromMaximum}")
     if(LargestDifference < DifferenceFromMaximum):
         set LargestDifference = DifferenceFromMaximum
         set TeamToAssign = option{CandidateTeam}
         Logger.Print("Found a team under maximum players: {DifferenceFromMaximum}")
  8. Enfin, renvoyez TeamToAssign. Votre code FindTeamWithLargestDifference()doit à présent ressembler à ceci : 
     # Trouve l'équipe ayant la plus grande différence entre son nombre de joueurs actuels et son
 # nombre maximum de joueurs.
 FindTeamWithLargestDifference():?team =
     Logger.Print("Attempting to find smallest team")
     var TeamToAssign:?team = false
     var LargestDifference:int = 0
     for:
         CandidateTeam:Teams
         CurrentTeamSize := GetPlayspace().GetTeamCollection().GetAgents[CandidateTeam].Length
         MaximumTeamSize := TeamsAndTotals[CandidateTeam]
     do:
         Logger.Print("Checking a team...")
         Logger.Print("Maximum size Maximum size of team {CandidateTeamIndex + 1} is {MaximumTeamSize}")
         DifferenceFromMaximum := MaximumTeamSize - CurrentTeamSize
         Logger.Print("Difference from minimum is {DifferenceFromMaximum}")
         if(LargestDifference < DifferenceFromMaximum):
             set LargestDifference = DifferenceFromMaximum
             set TeamToAssign = option{CandidateTeam}
             Logger.Print("Found a team under minimum players: {DifferenceFromMaximum}")
     return TeamToAssign
  9. De retour dans BalanceTeams(), assignez le joueur à une nouvelle équipe par l'intermédiaire de la fonction FortTeamCollection.AddToTeam[]. Si cette assignation échoue, c'est que le joueur était déjà dans la plus petite équipe. 
     var TeamToAssign:?team = false
 set TeamToAssign = FindTeamWithLargestDifference()
 if (AssignedTeam := TeamToAssign?, FortTeamCollection.AddToTeam[TeamPlayer, AssignedTeam]):
     Logger.Print("Attempting to assign player to a new team")
  10. Votre fonction BalanceTeams() doit ressembler à ce qui suit : 
     # Répartit les joueurs dans l'ensemble des équipes de la partie
 BalanceTeams():void=
     Logger.Print("Beginning to balance teams")
     var AllPlayers:[]player := GetPlayspace().GetPlayers()
     set AllPlayers = Shuffle(AllPlayers)
     Logger.Print("AllPlayers Length is {AllPlayers.Length}")
        
     for(TeamPlayer:AllPlayers):
         var TeamToAssign:?team = false
         set TeamToAssign = FindTeamWithLargestDifference()
         if (AssignedTeam := TeamToAssign?, FortTeamCollection.AddToTeam[TeamPlayer, AssignedTeam]):
             Logger.Print("Assigned player to a new team")

Téléporter les joueurs dans leurs zones d'apparition

Même si les joueurs se retrouvent dans l'équipe ayant la plus grande différence, il est possible qu'ils n'apparaissent pas dans la zone correcte. Cela s'explique par le fait que les joueurs apparaissent avant d'être équilibrés dans une nouvelle équipe. Pour corriger ce problème, vous allez créer une nouvelle fonction pour téléporter les joueurs dans leur zone d'apparition après l'équilibrage des équipes.

  1. Créez la fonction TeleportPlayersToStartLocations() dans la définition de la classe triad_infiltration_game. Cette fonction téléporte les joueurs dans la zone d'apparition de leur équipe une fois l'équilibrage terminé. 
     # Téléporte les joueurs au point d'apparition de leur équipe une fois l'équilibrage des équipes terminé.
 TeleportPlayersToStartLocations():void=
     Logger.Print("Teleporting players to start locations")
  2. Dans une boucle for, itérez à travers chaque matrice Teams, obtenez l'indice de cette équipe et stockez-le dans une variable appelée TeamIndex. 
     # Téléporte les joueurs au point d'apparition de leur équipe une fois l'équilibrage des équipes terminé.
 TeleportPlayersToStartLocations():void=
     Logger.Print("Teleporting players to start locations")
     for:
         TeamIndex -> PlayerTeam:Teams
  3. Obtenez les joueurs de l'équipe PlayerTeam en appelant GetAgents[] avec PlayerTeam. Obtenez ensuite le téléporteur associé à cette équipe en indexant la matrice Teleporters à l'aide de TeamIndex et en la stockant dans une variable TeamTeleporter. Stockez la transformation de ce téléporteur dans une variable Transform. 
     # Téléporte les joueurs au point d'apparition de leur équipe une fois l'équilibrage des équipes terminé.
 TeleportPlayersToStartLocations():void=
     Logger.Print("Teleporting players to start locations")
     for:
         TeamIndex -> PlayerTeam:Teams 
         TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[PlayerTeam]
         TeamTeleporter := Teleporters[TeamIndex]
         Transform := TeamTeleporter.GetTransform()

    Assurez-vous que l'ordre de vos équipes dans Teams correspond à l'ordre de vos téléporteurs dans Teleporters. Si les infiltrés sont l'équipe 1, le premier téléporteur dans Teleporters doit être destiné aux infiltrés. Vérifiez à nouveau dans l'éditeur que ces valeurs sont correctes.
  4. Maintenant, dans une seconde boucle for, itérez chaque joueur de TeamPlayers et faites-le réapparaître à la transformation du téléporteur en utilisant Respawn() ainsi que la translation et la rotation de Transform. Votre fonction TeleportPlayersToStartLocations() doit être similaire à celle-ci : 
     # Téléporte les joueurs au point d'apparition de leur équipe une fois l'équilibrage des équipes terminé.
 TeleportPlayersToStartLocations():void=
     Logger.Print("Teleporting players to start locations")
     for:
         TeamIndex -> PlayerTeam:Teams 
         TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[PlayerTeam]
         TeamTeleporter := Teleporters[TeamIndex]
         Transform := TeamTeleporter.GetTransform()
     do:
         for(TeamPlayer:TeamPlayers):
             TeamPlayer.Respawn(Transform.Translation, Transform.Rotation)
             Logger.Print("Teleported this player to their start location")
  5. Dans OnBegin(), ajoutez un appel à BalanceTeams() après avoir mélangé AllPlayers. Cela garantira l'équilibrage des joueurs dans un ordre aléatoire plutôt qu'une répartition dans la même équipe à chaque fois. Téléportez ensuite les joueurs à leur emplacement de départ en appelant TeleportPlayersToStartLocations(). 
     OnBegin<override>()<suspends> : void =
     # Obtenir toutes les équipes
     set Teams = GetPlayspace().GetTeamCollection().GetTeams()
     # Enregistrez les équipes pour y faire référence ultérieurement.
     set MaybeInfiltrators = option{Teams[0]}
     set MaybeAttackers = option{Teams[1]}
     set MaybeDefenders = option{Teams[2]}
        
     if:
         Infiltrators := MaybeInfiltrators?
         Attackers := MaybeAttackers?
         Defenders :=  MaybeDefenders?
         Logger.Print("Found all three teams")
         set TeamsAndTotals[Infiltrators] = MaximumInfiltrators
         set TeamsAndTotals[Attackers] = MaximumAttackers
         set TeamsAndTotals[Defenders] = MaximumDefenders
         Logger.Print("Set all three teams in TeamsAndTotals")
     then:
         BalanceTeams()
         TeleportPlayersToStartLocations()
     else:
         Logger.Print("Couldn't find all teams, make sure to assign the correct teams in your island settings.")

  6. Enregistrez le script, compilez-le, puis cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester le niveau. Lorsque vous testez votre niveau, chaque joueur doit rejoindre l'équipe présentant la plus grande différence et apparaître dans la zone d'apparition de cette équipe. Vérifiez ce comportement en utilisant le journal. Vous pouvez ajuster le nombre maximum de joueurs par équipe dans votre jeu triad_infiltration_game afin de tester cette fonctionnalité lorsque vous disposez d'un nombre de joueurs inférieur au nombre maximum. Par exemple, lorsque vous testez seul, essayez de définir le nombre maximum de joueurs de l'équipe que vous tentez de rejoindre sur une valeur plus élevée que les deux autres équipes. Si vous souhaitez rejoindre les attaquants, augmentez la valeur de MaximumAttackers. Si vous souhaitez rejoindre les infiltrés, augmentez la valeur de MaximumInfiltrators.

    Équilibrer les équipes de manière asymétrique

Étape suivante

À l'étape suivante de ce tutoriel, vous allez apprendre à attribuer des armes aux joueurs au début de la partie et lors de leurs apparitions.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page