Jeu d'évasion 10 - Le puzzle sur l'état des interrupteurs Verse dans l'Unreal Editor pour Fortnite | Fortnite Documentation

Deux énigmes ont été créées à l'aide de Verse, la première étant l'énigme Lumières balisées. L'énigme Lumières balisées est utilisée dans la pièce secrète située derrière les escaliers du deuxième sous-sol.

Énigme Lumières balisées configurée dans la pièce secrète

Vous pouvez copier-coller le code de la dernière section du tutoriel, mais il est fortement recommandé de construire l'énigme progressivement pour comprendre le fonctionnement du langage Verse.

La deuxième énigme utilise une clé logique programmée en dur pour vérifier chaque interrupteur et s'assurer que le bon interrupteur a été déclenché dans la bonne séquence.

Lorsque le bon interrupteur est actionné, un son de réussite est diffusé. De même, un son et un message d'échec sont déclenchés lorsque le mauvais interrupteur est actionné au cours de la séquence. Un son et un message de réussite finale sont émis, et quatre générateurs d'objets sont activés dès que l'énigme est résolue.

Vous pouvez utiliser une matrice pour vérifier les états correct et incorrect, ainsi que pour déclencher tout appareil connecté à un état. Dans le cadre de cet exemple, la clé de réponse a été codée en dur pour que les personnes n'étant pas habituées à programmer comprennent le code.

Configurer les appareils d'énigme

Pour cette énigme, vous aurez besoin des appareils suivants :

Renommez vos générateurs d'objets avec l'objet qu'ils génèrent.

Interrupteur

Placez un interrupteur sur le mur à côté de la porte et définissez les options suivantes.

Option	Valeur	Explication
Modèle d'appareil	Disjoncteur	Pour cette énigme, le joueur doit actionner le disjoncteur.
Son	Désactivé	Les appareils audio émettent des signaux sonores différents selon que l'état de l'énigme est Correct, Incorrect ou Réussite.
Durée d'interaction	0,1	L'interaction doit être immédiate.
Rayon d'interaction	1,0	Le joueur doit se trouver à moins d'un carré de l'interrupteur pour interagir avec lui.
Vérifier l'état au démarrage du jeu	Désactivé	C'est l'appareil Verse qui va se charger d'effectuer cette vérification.

Copiez trois autres interrupteurs sur le mur et placez-les de façon à former une ligne.

Appareil audio

Au centre du carré, placez un appareil audio. Réglez les options audio comme suit.

Option	Valeur	Explication
Relancer le son à l'activation	Activé	Le son doit être audible à plusieurs reprises et recommencer au début à chaque fois.
Activation à l'impact	Désactivé	C'est l'appareil Verse qui est chargé de déclencher l'appareil audio.

Copiez deux autres appareils audio. Renommez les appareils et ajoutez un signal sonore à chacun d'eux :

Correct - Pour l'appareil audio Correct, sélectionnez le signal sonore Match_Round_Change_01_Cue.
Incorrect - Pour l'appareil audio Incorrect, sélectionnez le signal sonore Player_Checkpoint_Trigger_Cue.
Réussite - Pour l'appareil audio Réussite, sélectionnez le signal sonore CTF_Return_Team_Cue

Déclencheur

À droite des interrupteurs, placez le déclencheur et définissez les options suivantes.

Option	Valeur	Explication
Visible pendant le jeu	Désactivé	Cet appareil ne doit pas être visible pendant le jeu.
Activer au démarrage du jeu	Désactivé	L'appareil Verse est chargé de contrôler le déclencheur.
Déclenché par un joueur	Désactivé	L'appareil Verse est chargé de contrôler le déclencheur.
Déclenché par un véhicule	Désactivé	L'appareil Verse est chargé de contrôler le déclencheur.
Déclenché par un séquenceur	Désactivé	L'appareil Verse est chargé de contrôler le déclencheur.
Déclenché par l'eau	Désactivé	L'appareil Verse est chargé de contrôler le déclencheur.
Nombre de déclenchements	Activé, 10	Vous souhaitez que le déclencheur puisse être utilisé plus d'une fois dans l'énigme.
Déclencher les effets visuels	Désactivé	Les effets visuels ne sont pas nécessaires.
Déclencher les effets sonores	Désactivé	Les appareils audio contrôlent le son.

Renommez l'appareil "Déclencheur incorrect".

Appareil de message d'ATH

