Gestionnaire de jeu réutilisable

Dans ce tutoriel, nous utilisons Verse pour rendre certaines fonctionnalités possibles. En utilisant Verse dans ce tutoriel, vous apprendrez à :

• Déclencher et jouer des animations par intermittence pour créer une mécanique de jeu.

• Mettre à jour des informations sur le score de tous les joueurs d'un mini-jeu.

• Créer des délais d'apparition des joueurs et des temps d'apparition intermittente des objets.

Vous pouvez réutiliser ce code pour effectuer les tâches suivantes :

• Activer ou désactiver les appareils pendant les transitions entre l'accueil et le mode de jeu.

• Vérifier les scores des joueurs pour trouver le score gagnant et l'afficher à l'accueil.

• Terminer le jeu et téléporter les joueurs vers l'accueil à la fin du mini-jeu.

Configurer l'appareil Verse et les objets modifiables

Procédez comme suit pour configurer votre appareil Verse et les objets modifiables :

1. Créez un nouvel appareil Verse nommé tiltnboom et ajoutez-le au niveau. Consultez la page Créer votre propre appareil avec Verse pour connaître la procédure.

2. Ajoutez les modules suivants au début du fichier :

   Verse

        using { /Fortnite.com/Characters }
        using { /Fortnite.com/Devices }
        using { /Fortnite.com/Game }
        using { /UnrealEngine.com/Temporary/Diagnostics }
        using { /Verse.org/Random }
        using { /Verse.org/Simulation }
   

   Copy full snippet(6 lines long)

3. Ajoutez les champs suivants à la définition de classe tiltnboom :

   1. Deux appareils trigger modifiables ; ActivateGameTrigger et EndGameTrigger. ActivateGameTrigger permet d'activer ce jeu. Le déclencheur peut être déclenché par tout élément comme un téléporteur vers le jeu ou après une cinématique d'introduction.

      EndGameTrigger permet de mettre fin au mini-jeu, et de supprimer toutes les caméras et tous les appareils de contrôle des joueurs à la fin du jeu.

   Verse

        @editable
        ActivateGameTrigger:trigger_device = trigger_device{}
   
        @editable
        EndGameTrigger:trigger_device = trigger_device{}
   

   Copy full snippet(5 lines long)

   1. Un chronomètre modifiable appelé GameTimer. Ce chronomètre met fin au jeu au bout d'un certain temps.

   2. Une matrice (array) d'appareils de séquence cinématique nommée CannonballSequences. Chaque appareil de la matrice lit une position d'atterrissage de boulet de canon différente.

   3. Une matrice de volumes de dégâts nommée DamageVolumes qui s'active et se désactive en fonction de l'état du jeu.

   4. Une matrice de générateurs d'objets nommée ItemSpawners qui génère un nombre aléatoire d'objets au cours du jeu.

   5. Une zone de capture nommée CaptureArea. Cet appareil attribue des points aux joueurs qui se trouvent sur le radeau. Il est activé ou désactivé en fonction de l'état du jeu.

   6. Un gestionnaire de score nommé ScoreManager, qui réinitialise le score des joueurs au début d'une partie et détermine le joueur gagnant à la fin de la partie.

   7. Un téléporteur nommé HUBTeleporter qui ramène tout le monde à l'accueil à la fin du jeu.

   8. Un appareil Référence de joueur nommé PlayerReference, qui affiche le joueur gagnant dans l'accueil entre les parties.

      Verse

                                   @editable
                                   GameTimer:timer_device = timer_device{}
      								        
                                   @editable
                                   CannonballSequences:[]cinematic_sequence_device = array{}
      								        
                                   @editable
                                   DamageVolumes:[]damage_volume_device = array{}
      								
                                   @editable
      
      Expand code Copy full snippet(23 lines long)

4. Deux matrices modifiables de points d'apparition de joueur nommées PlayerSpawners et HUBSpawners. Elles désactivent les apparitions à la fin du mini-jeu et renvoient les joueurs à l'accueil après le mini-jeu.

   Verse

            @editable
            PlayerSpawners:[]player_spawner_device = array{}
   		
            @editable
            HUBSpawners:[]player_spawner_device = array{}
   

   Copy full snippet(5 lines long)

5. Deux floats modifiables nommés MinimumItemSpawnTime et MaximumItemSpawnTime. Il s'agit des durées minimale et maximale d'attente entre les générations d'objets sur le radeau.

   Verse

            @editable
            MinimumItemSpawnTime:float = 5.0
   		
            @editable
            MaximumItemSpawnTime:float = 10.0
   

   Copy full snippet(5 lines long)

6. Un float modifiable nommé DelayAfterGame. Il s'agit du délai d'attente avant la téléportation des joueurs vers l'accueil une fois la partie terminée.

   Verse

            @editable
            DelayAfterGame:float = 5.0
   

   Copy full snippet(2 lines long)

7. Un float nommé DelayBetweenCannonballSequences. Il s'agit du délai d'apparition des boulets de canon entre les séquences pendant toute la durée du mini-jeu.

   Verse

        DelayBetweenCannonballSequences:float = 8.0
   

   Copy full snippet(1 line long)

