Indicatore di obiettivo mobile

Gli indicatori di obiettivo sono utilizzati in molti giochi per guidare il giocatore verso l'obiettivo o punto di interesse successivo. In questo tutorial, imparerai come creare un indicatore di obiettivo riutilizzabile con il dispositivo Indicatore Mappa e Verse.

Funzionalità del linguaggio Verse utilizzate

• struttura: è possibile raggruppare variabili di tipi diversi in una Struttura.

• Metodo di estensione: un tipo speciale di funzione che si comporta come un membro di una classe o di un tipo esistente, ma non richiede la creazione di un nuovo tipo o di una sottoclasse. In questa guida, imparerai a creare un metodo di estensione per una struttura.

• argomento con nome: argomento passato a una chiamata funzione con il nome parametro specificato.

API Verse utilizzate

• API creative_prop: l'API creative_prop fornisce metodi per il movimento degli oggetti scenografici.

• Proprietà modificabili: varie proprietà utilizzate sia per fare riferimento ai dispositivi sia per aggiornare i valori variabili per test rapidi.

Istruzioni

Segui questi passaggi per imparare a configurare un indicatore di obiettivo in grado di spostarsi su più obiettivi o punti di interesse. Gli script completi sono inclusi come riferimento alla fine di questa guida.

Configurazione del livello

Questo esempio utilizza i seguenti oggetti scenografici e dispositivi.

• 1 oggetto scenografico: oggetto scenografico che verrà utilizzato per spostare il dispositivo indicatore mappa.

• 1 dispositivo Indicatore mappa: dispositivo che visualizzerà gli indicatori personalizzati sulla minimappa e sulla mappa panoramica.

• 1 dispositivo Generatore di giocatori: da aggiungere vicino all'oggetto scenografico in modo che il giocatore sia generato accanto a esso.

Utilizzo dell'API oggetto scenografico

La prima operazione da eseguire per muovere un dispositivo con Verse è quella di spostare un oggetto con l'API oggetto scenografico. Segui questi passaggi per spostare un oggetto scenografico nel tuo livello:

1. Crea un nuovo dispositivo Verse denominato objective_coordinator_device.

2. Nelle espressioni predefinite using nella parte superiore del file Verse, aggiungi un'espressione using per il modulo SpatialMath. Questo modulo contiene il codice che ti servirà per spostare gli oggetti scenografici.

   Verse

        using { /UnrealEngine.com/Temporary/SpatialMath }
   

   Copy full snippet(1 line long)

3. Aggiungi due proprietà modificabili:

   • Costante creative_prop denominata RootProp per memorizzare un riferimento all'oggetto scenografico mobile.

   • Costante transform denominata Destination per memorizzare la posizione in cui si sposterà l'oggetto scenografico.

     Verse

       objective_coordinator_device<public> := class<concrete>(creative_device):
     
           @editable
           RootProp<public> : creative_prop = creative_prop{}
     
           @editable
           Destination<public> : transform = transform{}

     Copy full snippet(7 lines long)

4. Eseguendo questo codice e trascinando objective_coordinator_device nel tuo livello, potrai visualizzare le due proprietà nel pannello Dettagli.

5. Il metodo TeleportTo[] è ciò che sposta effettivamente l'oggetto scenografico. Chiamalo all'interno di un'espressione if e utilizza le parentesi quadre al posto delle parentesi perché TeleportTo[] è un'espressione fallibile. if crea un contesto di errore.

   Verse

        if(RootProp.TeleportTo[Destination.Translation, Destination.Rotation]):
            Print("Prop move successful")
        else:
            Print("Prop move failed")
   

   Copy full snippet(4 lines long)

6. Gli argomenti per TeleportTo[] sono Traslazione e Rotazione. Entrambi vengono forniti dalla proprietà Destinazione.

7. Torna all'editor e trascina un oggetto scenografico da Fortnite > Gallerie > Oggetti scenografici in Esplora contenuti. Quello utilizzato in questa guida è chiamato Coastal Buoy 02B, ma è idoneo qualsiasi altro della cartella Oggetti scenografici.