Configurez le premier appareil de message d'ATH à l'aide des options suivantes.

Option	Valeur	Explication
Message	Message d'ATH Incorrect : Ça ne marche pas. Message d'ATH Recherche d'objets : J'ai entendu des objets métalliques tomber au sous-sol. Ces objets me serviront peut-être à ouvrir la porte.	Ces messages d'énigme couvrent les états d'échec et de réussite.
Durée d'affichage	Message d'ATH Incorrect - 3,0 Message d'ATH Réussite - 5,0	Durée d'affichage des messages.

Déplacez ensuite l'appareil de message d'ATH à l'extérieur du mur du sous-sol pour qu'il ne soit pas visible dans la pièce et copiez-le.

Renommez chacun des appareils de message d'ATH comme suit :

Message d'ATH Recherche d'objets
Message d'ATH Incorrect

Appareil Verse

Vous êtes maintenant prêt à créer le programme Verse permettant de contrôler l'énigme. Créez un nouvel appareil Verse nommé switch_state_puzzle à l'aide de l'explorateur Verse, puis faites-le glisser dans le niveau. (Pour savoir comment créer un nouvel appareil dans Verse, consultez la rubrique Créer votre propre appareil avec Verse.)

Concevoir l'énigme

Pour franchir cette étape du jeu d'évasion, le joueur doit actionner les interrupteurs dans le bon ordre.

Lorsque le joueur actionne un interrupteur dans le bon ordre, une cloche retentit. Si le mauvais interrupteur est activé, un signal sonore retentit et réinitialise les interrupteurs. Les états incorrects entraînent l'affichage d'un message, tandis que la réussite de l'énigme est accompagnée d'un son, d'un message utile et de la génération d'objets.

Vous pouvez visualiser la logique de l'énigme à l'aide de l'organigramme ci-dessous.

Cliquez sur l'image pour l'agrandir.

La solution correcte de l'énigme est indiquée dans le tableau ci-dessous.

Matrice de la solution de l'énigme
Interrupteurs	2	3	1	4
1			X
2	X		X
3	X	X	X
4	X	X	X	X

Fonctionnalités du langage Verse utilisées

if, then, else: les expressions if, then et else vous permettent de trouver les états valides et non valides de chaque interrupteur et d'autres appareils qui dépendent des états.
failure: les contextes d'échec permettent de décider de l'état actuel du puzzle et de sa solution.
for : l'expression for permet d'itérer sur chaque interrupteur du puzzle et d'effectuer des opérations sur ceux-ci.

API utilisées

Propriétés modifiables : plusieurs propriétés d'appareils créés avec Verse sont exposées à l'UEFN afin que vous puissiez les personnaliser dans l'éditeur. Vous pouvez créer de nouvelles configurations d'énigme en modifiant ces propriétés.
Appareil Événements : Les boutons InteractedWithEvent servent à Contrôler l'état du jeu.

Interaction avec les interrupteurs

Réfléchissez aux étapes nécessaires à l'exécution de l'énigme. Vous devez d'abord vérifier si l'appareil Verse enregistre un événement lorsqu'un joueur coche la case. Pour ce faire, commencez par écrire un pseudocode pour prouver le concept d'interaction.

Ajoutez les champs modifiables suivants sous la définition de la classe switch_state_puzzle.
1. Une matrice modifiable de type switch_device nommée Switches. Elle permet de référencer tous vos interrupteurs dans l'énigme.
2. Une matrice variable de type cancelable nommée SwitchSubscriptions. Elle contient une référence à chaque abonnement switch_device que vous pouvez utiliser pour réinitialiser les interrupteurs.


    switch_state_puzzle := class(creative_device):
    
    @editable
    Switches : []switch_device = array{} #Référence les interrupteurs avec lesquels les joueurs peuvent interagir

    var SwitchSubscriptions : []cancelable = array{}

Dans le même fichier, créez une nouvelle classe appelée switch_event_handler. Dans cette classe, vous identifierez l'appareil Verse et les interrupteurs.
Ajouter une nouvelle méthode OnSwitchPressed() à la classe switch_event_handler. Cette méthode compare l'appareil Verse à l'interaction du joueur en appelant CheckSequence() dans la classe item_switch_puzzle. Elle affiche également Clicked (cliqué) à chaque interaction avec un interrupteur.