8. Une variable logique appelée GameActive pour déterminer si le jeu est actif ou non.

   Verse

            var GameActive:logic = false
   

   Copy full snippet(1 line long)

Démarrer le jeu

Lorsque le mini-jeu commence, plusieurs appareils sont activés et le score du joueur est remis à 0.

1. Au-dessus de la définition de la classe tiltnboom, ajoutez un canal de journal pour afficher des messages spécifiques au mini-jeu. Ajoutez ensuite un enregistreur chronologique à la définition de classe à utiliser avec le canal de journalisation.

   Verse

        tiltnboom_log_channel := class(log_channel){}
   		
        # A Verse-authored creative device that can be placed in a level
        tiltnboom := class(creative_device):
   		
            Logger:log = log{Channel := tiltnboom_log_channel}
   

   Copy full snippet(6 lines long)

2. Ajoutez une nouvelle méthode OnTriggered à la définition de la classe titnboom qui prend un InitiatingAgent et démarre le jeu. Ajoutez une expression if à la méthode qui indique si le jeu est déjà actif, car vous ne souhaitez pas démarrer le jeu si un jeu est déjà en cours.

   Verse

            OnTriggered(InitiatingAgent:?agent):void=
                if (GameActive?):
                    return
   		
                spawn{StartGame()}
   

   Copy full snippet(5 lines long)

3. Dans OnBegin(), abonnez le TriggeredEvent de ActivateGameTrigger à la fonction OnTriggered pour démarrer le jeu. Tout appareil devant être activé au début du mini-jeu s'abonne à cet événement et s'active au déclenchement de l'événement OnTrigger.

   Verse

            OnBegin<override>()<suspends>:void=
   
                ActivateGameTrigger.TriggeredEvent.Subscribe(OnTriggered)

   Copy full snippet(3 lines long)

4. Ajoutez une nouvelle méthode StartGame() qui gère la logique de démarrage du jeu. Ajoutez le modificateur <suspends> à cette fonction pour qu'elle puisse s'exécuter de manière asynchrone.

   Tout d'abord, définissez GameActive sur true pour signaler que le jeu est actif. Ensuite, activez CaptureArea et chaque DamageVolume dans la matrice DamageVolumes.

   Réinitialisez le score de chaque joueur si ce score est supérieur à 0 en lui attribuant l'inverse de son score actuel, ce qui ramène son score à 0.

   Ensuite, dans une expression race, programmez une course entre la fin du chronomètre, l'exécution de la séquence de boulets de canon et l'apparition d'objets aléatoire. La séquence de boulets de canon et l'apparition d'objets aléatoire sont des boucles infinies annulées dès la fin du chronomètre.

   Lorsque le jeu se termine, appelez la fonction OnGameFinished() pour gérer le nettoyage à la fin du jeu.

   Verse

        StartGame()<suspends>:void=
            Logger.Print("Starting game.")
            set GameActive = true
   
            CaptureArea.Enable()
   
            for (DamageVolume : DamageVolumes):
                DamageVolume.Enable()
   
            for:
   
   Expand code Copy full snippet(23 lines long)

Créer une boucle de boulets de canon

Cette section traite de l'ajout d'une fonction qui affiche les séquences cinématiques du boulet de canon.

1. Ajoutez une nouvelle méthode StartCannonSequence() à la définition de la classe tiltnboom qui joue les séquences de niveau de boulets de canon, puis utilise une boucle pour jouer l'expression de délai et insérer un délai entre les boulets de canon. Ajoutez le modificateur <suspends> à cette fonction pour qu'elle puisse s'exécuter de manière asynchrone.

   Dans une boucle, choisissez une séquence aléatoire dans la matrice CannonballSequences en l'indexant avec GetRandomInt(). Jouez la séquence, puis attendez une durée de DelayBetweenCannonballSequences avant de jouer une autre séquence.

   Verse

        StartCannonSequence()<suspends>:void=
            loop:
   
                RandomCannonballSequence:int = GetRandomInt(0, CannonballSequences.Length - 1)
   
                if (CannonballSequence := CannonballSequences[RandomCannonballSequence]):
                    Logger.Print("Set CannonballSequence to {RandomCannonballSequence}")
   
                    CannonballSequence.Play()
   
   
   Expand code Copy full snippet(11 lines long)

Créer des boucles d'apparition d'objets aléatoire

Cette section traite de la création d'une fonction qui génère en boucle des objets aléatoires à des endroits aléatoires du radeau, ce qui peut aider ou nuire aux chances des joueurs de gagner le mini-jeu.

1. Ajoutez une nouvelle méthode appelée SpawnRandomItems à la définition de la classe titlnboom. Cette méthode permet de contrôler les objets qui apparaissent sur le radeau.

2. Récupérez le nombre d'objets dans la matrice ItemSpawners, puis créez une boucle dans la matrice. Utilisez un int aléatoire pour obtenir un générateur d'objets aléatoire dans la matrice, puis activez-le. Attendez une durée aléatoire entre deux apparitions d'objets.

