1. Epic GamesDeveloper
  3. 4. Attivare/disattivare le luci con i pulsanti

4. Attivare/disattivare le luci con i pulsanti

Crea un puzzle in cui il giocatore deve trovare la giusta combinazione di luci accese e spente per generare un oggetto, utilizzando un dispositivo creato con Verse.

4. Attivare/disattivare le luci con i pulsanti
Prerequisite topics

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

Completando questo passaggio del tutorial Puzzle delle luci con tag, imparerai ad attivare/disattivare un gruppo di luci in base al pulsante con cui il giocatore interagisce.

Attivare/disattivare le luci

Dovrai creare una mappatura tra un pulsante e il gruppo di luci che deve attivare/disattivare, quando il giocatore interagisce con il pulsante. Per eseguire questa operazione, puoi associare ogni pulsante agli indici delle luci nell'array Lights.

Questo esempio utilizza la seguente mappatura tra pulsanti e luci:

  • Il pulsante 1 si associa alla luce dell'indice 0 e alla luce dell'indice 3
  • Il pulsante 2 si associa alla luce dell'indice 0, alla luce dell'indice 1 e alla luce dell'indice 2
  • Il pulsante 3 si associa alla luce dell'indice 0 e alla luce dell'indice 1
  • Il pulsante 4 si associa alla luce dell'indice 1

Puoi rappresentare questa mappatura con un array denominato ButtonsToLights, dove ogni elemento di ButtonsToLights è un altro array che contiene gli indici delle luci. Il tipo di ButtonsToLights è quindi [][]int, per specificare che ButtonsToLights è un array di array di interi.

Indice 0 1 2 3
Elemento array{0, 3} array{0, 1, 2} array{0, 1} array{1}