8. Seleziona il tuo dispositivo coordinatore degli obiettivi nell'Outliner. Nel pannello Dettagli, imposta RootProp sul tuo oggetto scenografico. In questo esempio, RootProp è impostato su Coastal Buoy 02B.

   

9. Nel pannello Dettagli, espandi Destinazione. Dal momento che Destinazione è di tipo transform, è composta da Scala, Rotazione e Traslazione. Per spostare l'oggetto scenografico, devi soltanto modificare Traslazione e quindi espanderlo. Imposta il campo che termina con X su 5000.0.

   

   Quando testi il codice, ti consigliamo di applicare modifiche sostanziali ai valori in modo che gli effetti siano ovvi. Con piccole modifiche, non potrai sapere se il tuo codice viene eseguito come previsto.

   Verse

    using { /Verse.org/Simulation }
    using { /Fortnite.com/Devices }
    using { /UnrealEngine.com/Temporary/SpatialMath }
   
    objective_coordinator_device<public> := class<concrete>(creative_device):
   
        @editable
        RootProp<public> : creative_prop = creative_prop{}
   
        # Where the marker will be moved to
   
   Expand code Copy full snippet(19 lines long)

10. Fai clic su Verse, quindi Compila codice Verse, quindi fai clic su Avvia sessione. Infine, fai clic su Avvia gioco. Devi vedere il tuo oggetto scenografico muoversi.

Genitore e strutture

Ora hai un oggetto scenografico mobile nel tuo livello, ma il vero scopo è spostare un dispositivo indicatore mappa in modo che i giocatori possano utilizzarlo come punto di riferimento. Segui questi passaggi per aggiungere un oggetto scenografico di costruzione e il dispositivo indicatore mappa al tuo livello e associarlo all'oggetto scenografico di costruzione.

1. Fai clic con il pulsante destro del mouse all'interno di Esplora contenuti per aprire il menu contestuale.

2. Seleziona Classe Blueprint dal menu contestuale.

   

3. Nella finestra Scegli classe genitore, fai clic su Oggetto scenografico di costruzione.

   

4. Una nuova classe Blueprint verrà visualizzata in Esplora contenuti. Rinominala BuildingProp.

   

5. Trascina l'oggetto scenografico di costruzione nel tuo livello. Questo oggetto scenografico non ha mesh, quindi vedrai solo il suo gizmo di trasformazione.

   

6. Nell'Outliner, trascina il dispositivo indicatore mappa sull'oggetto scenografico di costruzione. Ciò, fa sì che l'oggetto scenografico di costruzione diventi il genitore del dispositivo indicatore mappa. D'ora in avanti ogni volta che l'oggetto scenografico si sposterà, il dispositivo indicatore mappa si muoverà insieme di pari passo.

   

Sai già come creare un dispositivo utilizzando Verse, ma puoi anche creare file di Verse che non hanno un proprio dispositivo.

1. Crea un nuovo file Verse e nominalo objective_marker. Tale file non creerà un dispositivo. Includerà invece la definizione di una struct da mostrare al dispositivo Verse creato in precedenza.

2. Inizia dichiarando una struct con il nome objective_marker. Avrà due membri: RootProp e MapIndicator. Entrambi devono avere lo specificatore @editable.

   Verse

        objective_marker<public> := struct<concrete>:
   
        @editable
        RootProp<public> : creative_prop = creative_prop{}
   
        @editable
        MapIndicator<public> : map_indicator_device = map_indicator_device{}

   Copy full snippet(7 lines long)

Metodi di estensione e argomenti denominati

Dichiara un unico metodo, MoveMarker, che sposterà il membro RootProp e il dispositivo Indicatore mappa associato. Questo metodo introduce due funzioni caratteristiche del linguaggio: i metodi di estensione e gli argomenti con nome.

(Marker : objective_marker).MoveMarker<public>(Transform : transform, ?OverTime : float)<suspends> : void =

