1. Epic GamesDeveloper
  3. 4. Basculer des lumières à l'aide de boutons

4. Basculer des lumières à l'aide de boutons

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.

4. Basculer des lumières à l'aide de boutons
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 allez apprendre à activer/désactiver un groupe de lumières en fonction du bouton avec lequel le joueur interagit.

Activer/désactiver des lumières

Vous devez créer un mappage entre un bouton et le groupe de lumières qu'il doit activer ou désactiver lorsque le joueur interagit avec le bouton. Pour ce faire, vous pouvez mapper chaque bouton sur les index des lumières dans la matrice Lights.

Dans cet exemple, nous utilisons le mappage suivant entre les boutons et les lumières :

  • Le bouton 1 est mappé sur la lumière à l'index 0 et sur la lumière à l'index 3.
  • Le bouton 2 est mappé sur la lumière à l'index 0, sur la lumière à l'index 1 et sur la lumière à l'index 2.
  • Le bouton 3 est mappé sur la lumière à l'index 0 et sur la lumière à l'index 1.
  • Le bouton 4 est mappé sur la lumière à l'index 1.

Vous pouvez représenter ce mappage avec une matrice nommée ButtonsToLights, où chaque élément de ButtonsToLights est une autre matrice contenant les index des lumières. Le type de ButtonsToLights est alors [][]int, pour spécifier que ButtonsToLights est une matrice de matrice de nombres entiers.

Index 0 1 2 3
Élément array{0, 3} array{0, 1, 2} array{0, 1} array{1}

