10. Puzzle Cambia stato Verse

Utilizzando Verse, hai la possibilità di creare due puzzle: il primo è il Puzzle delle luci con tag. Il Puzzle delle luci con tag viene utilizzato nella stanza nascosta dietro le scale nel sottointerrato.

Puoi copiare e incollare direttamente il codice dall'ultima sezione del tutorial, ma ti consigliamo vivamente di costruire il puzzle procedendo per gradi per capire come funziona il linguaggio Verse.

Il secondo puzzle utilizza una chiave logica codificata per controllare ogni dispositivo di commutazione per assicurarsi che l'interruttore giusto sia stato attivato nella sequenza corretta.

Quando viene attivato l'interruttore corretto, la relativa accensione viene accompagnata da un suono positivo. Allo stesso modo, vengono invece attivati un suono e un messaggio di errore quando viene acceso l'interruttore sbagliato durante la sequenza. Infine, vengono riprodotti un suono e un messaggio finale di esito positivo e vengono attivati quattro generatori di oggetti quando viene risolto il puzzle.

Puoi utilizzare un array per controllare gli stati validi e non validi e per attivare qualsiasi dispositivo connesso a uno stato. In questo esempio, la chiave di risposta è stata codificata in modo da agevolare la comprensione di coloro che non sono familiari con la codifica, rendendo chiaro ciò che il codice sta eseguendo.

Configurazione dei dispositivi Puzzle

Per la creazione di questo puzzle, avrai bisogno dei seguenti dispositivi:

• 4 Dispositivi Interruttore

• 3 Dispositivi Riproduttore audio

• 4 Dispositivi Interruttore oggetto

• 2 Dispositivi Messaggio HUD

• 1 Dispositivo Attivatore

• 1 Dispositivo Verse

Rinomina i generatori di oggetti in modo che il loro nome rifletta il tipo di oggetto che generano.

Dispositivo Interruttore

Posiziona un dispositivo Interruttore sulla parete accanto alla porta e imposta le opzioni seguenti

Copia altri tre dispositivi Interruttore sulla parete e posizionali in fila.

Dispositivo Audio

Al centro del quadrato posiziona un dispositivo Audio. Imposta le opzioni Audio riportate di seguito.

Copia altri due dispositivi Audio. Rinomina i dispositivi e aggiungi un cue sonoro a ciascuno di essi:

• Valido - Per la riproduzione del dispositivo Audio valido, Match_Round_Change_01_Cue.

• Non valido - Per la riproduzione del dispositivo Audio non valido, Player_Checkpoint_Trigger_Cue.

• Completato - Per la riproduzione del dispositivo Audio completato, CTF_Return_Team_Cue

Dispositivo Attivatore

Posiziona il dispositivo Attivatore a destra degli interruttori e imposta le opzioni seguenti.

Rinomina il dispositivo Attivatore non valido.

Dispositivo Messaggio HUD

Imposta il primo dispositivo Messaggio HUD utilizzando le opzioni seguenti.

Successivamente, trasla il dispositivo Messaggio HUD al di fuori del muro del seminterrato in modo che non sia visibile nella stanza e copialo.

Rinomina ciascuno dei dispositivi Messaggio HUD:

• Trova il messaggio HUD degli oggetti

• Messaggio HUD non valido

Dispositivo Verse

Ora puoi procedere con la creazione del programma Verse che controlla il puzzle. Crea un nuovo dispositivo Verse denominato switch_state_puzzle utilizzando Verse Explorer e trascinalo nel livello. (Per i passaggi sulla creazione di un nuovo dispositivo Verse, vedi Creare un dispositivo utilizzando Verse.)

Progettazione del puzzle

Accendere gli interruttori nella sequenza corretta permette ai giocatori di superare questo punto della escape room.

