Disparition synchronisée de plateformes

Les séries de plateformes qui disparaissent sont essentielles dans les modes de jeu de plateformes, comme les courses à obstacles. Dans ce type de jeux, les joueurs doivent sauter au bon moment sur une série de plateformes, sous peine de tomber et de devoir recommencer.

Ce tutoriel va vous apprendre à créer une série de plateformes qui apparaissent et disparaissent à tour de rôle à l'aide d'un unique appareil créé avec Verse dans l'Unreal Editor pour Fortnite (l'UEFN).

Fonctionnalités du langage Verse utilisées

• array : le type array vous permet de stocker des références de plateforme pour y accéder rapidement et éviter la duplication de code.

• loop : le cycle d'apparition et de disparition des plateformes doit commencer au début du jeu et s'exécuter continuellement par la suite. Cet exemple montre comment créer ce comportement avec l'expression Verse loop.

• block : l'expression block vous permet de regrouper plusieurs expressions en vue de les exécuter de manière séquentielle.

• for : l'expression for vous permet d'itérer sur chaque plateforme de votre matrice.

• sync : l'expression sync et la concurrence structurée vous permettent d'exécuter plusieurs expressions asynchrones en même temps.

API Verse utilisées

• Sleep() : grâce à l'API Sleep(), vous pouvez choisir la durée pendant laquelle les plateformes restent invisibles ou visibles.

• Propriétés modifiables : plusieurs propriétés d'appareil créé avec Verse sont exposées à l'UEFN afin que vous puissiez les personnaliser dans l'éditeur : trois délais pour le comportement des plateformes et quatre références aux plateformes.

Instructions

Procédez comme suit pour configurer une série de plateformes qui disparaissent et apparaissent périodiquement. Le script complet est inclus à la fin de ce guide à titre de référence.

Configurer le niveau

Le point de départ du présent tutoriel est le modèle de démarrage Verse. Pour commencer, initialisez un nouveau projet à partir de l'exemple de fonctionnalitésAppareil Verse.

Dans cet exemple, nous utiliserons les accessoires et appareils suivants.

• 1 x point d'apparition de joueur : cet appareil définit l'emplacement d'apparition du joueur au début du jeu.

• 6 x accessoire du mode Créatif : Verse vous permet d'appeler plusieurs comportements des accessoires du mode Créatif, comme Hide() et Show(), pour basculer la visibilité de la plateforme et la collision. Ce tutoriel utilise l'Airborne Hoverplatform A comme plateforme avec laquelle le joueur interagit, mais vous pouvez en changer selon vos besoins.

Procédez comme suit pour configurer votre niveau :

1. Ajoutez une Airborne Hoverplatform A à votre scène. Placez-la au-dessus du sol pour que le joueur tombe s'il ne saute pas à temps de la plateforme qui disparaît. Dans l'organiseur, nommez la plateforme SynchronizedPlatform1.

   

2. Dupliquez la plateforme plusieurs fois pour créer une ligne. Placez ensuite le point d'apparition de joueur sur la plateforme où vous souhaitez faire commencer votre joueur. Votre configuration complète doit ressembler à ceci :

   

Création de l'appareil

Cet exemple s'appuie sur un appareil créé avec Verse pour définir le comportement permettant d'activer la visibilité des plateformes. Suivez ces étapes pour créer cet appareil en utilisant Verse.

1. Créez un nouvel appareil Verse nommé platform_series. Pour apprendre à créer un nouvel appareil dans Verse, consultez la rubrique Créer votre propre appareil avec Verse.

   

2. Faites glisser l'appareil platform_series du navigateur de contenu au niveau.

Modifier les propriétés de l'appareil dans l'UEFN

Dans cette section, nous vous expliquons comment exposer des propriétés d'appareil à l'UEFN afin de les personnaliser dans l'éditeur :

• Trois constantes float nommées HeadStart, AppearDelay et DisappearDelay indiquant la durée pendant laquelle les plateformes doivent être invisibles/visibles.

• Des références d'appareil aux objets du mode Créatif que vous avez placés dans le niveau.

Procédez comme suit pour exposer ces propriétés à partir de l'appareil platform_series que vous avez créé dans la section précédente.

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