Procédez comme suit pour activer/désactiver les lumières :

  1. Créez une matrice de matrices de nombres entiers nommée ButtonsToLights et initialisez-la avec le mappage des index bouton/lumière décrit dans le tableau ci-dessus. 
     ButtonsToLights : [][]int = array{array{0, 3}, array{0, 1, 2}, array{0, 1}, array{1}}

    Les index d'une matrice sont compris entre 0 et le nombre d'éléments, moins 1. Ainsi, le premier élément de ButtonsToLights commence à l'index 0 et le dernier élément à l'index 3.
  2. Ajoutez une méthode appelée ToggleLights() à la classe tagged_lights_puzzle. Cette méthode bascule les lumières de la matrice Lights en fonction des index fournis à la fonction sous forme de matrice de nombres entiers (pour les mettre en correspondance avec les éléments de la matrice ButtonsToLights) et met à jour les éléments aux mêmes index dans LightsState.
    1. Ajoutez le paramètre LightIndices : []int à la méthode ToggleLights(), et affichez chaque index dans le journal de sortie en utilisant l'expression for. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
 do:
     Logger.Print("Toggling light at {LightIndex}")
    2. Appelez ToggleLights() dans OnBegin() pour tester la méthode à mesure que vous la créez. Utilisez le premier élément de ButtonsToLights comme test. L'indexation dans une matrice étant une expression faillible, vous devrez accéder à la matrice à partir d'un contexte d'échec. Dans cet exemple, nous utilisons l'expression if pour le contexte d'échec.
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()

     # Utilisez le premier élément de ButtonsToLights pour tester la méthode ToggleLights
     if (LightIndices : []int = ButtonsToLights[0]):
         ToggleLights(LightIndices)
  3. Maintenant que vous disposez du LightIndex, accédez aux matrices Lights et LightsState à cet index pour obtenir la référence de l'appareil Lumière personnalisable et son état actuel. "Basculer une lumière" signifie que si la lumière est allumée, vous l'éteignez, et inversement. Mettez à jour l'instruction d'affichage pour indiquer quel sera le nouvel état de la lumière. 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         Light := Lights[LightIndex]
         IsLightOn := LightsState[LightIndex]
     do:
         Logger.Print("Turning light at {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
  4. Maintenant, actualisez l'état de l'appareil Lumière personnalisable à la fois dans le jeu et dans la matrice LightsState.
    1. Appelez TurnOn() sur la lumière si IsLightOn est false et TurnOff() si IsLightOn est true. La dernière expression d'un bloc de code correspond au résultat ; par conséquent, définir false ou true comme dernière expression signifie que cette valeur est stockée dans NewLightState. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     Light := Lights[LightIndex]
     IsLightOn := LightsState[LightIndex]
 do:
     Logger.Print("Turning light at {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             false
         else:
             Light.TurnOn()
             true
    2. Mettez à jour l'élément LighsState de l'index LightIndex selon la valeur de NewLightState. Dans la mesure où l'indexation de la matrice est une expression faillible, la configuration de LightsState doit être englobée dans un contexte d'échec. Dans cet exemple, le contexte d'échec est l'expression if. Indiquez dans le journal de sortie que l'état a été modifié. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     IsLightOn := LightsState[LightIndex]
     Light := Lights[LightIndex]
 do:
     Logger.Print("Turning light at {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             false
         else:
             Light.TurnOn()
             true
     if (set LightsState[LightIndex] = NewLightState):
         Logger.Print("Updated the state for light at {LightIndex}")

    Il est conseillé de mettre à jour le journal de sortie lorsque vous utilisez des contextes d'échec. Si une expression échoue dans un contexte d'échec, toutes les modifications apportées dans le contexte d'échec sont annulées, comme si elles n'avaient jamais eu lieu. Si vous mettez à jour le journal de sortie, vous pouvez vérifier que la modification a été effectuée si le texte apparaît dans le journal de sortie, sans compter uniquement sur l'état du jeu pour vérifier si la modification a réussi.

Relier l'appui sur des boutons à l'activation/la désactivation des lumières

Maintenant que vous avez défini comment activer/désactiver les lumières, l'étape suivante consiste à relier l'appui sur les boutons à l'activation/désactivation des lumières.

Pour cela, vous pouvez vous abonner à l'événement InteractedWithEvent du bouton. Consultez la rubrique Interactions des appareils de codage, pour plus d'informations sur la souscription à l'événement.

L'événement InteractedWithEvent attend un gestionnaire d'événements avec un paramètre InPlayer : agent et un type de retour void, mais le gestionnaire d'événements doit également savoir à quelles lumières est connecté le bouton ayant envoyé l'événement et contenir une référence à votre appareil Verse tagged_lights_puzzle pour pouvoir appeler sa méthode ToggleLights().

Vous pouvez regrouper toutes ces informations dans un objet personnalisé en créant une nouvelle classe qui contient les index et la fonction à laquelle s'abonner. De cette façon, chaque bouton a son propre état et son propre gestionnaire d'événements, représentés par cette nouvelle classe.

Procédez comme suit pour créer un objet personnalisé pour la gestion des événements :

  1. Créez une nouvelle classe nommée button_event_handler. La définition de classe doit contenir les éléments suivants :
    1. Une matrice de nombres entiers nommée Indices.
    2. Un champ tagged_lights_puzzle nommé PuzzleDevice, qui référence votre appareil Verse, afin que vous puissiez appeler la méthode ToggleLights().
    3. Une méthode appelée OnButtonPressed() avec le paramètre InPlayer : agent et un type de retour void, qui appelle la méthode ToggleLights() sur PuzzleDevice. 
       button_event_handler := class():
 # Positions utilisées pour accéder aux lumières que ce bouton contrôle.
 Indices : []int

 # tagged_lights_puzzle ayant créé ce button_event_handler afin de pouvoir appeler des fonctions dessus.
 PuzzleDevice : tagged_lights_puzzle
    
 OnButtonPressed(InPlayer : agent) : void =
     # Demandez à PuzzleDevice d'activer/de désactiver les lumières aux positions que ce bouton contrôle.
     PuzzleDevice.ToggleLights(Indices)
  2. Créez un champ de matrice button_device modifiable dans la classe tagged_lights_puzzle pour référencer les boutons avec lesquels le joueur peut interagir : 
     @editable
 Buttons : []button_device = array{}
  3. Maintenant, mettez à jour OnBegin() dans la classe tagged_lights_puzzle pour créer une instance button_event_handler pour chaque bouton. L'instance button_event_handler doit disposer des informations suivantes :
    • Les index des lumières associées au bouton, que vous pouvez obtenir auprès de la matrice ButtonsToLights en utilisant l'index de bouton fourni par l'expression for. Vous pouvez l'obtenir comme condition de filtre de l'expression for utilisée pour itérer tous les boutons. Il fait également office de garde-fou pour empêcher le code d'indexer des données non valides ; si l'indexation échoue, le programme reste valide, car cette itération défaillante est ignorée (cet échec peut se produire si vous avez oublié de mettre en correspondance le nombre de ButtonsToLights avec le nombre de Buttons).
    • Une référence à votre appareil Verse, l'instance de tagged_lights_puzzle. Pour obtenir une référence à l'objet actuel depuis l'intérieur d'une définition de classe, vous pouvez utiliser Self.
    • La création d'un objet button_event_handler avec ces données ressemble à ce qui suit : 
       OnBegin<override>()<suspends> : void =
  SetupPuzzleLights()
    
  for:
      ButtonIndex -> Button : Buttons
      LightIndices := ButtonsToLights[ButtonIndex]
  do:
      button_event_handler{Indices := LightIndices, PuzzleDevice := Self}
  4. Vous pouvez à présent utiliser la fonction OnButtonPressed() du gestionnaire nouvellement créé pour vous abonner à l'événement InteractedWithEvent de l'appareil Bouton. Lorsque la fonction OnButtonPressed() est appelée, vous avez accès aux index des lumières et à une référence à l'appareil tagged_lights_puzzle associé au bouton avec lequel le joueur a interagi. 
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
    
     for:
         ButtonIndex -> Button : Buttons
         LightIndices := ButtonsToLights[ButtonIndex]
     do:
         Button.InteractedWithEvent.Subscribe(button_event_handler{Indices := LightIndices, PuzzleDevice := Self}.OnButtonPressed)
  5. Enregistrez le script dans Visual Studio Code.
  6. Dans la barre d'outils de l'UEFN, cliquez sur Générer les scripts Verse pour mettre à jour votre appareil Verse dans le niveau avec votre nouveau code.
  7. Dans l'Organiseur, sélectionnez l'appareil tagged_lights_puzzle pour ouvrir le panneau Détails correspondant.
  8. Dans le panneau Détails, ajoutez quatre éléments à la matrice Buttons et attribuez un bouton différent à chacun d'eux. Vous n'avez pas besoin de modifier les autres propriétés, car le script les renseigne automatiquement.
  9. Cliquez sur Jouer dans la barre d'outils de l'UEFN pour tester le niveau.

Lorsque vous testez votre niveau, vous devez être en mesure d'interagir avec les boutons, et chaque bouton doit activer/désactiver un ensemble différent de lumières en fonction de la configuration de ButtonsLightsIndices. Remarque : dans la mesure où GetCreativeObjectsWithTag() ne garantit pas un ordre spécifique, il est possible que les lumières activées/désactivées en fonction de l'ordre dans le script ne correspondent pas à l'ordre que vous voyez dans le niveau.

Le joueur appuie sur des boutons et chaque bouton active/désactive un ensemble différent de lumières

Étape suivante

Dans l'étape suivante de ce tutoriel, vous apprendrez à détecter le moment où le joueur résout le casse-tête afin de faire apparaître un objet et d'empêcher toute autre interaction avec le jeu.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page