Quando il giocatore accende un interruttore nella sequenza corretta, suona un campanello. Se viene acceso l'interruttore sbagliato, viene invece emesso un segnale acustico e vengono ripristinati gli interruttori. Gli stati non validi causano la comparsa di un messaggio mentre il completamento del puzzle riproduce un suono di esito positivo, visualizza un messaggio di assistenza e genera oggetti.

Puoi visualizzare la logica del puzzle utilizzando il diagramma di flusso riportato di seguito.

Fai clic sull'immagine per ingrandirla.

La soluzione corretta del puzzle è mostrata nella tabella seguente.

Funzionalità del linguaggio Verse utilizzate

• if, then, else: con le espressioni if, then e else puoi trovare stati validi e non validi per ogni dispositivo interruttore e altri dispositivi dipendenti dagli stati.

• failure: I contesti di errore sono utilizzati per decidere lo stato attuale del puzzle e la sua soluzione.

• for: L'espressione for viene utilizzata per eseguire l'iterazione di ciascun interruttore del puzzle e operazioni su di esso.

API utilizzate

• Proprietà modificabili: varie proprietà dei dispositivi creati da Verse sono esposte a UEFN, in modo da poterle personalizzare nell'editor. Potrai creare nuove configurazioni di puzzle modificando queste proprietà.

• Eventi dispositivo: I pulsanti InteractedWithEvent sono utilizzati per controllare lo stato del gioco.

Interazione dell'Interruttore

Pensa ai diversi passaggi necessari per risolvere il puzzle. Innanzitutto, puoi controllare se il dispositivo Verse registra un evento quando un giocatore seleziona la casella. Per fare ciò, scrivi prima alcune righe di pseudocodice per dimostrare il concetto di interazione.

1. Sotto la definizione della classe switch_state_puzzle, aggiungi i seguenti campi modificabili.

   1. Array modificabile di tipo switch_device denominato Switches. Questo si riferirà a tutti gli interruttori del tuo puzzle.

   2. Array di variabili di tipo cancelable denominato SwitchSubscriptions. Contiene un riferimento a ogni sottoscrizione switch_device utilizzabile per reimpostare le opzioni.

    switch_state_puzzle := class(creative_device):
    
    @editable
    Interruttori : []switch_device = array{} #Fa riferimento agli interruttori con cui i giocatori possono interagire

    var SwitchSubscriptions : []cancelable = array{}

Copy full snippet

switch_state_puzzle := class(creative_device): @editable Interruttori : []switch_device = array{} #Fa riferimento agli interruttori con cui i giocatori possono interagire var SwitchSubscriptions : []cancelable = array{}

1. Nello stesso file, crea una nuova classe denominata switch_event_handler'. In questa classe identificherai il dispositivo Verse e gli interruttori.

2. Aggiungi un nuovo metodo OnSwitchPressed() alla classe switch_event_handler. Questo metodo verifica il dispositivo Verse rispetto all'interazione del giocatore chiamando CheckSequence() nella classe item_switch_puzzle. Stampa anche il testo Cliccato ogni volta che si interagisce con un interruttore.

## Una classe di gestori eventi per gestire le interazioni dell'interruttore
## Questo gestore eventi è collegato agli eventi nel loop precedente
switch_event_handler := class():
    PuzzleDevice : item_switch_puzzle
    Switch : switch_device

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

Copy full snippet

## Una classe di gestori eventi per gestire le interazioni dell'interruttore ## Questo gestore eventi è collegato agli eventi nel loop precedente switch_event_handler := class(): PuzzleDevice : item_switch_puzzle Switch : switch_device OnSwitchPressed(InPlayer : agent) : void = Print("Cliccato") PuzzleDevice.CheckSequence(InPlayer)

Aggiungi un logger di stampa

Una modalità per verificare se il codice ha un esito positivo o meno è quella di stampare l'output in un registro. In questo modo puoi vedere visivamente quali parti del codice funzionano come previsto stampando i messaggi. Aggiungi il logger di stampa sopra la classe del dispositivo di Fortnite Creativo.

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