## Classe de gestionnaire d'événements pour gérer les interactions avec les interrupteurs
## Ce gestionnaire d'événements est associé aux événements de la boucle ci-dessus
switch_event_handler := class():
    PuzzleDevice : item_switch_puzzle
    Switch : switch_device

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Clicked")
        PuzzleDevice.CheckSequence(InPlayer)

Ajouter un journal d'impression

Pour vérifier si votre code a réussi ou non, vous pouvez l'imprimer dans un journal. Cela vous permet de voir quelles parties de votre code fonctionnent comme prévu en imprimant des messages. Ajoutez le journal d'impression au-dessus de la classe d'appareil du mode Créatif.


    Print<native><public>(Message:[]char, Level:log_level):void

Référencement des interrupteurs

Il vous faut maintenant un moyen de référencer vos interrupteurs dans l'énigme. Le référencement des interrupteurs vous permet de parcourir en boucle tous les interrupteurs et d'ajouter des gestionnaires d'événements à chacun d'eux lorsque le jeu est en cours d'exécution.

Dans OnBegin() de la classe switch_state_puzzle, ajoutez une expression for pour itérer chaque Switch (interrupteur) dans la matrice Switches. Récupérez l'index de chaque Switch (interrupteur) et stockez-le dans une variable SwitchIndex.

1. Ajoutez une fonction d'affichage (Print) sous l'expression for qui identifie l'interrupteur avec lequel le joueur interagit pendant l'exécution en saisissant Switch {SwitchIndex} added dans la commande d'affichage.

La solution de l'énigme se basant sur l'ordre des états des interrupteurs, vous devez vérifier si l'énigme est résolue chaque fois qu'un interrupteur change d'état. Pour ce faire, vous utiliserez la classe switch_event_handler que vous avez définie plus tôt pour écouter deux événements différents par interrupteur. Pour chaque interrupteur, créez deux abonnements : un pour les interrupteurs TurnedOnEvent et l'autre pour les interrupteurs TurnedOffEvent. Abonnez ces deux événements à la fonction OnSwitchPressed() de votre classe switch_event_handler. Transmettez une référence à switch_state_puzzle et à l'interrupteur en cours.


    ## S'exécute à l'activation de l'appareil dans une partie en cours
    OnBegin<override>()<suspends>:void=
        Print("Loading Switch Puzzle")

        ## Parcourt en boucle chaque interrupteur et ajoute des gestionnaires d'événements pour chacun d'eux
        for (SwitchIndex -> Switch: Switches):
            Print("Switch {SwitchIndex} added")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

Enregistrez le script dans Visual Studio Code puis, dans l'UEFN, cliquez sur Verse -> Générer le code Verse.

Lorsque vous testez votre niveau, chaque fois que vous activez ou désactivez un interrupteur, vous devez voir s'afficher l'index de l'interrupteur avec lequel vous avez interagi et le mot Clicked.

États de l'énigme

Chaque interrupteur de l'énigme présente deux états, Correct et Incorrect.

Pour résoudre l'énigme, le joueur doit actionner les interrupteurs dans un certain ordre. Pour mettre en œuvre cet ordre dans le code, vous devez définir une séquence d'états corrects pour chaque interrupteur et vérifier cette séquence chaque fois qu'un joueur met à jour l'état de l'interrupteur.

Ajouter une nouvelle méthode ValidState() à la classe switch_state_puzzle. Cette méthode prend une chaîne et lit un clip audio chaque fois qu'un joueur actionne un interrupteur dans un état valide, ce qui déclenche une indication sonore pour indiquer au joueur qu'il est sur la bonne voie.
Dans ValidState(), affichez la chaîne State qui a été transmise et appelez Play() sur le lecteur ValidAudioPlayer configuré plus tôt.


    # Actions à effectuer lorsque l'état est correct
    ValidState(State : string) : void =
        # Lire un son de validation
        Print("Valid {State}")
        ValidAudioPlayer.Play()

Ajouter une nouvelle méthode InvalidState() à la classe switch_state_puzzle. Cette méthode réinitialise tous les interrupteurs après la lecture d'un son lorsque le joueur déclenche un état non valide.


    # Actions à effectuer lorsque l'état est incorrect
    InvalidState(InPlayer : agent) : void =
        # Lire un son d'avertisseur 
        # Effacer tous les interrupteurs
        Print("Invalid")

