Générer une grille de plateformes avec Scene Graph

Pour les jeux de plateforme, il est fréquent de générer une séquence de grille unique où seules quelques plateformes de chaque ligne sont accessibles. Cela oblige les joueurs à ralentir pour comprendre la séquence.

Ce tutoriel vous apprend à générer une grille dans laquelle les plateformes de chaque ligne sont sélectionnées au hasard pour les distinguer des autres en leur attribuant une collision et une couleur claire.

Création du préfabriqué de plateforme

Procédez comme suit pour créer un préfabriqué de plateforme que vous générerez avec Verse :

1. Placez une nouvelle entité et promouvez-la en préfabriqué nommé choose_one_platform_prefab. Pour obtenir des instructions, consultez Préfabriqué et instances de préfabriqué.

2. Dans l'éditeur de préfabriqué, ajoutez les composants suivants à l'entité :

   • transform_component : le composant de transformation pour positionner la plateforme.

   • mesh_component : le composant de maillage pour définir le maillage statique de la plateforme. Dans cet exemple, nous utilisons le maillage SM_block_02 de la ressource Stylized Egyptian World Pack du Marché Fab.

   • collision_component : le composant de collision pour activer et désactiver la collision sur la plateforme.

   • parent_constraint_component : le composant de contrainte parent permettant de configurer facilement la transformation par rapport à l'entité parente lors de la génération de ce préfabriqué dans le monde à l'aide de Verse.

   

3. Ajoutez une entité enfant et nommez-la Lumière.

4. Ajoutez les composants suivants à l'entité enfant Lumière :

   • transform_component : le composant de transformation qui place l'entité au-dessus de la plateforme.

   • point_light_component : le composant de point lumineux permettant d'ajouter une source de lumière qui change de couleur si la plateforme dispose ou non de la collision.

   • parent_constraint_component : le composant de contrainte de parent qui contraint la transformation de cette entité par rapport à l'entité parente.

   

5. Enregistrez le préfabriqué.

Votre préfabriqué apparaît désormais dans le fichier Assets.digest.verse en tant que classe avec le même nom que votre préfabriqué, choose_one_platform_prefab.

Générer une grille de plateformes

Procédez comme suit pour générer une grille créée à partir du préfabriqué de plateforme :

1. Créez un composant Verse nommé choose_one_component. Pour savoir comment créer un composant Verse, consultez la rubrique Créer votre propre composant Verse.

2. Ajoutez les propriétés modifiables suivantes :

   • Un champ vectoriel 2D de nombres entiers vector2i nommé GridSize, pour définir le nombre de plateformes dans la grille. X représente le nombre de lignes et Y le nombre de colonnes que contient la grille.

   • Un champ vectoriel 2D à virgule flottante vector2 nommé PlatformSpacing, permettant de spécifier l'espacement entre les plateformes sur les lignes et les colonnes.

     ~~~(verse) GridSizeTip<localizes>:message = "Taille de la grille, X représentant les unités de largeur et Y les unités de profondeur." PlatformSpacingTip<localizes>:message = "Distance entre chaque plateforme sur la grille."

     choose_one_component<public> := class(component):

     # Taille de la grille, X représentant les unités de largeur et Y les unités de profondeur. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

     # Distance entre chaque plateforme sur la grille. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0} ~~~

3. Dans la fonction OnSimulate, itérez sur le vecteur GridSize pour savoir combien de plateformes générer. Pour générer le préfabriqué dans le monde, créez une instance de votre classe de préfabriqués dans la boucle et ajoutez-la à l'entité à laquelle ce composant Verse est rattaché.

   ~~~(verse) GridSizeTip<localizes>:message = "Taille de la grille, X représentant les unités de largeur et Y les unités de profondeur." PlatformSpacingTip<localizes>:message = "Distance entre chaque plateforme sur la grille."

   choose_one_component<public> := class(component):

   # Taille de la grille, X représentant les unités de largeur et Y les unités de profondeur. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

   # Distance entre chaque plateforme sur la grille. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0}

   OnSimulate<override>()<suspends>:void= # Générez des plateformes pour créer la grille. for (Column := 0..GridSize.Y - 1): for (Row := 0..GridSize.X - 1): # Créer une instance de préfabriqué et l'ajouter à une entité existante générera le préfabriqué dans le monde. ChooseOnePlatform := choose_one_platform_prefab{} Entity.AddEntities(array{ChooseOnePlatform}) ~~~