Copy full snippet

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

Riferimento agli interruttori

Ora hai bisogno di un modo per fare riferimento ai tuoi dispositivi Interruttore nel puzzle. Il riferimento ai dispositivi interruttore consente di eseguire il loop di tutti gli interruttori e di aggiungere gestori eventi a ogni interruttore quando il gioco è in esecuzione.

1. In OnBegin() nella classe switch_state_puzzle, aggiungi un'espressione for per scorrere ogni Switch nell'array Switches. Recupera l'indice di ogni Switche memorizzarlo in una variabile SwitchIndex.

2. Aggiungi una funzione di stampa sotto l'espressione for che identifichi l'interruttore con cui si interagisce durante l'esecuzione digitando Interruttore {SwitchIndex} aggiunto nel comando Stampa.

3. Poiché la soluzione del puzzle si basa su un determinato ordine di stati dell'interruttore, è necessario verificare se il puzzle viene effettivamente risolto ogni volta che un interruttore cambia stato. A tale scopo, utilizzerai la classe switch_event_handler definita in precedenza per l'ascolto di due eventi diversi per ogni interruttore. Per ogni interruttore, crea due sottoscrizioni, una per gli interruttori TurnedOnEvent e una per gli interruttori TurnedOffEvent. Sottoscrivi entrambi gli eventi alla funzione OnSwitchPressed() della tua classe switch_event_handler. Passa un riferimento sia a switch_state_puzzle sia a Switchcorrente.

    ## Viene eseguito quando il dispositivo è avviato in un gioco in esecuzione
    OnBegin<override>()<suspends>:void=
        Print("Caricamento Puzzle Interruttore")

        # Loop di ogni interruttore e aggiunta di gestori eventi per ogni interruttore
        for (SwitchIndex -> Switch : Switches):
            Print("Interruttore {SwitchIndex} aggiunto")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

Copy full snippet

## Viene eseguito quando il dispositivo è avviato in un gioco in esecuzione OnBegin<override>()<suspends>:void= Print("Caricamento Puzzle Interruttore") # Loop di ogni interruttore e aggiunta di gestori eventi per ogni interruttore for (SwitchIndex -> Switch : Switches): Print("Interruttore {SwitchIndex} aggiunto") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

1. Salva lo script in Visual Studio Code e, in UEFN, fai clic su Verse -> Compila codice Verse.

Durante il test del livello, ogni volta che accendi o spegni un interruttore, dovresti visualizzare sia l'indice dell'interruttore con cui hai interagito che la parola Cliccato stampati.

Stati del puzzle

Ogni interruttore del puzzle può avere due stati: valido e non valido.

Per risolvere il puzzle, il giocatore deve attivare gli interruttori in un determinato ordine. Per implementare questo ordine nel codice, devi definire una sequenza di stati validi per ogni interruttore e controllare questa sequenza ogni volta che un giocatore aggiorna lo stato dell'interruttore.

1. Aggiungi un nuovo metodo ValidState() alla classe switch_state_puzzle. Questo metodo prende una stringa e riproduce una clip audio ogni volta che un giocatore sposta un interruttore su uno stato valido, fornendo un feedback audio per fargli sapere che è sulla strada giusta.

2. In ValidState(), stampa la stringa State che è stata passata e chiama Play() sulla funzione ValidAudioPlayer impostata prima.

    # Azioni da eseguire quando lo stato è valido
    ValidState(State : string) : void =
        # Riproduci un suono di convalida
        Print("{State} valido")
        ValidAudioPlayer.Play()

Copy full snippet

# Azioni da eseguire quando lo stato è valido ValidState(State : string) : void = # Riproduci un suono di convalida Print("{State} valido") ValidAudioPlayer.Play()