Dans InvalidState(), faites savoir au lecteur qu'il a déclenché un état incorrect en affichant Invalid et en démarrant la lecture d'un clip audio via l'appel de Play() sur le lecteur InvalidAudioPlayer créé plus tôt. Vous devez également appeler Trigger() sur votre InvalidTrigger et Show() sur votre InvalidHUDMessage.


	# Actions à effectuer lorsque l'état est incorrect
    InvalidState(InPlayer : agent) : void =
        # Lire un son d'avertisseur 
        # Effacer tous les interrupteurs
        Print("Invalid")
        InvalidAudioPlayer.Play()
        InvalidTrigger.Trigger()
        InvalidHUDMessage.Show()

Créez une boucle for qui s'abonne aux événements sur les interrupteurs. L'instruction "print" identifie les interrupteurs qu'un joueur actionne et l'ordre dans lequel il les actionne.


        ## Parcourt en boucle chaque interrupteur et ajoute des gestionnaires d'événements pour chacun d'eux
        for (SwitchIndex -> Switch: Switches):
            Print("Switch {SwitchIndex} added")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

Dans une boucle for, parcourez en boucle tous les interrupteurs et désactivez chacun d'eux. Dans la mesure où la méthode TurnOff() de l'interrupteur nécessite un joueur instigateur, indiquez le joueur ayant déclenché l'état incorrect.


        ## Parcourt en boucle les interrupteurs et désactive chacun d'eux 
        for (SwitchIndex -> Switch: Switches):
            Switch.TurnOff(InPlayer)

Enregistrez votre code, revenez à l'UEFN et sélectionnez Verse > Générer le code Verse.

Vous devez ensuite créer la logique dans la classe item_switch_puzzle qui parcourt en boucle chaque interrupteur et valide son état par rapport à la matrice de l'énigme afin de déterminer l'état (correct ou incorrect) dans lequel se trouve le bouton de l'interrupteur.

Trier les états des interrupteurs

Pour vérifier la validité de l'actionnement d'un interrupteur, vous devez créer une méthode CheckSequence qui utilise une expression for pour vérifier l'état actuel de l'interrupteur. Pour déterminer si le changement d'état d'un interrupteur est correct ou non, utilisez une instruction if afin de définir les actionnements corrects dans la séquence et ceux qui ne le sont pas.

Ajoutez une nouvelle méthode CheckSequence(). Cette méthode considère le joueur comme instigateur des changements d'état de l'interrupteur et récupère une matrice de valeurs logiques correspondant aux états de l'interrupteur. Dans CheckSequence(), créez une boucle for pour itérer sur chaque interrupteur de la matrice Switches. Obtenez l'index de chaque interrupteur de la matrice et enregistrez-le dans une variable SwitchIndex. Dans la boucle for, vérifiez l'état de chaque interrupteur en appelant GetCurrentState[]. Affichez ensuite l'état du commutateur dans le journal.


    # Fonction de validation de la séquence d'interrupteurs
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch: Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")

Vous devez maintenant créer une séquence d'états à vérifier en utilisant CheckSequence(). Pour ce faire, vous allez ajouter une nouvelle fonctionnalité à la méthode OnSwitchPressed() de switch_event_handler.

Séquence d'états

Créez la séquence d'états de l'interrupteur à l'aide de matrices. Chaque matrice vérifie la validité de l'ordre d'actionnement des interrupteurs. Enregistrez la séquence des actions du joueur sur les interrupteurs à l'aide du journal d'affichage pour vérifier si le joueur a cliqué (Clicked) sur les interrupteurs et si la séquence est correcte en affichant le numéro de la séquence dans le journal ("One", "Two", "Three" et "Four").

Dans OnSwitchPressed(), à l'intérieur d'une instruction if, appelez CheckSequence() en transmettant à la fois le joueur et une nouvelle matrice de valeurs logiques. Cette nouvelle matrice doit correspondre à votre série d'interrupteurs, les valeurs false représentant les interrupteurs désactivés et les valeurs true les interrupteurs activés. Réglez l'interrupteur que le joueur doit actionner en premier sur true et tous les autres sur false. Si l'appel à CheckSequence[] réussit, appelez ValidState() en transmettant "One" pour représenter le premier interrupteur actionné.


    OnSwitchPressed(InPlayer : agent) : void =
        Print("Clicked")
        PuzzleDevice.CheckSequence(InPlayer)