4. Si vous exécutiez le code à ce stade, toutes les plateformes apparaîtraient au même endroit. Étant donné que le préfabriqué contient le composant de transformation et le composant de contrainte de parent, vous pouvez définir la propriété InitialRelativeTransform sur son composant de transformation pour générer le préfabriqué avec un décalage par rapport à l'emplacement de l'entité à laquelle vous ajoutez le préfabriqué. Sans le composant parent constraint sur l'entité que vous générez, vous devrez spécifier l'emplacement dans l'espace du monde (et non par rapport à l'entité racine).

   Verse

        GridSizeTip<localizes>:message = "Size of the grid, where the grid is X units wide by Y units deep."
        PlatformSpacingTip<localizes>:message = "The distance between each platform on the grid."
   
        choose_one_component<public> := class(component):
   
            # Size of the grid, where the grid is X units wide by Y units deep.
            @editable_vector_number(int):
                ToolTip := GridSizeTip
                MinComponentValue := option{0}
            GridSize:vector2i = vector2i{X := 3, Y := 10}
   
   Expand code Copy full snippet(45 lines long)

5. Enregistrez votre code et compilez-le.

Si vous rattachez ce composant Verse à une entité et lancez une session, une grille de plateformes apparaîtra à l'emplacement de cette entité.

Sélectionner aléatoirement des plateformes valides

Maintenant que vous disposez d'une grille de plateformes générées dans le monde, vous pouvez leur ajouter plus de fonctionnalités. La procédure suivante vous apprend à sélectionner aléatoirement des plateformes pour qu'elles disposent de la collision et génèrent une séquence unique et changeante de plateformes auxquelles un joueur peut accéder.

Procédez comme suit pour sélectionner aléatoirement des plateformes valides dans la grille :

1. Ajoutez les propriétés modifiables suivantes au composant Verse :

   • Une variable de nombre entier nommée MinCorrectPlatformsPerRow pour spécifier le nombre minimum de plateformes disposant de la collision.

   • Une variable de nombre entier nommée MaxCorrectPlatformsPerRow pour spécifier le nombre maximal de plateformes disposant de la collision.

   • Une variable de couleur nommée ChosenColor pour définir la couleur de la plateforme si la collision est activée.

   • Une variable de couleur nommée NotChosenColor pour définir la couleur de la plateforme si la collision n'est pas activée.

     Verse

                               using { /UnrealEngine.com/Temporary/SceneGraph }
                               using { /UnrealEngine.com/Temporary/SpatialMath }
                               using { /Verse.org }
                               using { /Verse.org/Colors }
                               using { /Verse.org/Native }
                               using { /Verse.org/Random }
                               using { /Verse.org/Simulation }
     
                               GridSizeTip<localizes>:message = "Size of the grid, where the grid is X units wide by Y units deep."
                               PlatformSpacingTip<localizes>:message = "The distance between each platform on the grid."
     
     Expand code Copy full snippet(54 lines long)

2. Le résultat d'une expression for est une matrice de chaque itération. Stockez toutes les plateformes générées pour une ligne dans une matrice et transmettez celle-ci à une fonction pour définir de manière aléatoire les plateformes nommées RandomizeCollidablePlatformsPerRow().

   Verse

        OnSimulate<override>()<suspends>:void=
            # For each row, spawn multiple platforms and pick a number of them to have collision while the others don't.
            # The platforms with collision will have the Chosen color for their light component.
            # The platforms without collision will have the NotChosen color for their light component.
            for (Row := 0..GridSize.Y - 1):
                EntitiesInRow := for (Column := 0..GridSize.X - 1):
                    # The prefab has a parent constraint component so set the InitialRelative Transform
                    # on the transform component to offset each platform relative to this entity.
                    # This means the platform prefabs will spawn same distance from each other
                    # but moving the root entity will change where the platforms originate.
   
   Expand code Copy full snippet(34 lines long)