1. Aggiungi un nuovo Metodo InvalidState() alla classe switch_state_puzzle. Questo metodo reimposta tutti gli interruttori dopo aver riprodotto un suono quando il giocatore attiva uno stato non valido.

    # Azioni da eseguire quando lo stato non è valido
    InvalidState(InPlayer : agent) : void =
        # Riproduci un ronzio 
        # Cancella tutti gli interruttori
        Print("Non valido")
        
Copy full snippet

# Azioni da eseguire quando lo stato non è valido InvalidState(InPlayer : agent) : void = # Riproduci un ronzio # Cancella tutti gli interruttori Print("Non valido")

1. In InvalidState(), fai sapere al giocatore che ha attivato uno stato non valido stampando Non valido e riproducendo una clip audio chiamando Play() sulla funzione InvalidAudioPlayer impostata prima. Devi anche chiamare Trigger() sul tuo InvalidTrigger, e Show() il tuo InvalidHUDMessage.

	# Azioni da eseguire quando lo stato non è valido
    InvalidState(InPlayer : agent) : void =
        # Riproduci un ronzio 
        # Cancella tutti gli interruttori
        Print("Non valido")
        InvalidAudioPlayer.Play()
        InvalidTrigger.Trigger()
        InvalidHUDMessage.Show()
        
Copy full snippet

# Azioni da eseguire quando lo stato non è valido InvalidState(InPlayer : agent) : void = # Riproduci un ronzio # Cancella tutti gli interruttori Print("Non valido") InvalidAudioPlayer.Play() InvalidTrigger.Trigger() InvalidHUDMessage.Show()

Crea un loop for che sottoscriva gli eventi sui dispositivi Interruttore. L'istruzione di stampa identifica gli interruttori attivati da un giocatore e la sequenza in cui gli interruttori vengono attivati.

        # Loop di ogni interruttore e aggiunta di gestori eventi per ogni interruttore
        for (SwitchIndex -> Switch : Switches):
            Print("Interruttore {SwitchIndex} aggiunto")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            
Copy full snippet

# Loop di ogni interruttore e aggiunta di gestori eventi per ogni interruttore for (SwitchIndex -> Switch : Switches): Print("Interruttore {SwitchIndex} aggiunto") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

In un loop for, esegui il loop di tutti gli interruttori e spegnili tutti. Poiché il metodo TurnOff()dell'interruttore richiede un istigatore del giocatore, passa al giocatore che ha attivato lo stato non valido.

        ## Loop e spegnimento di tutti gli interruttori 
        for (SwitchIndex -> Switch : Switches):
            Switch.TurnOff(InPlayer)

Copy full snippet

## Loop e spegnimento di tutti gli interruttori for (SwitchIndex -> Switch : Switches): Switch.TurnOff(InPlayer)

1. Salva il tuo codice, torna a UEFN e seleziona Verse > Compila codice Verse.

Successivamente, devi creare la logica nella classe item_switch_puzzle che esegue il loop di ogni interruttore e ne convalida lo stato rispetto all'array del puzzle per determinare in quale stato (valido o non valido) rientra l'inversione dell'interruttore.

Ordinamento degli stati dell'interruttore

Il controllo della validità di un'inversione dell'interruttore viene eseguito creando un metodo CheckSequence che utilizza un'espressione for per controllare lo stato corrente dell'interruttore. Per definire se la modifica dello stato di un interruttore è valida o meno, puoi utilizzare un'istruzione if per definire quale inversione dell'interruttore è valida nella sequenza e quale no.

1. Aggiungi un nuovo metodo CheckSequence(). Questo metodo considera il giocatore come istigatore delle modifiche dello stato dell'interruttore e array di valori logici corrispondenti agli stati dell'interruttore. In CheckSequence(), crea un loop for per eseguire l'iterazione di ciascun interruttore nell'array Switches. Ottieni l'indice di ogni interruttore nell'array e salvalo in una variabile SwitchIndex. Nel loop for, verifica ogni stato dell'interruttore chiamando GetCurrentState[]. Stampa quindi lo stato dell'interruttore nel registro.

    # Funzione per convalidare la sequenza degli interruttori
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")