2. Ajoutez les champs suivants à la définition de la classe platform_series :

   • Un float modifiable nommé HeadStart. * Il représente le temps d'attente, en secondes, après l'apparition des plateformes et avant leur disparition. Initialisez cette valeur à 2,5, soit deux secondes et demie.

     Verse

       # How long to wait in seconds after platforms start appearing
       # before they start disappearing.
       @editable
       HeadStart:float = 2.5
     

     Copy full snippet(4 lines long)

   • Un float modifiable nommé AppearDelay. * Il représente le temps d'attente, en secondes, avant l'apparition de la plateforme suivante. Initialisez cette valeur à 1.0, soit une seconde.

     Verse

       # How long to wait in seconds before the next platform appears.
       @editable
       AppearDelay:float = 1.0
     

     Copy full snippet(3 lines long)

   • Un float modifiable nommé DisappearDelay. * Il représente le temps d'attente, en secondes, avant la disparition de la plateforme suivante. Initialisez cette valeur à 1,25, soit une seconde un quart.

     Verse

       # How long to wait in seconds before the next platform disappears.
       @editable
       DisappearDelay:float = 1.25
     

     Copy full snippet(3 lines long)

   • Un creative_prop modifiable nommé DisappearingPlatform. Il s'agit de la plateforme au sein du niveau qui disparaîtra et apparaîtra. Vous allez l'instancier avec un archétype creative_prop{} vide, dans la mesure où votre code n'a pas encore de référence à cet objet dans le niveau. Vous assignerez ultérieurement cette référence à votre plateforme flottante.

     Verse

       # The in-level platform that disappears and reappears.
       @editable
       DisappearingPlatform:creative_prop = creative_prop{}
     

     Copy full snippet(3 lines long)

3. Les champs de votre classe platform_series doivent ressembler à ceci :

   Verse

        # A Verse-authored creative device that can be placed in a level
        platform_series := class(creative_device):
   		
        # How long to wait in seconds after platforms start appearing
        # before they start disappearing.
        @editable
        HeadStart:float = 2.5
   		
        # How long to wait in seconds before the next platform appears.
        @editable
   
   Expand code Copy full snippet(19 lines long)

   L'attribut @editable est utile pour exposer des valeurs comme AppearDelay à l'éditeur à partir de vos scripts. Il vous permet de personnaliser leurs valeurs dans l'UEFN sans avoir à recréer le code Verse chaque fois. Vous pouvez donc itérer rapidement et trouver les valeurs qui correspondent à votre expérience de jeu.

4. Enregistrez le script dans Visual Studio Code.

5. Dans la barre d'outils de l'UEFN, cliquez sur Verse, puis Générer le code Verse pour mettre à jour l'appareil platform_series qui se trouve dans le niveau.

   

6. Dans le panneau Organiseur de l'UEFN, sélectionnez l'appareil platform_series pour ouvrir son panneau Détails.

