1. Epic GamesDeveloper
  3. Suivre les joueurs à l'aide de mappages

Suivre les joueurs à l'aide de mappages

Utilisez Verse pour créer un mode de jeu compétitif multijoueur qui fait avancer les équipes grâce à une série d'armes.

Suivre les joueurs à l'aide de mappages
Prerequisite topics

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

Vous allez utiliser une carte pour effectuer un suivi du nombre d'éliminations d'un joueur. Les cartes permettent d'associer des clés à des valeurs. Dans ce tutoriel, vous utiliserez le joueur comme clé et son niveau d'armement (représenté par un nombre entier, int) comme valeur. De cette façon, vous pouvez obtenir le niveau actuel d'un joueur à partir d'une simple référence au joueur. Vous trouverez ci-dessous un exemple de carte des associations de niveaux entre joueurs et armes.

Clé joueur 1 joueur 2 joueur 3
Valeur 1 2 2
Arme dans le jeu Pistolet de combat de niveau 1 Pistolet Flint-Knock de niveau 1 Pistolet Flint-Knock de niveau 1

Procédez comme suit pour configurer et remplir votre carte de joueurs :

  1. Ajoutez le mappage [player]int nommé PlayerMap à la classe team_elimination_game. Il stocke une référence à chaque joueur et son niveau d'arme.

     team_elimination_game := class(creative_device):
     var PlayerMap : [player]int = map{}

  2. Ajoutez une méthode PopulateTeamsAndPlayers() à la classe team_elimination_game. Cette méthode remplit votre mappage PlayerMap et sera appelée à partir d'OnBegin().

     PopulateTeamsAndPlayers() : void=
 Print("Beginning to populate players")

  3. Ajoutez une nouvelle méthode, OnPlayerEliminated, à la classe team_elimination_game. Cette méthode est appelée chaque fois qu'un joueur est éliminé. Elle détermine qui est le joueur qui l'a éliminé en accédant à la struct. elimination_result transmise en tant qu'argument.

     OnPlayerEliminated(Result : elimination_result) : void=
     Print("A Player was eliminated!")

  4. Lorsque le jeu commence, vous devez parcourir la liste des joueurs et leur attribuer à tous le premier niveau d'armement. Dans PopulateTeamsAndPlayers, obtenez la liste des joueurs en utilisant GetPlaySpace().GetPlayers() et enregistrez-la dans une matrice AllPlayers. Pour chaque joueur, récupérez le personnage FortCharacter de ce joueur et enregistrez-le dans une variable FortCharacter. Définissez le score de ce joueur dans la carte PlayerMap sur 0 pour représenter la première arme dans la matrice WeaponGranters, puis abonnez FortCharacter.EliminatedEvent() à OnPlayerEliminated.

     AllPlayers := GetPlayspace().GetPlayers()
 for (Agent : AllPlayers, TeamPlayer := player[Agent], FortCharacter := TeamPlayer.GetFortCharacter[]):
     if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]):
         Print("Assigned Player to PlayerMap with Tier {WeaponTier}")
         FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)

  5. Après avoir défini la référence au score du joueur dans la carte PlayerMap, vous pouvez accorder aux joueurs leur première arme. Modifiez OnPlayerSpawn pour accorder aux joueurs leur première arme. Lorsqu'un joueur apparaît, récupérez son niveau d’armement dans PlayerMap et enregistrez-le dans la variable WeaponTier, puis appelez GrantWeapon en transmettant WeaponTier et une référence au joueur.

     OnPlayerSpawn(InPlayer : agent) : void =
     Print("A player just spawned!")
         if(WeaponTier := PlayerMap[InPlayer]):
             GrantWeapon(option{InPlayer}, WeaponTier)
             Print("Spawned Player was granted a gun of tier {WeaponTier}")

  6. Enregistrez le script dans Visual Studio Code, compilez-le et cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester votre niveau. Lorsque vous testez votre niveau, vous devez apparaître avec la première arme de la matrice WeaponGranters. Vérifiez ce comportement à l'aide du journal.

Affecter un joueur à la carte de joueurs

Cartographier les équipes de joueurs

Une fois la carte des joueurs établie, réfléchissez à la manière de vérifier le score d'un joueur. Puisque votre script va automatiquement promouvoir le joueur de l'équipe qui a le moins d'éliminations, il est inutile de vérifier le niveau d'armement des joueurs de l'équipe adverse. Ici, un problème se pose : PlayerMap ne fait pas de différence entre les équipes.