Copy full snippet

# Funzione per convalidare la sequenza degli interruttori CheckSequence(InPlayer : agent) : void = for (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")

Ora devi creare una sequenza di stati da controllare utilizzando CheckSequence(). A tale scopo, aggiungi una nuova funzionalità al metodo OnSwitchPressed() di switch_event_handler.

Stati della sequenza

Crea la sequenza degli stati dell'interruttore utilizzando gli array. Ogni array controlla la validità della sequenza in cui gli interruttori vengono invertiti. Registra la sequenza delle azioni del giocatore sugli interruttori utilizzando il logger di stampa per registrare se gli interruttori sono stati cliccati e se la sequenza è valida stampando il numero della sequenza sul logger ("Uno", "Due", "Tre" e "Quattro").

1. In OnSwitchPressed(), all'interno di un'istruzione if, chiama CheckSequence() passando sia il giocatore che un nuovo array di valori logici. Questo nuovo array deve corrispondere alla serie di interruttori, con valori false che rappresentano gli interruttori disattivi e valori true che rappresentano gli switch attivi. Imposta su true l'interruttore che vuoi che i giocatori premano per primo e tutti gli altri valori su false. Se la chiamata a CheckSequence[] ha esito positivo, chiama ValidState() passando "One" per rappresentare il primo interruttore premuto.

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

Copy full snippet

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

1. Codifica il tasto di risposta per le inversioni degli interruttori per ciascuno degli interruttori del tuo puzzle, nell'ordine in cui vuoi che vengano premuti.

    if:
            # controlla gli stati validi e codifica la convalida degli stati
            # [off],[off],[on],[off] Stato uno
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

        else if:
            # controlla gli stati validi
            #[On], [Off], [On], [Off] Stato due
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

        else if:
            # controlla gli stati validi
            #[On], [On], [On], [Off] Stato tre
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # controlla gli stati validi
            #[On], [On], [On], [On] Stato quattro, il puzzle è completato
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

Copy full snippet

if: # controlla gli stati validi e codifica la convalida degli stati # [off],[off],[on],[off] Stato uno not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("One") else if: # controlla gli stati validi #[On], [Off], [On], [Off] Stato due Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Two") else if: # controlla gli stati validi #[On], [On], [On], [Off] Stato tre Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Three") else if: # controlla gli stati validi #[On], [On], [On], [On] Stato quattro, il puzzle è completato Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState()

1. Infine, aggiungi un'espressione else alla fine che chiama InvalidState(). Ciò si verifica se una qualsiasi delle chiamate a CheckSequence[] ha esito negativo.

    
    else:
            # Non è uno stato valido, quindi non è valido
            InvalidState(InPlayer)

Copy full snippet

else: # Non è uno stato valido, quindi non è valido InvalidState(InPlayer)