• Metodi di estensione: aggiungi il metodo MoveMarker() alla struttura objective_marker. Un metodo di estensione viene dichiarato utilizzando parentesi tonde che delimitano un identificatore e un tipo separati da due punti. In questo caso: (Marker : objective_marker).

• Argomenti con nome: il secondo argomento ?OverTime utilizza ? per indicare che deve essere nominato nella chiamata della funzione MoveMarker. Questo aiuta gli sviluppatori che leggono o scrivono una chiamata a MoveMarker a capire cosa fa l'argomento float.

MoveMarker() chiamerà uno dei due metodi dell'API oggetto scenografico: TeleportTo[], che hai utilizzato in precedenza, o MoveTo(). Crea un blocco if..else per verificare se il parametro OverTime è maggiore di 0.0. Se lo è, chiama MoveTo(). Ciò farà sì che il tuo obiettivo si sposti nella posizione successiva nel periodo di tempo da te specificato, invece di teletrasportarsi istantaneamente.

(Marker : objective_marker).MoveMarker<public>(Transform : transform, ?OverTime : float)<suspends> : void =

 if (OverTime > 0.0):
        Marker.RootProp.MoveTo(Transform.Translation, Transform.Rotation, OverTime)
    else:
        if:
            Marker.RootProp.TeleportTo[Transform.Translation, Transform.Rotation]

Compilando il codice ora, potrai già ottenere i risultati desiderati senza però vedere alcun nuovo dispositivo nella cartella CreativeDevices di Esplora contenuti. Ciò è dovuto al fatto che objective_marker è una struct, non una classe che eredita da creative_device.

Aggiornamento del dispositivo coordinatore degli obiettivi

Ora che hai un nuovo tipo a cui fare riferimento, devi aggiornare il campo objective_coordinator_device in modo da attivarlo.

1. Elimina la proprietà RootProp e sostituiscila con una proprietà denominata PickupMarker di tipo objective_marker. Questo è il tipo che hai creato.

2. MoveMarker() richiede un argomento di tipo float, quindi crealo come una proprietà modificabile chiamata MoveTime.

3. Elimina la chiamata a TeleportTo[]. Chiama invece il metodo MoveMarker() che hai creato per objective_marker. Richiede l'argomento con nome ?OverTime.

   Verse

        objective_coordinator_device<public> := class<concrete>(creative_device):
   
            @editable
            PickupMarker<public> : objective_marker = objective_marker{}
   
            # Where the marker will be moved to
            @editable
            Destination<public> : transform = transform{}
   
            # How much time the marker should take to reach its new location
   
   Expand code Copy full snippet(16 lines long)

Compila questo codice e verifica attentamente i dettagli del dispositivo coordinatore degli obiettivi. Devi visualizzare le proprietà PickupMarker e MoveTime e PickupMarker deve contenere parametri RootProp e MapIndicator.

1. Imposta il campo RootProp su BuildingProp e il campo MapIndicator su Dispositivo indicatore mappa

   

2. Compila il tuo codice e fai clic su Avvia sessione. Dovresti vedere un indicatore sulla minimappa che si sposta poco dopo l'inizio del gioco. Testalo con MoveTime impostato su diversi valori compreso 0.0. Considera quali possono essere i movimenti migliori per diversi scenari.

GetPlayers() e ActivateObjectivePulse()

Esiste un'opzione specifica che consente di aiutare i giocatori a raggiungere l'obiettivo successivo. Si chiama **impulso obiettivo** e quando è abilitato visualizza una linea punteggiata che parte dal giocatore fino al dispositivo indicatore mappa. Per aggiungere un impulso obiettivo al tuo coordinatore degli obiettivi, segui le istruzioni seguenti.

Il metodo che permette di attivare l'impulso obiettivo si chiama ActivateObjectivePulse() e richiede un argomento di tipo agent. Inizia creando tale metodo per ottenere un'istanza di agent che rappresenti i personaggi dei tuoi giocatori.