Pour contourner ce problème, vous pouvez utiliser une autre carte. Pour cela, vous allez adapter la carte PlayerMap que vous avez créée précédemment en un système de cartes imbriquées. Étant donné que les paires clé-valeur d'une carte peuvent être des paires de types quelconques, il est logique qu'une clé "team" puisse avoir une autre carte comme valeur. La première carte associe les équipes (clé) à une autre carte de joueurs de cette équipe (valeur). La carte intérieure associe les joueurs (clé) à leur score (valeur).

Vous pouvez désormais vérifier dans quelle équipe se trouve un joueur spécifique en utilisant GetTeam(). De là, vous pouvez récupérer une liste de coéquipiers pour comparer le nombre d'éliminations.

La syntaxe de la carte imbriquée [team][player]int n'est peut-être pas tout à fait claire. Pour vous aider à mieux la comprendre, vous pouvez utiliser l’alias de type afin de créer un nom plus simple pour référencer la carte. Dans ce tutoriel, vous allez donner à [player]int l'alias player_map. Autrement dit, vous pouvez utiliser le nom player_map chaque fois que vous avez besoin de [player]int, et pouvez réécrire la carte imbriquée en tant que [team]player_map, ou toute autre carte qui associe des équipes à des cartes de joueurs.

Procédez comme suit pour adapter votre carte à un système de cartes imbriquées :

  1. Au-dessus de la définition de classe team_elimination_game, ajoutez un alias pour [player]int nommé player_map.

     player_map := [player]int # This is a type alias!
 team_elimination_game := class(creative_device):

  2. Remplacez la variable PlayerMap précédemment configurée dans team_elimination_game par une nouvelle variable TeamMap de type [team]player_map.

     # Carte des cartes d’équipes, où la clé est l'équipe et la valeur est une carte de
 # joueurs->paires clés/valeurs int
 var TeamMap : [team]player_map = map{}

  3. La valeur de TeamMap étant de type player_map, pour chaque équipe, vous devez initialiser un mappage de joueurs, le remplir, définir le score de chaque joueur sur 0, puis attribuer le mappage de joueurs à TeamMap. Mettez PopulateTeamsAndPlayers() à jour des modifications de code.

    • Pour chaque équipe, récupérez les joueurs de cette équipe et enregistrez-les dans une variable TeamPlayers. Initialisez une nouvelle variable PlayerMap de type player_map pour associer les joueurs à leur score.
     PopulateTeamsAndPlayers() : void=
     Print("Beginning to populate players")
     for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
    • Pour chaque joueur dans TeamPlayers, récupérez le personnage FortCharacter de ce joueur et enregistrez-le dans une variable FortCharacter. Définissez le score de ce joueur dans la carte PlayerMap sur 0 pour représenter la première arme dans la matrice WeaponGranters, puis abonnez FortCharacter.EliminatedEvent() à OnPlayerEliminated.
     PopulateTeamsAndPlayers() : void =
     Print("Beginning to populate players")
     for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
         for (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): 
             if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): 
                 Print("Assigned Player to PlayerMap with Tier {WeaponTier}")
             FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)
    • Enfin, définissez PlayerMap comme valeur de la clé Team actuelle dans TeamMap. Votre code PopulateTeamsAndPlayers doit être similaire à celui-ci.
     PopulateTeamsAndPlayers() : void =
     Print("Beginning to populate players")
     for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
         for (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): 
             if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): 
                 Print("Assigned Player to PlayerMap with Tier {WeaponTier}")
             FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) 
         if(set TeamMap[Team] = PlayerMap):
             Print("Successfully set this team in the TeamMap")

  4. Une fois le mappage TeamMap défini, mettez à jour OnPlayerSpawn pour accéder à l'équipe d'un joueur en utilisant GetTeam[] et en le stockant dans une variable locale PlayerTeam. Définissez WeaponTier en récupérant le score actuel du joueur dans TeamMap, en utilisant à la fois PlayerTeam et une référence au joueur. L'OnPlayerSpawn() à jour doit ressembler au code suivant.

     OnPlayerSpawn(InPlayer : agent) : void =
      Print("A player just spawned!")
     if:
         PlayerTeam := GetPlayspace().GetTeamCollection().GetTeam[InPlayer]
         WeaponTier:int := TeamMap[PlayerTeam][InPlayer]
     then:
         GrantWeapon(option{InPlayer}, WeaponTier)
         Print("Spawned Player was granted a gun of tier {WeaponTier}")

Enregistrez le script dans Visual Studio Code, compilez-le et cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester votre niveau. Lorsque vous testez votre niveau, vous devez à nouveau apparaître avec la première arme de la matrice WeaponGranters. Vérifiez ce comportement à l'aide du journal.

Affecter un joueur à une carte d'équipe

Étape suivante

Dans l'étape suivante de ce tutoriel, vous apprendrez à accorder des armes aux joueurs chaque fois qu’ils parviennent à éliminer une cible.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page