5. Gérer les boucles et les manches de jeu

Utilisez le code Verse de cette section pour ajouter un système de gestion des boucles et des manches de jeu.

5. Gérer les boucles et les manches de jeu

Constitution des équipes

Dans cette section, vous apprendrez à configurer les équipes des chasseurs et des accessoires au début du jeu et à les téléporter dans leurs zones de départ.

Ce tutoriel comprend des extraits de code Verse qui vous expliquent comment exécuter les mécaniques de jeu nécessaires dans ce jeu. Suivez les étapes ci-dessous et copiez le script complet à l'étape 6 de ce tutoriel.

Procédez comme suit pour configurer correctement vos équipes :

  1. Créez une nouvelle fonction SetupTeams(). Vous y configurerez plusieurs abonnements à des fonctions que vous définirez ultérieurement, par exemple des fonctions relatives à l'élimination des accessoires ou à la marche à suivre lorsqu'un joueur rejoint le jeu.

     # Au début d'une manche, s'abonner aux appareils de l'équipe, choisir au hasard les agents de chasseur, activer le chronomètre des chasseurs, définir les agents d'accessoire et les téléporter dans la zone de jeu.
 SetUpTeams()<suspends>:void =
     Logger.Print("Setting up teams.")

  2. Commencez par vous abonner au SuccessEvent du chronomètre de score et à l'événement d'élimination du gestionnaire de l'équipe des accessoires, puis définissez le score attribué par le gestionnaire de score.

     # Au début d'une manche, s'abonner aux appareils de l'équipe, choisir au hasard les agents de chasseur, activer le chronomètre des chasseurs, définir les agents d'accessoire et les téléporter dans la zone de jeu.
 SetUpTeams()<suspends>:void =
     Logger.Print("Setting up teams.")

     # S'abonner au chronomètre de score de l'équipe des accessoires, définir la récompense de score et s'abonner à l'événement d'élimination de l'équipe des accessoires.
     PropTeam.ScoreTimer.SuccessEvent.Subscribe(PropTeam.OnPropsScore)
     PropTeam.ScoreManager.SetScoreAward(PropTeam.ScorePerSecond)
     PropTeam.TeamManager.TeamMemberEliminatedEvent.Subscribe(OnPropEliminated) # Se produit à l'élimination d'un agent d'accessoire.

  3. Ensuite, faites de même pour l'équipe des chasseurs. Définissez ensuite le chronomètre d'attente de l'équipe des chasseurs sur le délai d'apparition des chasseurs.

     # Au début d'une manche, s'abonner aux appareils de l'équipe, choisir au hasard les agents de chasseur, activer le chronomètre des chasseurs, définir les agents d'accessoire et les téléporter dans la zone de jeu.
 SetUpTeams()<suspends>:void =
     Logger.Print("Setting up teams.")

     # S'abonner au chronomètre de score de l'équipe des accessoires, définir la récompense de score et s'abonner à l'événement d'élimination de l'équipe des accessoires.
     PropTeam.ScoreTimer.SuccessEvent.Subscribe(PropTeam.OnPropsScore)
     PropTeam.ScoreManager.SetScoreAward(PropTeam.ScorePerSecond)
     PropTeam.TeamManager.TeamMemberEliminatedEvent.Subscribe(OnPropEliminated) # Se produit à l'élimination d'un agent d'accessoire.

     # S'abonner au chronomètre d'attente de l'équipe des chasseurs et définir la durée. S'abonner également à l'événement d'élimination de l'équipe des chasseurs.
     HunterTeam.WaitTimer.SuccessEvent.Subscribe(HuntersGo)
     HunterTeam.WaitTimer.SetMaxDuration(HunterTeam.SpawnDelay)
     HunterTeam.TeamManager.EnemyEliminatedEvent.Subscribe(OnHunterEliminated) # Se produit lorsqu'un agent de chasseur élimine un agent d'accessoire.

  4. Toujours dans SetupTeams(), initialisez les matrices des agents de chasseur et d'accessoire de départ, puis activez l'ATH d'attente tout en vous assurant du nombre suffisant de joueurs pour commencer le jeu. Le cas échéant, désactivez l'ATH d'attente.

     # Initialiser les matrices des agents de chasseur et d'accessoire de départ. Obtenir les joueurs et trouver le nombre de joueurs dans le serveur.
 var StartingHunterAgents:[]agent = array{}
 var StartingPropAgents:[]agent = array{}
 var Players:[]player = GetPlayspace().GetPlayers()

 # Activer l'ATH approprié à l'attente des joueurs.
 HUDControllerWaiting.Enable()

 # Vérifier qu'assez de joueurs sont présents pour lancer la manche.
 set Players = WaitingForMorePlayers.WaitForMinimumNumberOfPlayers(Players)
 Logger.Print("Round started.")

 # Désactiver l'ATH d'attente pour utiliser l'ATH de priorité supérieure suivant.
 HUDControllerWaiting.Disable()

  5. Maintenant que la manche a commencé, vous devez gérer ce qui se produit lorsqu'un joueur rejoint la partie ou en est éliminé. Vous configurerez les abonnements ici et définirez ces fonctions ultérieurement.

     # Maintenant que la manche a commencé, il convient de gérer les joueurs ajoutés ou retirés du jeu. S'abonner à ces événements.
 GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
 GetPlayspace().PlayerRemovedEvent().Subscribe(OnPlayerRemoved)

  6. Le nombre de chasseurs de départ dépend du nombre de joueurs dans votre partie. Il est préférable qu'un chasseur ne doive pas faire face à dix accessoires, c'est pourquoi vous créerez une fonction qui définit le nombre de chasseurs selon une formule. Convertissez le nombre de joueurs en float à utiliser dans la formule.

     # Calculer le nombre d'agents de chasseur de départ en fonction du nombre de joueurs et du nombre d'agents de chasseur par nombre de joueurs.
 NumberOfPlayers:float = 1.0 * Players.Length # Convertit Players.Length en float afin de l'utiliser dans la fonction Ceil suivante.

  7. Définissez maintenant le nombre de chasseurs de départ sur le plafond de la formule suivante. Mélangez ensuite la matrice des joueurs, car il est préférable que les chasseurs de départ soient sélectionnés aléatoirement dans la liste des joueurs.

     # Calculer le nombre d'agents de chasseur de départ en fonction du nombre de joueurs et du nombre d'agents de chasseur par nombre de joueurs.
 NumberOfPlayers:float = 1.0 * Players.Length # Convertit Players.Length en float afin de l'utiliser dans la fonction Ceil suivante.

 if (NumberOfStartingHunters:int = Ceil[NumberOfPlayers / Max(1.1, HunterTeam.HunterAgentPerNumberOfPlayers)]):
     # Mélanger les joueurs, puis diviser la matrice pour obtenir les agents de chasseur de départ. Les joueurs restants sont les agents d'accessoires de départ. 
     var RandomizedPlayers:[]agent = Shuffle(Players)

  8. Divisez la matrice aléatoire sur une taille comprise entre 0 et votre nombre de chasseurs de départ. Dans la mesure où il s'agit de l'équipe de départ des chasseurs, définissez-la sur StartingHunterAgents. Les autres joueurs formeront l'équipe de départ des accessoires et doivent donc être des StartingPropAgents.

     # Calculer le nombre d'agents de chasseur de départ en fonction du nombre de joueurs et du nombre d'agents de chasseur par nombre de joueurs.
 NumberOfPlayers:float = 1.0 * Players.Length # Convertit Players.Length en float afin de l'utiliser dans la fonction Ceil suivante.

 if (NumberOfStartingHunters:int = Ceil[NumberOfPlayers / Max(1.1, HunterTeam.HunterAgentPerNumberOfPlayers)]):
     # Mélanger les joueurs, puis diviser la matrice pour obtenir les agents de chasseur de départ. Les joueurs restants sont les agents d'accessoires de départ. 

     var RandomizedPlayers:[]agent = Shuffle(Players)
     if (set StartingHunterAgents = RandomizedPlayers.Slice[0,NumberOfStartingHunters]) {}

     if (set StartingPropAgents = RandomizedPlayers.Slice[NumberOfStartingHunters,RandomizedPlayers.Length]) {}
     # Itérer les agents de chasseur de départ et les affecter à l'équipe des chasseurs. Lancer ensuite le chronomètre d'attente des chasseurs.
     Logger.Print("Setting {StartingHunterAgents.Length} hunter agent(s).")

     for (StartingHunterAgent : StartingHunterAgents): HunterTeam.InitializeAgent(StartingHunterAgent)
         HunterTeam.WaitTimer.Start()

         # Itérer les agents d'accessoire de départ et les affecter à l'équipe des accessoires. Les téléporter dans la zone de jeu.
         Logger.Print("Setting {StartingPropAgents.Length} prop agent(s).")

  9. Une fois les équipes constituées, activez le téléporteur du salon pour déplacer les accessoires hors de la pièce de départ et activez leur HeartBeat (battement de cœur). Désactivez ensuite le téléporteur du salon, car vous n'en aurez plus besoin après cela. Enfin, définissez le nombre d'accessoires restants dans le PropsRemainingTracker sur la taille de l'équipe des accessoires.

     LobbyTeleporter.Enable()

 for (StartingPropAgent : StartingPropAgents):
     PropTeam.InitializeAgent(StartingPropAgent)

     PropTeam.HeartBeat.SetUpUI(StartingPropAgent)

     LobbyTeleporter.Activate(StartingPropAgent)

     LobbyTeleporter.Disable()

     # Définir la cible et la valeur du traqueur d'accessoires restants sur le nombre actuel d'accessoires.
     # À l'avenir, ne mettre à jour la valeur qu'à mesure de l'élimination des accessoires.
     PropTeam.PropsRemainingTracker.SetTarget(PropTeam.Count())
     PropTeam.UpdatePropsRemainingTracker()