1. Codez en dur la clé de réponse des interrupteurs pour chacun des interrupteurs de votre puzzle, dans l'ordre dans lequel vous souhaitez qu'ils soient actionnés.


    if:
            # Vérifier la validité des états et programmer en dur la validation des états
            # [éteint],[éteint],[allumé],[éteint] État 1
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

        else if:
            # Vérifier la validité des états
            #[allumé], [éteint], [allumé], [éteint] État 2
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

        else if:
            # Vérifier la validité des états
            #[allumé], [allumé], [allumé], [éteint] État 3
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # Vérifier la validité des états
            #[allumé], [allumé], [allumé], [allumé] État 4, énigme terminée
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

if:
            # Vérifier la validité des états et programmer en dur la validation des états
            # [éteint],[éteint],[allumé],[éteint] État 1
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

else if:
            # Vérifier la validité des états
            #[allumé], [éteint], [allumé], [éteint] État 2
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

else if:
            # Vérifier la validité des états
            #[allumé], [allumé], [allumé], [éteint] État 3
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # Vérifier la validité des états
            #[allumé], [allumé], [allumé], [allumé] État 4, énigme terminée
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

Enfin, ajoutez une expression else à la fin qui appelle InvalidState(). Cette fonction est exécutée si l'un des appels à CheckSequence() échoue.

    
    else:
            # Son état n'étant pas correct, elle est incorrecte
            InvalidState(InPlayer)

Votre code switch_event_handler doit maintenant ressembler à celui-ci.


    # Fonction de validation de la séquence d'interrupteurs
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch: Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")
        
        if:
            # Vérifier la validité des états et programmer en dur la validation des états
            # [éteint],[éteint],[allumé],[éteint] État 1
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

        else if:
            # Vérifier la validité des états
            #[allumé], [éteint], [allumé], [éteint] État 2
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

        else if:
            # Vérifier la validité des états
            #[allumé], [allumé], [allumé], [éteint] État 3
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # Vérifier la validité des états
            #[allumé], [allumé], [allumé], [allumé] État 4, énigme terminée
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

        else:
            # Son état n'étant pas correct, elle est incorrecte
            InvalidState(InPlayer)

# Fonction de validation de la séquence d'interrupteurs
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch: Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")
        
        if:
            # Vérifier la validité des états et programmer en dur la validation des états
            # [éteint],[éteint],[allumé],[éteint] État 1
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

else:
            # Son état n'étant pas correct, elle est incorrecte
            InvalidState(InPlayer)

Enregistrez votre code, revenez à l'UEFN et sélectionnez Verse > Générer le code Verse.

Dorénavant, lorsque vous activez des interrupteurs dans le jeu, le journal affiche ce qui suit :

Loading Switch Puzzle : au début de la partie
Switch {SwitchIndex} added : à l'ajout d'un interrupteur à la boucle
Clicked : lorsqu'un joueur actionne un interrupteur
Valid {State} : si le joueur actionne le bon interrupteur dans le bon ordre
Invalid : si le joueur actionne le mauvais interrupteur

Si le journal rapporte correctement les actionnements des interrupteurs, vous pouvez ajouter d'autres appareils modifiables à la classe item_switch_puzzle et faire en sorte que chacun de ces états déclenche une action.

Ajout d'appareils

Une fois que le joueur a résolu l'énigme (en déclenchant tous les états corrects des interrupteurs pour aboutir à l'état Réussite), sa réussite doit avoir un résultat, comme la réception d'un objet.

Il en va de même pour les états incorrects. Si le joueur se trompe, le script doit en tenir compte et informer le joueur qu'il doit faire une nouvelle tentative. Pour ce faire, vous devez ajouter des appareils supplémentaires à la classe item_switch_puzzle.

Lorsque vous ajoutez des appareils modifiables à votre script, ceux-ci apparaissent dans les options utilisateur de l'appareil Verse, où vous pouvez connecter les appareils à l'appareil Verse pour qu'ils fonctionnent dans le jeu conformément au script Verse.

1. Ajoutez les appareils @editable suivants sous item_switch_puzzle :


	@editable 
	InvalidTrigger : trigger_device = trigger_device{}

	@editable 
	InvalidHUDMessage : hud_message_device = hud_message_device{}

	@editable 
	InvalidAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	ValidAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	FindItemsHUDMessage : hud_message_device = hud_message_device{}

	@editable 
	CompletedAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	ItemSpawners : item_spawner_device = item_spawner_device{} #Récupère tous les générateurs d'objets associés à cette énigme

