1. Epic GamesDeveloper
  3. 3. Trovare le luci nel runtime con i tag di gameplay

3. Trovare le luci nel runtime con i tag di gameplay

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.

3. Trovare le luci nel runtime con i tag di gameplay
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 a utilizzare i Tag di gameplay per individuare gli attori contrassegnati da un tag specifico, mentre la partita è in corso. I tag di gameplay ti consentono di lavorare con più dispositivi, senza doverne impostare i riferimenti nell'editor. Ciò può comportare interessanti opportunità di gameplay in cui, ad esempio, il codice cambia dinamicamente i dispositivi attivi, man mano che il giocatore avanza nel gioco.

Per creare un nuovo Tag di gameplay e assegnarlo a tutte le luci del livello per il puzzle, attieniti ai passaggi seguenti:

  1. Apri Verse Explorer e fai doppio clic su tagged_lights_puzzle.verse per aprire lo script in Visual Studio Code.
  2. All'inizio del file di codice:
    • Aggiungi using { /Verse.org/Simulation/Tags } per fare riferimento alla classe tag e utilizzare la funzione GetCreativeObjectsWithTag().
    • Aggiungi using { /Verse.org/Simulation } per poter rendere modificabili le proprietà.
     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. Sopra la classe log_tagged_lights_puzzle, aggiungi una nuova sottoclasse denominata puzzle_light, che eredita dalla classe tag. Il nome della classe ereditata diventa un tag di gameplay personalizzato, che puoi utilizzare su qualsiasi dispositivo creativo.

     # Deriva dalla classe `tag` del modulo Verse.org/Simulation/Tags per creare un nuovo tag di gameplay.
 puzzle_light := class(tag){}

 log_tagged_lights_puzzle := class(log_channel){}
  4. Nella barra degli strumenti UEFN, fai clic su Compila gli script di Verse per compilare il codice e il nuovo tag di gameplay puzzle_light nel tuo progetto.
  5. In Outliner di UEFN, seleziona un Dispositivo luce personalizzabile per aprire il relativo pannello Dettagli.
  6. Nel pannello Dettagli:
    1. Fai clic su Aggiungi nuovo componente e scegli Tag markup Verse.
    2. Seleziona il componente VerseTagMarkup per visualizzare le relative impostazioni nel pannello Dettagli.
    3. In Tag di gameplay, modifica la proprietà Tag e aggiungi il tag puzzle_light.
    Aggiungi il componente VerseTagMarkup e aggiungi il tag puzzle_light

    Puoi aggiungere più tag allo stesso dispositivo, in modo che ogni dispositivo possa appartenere a più gruppi contemporaneamente. Ad esempio, un dispositivo con tag1 e tag2 verrà trovato quando si chiama GetCreativeObjectsWithTag(tag1{}) o GetCreativeObjectsWithTag(tag2{}).
  7. Nella definizione della classe tagged_lights_puzzle, aggiungi due campi di array di variabili:
    • Una variabile di array modificabile logic, denominata LightsState, per rappresentare lo stato attuale di tutte le luci (se sono spente o accese). Dal momento che viene utilizzata anche per impostare lo stato iniziale delle luci, il suo numero di elementi deve corrispondere al numero di luci con il tag puzzle_light. In questo esempio, tutte le luci sono spente per impostazione predefinita, quindi il valore iniziale per tutte le luci è false. 
       @editable
 var LightsState : []logic = array{false, false, false, false}
    • Una variabile di array modificabile customizable_light_device denominata Lights per memorizzare tutti i dispositivi Luce personalizzabili contrassegnati con il tag di gameplay puzzle_light. 
       @editable
 var Lights : []customizable_light_device = array{}
  8. Quando inizia la partita, il dispositivo deve impostare le luci in modo che corrispondano alla configurazione iniziale specificata nell'array LightsState e salvare i riferimenti nell'array Lights, in modo che possano essere aggiornati quando cambia lo stato del gioco. Questo lavoro sarà svolto in un metodo chiamato SetupPuzzleLights() : void e richiamato nel metodo OnBegin(), in modo che le luci siano impostate all'avvio del gioco. 
     SetupPuzzleLights() : void =
     Logger.Print(“Configurazione delle luci in gioco”)
    
 OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
  9. In SetupPuzzleLights(), trova tutti i dispositivi con il tag puzzle_light chiamando GetCreativeObjectsWithTag(puzzle_light{}) e salvali in un array denominato TaggedActors. Poiché TaggedActors è un array costante il cui ambito è locale al metodo SetupPuzzleLights(), non è necessario specificare esplicitamente un tipo per l'array, perché può essere dedotto in questo contesto. 
     SetupPuzzleLights() : void =
     Logger.Print("Configurazione delle luci in gioco")
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})

    Chiamate diverse della funzione GetCreativeObjectsWithTag() possono posizionare i dispositivi in ordini diversi nell'array dei risultati, perché non esiste un ordine garantito quando si recuperano attori con tag di gameplay.
  10. Ora che hai raccolto tutti i dispositivi che hanno il tag puzzle_light, assicurati che ogni luce corrisponda allo stato iniziale specificato dall'array LightsState. Puoi utilizzare un loop for per scorrere tutti i dispositivi contrassegnati. 
     for:
     ActorIndex -> TaggedActor : TaggedActors
 do:
     TaggedActor
  11. La funzione GetCreativeObjectsWithTag() restituisce un array di tipo creative_object_interface. In questo esempio, vuoi interagire con ogni TaggedActor come un customizable_light_device, in modo da poter accendere o spegnere la luce.
    • Puoi convertire una classe in una delle sue sottoclassi (denominata cast di tipo) usando la sintassi NewDeviceReference := device_type_to_cast_to[DeviceReference], dove device_type_to_cast_to è il tipo di dispositivo desiderato, che in questo esempio è customizable_light_device. Si tratta di un'espressione fallibile, perché la conversione del tipo fallirà se il dispositivo non può essere convertito in quel tipo (ad esempio se si tratta di un tipo diverso di dispositivo). 
       LightDevice := customizable_light_device[TaggedActor]

    La funzione GetCreativeObjectsWithTag() ha il tipo restituito []creative_object_interface perché la funzione può restituire diversi tipi di attori, quindi il suo tipo restituito è l'interfaccia che tutti gli attori devono implementare per essere restituiti da GetCreativeObjectsWithTag(). Per ulteriori informazioni, vedi Tag di gameplay.
    • Con le espressioni for, è possibile utilizzare le espressioni che possono fallire come filtro e creare nuove variabili da usare nel blocco di codice for. In questo caso, aggiungi all'espressione di iterazione la conversione del tipo in customizable_light_device del passaggio precedente. 
       for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • L'ultima espressione di un blocco di codice è il risultato del blocco stesso. L'espressione for restituisce il risultato del blocco di codice di ogni iterazione in un array, quindi il risultato di questa espressione for è un array di riferimenti a customize_light_device che sono stati contrassegnati con puzzle_light. Ciò significa che è possibile aggiornare direttamente l'array Lights con il risultato dell'espressione for. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • Questo loop for dovrebbe anche chiamare TurnOn() / TurnOff() sulle luci, in modo che corrispondano al loro LightsState iniziale impostato nell'editor. L'espressione for può restituire l'indice usato per ottenere il dispositivo con tag corrente (ActorIndex, nell'esempio), che può essere usato per indicizzare l'array LightsState per verificare se la luce deve essere accesa o spenta. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn:= LightsState[ActorIndex]
 do:
      LightDevice
    • Quindi, chiama TurnOn() / TurnOff() a seconda che ShouldLightBeOn sia true / false. Puoi utilizzare un'espressione if per eseguire espressioni diverse in base a una condizione, in particolare un'espressione fallibile. In questo caso, l'espressione fallibile può usare l'operatore di query ? con IsLightOn, che riuscirà se ShouldLightBeOn è true, (quindi chiama TurnOn()) e fallirà se ShouldLightBeOn è false (quindi chiama 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
    • È una buona idea stampare anche l'indice della luce e il relativo valore iniziale, in modo da poter verificare che il codice funzioni come previsto e confrontarlo con ciò che vedi nel livello.
    • Quando utilizzi {} in mezzo a una stringa, l'espressione tra {} viene valutata per prima e il suo valore viene aggiunto alla stringa. È quindi possibile utilizzare un'espressione if nel mezzo di una stringa per aggiungere valori in modo condizionale. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[ActorIndex]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      Logger.Print("Aggiunta delle luci all'indice {ActorIndex} con stato:{if (ShouldLightBeOn?) then "On" else "Off"}")
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
  12. Il metodo SetupPuzzleLights() dovrebbe ora essere simile a: 
     SetupPuzzleLights() : void =
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})
     <#
     Per ogni dispositivo con il tag puzzle_light, verifica se si tratta di un dispositivo customizable_light_device, provando a eseguirne il cast in quel tipo.
     Se lo è, ottieni il suo LightState iniziale per eseguire TurnOn() o TurnOff() del LightDevice.
     Salva tutti i customizable_light_device con tag nell'array Lights.
     #>
     set Lights = for:
             ActorIndex -> TaggedActor : TaggedActors
             LightDevice := customizable_light_device[TaggedActor]
             ShouldLightBeOn := LightsState[ActorIndex]
     do:
             Logger.Print("Aggiunta delle luci all'indice {ActorIndex} con stato:{if (ShouldLightBeOn?) then "On" else "Off"}")
             if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
             LightDevice
  13. Salva lo script in Visual Studio Code.
  14. Nella barra degli strumenti UEFN, fai clic su Compila gli script di Verse per compilare il codice.
  15. Per eseguire il playtest del livello, fai clic su Gioca nella barra degli strumenti UEFN.

Durante il playtest del livello, dovresti vedere ogni luce aggiunta all'array Lights, insieme al relativo stato iniziale, stampata nel registro di output.

Passaggio successivo

Nel passaggio successivo di questo tutorial, imparerai come attivare/disattivare un set specifico di luci quando il giocatore preme i pulsanti.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page