Como gerar uma grade de plataformas com o Scene Graph

A geração de uma sequência de grade única de plataformas em que apenas algumas plataformas em cada linha são válidas para pular é comum nos modos de jogos de plataforma. Isso exige que os jogadores diminuam a velocidade e descubram a sequência.

Esse tutorial mostra como gerar uma grade de plataformas em que as plataformas de cada linha são selecionadas aleatoriamente para ter colisão e cor clara para distingui-las, enquanto as demais não têm.

Como criar a estrutura pré-fabricada da plataforma

Siga estas etapas para criar uma estrutura pré-fabricada de plataforma que será gerada a partir do Verse:

1. Coloque uma nova entidade e promova-a a uma estrutura pré-fabricada chamada choose_one_platform_prefab. Para instruções, consulte Estrutura pré-fabricada e instâncias de estrutura pré-fabricada.

2. No Editor de Estruturas Pré-fabricadas, adicione os seguintes componentes à entidade:

   • transform_component: o componente de transformação para posicionar a plataforma.

   • mesh_component: o componente de malha para definir a malha estática da plataforma. Este exemplo usa a malha SM_block_02 do ativo Stylized Egyptian World Pack na Loja Fab.

   • collision_component: o componente de colisão para habilitar e desabilitar a colisão na plataforma.

   • parent_constraint_component: o componente de restrição pai para definir facilmente a transformação relativa à entidade pai ao gerar essa estrutura pré-fabricada no mundo usando o Verse.

   

3. Adicione uma entidade filha e chame-a de Light.

4. Adicione os seguintes componentes à entidade filha Light:

   • transform_component: o componente de transformação que posiciona a entidade acima da plataforma.

   • point_light_component: o componente de luz pontual para adicionar uma fonte de luz que muda de cor com base no fato de a plataforma ter colisão.

   • parent_constraint_component: o componente de restrição pai que restringe a transformação dessa entidade em relação à entidade pai.

   

5. Salve a estrutura pré-fabricada.

Sua estrutura pré-fabricada agora aparece no arquivo Assets.digest.verse como uma classe com o mesmo nome da sua estrutura pré-fabricada, choose_one_platform_prefab.

Como gerar uma grade de plataformas

Siga estas etapas para gerar uma grade feita a partir da estrutura pré-fabricada de plataforma:

1. Crie um componente Verse chamado choose_one_component. Para ver as etapas de como criar um componente Verse, consulte Como criar seu próprio componente Verse.

2. Adicione as seguintes propriedades editáveis:

   • Um campo vector2i de vetor 2D inteiro chamado GridSize para definir quantas plataformas estão na grade. X é o número de linhas e Y é o número de colunas na grade.

   • Um campo vector2 de vetor 2D de ponto flutuante chamado PlatformSpacing para especificar o espaçamento entre as plataformas nas linhas e colunas.

     ~~~(verse) GridSizeTip<localizes>:message = "Tamanho da grade, onde a grade tem X unidades de largura por Y unidades de profundidade." PlatformSpacingTip<localizes>:message = "A distância entre cada plataforma na grade."

     choose_one_component<public> := class(component):

     # Tamanho da grade, em que a grade tem X unidades de largura por Y unidades de profundidade. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

     # Distância entre cada plataforma na grade. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0} ~~~

3. Na função OnSimulate, itere pelo vetor GridSize para saber quantas plataformas gerar. No loop, crie uma instância de sua classe de pré-fabricado e adicione-a à entidade à qual esse componente do Verse está anexado, para gerar a estrutura pré-fabricada no mundo.

   ~~~(verse) GridSizeTip<localizes>:message = "Tamanho da grade, onde a grade tem X unidades de largura por Y unidades de profundidade." PlatformSpacingTip<localizes>:message = "A distância entre cada plataforma na grade."

   choose_one_component<public> := class(component):

   # Tamanho da grade, em que a grade tem X unidades de largura por Y unidades de profundidade. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

   # Distância entre cada plataforma na grade. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0}

   OnSimulate<override>()<suspends>:void= # Gerar plataformas para criar a grade. for (Column := 0..GridSize.Y - 1): for (Row := 0..GridSize.X - 1): # Criar uma instância de uma estrutura pré-fabricada e adicioná-la a uma entidade existente gerará essa estrutura no mundo. ChooseOnePlatform := choose_one_platform_prefab{} Entity.AddEntities(array{ChooseOnePlatform}) ~~~

4. Se você executasse o código agora, todas as plataformas surgiriam na mesma posição. Como a estrutura pré-fabricada tem o componente de transformação e o componente pai, você pode definir a propriedade InitialRelativeTransform em seu componente de transformação para fazer a estrutura pré-fabricada surgir com um deslocamento relativo à posição da entidade à qual você está adicionando a estrutura pré-fabricada. Sem o componente de restrição pai na entidade que está sendo gerada, você teria que especificar a localização no espaço do mundo (e não em relação à entidade raiz).

   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. Salve e compile seu código.

Se você anexar esse componente do Verse a uma entidade e iniciar uma sessão, uma grade de plataformas aparecerá no local da entidade.

Como selecionar aleatoriamente plataformas válidas

Agora que você tem uma grade de plataformas geradas no mundo, pode adicionar mais funcionalidades a elas. As etapas a seguir mostram como selecionar aleatoriamente plataformas para colisão, a fim de gerar uma sequência única e variável de plataformas que o jogador pode atravessar.

Siga estas etapas para selecionar plataformas válidas aleatoriamente na grade:

1. Adicione as seguintes propriedades editáveis ao componente Verse:

   • Uma variável de inteiro denominada MinCorrectPlatformsPerRow para especificar o número mínimo de plataformas que têm colisão.

   • Uma variável de inteiro chamada MaxCorrectPlatformsPerRow para especificar o número máximo de plataformas que têm colisão.

   • Uma variável de cor chamada ChosenColor para definir a cor da plataforma se a colisão estiver habilitada.

   • Uma variável de cor chamada NotChosenColor para definir a cor da plataforma se a colisão não estiver habilitada.

     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. O resultado de uma expressão for é uma matriz de cada iteração. Armazena todas as plataformas geradas para uma linha em uma matriz e passa essa matriz para uma função que define aleatoriamente as plataformas chamada 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. Crie uma função chamada RandomizeCollidablePlatformsPerRow que deve selecionar aleatoriamente as entidades que terão colisão e faça com que ela desabilite a colisão em todas as entidades. Já que o componente de luz pontual está na entidade filho da estrutura pré-fabricada, você pode usar FindComponents para pesquisar entre os filhos da entidade para mudar a cor da luz pontual.

   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. Crie um método de extensão para matrizes chamado ChooseOne para escolher um elemento aleatório da matriz. O resultado é uma tupla que contém o elemento escolhido e uma matriz com todos os outros elementos que não foram selecionados.

   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. Chame ChooseOne de RandomizeCollidablePlatformsPerRow para selecionar uma entidade que terá colisão e mudará de cor.

   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. Atualize RandomizeCollidablePlatformsPerRow para escolher várias entidades que terão colisão com base nas propriedades editáveis. Primeiro, obtenha um valor aleatório entre o número mínimo e máximo de plataformas corretas por linha e escolha uma entidade tantas vezes quantas forem necessárias e, em seguida, remova a entidade que foi escolhida da lista dos próximos candidatos a serem escolhidos.

   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. Salve e compile seu código.

Se você iniciar uma sessão agora, uma grade de plataformas será gerada no mundo com uma sequência exclusiva de plataformas que têm colisão e a cor escolhida.

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."