Ajouter une nouvelle méthode CompletedState() à la classe item_switch_puzzle. Cette méthode gère les actions effectuées une fois le puzzle terminé.


    ## Actions à effectuer lorsque l'énigme est terminée
    CompletedState() : void =
        # Lire un son de réussite
        # Désactiver tous les interrupteurs
        # Générer des objets sur les générateurs d'objets associés
        Print("Completed")

1. Ajoutez une expression for à la méthode CompletedState() qui itère sur chaque générateur d'objets dans ItemSpawners. Activez chaque générateur d'objets avec Enable(), puis appelez SpawnItem() afin d'accorder au joueur la récompense pour avoir résolu le puzzle.


    ## Parcourir en boucle les générateurs d'objets pour appeler chaque générateur d'objets en vue de l'activer et de générer son objet
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

1. Une fois le puzzle terminé avec succès, vous devez appeler Play() sur CompletedAudioPlayer, configuré plus tôt, générer les pièces de métal sur les générateurs d'objets en utilisant ItemSpawnerIndex, et appeler Enable1 et SpawnItem. Informez le joueur qu'il doit rechercher les objets nouvellement générés en appelant Show() sur FindItemsHUDMessage. Par ailleurs, vous ne souhaitez pas que le joueur continue à interagir avec vos interrupteurs. Ajoutez une seconde expression for pour parcourir en boucle chaque interrupteur dans Switches et les désactiver en appelant Disable().


    # Actions à effectuer lorsque l'énigme est résolue
    CompletedState() : void =
        # Lire un son de réussite
        # Désactiver tous les interrupteurs
        # Générer des objets sur les générateurs d'objets associés
        Print("Completed")
        
        # Parcourir en boucle les générateurs d'objets pour appeler chaque générateur d'objets en vue de l'activer et de générer son objet
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

        # Lit le signal audio spécial une fois terminée la séquence de l'énigme
        CompletedAudioPlayer.Play()

        # Lit un message d'ATH pour indiquer au joueur qu'il doit rechercher les objets nouvellement générés
        FindItemsHUDMessage.Show()

	    # Désactiver tous les interrupteurs une fois l'énigme résolue
        for (SwitchIndex -> Switch: Switches):
            Switch.Disable()

Enregistrez votre code, revenez à l'UEFN et sélectionnez Verse > Générer le code Verse.

Ces appareils ont été ajoutés à l'appareil Énigme d'interrupteur d'objets dans l'UEFN.

Sélectionner des appareils

Tous les appareils @editable sont ajoutés à l'appareil Verse. Vous devez maintenant associer à l'appareil Verse les appareils que vous avez utilisés pour créer l'énigme. Pour ce faire, sélectionnez item_switch_puzzle dans l'organiseur. Tous les emplacements d'appareils sont alors visibles dans le panneau Détails. Il vous suffit de mettre en correspondance l'appareil avec l'emplacement.

1. Ajoutez les interrupteurs du puzzle aux éléments de la matrice Switches 4 sous Item Switch Puzzle.

Ajouter tous les interrupteurs à la matrice Switches

Ajoutez le Déclencheur non valide au créneau InvalidTrigger

1. Ajoutez le message d'ATH non valide au créneau InvalidHUDMessage.

1. Ajoutez le lecteur audio non valide au créneau InvalidAudioPlayer.

Ajouter tous les appareils incorrects à leurs emplacements individuels

Ajoutez le lecteur audio valide au créneau ValidAudioPlayer.
Ajoutez l'appareil Rechercher le message d'ATH au créneau FindHUDMessage.

1. Ajoutez le lecteur audio de fin au créneau CompletedAudioPlayer .

Ajouter les appareils aux bons emplacements individuels

1. Ajoutez les générateurs d'objets aux éléments de la matrice ItemSpawners 4.

Ajouter les générateurs d'objets à la matrice

Décochez l'option Visible pendant le jeu pour masquer l'appareil Verse pendant le jeu.

Vous êtes maintenant prêt à tester votre niveau et à découvrir la façon dont les énigmes enrichissent l'expérience du jeu d'évasion.

Section suivante

Une fois que l'énigme sur l'état des interrupteurs fonctionne correctement, vous pouvez créer le script Verse de téléportation automatique qui permet au joueur qui visionne la cinématique d'ouverture de passer à la zone de captivité située dans le deuxième sous-sol du chalet, une fois la cinématique terminée.

%escape-room-11-teleporting-players-in-unreal-editor-for-fortnite:topic%

10. Puzzle sur l'état des interrupteurs Verse

Prerequisite topics