1. Il codice switch_event_handler deve ora essere simile al seguente.

    # Funzione per convalidare la sequenza degli interruttori
    CheckSequence(InPlayer : agent) : void =
        for (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")
        
        if:
            # controlla gli stati validi e codifica la convalida degli stati
            # [off],[off],[on],[off] Stato uno
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

        else if:
            # controlla gli stati validi
            #[On], [Off], [On], [Off] Stato due
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

        else if:
            # controlla gli stati validi
            #[On], [On], [On], [Off] Stato tre
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # controlla gli stati validi
            #[On], [On], [On], [On] Stato quattro, il puzzle è completato
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

        else:
            # Non è uno stato valido, quindi non è valido
            InvalidState(InPlayer)

Copy full snippet

# Funzione per convalidare la sequenza degli interruttori CheckSequence(InPlayer : agent) : void = for (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off") if: # controlla gli stati validi e codifica la convalida degli stati # [off],[off],[on],[off] Stato uno not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("One") else if: # controlla gli stati validi #[On], [Off], [On], [Off] Stato due Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Two") else if: # controlla gli stati validi #[On], [On], [On], [Off] Stato tre Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Three") else if: # controlla gli stati validi #[On], [On], [On], [On] Stato quattro, il puzzle è completato Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState() else: # Non è uno stato valido, quindi non è valido InvalidState(InPlayer)

1. Salva il tuo codice, torna a UEFN e seleziona Verse > Compila codice Verse.

Ora, all'accensione degli interruttori nel gioco, il registro stamperà:

• Caricamento puzzle interruttore - all'inizio del gioco

• Interruttore {SwitchIndex} aggiunto - quando uno switch viene aggiunto al loop

• Cliccato - quando un giocatore accende un interruttore

• {State} valido - se il giocatore accende l'interruttore destro nell'ordine di sequenza

• Non valido - se il giocatore accende l'interruttore sbagliato

Se il registro segnala correttamente le inversioni degli interruttori, puoi aggiungere altri dispositivi modificabili alla classe item_switch_puzzle e fare in modo che ognuno di questi stati esegua un'operazione.

Aggiunta di dispositivi

Una volta che il puzzle è stato completato correttamente dal giocatore e ha eseguito il loop attraverso gli stati validi degli interruttori fino a CompletedState, il risultato positivo deve generare un'azione, come la concessione di oggetti.

Lo stesso vale per gli InvalidStates. Se un giocatore non completa correttamente il puzzle, lo script deve tenerne conto e fargli sapere che deve riprovare. A tale scopo, devi aggiungere altri dispositivi alla classe item_switch_puzzle.

Aggiungendo dispositivi modificabili al tuo script, essi saranno elencati nelle Opzioni utente del dispositivo Verse. Qui potrai collegare tali dispositivi al dispositivo Verse, consentendo loro di funzionare nel gioco seguendo le istruzioni presenti nello script Verse.

1. Aggiungi i seguenti dispositivi @editable sotto 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{} #Cattura tutti i generatori di oggetti associati a questo puzzle
    
Copy full snippet

@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{} #Cattura tutti i generatori di oggetti associati a questo puzzle

1. Aggiungi un nuovo metodo CompletedState() alla classe item_switch_puzzle. Questo metodo gestisce le azioni eseguite quando il puzzle è completato.

    ## Azioni da eseguire quando il puzzle è completato
    CompletedState() : void =
        # Riproduci un suono di esito positivo
        # Imposta tutti gli interruttori su disabilitati
        # Genera oggetti sui generatori di oggetti collegati
        Print("Puzzle completato")

Copy full snippet

## Azioni da eseguire quando il puzzle è completato CompletedState() : void = # Riproduci un suono di esito positivo # Imposta tutti gli interruttori su disabilitati # Genera oggetti sui generatori di oggetti collegati Print("Puzzle completato")

1. Aggiungi un'espressione for al metodo CompletedState() che esegue l'iterazione di ciascun generatore di oggetti in ItemSpawners. Abilita ciascun generatore di oggetti con Enable(), quindi chiama SpawnItem() per garantire al giocatore la ricompensa per aver risolto il puzzle.

    ## Scorrere i generatori di oggetti ti permette di chiamare ogni generatore di oggetti per abilitare e generare il suo oggetto
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

Copy full snippet

## Scorrere i generatori di oggetti ti permette di chiamare ogni generatore di oggetti per abilitare e generare il suo oggetto for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem()

1. Una volta che il puzzle è stato completato correttamente, devi chiamare Play() su CompletedAudioPlayer impostata in precedenza, generare i pezzi di metallo sui generatori di oggetti utilizzando ItemSpawnerIndexe chiamare Enable1 e SpawnItem. Informa il giocatore che deve cercare gli oggetti appena generati chiamando Show() su FindItemsHUDMessage. Inoltre, il giocatore non dovrebbe continuare a interagire con i tuoi interruttori. Aggiungi una seconda espressione for per scorrere ogni interruttore in Switches e disabilitalo chiamando Disable().

    # Azioni da eseguire quando il puzzle è completato
    CompletedState() : void =
        # Riproduci un suono di esito positivo
        # Imposta tutti gli interruttori su disabilitati
        # Genera oggetti sui generatori di oggetti collegati
        Print("Puzzle completato")
        
        # Scorrere i generatori di oggetti ti permette di chiamare ogni generatore di oggetti per abilitare e generare il suo oggetto
        for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

        # Riproduce il cue audio specifico previsto per il completamento della sequenza del puzzle
        CompletedAudioPlayer.Play()

        # Riproduce un messaggio HUD per dire ai giocatori di cercare gli oggetti appena generati
        FindItemsHUDMessage.Show()

	    # Disabilita tutti gli interruttori quando il puzzle è stato completato correttamente
        for (SwitchIndex -> Switch : Switches):
            Switch.Disable()

Copy full snippet

# Azioni da eseguire quando il puzzle è completato CompletedState() : void = # Riproduci un suono di esito positivo # Imposta tutti gli interruttori su disabilitati # Genera oggetti sui generatori di oggetti collegati Print("Puzzle completato") # Scorrere i generatori di oggetti ti permette di chiamare ogni generatore di oggetti per abilitare e generare il suo oggetto for (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem() # Riproduce il cue audio specifico previsto per il completamento della sequenza del puzzle CompletedAudioPlayer.Play() # Riproduce un messaggio HUD per dire ai giocatori di cercare gli oggetti appena generati FindItemsHUDMessage.Show() # Disabilita tutti gli interruttori quando il puzzle è stato completato correttamente for (SwitchIndex -> Switch : Switches): Switch.Disable()

1. Salva il tuo codice, torna a UEFN e seleziona Verse > Compila codice Verse.

Ora questi dispositivi sono risultano aggiunti al dispositivo Puzzle Interruttore oggetto in UEFN.

Selezione dei dispositivi

Tutti i dispositivi @editable vengono aggiunti al dispositivo Verse. Ora devi collegare al dispositivo Verse i dispositivi che hai impiegato per creare il puzzle. A tale scopo, seleziona item_switch_puzzle nell'Outliner e tutti gli slot del dispositivo sono visibili nel pannello Dettagli. Devi solo abbinare il dispositivo allo slot.

1. Aggiungi i dispositivi Interruttore del puzzle ai 4 elementi dell'array Interruttori sotto Puzzle Interruttore oggetto.

   

2. Aggiungi Attivatore non valido allo slot InvalidTrigger

3. Aggiungi Messaggio HUD non valido allo slot InvalidHUDMessage.

4. Aggiungi Riproduttore audio non valido allo slot InvalidAudioPlayer.

   

5. Aggiungi Riproduttore audio valido allo slot ValidAudioPlayer.

6. Aggiungi il dispositivo Trova messaggio HUD allo slot FindHUDMessage.

7. Aggiungi Riproduttore audio completato allo slot CompletedAudioPlayer.

   

8. Aggiungi i Generatori di oggetti ai 4 elementi dell'array ItemSpawners.

   

9. Deseleziona l'opzione Visibile nel gioco per nascondere il dispositivo Verse durante il gioco.

   ![Rendi invisibile il dispositivo Verse durante il gioco in modo che i giocatori non lo vedano.] (visible.png) (L:500)

Ora puoi procedere ad eseguire il playtest del tuo livello e vedere come i puzzle migliorano l'esperienza dell'escape room.

Sezione successiva

Una volta configurato il Puzzle Cambia stato, puoi procedere con la creazione dello script di teletrasporto automatico di Verse che porta i giocatori dallo stato di osservazione del filmato di apertura alla stanza di attesa nel sottointerrato della capanna al termine della riproduzione del filmato.