Gérer les éliminations de joueurs

Les chasseurs gagnent le jeu s'ils éliminent tous les accessoires et les convertissent en chasseurs. Procédez comme suit pour attribuer des points aux chasseurs lorsqu'un accessoire est éliminé et pour transférer les accessoires éliminés dans l'équipe des chasseurs.

  1. Créez une fonction nommée OnHunterEliminated(). Vous avez déjà abonné le gestionnaire d'équipe de chasseurs EnemyEliminatedEvent à cet événement, de façon à l'activer chaque fois qu'un chasseur élimine un accessoire.

     # Lorsqu'un agent de chasseur élimine un agent d'accessoire, les points sont attribués. Le score est divisé par le nombre d'agents d'accessoire restants.
 OnHunterEliminated(HunterAgent:agent):void =
 Logger.Print("Hunter agent eliminated a prop agent.")

  2. Vous devez d'abord attribuer aux chasseurs un score proportionnel au nombre d'agents d'accessoire restants. Créez une variable EliminationAward égale au MaxEliminationScore divisé par PropTeamSize. Définissez le gestionnaire de score de l'équipe des chasseurs sur ce score, puis attribuez les points au chasseur qui a éliminé l'accessoire.

     # Lorsqu'un agent de chasseur élimine un agent d'accessoire, les points sont attribués. Le score est divisé par le nombre d'agents d'accessoire restants.
 OnHunterEliminated(HunterAgent:agent):void =
     Logger.Print("Hunter agent eliminated a prop agent.")

     PropTeamSize := PropTeam.Count()

     if (EliminationAward := Floor(HunterTeam.MaxEliminationScore / PropTeamSize)):
         Logger.Print("Awarding {EliminationAward} points.")
         HunterTeam.ScoreManager.SetScoreAward(EliminationAward)
         HunterTeam.ScoreManager.Activate(HunterAgent)

  3. Vous devez également gérer ce qu'il advient de l'équipe des accessoires lorsqu'un accessoire est éliminé. Créez une fonction nommée OnPropEliminated(). Comme pour OnHunterEliminated(), vous avez souscrit à cette fonction antérieurement. Lorsqu'un accessoire est éliminé, vous devez le retirer de l'équipe des accessoires à l'aide de la fonction EliminateAgent() de l'équipe des accessoires, puis l'initialiser en tant que chasseur à l'aide de la fonction InitializeAgent() de l'équipe des chasseurs.

     # Lorsqu'un agent d'accessoire est éliminé, retirer l'accessoire de l'équipe des accessoires, vérifier la fin de la manche et le définir en tant que chasseur.
 OnPropEliminated(PropAgent:agent):void =
     Logger.Print("Prop agent eliminated.")
     spawn{ PropTeam.EliminateAgent(PropAgent) }

     HunterTeam.InitializeAgent(PropAgent)