Per attivare/disattivare le luci, procedi come segue:

  1. Crea un array di interi denominato ButtonsToLights e inizializzalo con la mappatura degli indici dei pulsanti e delle luci descritta nella tabella precedente. 
     ButtonsToLights : [][]int = array{array{0, 3}, array{0, 1, 2}, array{0, 1}, array{1}}

    Gli indici di un array partono da 0 e arrivano fino al numero di elementi meno 1. Quindi il primo elemento di ButtonsToLights è all'indice 0 e l'ultimo elemento è all'indice 3.
  2. Aggiungi un nuovo metodo chiamato ToggleLights() alla classe tagged_lights_puzzle. Questo metodo accende/spegne le luci nell'array Lights in base agli indici forniti alla funzione come array di interi (per corrispondere agli elementi dell'array ButtonsToLights) e aggiorna gli elementi agli stessi indici in LightsState.
    1. Aggiungi il parametro LightIndices : []int al metodo ToggleLights() e stampa ogni indice nel registro di output utilizzando l'espressione for. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
 do:
     Logger.Print("Attivazione/disattivazione delle luci a {LightIndex}")
    2. Chiama ToggleLights() in OnBegin() per eseguire il test del metodo mentre lo crei. Utilizza il primo elemento di ButtonsToLights come test. Poiché l'indicizzazione in un array è un'espressione fallibile, dovrai accedere all'array da un contesto di fallimento. Questo esempio utilizza l'espressione if per il contesto di fallimento.
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()

     # Utilizza il primo elemento di ButtonsToLights per eseguire il test del metodo ToggleLights
     if (LightIndices : []int = ButtonsToLights[0]):
         ToggleLights(LightIndices)
  3. Ora che disponi di LightIndex, esegui l'accesso agli array Lights e LightsState su quell'indice per ottenere il riferimento al dispositivo Luce personalizzabile e al relativo stato corrente. Attivare/disattivare una luce significa: se la luce è accesa, spegnila, se la luce è spenta, accendila. Aggiorna l'istruzione di stampa per indicare il nuovo stato della luce. 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         Light := Lights[LightIndex]
         IsLightOn := LightsState[LightIndex]
     do:
         Logger.Print("Impostazione delle luci su {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
  4. Ora aggiorna lo stato del dispositivo Luce personalizzabile, sia nel gioco che nell'array LightsState.
    1. Chiama TurnOn() sulla luce se IsLightOn è false e TurnOff() sulla luce se IsLightOn è true. L'ultima espressione di un blocco di codice è il risultato, quindi impostare false o true come ultima espressione significa che quel valore sarà memorizzato in NewLightState. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     Light := Lights[LightIndex]
     IsLightOn := LightsState[LightIndex]
 do:
     Logger.Print("Impostazione delle luci su {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             falso
         else:
             Light.TurnOn()
             vero
    2. Aggiorna l'elemento LighsState a LightIndex con il valore in NewLightState. Poiché l'indicizzazione dell'array è un'espressione fallibile, deve essere eseguito il wrapping dell'impostazione di LightsState in un contesto di fallimento. In questo esempio, il contesto di fallimento è l'espressione if. Stampa nel registro di output che lo stato è stato aggiornato. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     IsLightOn := LightsState[LightIndex]
     Light := Lights[LightIndex]
 do:
     Logger.Print("Impostazione delle luci su {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             falso
         else:
             Light.TurnOn()
             vero
     if (set LightsState[LightIndex] = NewLightState):
         Logger.Print("Stato per le luci a {LightIndex} aggiornato")

    È sempre una buona idea stampare sul registro di output quando si utilizzano contesti di fallimento. Se un'espressione fallisce in un contesto di fallimento, viene eseguito il rollback di tutte le modifiche apportate nel contesto di fallimento, come se non fossero mai avvenute. Se stampi sul registro di output, puoi controllare che la modifica sia stata effettuata se il testo viene visualizzato nel registro di output, senza affidarti esclusivamente allo stato nel gioco per verificare se la modifica è andata a buon fine.

Collegamento della pressione dei tasti all'attivazione/disattivazione delle luci

Dopo aver definito come attivare/disattivare le luci, il passaggio successivo è collegare la pressione dei pulsanti all'accensione o allo spegnimento delle luci.

Puoi eseguire questa operazione sottoscrivendo all'InteractedWithEvent del pulsante. Per maggiori dettagli sulla sottoscrizione agli eventi, vedi Codificare le interazioni tra dispositivi.

L'evento InteractedWithEvent si aspetta un gestore eventi con un parametro InPlayer : agent e un tipo restituito void, ma il gestore eventi deve anche sapere a quali luci è collegato il pulsante che ha inviato l'evento e contenere anche un riferimento al dispositivo Verse tagged_lights_puzzle per poter chiamare il relativo metodo ToggleLights().

Puoi raggruppare tutte queste informazioni in un oggetto personalizzato, creando una nuova classe che contenga gli indici e la funzione da sottoscrivere. In questo modo, ogni pulsante ha il suo stato personale e il relativo gestore eventi, rappresentato da questa nuova classe.

Per creare un oggetto personalizzato per la gestione eventi, attieniti ai passaggi seguenti:

  1. Crea una nuova classe denominata button_event_handler. La definizione della classe deve avere le seguenti caratteristiche:
    1. Un array di interi denominato Indices.
    2. Un campo tagged_lights_puzzle denominato PuzzleDevice, che è il riferimento al tuo dispositivo Verse, per poter chiamare il metodo ToggleLights().
    3. Un metodo denominato OnButtonPressed() con il parametro InPlayer : agent e un tipo restituito void, che chiama ToggleLights() sul PuzzleDevice. 
       button_event_handler := class():
 # Posizioni utilizzate per accedere alle luci controllate da questo pulsante.
 Indices : []int

 # tagged_lights_puzzle che ha creato questo button_event_handler, in modo da poter chiamare le funzioni su di esso.
 PuzzleDevice : tagged_lights_puzzle
    
 OnButtonPressed(InPlayer : agent) : void =
     # Indica al PuzzleDevice di attivare/disattivare le luci nelle posizioni controllate da questo pulsante.
     PuzzleDevice.ToggleLights(Indices)
  2. Crea un campo array modificabile button_device nella classe tagged_lights_puzzle per fare riferimento ai pulsanti con cui il giocatore può interagire: 
     @editable
 Buttons : []button_device = array{}
  3. Ora aggiorna OnBegin() nella classe tagged_lights_puzzle per creare un'istanza button_event_handler per ogni pulsante. La funzione button_event_handler richiede le seguenti informazioni:
    • Indici delle luci associate al pulsante, che si possono ottenere dall'array ButtonsToLights utilizzando il ButtonIndex fornito dall'espressione for. Lo puoi ottenere come condizione di filtro dell'espressione for utilizzata per scorrere tutti i Buttons. Questa operazione agisce anche come una misura di sicurezza che protegge il codice dall'indicizzazione di dati non validi, se l'indicizzazione fallisce, il programma sarebbe comunque valido, poiché l'iterazione non riuscita viene saltata. Questo errore potrebbe verificarsi se dimentichi di far corrispondere il numero di ButtonsToLights al numero di Buttons).
    • Un riferimento al tuo dispositivo Verse, l'istanza di tagged_lights_puzzle. Per ottenere un riferimento all'oggetto corrente dall'interno di una definizione di classe, puoi utilizzare Self.
    • La creazione di un oggetto button_event_handler con questi dati è simile a quanto segue: 
       OnBegin<override>()<suspends> : void =
  SetupPuzzleLights()
    
  for:
      ButtonIndex -> Button : Buttons
      LightIndices := ButtonsToLights[ButtonIndex]
  do:
      button_event_handler{Indices := LightIndices, PuzzleDevice := Self}
  4. Ora puoi utilizzare la funzione OnButtonPressed() del gestore appena creato per eseguire la sottoscrizione all'evento InteractedWithEvent del dispositivo Pulsante. Quando viene richiamata la funzione OnButtonPressed(), avrai accesso agli indici delle luci e a un riferimento al dispositivo tagged_lights_puzzle associato al pulsante con cui il giocatore ha interagito. 
     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. Salva lo script in Visual Studio Code.
  6. Nella barra degli strumenti UEFN, fai clic su Compila gli script di Verse per aggiornare il tuo dispositivo di Verse nel livello con il nuovo codice.
  7. In Outliner, seleziona il dispositivo tagged_lights_puzzle per aprire il relativo pannello Dettagli.
  8. Nel pannello Dettagli, aggiungi quattro elementi all'array Buttons e assegna a ciascuno un pulsante diverso. Non dovrai modificare le altre proprietà, perché sarà lo script a popolarle.
  9. Nella barra degli strumenti di UEFN, fai clic su Gioca per eseguire il playtest del tuo livello.

Quando esegui il playtest del livello, dovresti essere in grado di interagire con i pulsanti e ogni pulsante dovrebbe attivare/disattivare un diverso set di luci, in base all'impostazione ButtonsLightsIndices. Tieni presente che GetCreativeObjectsWithTag() non garantisce un ordine specifico, quindi le luci che vengono attivate/disattivate in base all'ordine nello script potrebbero non corrispondere all'ordine che vedi nel livello.

Il giocatore preme i pulsanti e ogni pulsante attiva/disattiva un set di luci diverse

Passaggio successivo

Nel passaggio successivo di questo tutorial, imparerai a riconoscere quando il giocatore risolve il puzzle, in modo da poter generare un oggetto e impedire ulteriori interazioni con il puzzle

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page