1. Dichiara una funzione chiamata FindPlayer() impostata su <private>, con un valore di ritorno void.

2. Ottieni una matrice di tutti i giocatori del tuo livello con Self.GetPlayspace().GetPlayers(). Memorizza l'array in una variabile chiamata AllPlayers.

   Verse

        FindPlayer<private>() : void =
   
            AllPlayers := Self.GetPlayspace().GetPlayers()

   Copy full snippet(3 lines long)

3. Per ottenere il riferimento a un solo giocatore nel tuo livello, assegna il primo elemento dell'array alla sua variabile. L'accesso a un array è una espressione fallibile, quindi inseriscila in un'espressione if.

   Verse

        if (FirstPlayer := AllPlayers[0]):
   

   Copy full snippet(1 line long)

4. Dal momento che l'assegnazione del tuo player a una variabile potrebbe non riuscire, ti consigliamo di utilizzare una variabile di tipo option quando fai riferimento al giocatore nel tuo codice. Dichiara una variabile giocatore opzionale ?player. Tale variabile deve corrispondere alle altre variabili membro.

   Verse

        objective_coordinator_device<public> := class<concrete>(creative_device):
   
        var PlayerOpt<private> : ?player = false
   
        @editable
        PickupMarker<public> : objective_marker = objective_marker{}
   
        # Where the marker will be moved to
        @editable
        Destination<public> : transform = transform{}
   
   Expand code Copy full snippet(14 lines long)

5. Imposta la tua nuova variabile e crea un blocco else con un'espressione Print() che ti informerà se un giocatore non è stato trovato. La tua funzione FindPlayer() è ora completa.

   Verse

        FindPlayer<private>() : void =
   
            # Since this is a single player experience, the first player [0]
            # should be the only one available.
   
            AllPlayers := Self.GetPlayspace().GetPlayers()
   
            if (FirstPlayer := AllPlayers[0]):
                set PlayerOpt = option{FirstPlayer}
                Print("Player found")
   
   Expand code Copy full snippet(13 lines long)

Tornando alla funzione OnBegin(), devi apportare altre due modifiche:

1. Chiama la funzione FindPlayer().

   Verse

        OnBegin<override>()<suspends> : void =
   
            FindPlayer()

   Copy full snippet(3 lines long)

2. Dopo aver chiamato MoveMarker(), utilizza un'altra espressione if per impostare la variabile opzionale del giocatore su una nuova variabile e trasmettila come argomento a PickupMarker.MapIndicator.ActivateObjectivePulse()

   Verse

        if (FoundPlayer := PlayerOpt?):
            PickupMarker.MapIndicator.ActivateObjectivePulse(FoundPlayer)
   

   Copy full snippet(2 lines long)

Se esegui il codice ora, devi vedere l'impulso obiettivo diretto dal personaggio alla posizione dell'indicatore di obiettivo del livello.

Script completi

Objective_marker.verse

using { /Verse.org/Simulation }
using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Fortnite.com/Devices/CreativeAnimation }

objective_marker<public> := struct<concrete>:

    # The prop that will be moved
    @editable
    RootProp<public> : creative_prop = creative_prop{}

Objective_coordinator_device.verse

using { /Verse.org/Simulation }
using { /Fortnite.com/Devices }
using { /Fortnite.com/Playspaces }
using { /UnrealEngine.com/Temporary/SpatialMath }

objective_coordinator_device<public> := class<concrete>(creative_device):

    var PlayerOpt<private> : ?player = false

    @editable

In autonomia

Il codice di movimento che hai scritto qui funziona per qualsiasi oggetto scenografico. Se riesci a rendere un oggetto scenografico in movimento il genitore di un dispositivo, quest'ultimo si muoverà con esso. Prova a muovere altri oggetti scenografici e dispositivi e valuta in che modo possono essere utilizzati in altri giochi.

Step successivi

Se hai consultato questa guida per compilare un gioco di raccolta/consegna, il passaggio successivo è approfondire come creare una funzione di Conto alla rovescia.