Gérer l'arrivée des joueurs dans votre jeu et leur départ

Lorsqu'un joueur rejoint le jeu au milieu d'une manche, il est préférable qu'il apparaisse en tant que chasseur.

  1. Créez une fonction OnPlayerAdded() à cet effet. Cette fonction se limite à initialiser le joueur qui rejoint le jeu en tant que chasseur.

     # Lorsqu'un joueur rejoint le jeu au milieu d'une manche, faire de lui un chasseur.
 OnPlayerAdded(Player:player):void =
     Logger.Print("A player joined the game.")
     HunterTeam.InitializeAgent(Player)

  2. La gestion des joueurs qui quittent le jeu est un peu plus complexe. Si un joueur quitte la partie, vous devez le retirer de son équipe et vérifier si son départ entraîne la fin de la partie. Cela pourrait être le cas si ce joueur était le dernier accessoire ou le seul chasseur encore en jeu. Cette logique étant gérée par les fonctions EliminateAgent() de chaque équipe, vous créerez une instance de ces fonctions selon l'équipe à laquelle appartenait le joueur retiré.

     # Lorsqu'un joueur quitte le jeu, vérifier l'équipe dans laquelle il se trouvait, puis vérifier si la fin de la manche a lieu.
 OnPlayerRemoved(Player:player):void=
     Logger.Print("A player left the game.")

     if (PropTeam.FindOnTeam[Player]):
         Logger.Print("Player was a Prop.")
         spawn{ PropTeam.EliminateAgent(Player) }

     if (HunterTeam.FindOnTeam[Player]):
         Logger.Print("Player was a Hunter.")
         spawn{ HunterTeam.EliminateAgent(Player) }

