Generazione di una griglia di piattaforme con Scene Graph

Generazione di una sequenza unica di griglie di piattaforme in cui solo una coppia di piattaforme in ogni riga è valida per saltare è comune per le modalità di gioco platform. Richiede che i giocatori rallentino e individuino la sequenza.

Questo tutorial mostra come generare una griglia di piattaforme in cui le piattaforme di ogni riga vengono selezionate a caso per avere collisioni e colori chiari per distinguerle dalle altre.

Creazione del prefabbricato delle piattaforme

Segui questa procedura per creare un prefab delle piattaforme che generi da Verse:

1. Posiziona una nuova entità e promuovila a un prefabbricato denominato choose_one_platform_prefab. Per le istruzioni, consulta Prefabbricati e istanze di prefabbricati.

2. Nell'editor dei prefab, aggiungi i seguenti componenti all'entità:

   • transform_component: componente di trasformazione per posizionare la piattaforma.

   • mesh_component: componente di mesh per impostare la mesh statica della piattaforma. Questo esempio utilizza la mesh SM_block_02 dall'asset Pacchetto Mondo Egizio stilizzato nel Marketplace Fab.

   • collision_component: componente di collisione per abilitare e disabilitare la collisione sulla piattaforma.

   • parent_constraint_component: componente di vincolo genitore per l'impostazione facile della trasformata relativa all'entità genitore quando generi questo prefabbricato nel mondo utilizzando Verse.

   

3. Aggiungi un'entità figlio e assegna il nome Luce.

4. Aggiungi i seguenti componenti all'entità Luce figlia:

   • transform_component: componente di trasformazione che posiziona l'entità sopra la piattaforma.

   • point_light_component: componente luce puntiforme per aggiungere una fonte di luce che modifica i colori in base alla presenza di collisioni della piattaforma.

   • parent_constraint_component: componente di vincolo genitore che impone vincoli alla trasformata relativa a questa entità relativa all'entità genitore.

   

5. Salva il prefabbricato.

Il prefabbricato viene ora visualizzato nel file Assets.digest.Verse come classe con lo stesso nome del prefabbricato, choose_one_platform_prefab.

Generazione di una griglia di piattaforme

Segui questa procedura per generare una griglia realizzata dal prefab delle piattaforme:

1. Crea un componente Verse chiamato choose_one_component. Per la procedura di creazione di un componente Verse, dai un'occhiata a Creazione del tuo componente Verse

2. Aggiungi le seguenti proprietà modificabili:

   • Campo di vettore 2D intero vector2i chiamato GridSize per definire quante piattaforme sono presenti nella griglia. X è il numero di righe e Y il numero di colonne nella griglia.

   • Campo di vettore 2D in virgola mobile vector2 chiamato PlatformSpacing per indicare la spaziatura tra le piattaforme in righe e colonne.

     ~~~(verse) GridSizeTip<localizes>:message = "Dimensione della griglia, con larghezza X unità e profondità Y unità." PlatformSpacingTip<localizes>:message = "Distanza tra ogni piattaforma sulla griglia."

     choose_one_component<public> := class(component):

     # Dimensione della griglia con larghezza X unità e profondità Y unità. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

     # Distanza tra ogni piattaforma sulla griglia. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0} ~~~

3. Nella funzione OnSimulate, itera sul vettore GridSize per sapere quante piattaforme generare. Nel loop, crea un'istanza della tua classe di prefab e aggiungila all'entità a cui è associato questo componente Verse per generare il prefab nel mondo.

   ~~~(verse) GridSizeTip<localizes>:message = "Dimensione della griglia, con larghezza X unità e profondità Y unità." PlatformSpacingTip<localizes>:message = "Distanza tra ogni piattaforma sulla griglia."

   choose_one_component<public> := class(component):

   # Dimensione della griglia con larghezza X unità e profondità Y unità. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

   # Distanza tra ogni piattaforma sulla griglia. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0}

   OnSimulate<override>()<suspends>:void= # Genera le piattaforme per creare la griglia. for (Column := 0..GridSize.Y - 1): for (Row := 0..GridSize.X - 1): # La creazione di un'istanza di un prefab e la sua aggiunta a un'entità esistente genererà il prefab nel mondo. ChooseOnePlatform := choose_one_platform_prefab{} Entity.AddEntities(array{ChooseOnePlatform}) ~~~