7. Dans le panneau Détails, sous Série de plateformes, réglez DisappearingPlatform sur SynchronizedPlatform1 (l'accessoire du mode Créatif que vous avez ajouté au niveau) en cliquant sur le sélecteur d'objets et en sélectionnant la plateforme dans le hublot.

Masquer et afficher une plateforme

Maintenant que vous avez configuré le niveau et la première plateforme, vous pouvez ajouter la fonctionnalité permettant d'afficher et de masquer la plateforme. Procédez comme suit pour ajouter ce comportement à l'appareil platform_series :

1. La classe creative_prop dispose de deux méthodes pour activer sa visibilité : Hide() et Show(). De retour dans Visual Studio Code, dans OnBegin(), appelezHide() puis Show() sur votre DisappearingPlatform.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
   		
            # Hide the platform.
            DisappearingPlatform.Hide()
   		
            # Show the platform.
            DisappearingPlatform.Show()
   

   Copy full snippet(8 lines long)

   Si vous exécutez ce code, la plateforme ne disparaît pas et ne réapparaît pas, car les appels Hide() et Show() se produisent immédiatement l'un après l'autre.

2. Pour que la plateforme reste plus longtemps dans un état visible ou invisible, vous pouvez ajouter un délai lors de l'appel de Hide() ou de Show() en utilisant Sleep(). La fonction Sleep() suspend l'exécution d'une routine, et vous spécifiez la durée (en secondes) de la suspension de l'exécution en transmettant un argument float à la fonction. Appelez Sleep() avant chaque appel à Hide() et à Show(), en transmettant le DisappearDelay défini précédemment.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
   		
            # Hide the platform.
            DisappearingPlatform.Hide()
   		
            # Wait for DisappearDelay seconds.
            Sleep(DisappearDelay)
   		
            # Show the platform.
   
   Expand code Copy full snippet(11 lines long)

   Si vous exécutez ce code, la Platform est invisible pendant une seconde (la durée définie par DisappearDelay) avant de devenir visible le reste du jeu.

   La fonction Sleep() ne peut être appelée que dans un contexte asynchrone. La méthode OnBegin() est déjà un contexte asynchrone puisqu'elle dispose du spécificateur suspends. Aucune autre action n'est donc nécessaire de votre part. Pour en savoir plus sur le spécificateur suspends, consultez la page Spécificateurs et attributs.

Masquer et afficher plusieurs plateformes

Vous pouvez répéter le code de l'étape précédente pour chaque plateforme du niveau que vous souhaitez faire disparaître, mais créer une matrice où stocker toutes les références d'appareil est plus efficace. Cela vous permet d'itérer et d'exécuter le code sur chaque plateforme de la matrice sans avoir à dupliquer l'appareil Verse à de multiples reprises. Procédez comme suit pour masquer et afficher plusieurs plateformes :

1. Dans votre définition de classe platform_series, changez le champ DisappearingPlatform en matrice de creative_prop intitulée DisappearingPlatforms. Vous utiliserez cette matrice pour itérer les plateformes, dans l'ordre. Initialisez la variable avec la valeur par défaut array{}, c'est-à-dire une matrice vide.

   Verse

        # The in-level platforms that disappear and reappear in sequence.
        @editable
        DisappearingPlatforms:[]creative_prop = array{}
   

   Copy full snippet(3 lines long)

2. Vous pouvez utiliser l'expression for pour itérer sur chaque élément de la matrice. L'expression for fait appel au motif X -> Y pour fournir une paire index-valeur. L'index est lié à la partie gauche (X), et la valeur est liée à la partie droite (Y). Dans ce cas, X correspond au numéro/à l'index de la plateforme et Y à chaque référence de plateforme récupérée dans la matrice. D'abord, créez une expression for pour itérer sur chaque élément et obtenez l'index de chaque numéro d'une variable PlatformNumber.

   ~~~(verse) # S'exécute à l'activation de l'appareil dans une partie en cours. OnBegin<override>()<suspends>:void= for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: ~~~

3. Affichez le numéro de la plateforme et appelez Hide() pour masquer la plateforme. Ensuite,Sleep() (mettez en veille) pendant le nombre de secondes indiqué par DisappearDelay.

   Verse

        # For each platform in DisappearingPlatforms, make it invisible and sleep.
        for:
            PlatformNumber -> DisappearingPlatform:DisappearingPlatforms
        do:
            # Hide the platform
            DisappearingPlatform.Hide()
            Print("Platform {PlatformNumber} is now hidden")
            Sleep(DisappearDelay)
   

   Copy full snippet(8 lines long)

4. Pour faire réapparaître les plateformes, vous utiliserez une seconde expression for après la première. Itérez de cette manière sur chaque plateforme de DisappearingPlatforms, mais cette fois appelez Show() pour faire apparaître la plateforme et Sleep() pendant le nombre de secondes indiqué par AppearDelay.

   ~~~(verse) # Rendre visible et mettre en veille chaque plateforme de DisappearingPlatforms. for: PlatformNumber -> DisappearingPlatform:DisappearingPlatforms do: # Afficher la plateforme. DisappearingPlatform.Show() Print("Platform {PlatformNumber} is now visible") Sleep(AppearDelay) ~~~

5. Lorsque vous rédigez du code, il peut être sage de mettre du code réutilisable dans des fonctions séparées. Cela vous permet d'appeler le code dans des contextes différents et de ne pas devoir rédiger sans cesse le même code. En fonction de votre expérience, vous voudrez peut-être afficher et masquer les plateformes dans des situations différentes, et ces fonctions vous permettront de traiter chacune de ces situations. Ajoutez deux nouvelles fonctions intitulées HideAllPlatforms() et ShowAllPlatforms() à votre définition de classe platform_series. Déplacez l'expression for qui gère le masquage des plateformes dans HideAllPlatforms() et l'expression qui traite l'affichage des plateformes dans ShowAllPlatforms(). Puisque vous utilisez la fonction Sleep(), il est nécessaire que ces fonctions soient asynchrones. Vous devez donc ajouter le modificateur <suspends> à chacune d'elles. Ensuite, dans OnBegin(), appelezHideAllPlatforms(), puis ShowAllPlatforms().

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            HideAllPlatforms()
            ShowAllPlatforms()
   
        HideAllPlatforms()<suspends>:void=
            # For each platform in DisappearingPlatforms, make it invisible and sleep.
            for:
                PlatformNumber -> DisappearingPlatform:DisappearingPlatforms
            do:
   
   Expand code Copy full snippet(24 lines long)

6. En l'état, ce code ne s'exécutera qu'une seule fois. Pour faire disparaître et réapparaître la plateforme aussi longtemps que le jeu est en cours d'exécution, vous pouvez utiliser l'expression loop pour répéter ce comportement. Pour ce faire, ajoutez à OnBegin() une expression loop qui comprend les appels à HideAllPlatforms() et à ShowAllPlatforms(). Dans cet exemple, vous cherchez à basculer la visibilité des plateformes tant que le jeu est en cours, il n'est donc pas nécessaire d'ajouter une expression break pour sortir de la loop.

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Hide all platforms.
                HideAllPlatforms()
   
                # Show all platforms.
                ShowAllPlatforms()

   Copy full snippet(8 lines long)

   Si vous exécutez ce code, les plateformes disparaissent toutes en séquence, puis réapparaissent toutes dans le même ordre jusqu'à la fin du jeu.

7. Enregistrez votre code et compilez-le. Dans le panneau Organiseur de l'UEFN, sélectionnez l'appareil platform_series pour ouvrir son panneau Détails.

8. Dans le panneau Détails, sous DisappearingPlatforms, ajoutez un élément de matrice pour chaque plateforme du niveau. Ajoutez des éléments à la matrice à l'aide du bouton "Ajouter un élément", puis cliquez sur le sélecteur d'objets et sélectionnez l'accessoire du mode Créatif dans le hublot. Assurez-vous que l'ordre de cette matrice correspond à l'ordre dans lequel vous souhaitez itérer :

   

Si vous exécutez ce code, les plateformes disparaissent toutes en séquence, puis réapparaissent dans le même ordre jusqu'à la fin du jeu.

Synchroniser la disparition et la réapparition des plateformes

Pour exercer une pression sur le joueur lorsqu'il saute sur les carreaux, vous pouvez faire en sorte que les plateformes commencent à disparaître alors que celles situées plus loin dans la séquence apparaissent encore. Le joueur doit donc se précipiter sur la série sous peine de tomber. Pour créer ce comportement, les deux routines (ShowAllPlatforms() et HideAllPlatforms()) doivent être exécutées en même temps, la seconde étant décalée par rapport à la première, afin que le joueur ait une longueur d'avance pour sauter sur la plateforme suivante avant qu'elle disparaisse.

Procédez comme suit pour masquer et afficher toutes les plateformes simultanément.

1. Pour que HideAllPlatforms() et ShowAllPlatforms() s'exécutent simultanément, vous pouvez utiliser l'expression sync. L'expression sync exécute simultanément les deux (ou plus) expressions asynchrones de son bloc de code, et attend que toutes ses expressions soient terminées avant de continuer. Dans OnBegin(), à l'intérieur de l'expression loop, ajoutez une expression sync sur HideAllPlatforms() et ShowAllPlatforms().

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Run both expressions concurrently using sync.
                sync:
                    # Hide all platforms.
                    HideAllPlatforms()
   
                    # Show all platforms.
                    ShowAllPlatforms()

   Copy full snippet(10 lines long)

2. Si vous lancez ce code tel quel, l'apparition et la disparition de la plateforme auront lieu simultanément, ce qui n'est pas le résultat souhaité. Vous devrez donc retarder un peu la disparition de la plateforme. Pour donner un temps d'avance au joueur, vous devrez utiliser Sleep() en transmettant la valeur HeadStart. Dans la mesure où l'expression sync exécute simultanément toutes les expressions de son bloc de code, vous devez utiliser l'expression block pour imbriquer Sleep() et HideAllPlatforms(). Ajoutez une expression block qui couvre Sleep() et HideAllPlatforms(). La synchronisation exécutera maintenant deux expressions. La première appelle ShowAllPlatforms() et la seconde Sleep() avant d'appeler HideAllPlatforms().

   Verse

        # Runs when the device is started in a running game
        OnBegin<override>()<suspends>:void=
            loop:
                # Run both expressions concurrently using sync.
                sync:
                    block:
                        Sleep(HeadStart)
                        # Hide all platforms.
                        HideAllPlatforms()
                    # Show all platforms.
   
   Expand code Copy full snippet(11 lines long)

3. Enregistrez le script et cliquez sur Verse, puis sur Générer le code Verse pour compiler le code.

4. Cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester le niveau.

   

Lorsque vous testez le niveau, les plateformes commencent à disparaître en séquence, tandis que les plateformes suivantes de la séquence réapparaissent. Ce motif se répète tout au long du jeu.

Script complet

Le code suivant constitue le script complet pour faire apparaître et disparaître en séquence une série de plateformes.

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

# See https://dev.epicgames.com/documentation/en-us/uefn/create-your-own-device-in-verse for how to create a verse device.

# A Verse-authored creative device that can be placed in a level
platform_series := class(creative_device):

    # How long to wait in seconds after platforms start appearing

À vous de jouer

À l'issue de ce tutoriel, vous avez appris à créer un appareil utilisant Verse qui permet de faire basculer la visibilité d'une série de plateformes pendant toute la durée d'une partie.

En vous servant de ce que vous venez d'apprendre, essayez d'effectuer les tâches suivantes :

• Modifier l'ordre d'apparition et de disparition des plateformes.

• Appliquez les mêmes concepts pour appeler périodiquement des fonctions sur d'autres types d'appareils, tels que le déplaceur d'accessoire.