Fin de la manche

Une fois toutes les équipes constituées, vous devez contrôler la taille de chaque équipe pour vérifier si la fin de la manche a lieu. Le jeu se termine lorsque l'une des deux équipes n'a plus de joueurs, ou lorsque le temps imparti pour la manche est écoulé. Vous devez donc utiliser une expression race pour déterminer laquelle de ces conditions se produit en premier.

  1. la fin de votre fonction OnBegin(), dans une expression race, définissez la fonction Await() sur l'événement TeamEmptyEvent des équipes des chasseurs et des accessoires, ainsi que la fonction AwaitEnd() de RoundTimer. Au terme de l'expression race, appelez la fonction EndRound() que vous définirez à l'étape suivante.

     # Lorsqu'il n'y a plus d'agents d'accessoire ou d'agents de chasseur (selon la première occurrence), lorsque le chronomètre de la manche se termine ou lorsque la manche s'achève.
 race: 
     PropTeam.TeamEmptyEvent.Await()
     HunterTeam.TeamEmptyEvent.Await()
     RoundTimer.AwaitEnd()
 Logger.Print("Round ending.")
 EndRound()

  2. Dans la fonction EndRound(), vous devez désactiver le capteur de battements de cœur pour chaque joueur de l'équipe des accessoires et appeler EndRound() sur l'appareil RoundSettings (paramètres de manches). Étant donné que la fonction EndRound() de l'appareil RoundSettings nécessite qu'un joueur lui soit transmis, récupérez le premier joueur de la matrice des joueurs et transmettez-le en tant qu'instigateur.

     # Nettoie l'effet visuel de battement de cœur et met fin à la manche.
 EndRound():void=
     PropTeam.HeartBeat.DisableAll()
    
     # Transmettre un joueur à EndRound.
     Players:[]player = GetPlayspace().GetPlayers()
    
     if (RoundEndInstigator := Players[0]):
         Logger.Print("Round ended.")
         RoundSettings.EndRound(RoundEndInstigator)

Section suivante

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page