4. Se esegui ora il codice, tutte le piattaforme vengono generate nella stessa posizione. Dato che il prefabbricato ha il componente di trasformazione e il componente di vincolo genitore, puoi impostare la proprietà InitialRelativeTransform alla generazione del suo componente di trasformazione per generare il prefabbricato a uno sfalsamento relativo alla posizione dell'entità a cui aggiungi il prefabbricato. Senza il componente di vincolo genitore sull'entità che stai generando, devi indicare la posizione nello spazio mondo (e non relativa all'entità radice).

   Verse

        GridSizeTip<localizes>:message = "Size of the grid, where the grid is X units wide by Y units deep."
        PlatformSpacingTip<localizes>:message = "The distance between each platform on the grid."
   
        choose_one_component<public> := class(component):
   
            # Size of the grid, where the grid is X units wide by Y units deep.
            @editable_vector_number(int):
                ToolTip := GridSizeTip
                MinComponentValue := option{0}
            GridSize:vector2i = vector2i{X := 3, Y := 10}
   
   Expand code Copy full snippet(45 lines long)

5. Salva e compila il tuo codice.

Se assegni questo componente Verse a un'entità e lanci una sessione, apparirà una griglia di piattaforme nella posizione di quell'entità.

Selezione casuale delle piattaforme valide

Ora che hai una griglia di piattaforme generate nel mondo, puoi aggiungere altre funzionalità. I passi successivi mostrano come selezionare casualmente le piattaforme per avere collisioni per generare una sequenza di piattaforme attraverso cui un giocatore può saltare.

Segui questa procedura per selezionare casualmente piattaforme valide nella griglia:

1. Aggiungi le seguenti proprietà modificabili al componente Verse:

   • Variabile intera chiamata MinCorrectPlatformsPerRow per indicare il numero minimo di piattaforme che hanno collisioni.

   • Variabile intera chiamata MaxCorrectPlatformsPerRow per indicare il numero massimo di piattaforme che hanno collisioni.

   • Variabile di colore chiamata ChosenColor per impostare il colore della piattaforma se la collisione è abilitata.

   • Variabile di colore chiamata NotChosenColor per impostare il colore della piattaforma se la collisione non è abilitata.

     Verse

                               using { /UnrealEngine.com/Temporary/SceneGraph }
                               using { /UnrealEngine.com/Temporary/SpatialMath }
                               using { /Verse.org }
                               using { /Verse.org/Colors }
                               using { /Verse.org/Native }
                               using { /Verse.org/Random }
                               using { /Verse.org/Simulation }
     
                               GridSizeTip<localizes>:message = "Size of the grid, where the grid is X units wide by Y units deep."
                               PlatformSpacingTip<localizes>:message = "The distance between each platform on the grid."
     
     Expand code Copy full snippet(54 lines long)

2. Il risultato di un'espressione for è un array di ogni iterazione. Memorizza tutte le piattaforme generate per una riga in un array e passa l'array a una funzione per l'impostazione casuale delle piattaforme chiamata RandomizeCollidablePlatformsPerRow().

   Verse

        OnSimulate<override>()<suspends>:void=
            # For each row, spawn multiple platforms and pick a number of them to have collision while the others don't.
            # The platforms with collision will have the Chosen color for their light component.
            # The platforms without collision will have the NotChosen color for their light component.
            for (Row := 0..GridSize.Y - 1):
                EntitiesInRow := for (Column := 0..GridSize.X - 1):
                    # The prefab has a parent constraint component so set the InitialRelative Transform
                    # on the transform component to offset each platform relative to this entity.
                    # This means the platform prefabs will spawn same distance from each other
                    # but moving the root entity will change where the platforms originate.
   
   Expand code Copy full snippet(34 lines long)

3. Crea una funzione chiamata RandomizeCollidablePlatformsPerRow che seleziona casualmente le entità che hanno collisioni e fai in modo che disabiliti le collisioni di tutte le entità. Dato che il componente luce puntiforme è sull'entità figlio del prefabbricato, puoi utilizzare FindComponents per eseguire ricerche tra le entità figlio per modificare il colore della luce puntiforme.

   Verse

        # Randomly choose platforms to have collision in the row.
        RandomizeCollidablePlatformsPerRow(Entities:[]entity):void=
            # Disable all the entities before choosing which ones to enable.
                # It disables an entity by disabling the collision on the entity,
                # and finding a point light in its child entities to change its color.
                for:
                    EntityPlatform : Entities
                    Collision := EntityPlatform.GetComponents(collision_component)[0]
                    Light := EntityPlatform.FindComponents(point_light_component)[0]
                do:
   
   Expand code Copy full snippet(12 lines long)

4. Crea un metodo di estensione per gli array chiamato ChooseOne per scegliere un elemento casuale dall'array. Il risultato è una tupla che contiene sia l'elemento scelto che un array con tutti gli altri elementi che non sono stati selezionati.

   Verse

        # An extension method for an array to get a randomly selected element from the array.
        (Input:[]t where t:subtype(comparable)).ChooseOne()<decides><transacts>:tuple(t, []t)=
            ChosenElement := Input[GetRandomInt(0, Input.Length - 1)]
            NotChosenElements := Input.RemoveFirstElement[ChosenElement]
            (ChosenElement, NotChosenElements)

   Copy full snippet(5 lines long)

5. Chiama ChooseOne da RandomizeCollidablePlatformsPerRow per selezionare un'entità con collisione e cambiarne il colore.

   Verse

        # Randomly choose platforms to have collision in the row.
        RandomizeCollidablePlatformsPerRow(Entities:[]entity):void=
            # Disable all the entities before choosing which ones to enable.
            # It disables an entity by disabling the collision on the entity,
            # and finding a point light in its child entities to change its color.
            for:
                EntityPlatform : Entities
                Collision := EntityPlatform.GetComponents(collision_component)[0]
                Light := EntityPlatform.FindComponents(point_light_component)[0]
            do:
   
   Expand code Copy full snippet(23 lines long)

6. Aggiorna RandomizeCollidablePlatformsPerRow per scegliere più entità che hanno una collisione in base alle proprietà modificabili. Prima ottieni un valore casuale tra i numeri massimo e minimo di piattaforme corrette per riga e scegli un'entità altrettante volte, poi rimuovi l'entità che è stata scelta dall'elenco dei candidati successivi da cui scegliere.

   Verse

        # Randomly choose platforms to have collision in the row.
        RandomizeCollidablePlatformsPerRow(Entities:[]entity):void=
            # Disable all the entities before choosing which ones to enable.
            # It disables an entity by disabling the collision on the entity,
            # and finding a point light in its child entities to change its color.
            for:
                EntityPlatform : Entities
                Collision := EntityPlatform.GetComponents(collision_component)[0]
                Light := EntityPlatform.FindComponents(point_light_component)[0]
            do:
   
   Expand code Copy full snippet(29 lines long)

7. Salva e compila il tuo codice.

Se lanci ora una sessione, viene generata nel mondo una griglia di piattaforme con una sequenza univoca di piattaforme che hanno collisioni e il colore scelto.

Script completo

using { /UnrealEngine.com/Temporary/SceneGraph }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org }
using { /Verse.org/Colors }
using { /Verse.org/Native }
using { /Verse.org/Random }
using { /Verse.org/Simulation }

GridSizeTip<localizes>:message = "Size of the grid, where the grid is X units wide by Y units deep."
PlatformSpacingTip<localizes>:message = "The distance between each platform on the grid."