3. Créez une fonction nommée RandomizeCollidablePlatformsPerRow qui doit sélectionner aléatoirement les entités qui disposeront de la collision et celles qui n'en disposeront pas. Le composant point light étant sur l'entité enfant du préfabriqué, vous pouvez utiliser FindComponents pour effectuer une recherche parmi les enfants de l'entité et modifier la couleur du point lumineux.

   Verse

        # Randomly choose platforms to have collision in the row.
        RandomizeCollidablePlatformsPerRow(Entities:[]entity):void=
            # Disable all the entities before choosing which ones to enable.
                # It disables an entity by disabling the collision on the entity,
                # and finding a point light in its child entities to change its color.
                for:
                    EntityPlatform : Entities
                    Collision := EntityPlatform.GetComponents(collision_component)[0]
                    Light := EntityPlatform.FindComponents(point_light_component)[0]
                do:
   
   Expand code Copy full snippet(12 lines long)

4. Créez une méthode d'extension pour les matrices d'extension nommées ChooseOne pour choisir un élément sélectionné aléatoirement dans la matrice. Le résultat est un tuple contenant à la fois l'élément choisi et une matrice avec tous les autres éléments non sélectionnés.

   Verse

        # An extension method for an array to get a randomly selected element from the array.
        (Input:[]t where t:subtype(comparable)).ChooseOne()<decides><transacts>:tuple(t, []t)=
            ChosenElement := Input[GetRandomInt(0, Input.Length - 1)]
            NotChosenElements := Input.RemoveFirstElement[ChosenElement]
            (ChosenElement, NotChosenElements)

   Copy full snippet(5 lines long)

5. Appelez ChooseOne à partir de RandomizeCollidablePlatformsPerRow pour sélectionner une entité qui disposera de la collision et modifier sa couleur.

   Verse

        # Randomly choose platforms to have collision in the row.
        RandomizeCollidablePlatformsPerRow(Entities:[]entity):void=
            # Disable all the entities before choosing which ones to enable.
            # It disables an entity by disabling the collision on the entity,
            # and finding a point light in its child entities to change its color.
            for:
                EntityPlatform : Entities
                Collision := EntityPlatform.GetComponents(collision_component)[0]
                Light := EntityPlatform.FindComponents(point_light_component)[0]
            do:
   
   Expand code Copy full snippet(23 lines long)

6. Modifiez RandomizeCollidablePlatformsPerRow de manière à choisir plusieurs entités qui disposeront de la collision en fonction de leurs propriétés modifiables. D'abord, obtenez une valeur aléatoire entre le nombre minimal et maximal de plateformes correctes par ligne et choisissez une entité ce nombre de fois, puis supprimez celle choisie dans la liste des prochains candidats sélectionnables.

   Verse

        # Randomly choose platforms to have collision in the row.
        RandomizeCollidablePlatformsPerRow(Entities:[]entity):void=
            # Disable all the entities before choosing which ones to enable.
            # It disables an entity by disabling the collision on the entity,
            # and finding a point light in its child entities to change its color.
            for:
                EntityPlatform : Entities
                Collision := EntityPlatform.GetComponents(collision_component)[0]
                Light := EntityPlatform.FindComponents(point_light_component)[0]
            do:
   
   Expand code Copy full snippet(29 lines long)

7. Enregistrez votre code et compilez-le.

Si vous lancez une session maintenant, une grille de plateformes est générée dans le monde avec une séquence unique de plateformes disposant de la collision et ayant la couleur choisie.

Script complet

using { /UnrealEngine.com/Temporary/SceneGraph }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org }
using { /Verse.org/Colors }
using { /Verse.org/Native }
using { /Verse.org/Random }
using { /Verse.org/Simulation }

GridSizeTip<localizes>:message = "Size of the grid, where the grid is X units wide by Y units deep."
PlatformSpacingTip<localizes>:message = "The distance between each platform on the grid."