3. La boucle décide aléatoirement du nombre d'objets à faire apparaître et sélectionne aléatoirement un objet à faire apparaître autant de fois que NumberOfItemsToSpawn le précise. DelayBetweenItemSpawns génère un temps d'attente indéterminé entre les apparitions.

   Verse

            SpawnRandomItems()<suspends>:void=
                ItemSpawnerCount:int = ItemSpawners.Length - 1
   
                loop:
   
                    NumberOfItemsToSpawn:int = GetRandomInt(0, ItemSpawnerCount)
   
                    # Spawn a randomly selected item, as many times as NumberOfItemsToSpawn.
                    for:
                        CurrentItemSpawnNumber := 0..NumberOfItemsToSpawn
   
   Expand code Copy full snippet(17 lines long)

Mettre fin au jeu

À la fin du mini-jeu, vous devrez envoyer le score du gagnant à l'accueil, désactiver les appareils et téléporter les joueurs vers l'accueil.

1. Ajoutez une nouvelle méthode OnGameFinished à la définition de la classe tiltnboom. Lorsque le jeu est terminé, cette fonction le rend inactif et désactive les appareils concernés.

   ~~~(verse) OnGameFinished()<suspends>:void= Logger.Print("Game is finished.") set GameActive = false

   CaptureArea.Disable()

   for (PlayerSpawner : PlayerSpawners): PlayerSpawner.Disable()

   for (DamageVolume : DamageVolumes): DamageVolume.Disable() ~~~

2. Ajoutez variable int HighestScore pour suivre le joueur affichant le meilleur score, et une option variable de référence à ce joueur WinningPlayer.

   Verse

                var HighestScore:int = -1
                var WinningPlayer:?agent = false
   

   Copy full snippet(2 lines long)

3. Dans une expression for/do, récupérez tous les joueurs dans l'espace de jeu, puis le FortCharacter de chacun d'entre eux. Figez le personnage sur place à l'aide de PutInStasis(), en transmettant un nouvel ensemble de stasis_args pour autoriser les emotes et les rotations afin que les joueurs puissent célébrer le jeu.

   Verse

                for:
                    Player : GetPlayspace().GetPlayers()
                    FortCharacter := Player.GetFortCharacter[]
                do:
                    FortCharacter.PutInStasis(stasis_args{AllowTurning := true, AllowEmotes := true})
   

   Copy full snippet(5 lines long)

4. Dans une instruction if, vérifiez le score de chaque joueur pour trouver et enregistrer le score gagnant dans l'appareil Référence de joueur de l'accueil.

   Verse

                    if (ScoreManager.GetCurrentScore(Player) > HighestScore):
   		                
                        set HighestScore = ScoreManager.GetCurrentScore(Player)
                        set WinningPlayer = option{Player}
   

   Copy full snippet(4 lines long)

5. Enfin, dans une autre instruction if, appelez TeleportPlayersToHUB() pour téléporter tout le monde vers l'accueil une fois un score gagnant trouvé.

   Verse

                if(Winner := WinningPlayer?):
                    PlayerReference.Register(Winner)
   		
                TeleportPlayersToHUB()
   

   Copy full snippet(4 lines long)

Rediriger les joueurs vers l'accueil

Une fois les scores calculés et un vainqueur déclaré, tous les joueurs doivent revenir à l'accueil.

1. Ajoutez une nouvelle méthode TeleportPlayersToHUB() à la définition de classe tiltnboom. Cette méthode active tous les points d'apparition de joueur de l'accueil, puis attend quelques secondes avant de rediriger tout le monde vers l'accueil. Cette méthode doit également déclencher EndGameTrigger pour retirer la caméra et les appareils de contrôle des joueurs.

   Verse

            TeleportPlayersToHUB()<suspends>:void=
   
                for (HUBSpawner : HUBSpawners):
                    HUBSpawner.Enable()
   
                Sleep(DelayAfterGame)
   
                EndGameTrigger.Trigger()

   Copy full snippet(8 lines long)

2. Dans une expression for, téléportez de nouveau tous les joueurs vers le HUBTeleporter et libérez-les de l'état de stase.

   Verse

                for:
                    Player : GetPlayspace().GetPlayers()
                    FortCharacter := Player.GetFortCharacter[]
                do:
                    HUBTeleporter.Teleport(Player)
   		
                    Sleep(1.0)
   		
                    FortCharacter.ReleaseFromStasis()
   

   Copy full snippet(9 lines long)

À vous de jouer

Modifiez ce code pour créer différentes tâches à effectuer par le chronomètre. Au lieu de déterminer la durée d'un mini-jeu, vous pouvez utiliser le chronomètre pour minuter une course.

    using { /Fortnite.com/Characters }
    using { /Fortnite.com/Devices }
    using { /Fortnite.com/Game }
    using { /UnrealEngine.com/Temporary/Diagnostics }
    using { /Verse.org/Random }
    using { /Verse.org/Simulation }

    tiltnboom_log_channel := class(log_channel){}

    # A Verse-authored creative device that can be placed in a level