1. Epic GamesDeveloper
  3. 3. Trouver des lumières pendant l'exécution grâce aux balises de jeu

3. Trouver des lumières pendant l'exécution grâce aux balises de jeu

Créez un jeu de casse-tête où le joueur doit trouver la bonne combinaison de lumières allumées et éteintes pour faire apparaître un objet, en utilisant un appareil créé avec Verse.

3. Trouver des lumières pendant l'exécution grâce aux balises de jeu
Prerequisite topics

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

Dans cette étape du tutoriel Créer un jeu de casse-tête avec séquences de lumières balisées, vous apprendrez à utiliser l'API Étiquettes de jeu pour rechercher les acteurs portant une balise spécifique pendant le jeu. Les étiquettes de jeu vous permettent d'utiliser plusieurs appareils sans avoir à configurer leurs références dans l'éditeur. Elles vous ouvrent donc des possibilités de jeu intéressantes en vous permettant notamment de programmer le code de façon à modifier les appareils actifs à mesure que le joueur progresse dans le jeu.

Procédez comme suit pour créer une nouvelle étiquette de jeu et l'attribuer à toutes les lumières du niveau pour le jeu de casse-tête :

  1. Ouvrez l'explorateur Verse et double-cliquez sur tagged_lights_puzzle.verse pour ouvrir le script dans Visual Studio Code.
  2. Dans la partie supérieure du fichier de code :
    • Ajoutez using { /Verse.org/Simulation/Tags } pour référencer la classe tag et utilisez la fonction GetCreativeObjectsWithTag().
    • Ajoutez using { /Verse.org/Simulation } de façon à pouvoir créer des propriétés modifiables.
     using { /Fortnite.com/Devices }
 using { /Verse.org/Native }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 using { /Verse.org/Simulation/Tags }
 using { /Verse.org/Simulation } }
    
 log_tagged_lights_puzzle := class(log_channel){}

  3. Au-dessus de la classe log_tagged_lights_puzzle, ajoutez une nouvelle sous-classe nommée puzzle_light qui hérite de la classe tag. Le nom de la classe héritée est converti en balise de jeu personnalisée que vous pouvez utiliser sur tout appareil du mode Créatif.

     # Dérivez la classe `tag` du module Verse.org/Simulation/Tags pour créer une nouvelle étiquette de jeu.
 puzzle_light := class(tag){}

 log_tagged_lights_puzzle := class(log_channel){}
  4. Dans la barre d'outils d'UEFN, cliquez sur Générer les scripts Verse pour compiler votre code et votre nouvelle étiquette de jeu puzzle_light dans votre projet.
  5. Dans l’organiseur d'UEFN, sélectionnez un appareil Lumière personnalisable pour ouvrir le panneau Détails correspondant.
  6. Dans le panneau Détails :
    1. Cliquez sur Ajouter un nouveau composant et choisissez Marquage de balises Verse.
    2. Sélectionnez le composant VerseTagMarkup pour afficher ses paramètres dans le panneau Détails.
    3. Sous Étiquettes de jeu, modifiez la propriété Balises et ajoutez la balise puzzle_light.
    Ajouter le composant VerseTagMarkup et ajouter la balise puzzle_light

    Vous pouvez ajouter plusieurs balises à un même appareil, de sorte que chaque appareil peut appartenir à plusieurs groupes en même temps. Par exemple, un appareil avec les balises tag1 et tag2 est détecté lors de l'appel de GetCreativeObjectsWithTag(tag1{}) ou GetCreativeObjectsWithTag(tag2{}).
  7. Dans la définition de classe tagged_lights_puzzle, ajoutez deux champs de matrice de variables :
    • Une matrice de variables logic modifiable nommée LightsState pour représenter l'état actuel de toutes les lumières (éteintes ou allumées). Cette matrice étant également utilisée pour définir l'état initial des lumières, le nombre de ses éléments doit correspondre au nombre de lumières portant la balise puzzle_light. Dans cet exemple, toutes les lumières sont éteintes par défaut ; par conséquent, la valeur de départ pour toutes les lumières est false. 
       @editable
 var LightsState : []logic = array{false, false, false, false}
    • Une matrice de variables customizable_light_device modifiable nommée Lights pour stocker tous les appareils Lumière personnalisable portant l’étiquette de jeu puzzle_light. 
       @editable
 var Lights : []customizable_light_device = array{}
  8. Lorsque le jeu commence, l'appareil doit configurer les lumières en fonction de la configuration initiale spécifiée dans la matrice LightsState, et enregistrer les références dans la matrice Lights afin qu'elles puissent être mises à jour lors du changement d’état du jeu. Cette tâche est confiée à une méthode SetupPuzzleLights() : void, appelée dans la méthode OnBegin() pour que les lumières soient configurées au début du jeu. 
     SetupPuzzleLights() : void =
     Logger.Print(“Setting up in-game lights”)
    
 OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
  9. Dans SetupPuzzleLights(), recherchez tous les appareils avec la balise puzzle_light en appelant GetCreativeObjectsWithTag(puzzle_light{}), puis enregistrez-les dans une matrice appelée TaggedActors. Dans la mesure où TaggedActors est une matrice de constante dont l’étendue est locale à la méthode SetupPuzzleLights(), vous n'avez pas besoin de spécifier explicitement un type pour la matrice, car il peut être déduit dans ce contexte. 
     SetupPuzzleLights() : void =
     Logger.Print("Setting up in-game lights")
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})

    Des appels différents de la fonction GetCreativeObjectsWithTag() peuvent placer les appareils dans des ordres différents dans le résultat de la matrice, car aucun ordre n'est garanti lors de la récupération d’acteurs avec des étiquettes de jeu.
  10. Maintenant que vous avez collecté tous les appareils dotés de la balise puzzle_light, assurez-vous que chaque lumière correspond à l'état de départ spécifié par la matrice LightsState. Vous pouvez utiliser une boucle for pour itérer tous les appareils balisés. 
     for:
     ActorIndex -> TaggedActor : TaggedActors
 do:
     TaggedActor
  11. La fonction GetCreativeObjectsWithTag() renvoie une matrice de type creative_object_interface. Dans cet exemple, vous souhaitez interagir avec chaque appareil TaggedActor en tant qu'appareil customizable_light_device pour pouvoir allumer ou éteindre la lumière.
    • Vous pouvez convertir une classe en l'une de ses sous-classes (processus appelé conversion de type(verse-glossary#type-casting)) en utilisant la syntaxe NewDeviceReference := device_type_to_cast_to[DeviceReference], où device_type_to_cast_to correspond au type d'appareil que vous demandez, en l'occurrence customizable_light_device. Cette expression est faillible, car la conversion de type échoue s'il s'avère impossible de convertir l'appareil en ce type (par exemple, s'il s'agit d'un autre type d'appareil). 
       LightDevice := customizable_light_device[TaggedActor]

    La fonction GetCreativeObjectsWithTag() a le type de retour []creative_object_interface, car la fonction peut renvoyer différents types d’acteurs ; son type de retour est donc l’interface que tous les acteurs doivent implémenter pour être renvoyés par GetCreativeObjectsWithTag(). Consultez la rubrique Étiquettes de jeu pour en savoir plus.
    • Avec les expressions for, vous pouvez utiliser des expressions faillibles comme filtre et créer de nouvelles variables pour pouvoir les utiliser ensuite dans le bloc de code for. Dans ce cas, ajoutez la conversion de type customizable_light_device de l'étape précédente à l'expression d'itération. 
       for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • La dernière expression d'un bloc de code est le résultat du bloc de code. L'expression for renvoie le résultat du bloc de code de chaque itération dans une matrice ; par conséquent, le résultat de cette expression for est une matrice de références customize_light_device qui ont été balisées avec puzzle_light. Cela signifie que vous pouvez mettre à jour la matrice Lights avec le résultat de l'expression for directement. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • Cette boucle for doit également appeler TurnOn() / TurnOff() sur les lumières pour correspondre à leur configuration LightsState initiale dans l'éditeur. L'expression for peut renvoyer l'index utilisé pour obtenir l'appareil balisé actuel (ActorIndex dans cet exemple), que vous pouvez utiliser pour l'indexer dans la matrice LightsState afin de savoir si la lumière doit être allumée ou éteinte. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn:= LightsState[ActorIndex]
 do:
      LightDevice
    • Ensuite, appelez TurnOn() / TurnOff() selon que ShouldLightBeOn est true / false. Vous pouvez utiliser une expression if pour exécuter différentes expressions en fonction d'une condition (plus précisément, une expression faillible). Dans ce cas, l'expression faillible peut utiliser l'opérateur de requête ? avec IsLightOn, qui réussit si ShouldLightBeOn est true (donc, appeler TurnOn()), et échoue si ShouldLightBeOn est false (donc, appeler TurnOff()). 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
    • Il est également recommandé d'imprimer l'index de la lumière et sa valeur de départ afin de vérifier que votre code fonctionne comme prévu et de le comparer à ce que vous voyez dans le niveau.
    • Lorsque vous utilisez {} au milieu d'une chaîne, l'expression entre {} est évaluée en premier et sa valeur est ajoutée à la chaîne. Vous pouvez donc utiliser une expression if au milieu d'une chaîne pour ajouter des valeurs de manière conditionnelle. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[ActorIndex]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      Logger.Print("Adding Light at index {ActorIndex} with State:{if (ShouldLightBeOn?) then "On" else "Off"}")
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
  12. Votre méthode SetupPuzzleLights() doit maintenant être similaire à ceci : 
     SetupPuzzleLights() : void =
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})
     <#
     Pour chaque appareil avec la balise puzzle_light, vérifiez s'il s'agit d'un appareil customizable_light_device en essayant de le convertir en ce type.
     S'il est converti, obtenez son état LightState initial pour allumer (TurnOn()) ou éteindre (TurnOff()) l'appareil LightDevice.
     Enregistrez tous les appareils customizable_light_device balisés dans la matrice Lumières.
     #>
     set Lights = for:
             ActorIndex -> TaggedActor : TaggedActors
             LightDevice := customizable_light_device[TaggedActor]
             ShouldLightBeOn := LightsState[ActorIndex]
     do:
             Logger.Print("Adding Light at index {ActorIndex} with State:{if (ShouldLightBeOn?) then "On" else "Off"}")
             if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
             LightDevice
  13. Enregistrez le script dans Visual Studio Code.
  14. Dans la barre d'outils de l'UEFN, cliquez sur Générer les scripts Verse pour compiler votre code.
  15. Cliquez sur Jouer dans la barre d'outils de l'UEFN pour tester le niveau.

Lorsque vous testez votre niveau, chaque lumière ajoutée à la matrice Lights ainsi que son état initial doivent s'afficher dans le journal de sortie.

Étape suivante

Dans l'étape suivante de ce tutoriel, vous apprendrez à activer/désactiver un ensemble spécifique de lumières lorsque le joueur appuie sur les boutons.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page