Spawnen eines Rasters von Plattformen mit Scene Graph

In der Regel wird bei Plattform-Spielmodi eine einmalige Rastersequenz von Plattformen erzeugt, wobei in jeder Zeile nur wenige Plattformen zum Springen zur Verfügung stehen. Dadurch müssen die Spieler langsamer machen und die Sequenz herausfinden.

Dieses Tutorial zeigt, wie man ein Raster von Plattformen erstellt, wobei die Plattformen in jeder Zeile zufällig für die Kollisionsfunktion ausgewählt werden und eine helle Farbe haben, um sie von den anderen zu unterscheiden.

Erstellen des Plattform-Prefab

Befolge diese Schritte, um ein Plattform-Prefab zu erstellen, das du in Verse spawnen wirst:

1. Platziere eine neue Entität und befördere sie zu einem Prefab mit dem Namen choose_one_platform_prefab. Weitere Anweisungen findest du unter Prefab und Prefab-Instanzen.

2. Füge im Prefab-Editor die folgenden Komponenten zur Entität hinzu:

   • transform_component: Die Transformationskomponente zur Positionierung der Plattform.

   • mesh_component: Die Mesh-Komponente, um das statische Mesh der Plattform festzulegen. In diesem Beispiel wird das Mesh SM_block_02 aus dem Asset Stilisiertes ägyptisches Weltpaket im Fab-Marketplace verwendet.

   • collision_component: Die Kollisionskomponente zur Aktivierung und Deaktivierung von Kollisionen auf der Plattform.

   • parent_constraint_component: Die Parent Beschränkungskomponente zum einfachen Festlegen der Transformation relativ zur übergeordneten Entität, wenn dieses Prefab mit Verse in der Welt erzeugt wird.

   

3. Füge eine Child-Entität hinzu und nenne sie Licht.

4. Füge der Child-Entität Licht die folgenden Komponenten hinzu:

   • transform_component: Die Transformationskomponente zur Positionierung der Entität.

   • point_light_component: Die Punktlichtkomponente, um eine Lichtquelle hinzuzufügen, die die Farbe ändert, je nachdem, ob die Plattform kollidiert ist.

   • parent_constraint_component: Die Parent Beschränkungskomponente, die das Transformieren dieser Entität relativ zu Parent Entität beschränkt.

   

5. Speichere das Prefab.

Dein Prefab erscheint nun in der Datei Assets.digest.verse als class mit demselben Namen wie dein Prefab, choose_one_platform_prefab.

Ein Raster von Plattformen spawnen

Folge diesen Schritten, um ein Raster aus dem Plattform-Prefab zu spawnen:

1. Erstelle eine Verse-Komponente mit dem Namen chose_one_component. Schritte zum Erstellen einer Verse-Komponente findest du unter Erstellen deiner eigenen Komponente mit Verse.

2. Füge die folgenden bearbeitbaren Eigenschaften hinzu:

   • Ein Ganzzahl-2D-Vektor-Feld vector2i mit dem Namen GridSize, um zu definieren, wie viele Plattformen im Raster sind. X ist die Anzahl der Zeilen und Y ist die Anzahl der Spalten des Rasters.

   • Ein Fließkomma-2D-Vektor Feld vector2 mit dem Namen PlatformSpacing, um den Abstand zwischen den Plattformen in den Zeilen und Spalten festzulegen.

     ~~~(Verse) GridSizeTip<localizes>:message = „Größe des Rasters, wobei das Raster x Einheiten breit und y Einheiten tief ist.“ PlatformSpacingTip<localizes>:message = „Der Abstand zwischen den einzelnen Plattformen auf dem Raster.“

     choose_one_component<public> := class(component):

     # Größe des Rasters, wobei das Raster x Einheiten breit und y Einheiten tief ist. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

     # Abstand zwischen den einzelnen Plattformen auf dem Raster. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0} ~~~

3. In der Funktion OnSimulate iteriere über den Vektor GridSize, um zu wissen, wie viele Plattformen gespawnt werden sollen. Erstelle in der Schleife eine Instanz deiner Prefab-Klasse und füge sie der Entität hinzu, an die diese Verse-Komponente angekoppelt ist, um das Prefab in der Welt zu spawnen.

   ~~~(Verse) GridSizeTip<localizes>:message = „Größe des Rasters, wobei das Raster x Einheiten breit und y Einheiten tief ist.“ PlatformSpacingTip<localizes>:message = „Der Abstand zwischen den einzelnen Plattformen auf dem Raster.“

   choose_one_component<public> := class(component):

   # Größe des Rasters, wobei das Raster x Einheiten breit und y Einheiten tief ist. @editable_vector_number(int): ToolTip := GridSizeTip MinComponentValue := option{0} GridSize:vector2i = vector2i{X := 3, Y := 10}

   # Abstand zwischen den einzelnen Plattformen auf dem Raster. @editable_vector_number(float): ToolTip := PlatformSpacingTip MinComponentValue := option{0.0} PlatformSpacing:vector2 = vector2{X := 256.0, Y := 256.0}

   OnSimulate<override>()<suspends>:void= # Spawne Plattformen, um das Raster zu erstellen. for (Column := 0..GridSize.Y - 1): for (Row := 0..GridSize.X - 1): # Wenn du eine Instanz eines Prefabs erstellst und sie zu einer bestehenden Entität hinzufügst, spawnt das Prefab in der Welt. ChooseOnePlatform := choose_one_platform_prefab{} Entität.AddEntities(array{ChooseOnePlatform}) ~~~

4. Wenn du den Code jetzt ausführen würdest, würden alle Plattformen an der gleichen Stelle spawnen. Da das Prefab über die Transformationskomponente und die Parent-Beschränkungskomponente verfügt, kannst du die Eigenschaft InitialRelativeTransform für seine Transformationskomponente festlegen, um das Prefab mit einem Versatz relativ zur Position der Entität, dem du das Prefab hinzufügst, zu erzeugen. Ohne die Komponente der Parent-Beschränkung auf der Entität, die du spawnen willst, müsstest du die Position im Welt-Bereich angeben (und nicht relativ zur Stamm-Entität).

   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. Speichere und kompiliere deinen Code.

Wenn du diese Verse-Komponente an eine Entität ankoppelst und eine Sitzung startest, erscheint an der Position der Entität ein Raster mit Plattformen.

Gültige Plattformen zufällig auswählen

Jetzt, wo du ein Raster von Plattformen in der Welt gespawnt hast, kannst du ihnen mehr Funktionalität hinzufügen. Die folgenden Schritte zeigen, wie du Plattformen zufällig auswählst, die eine Kollision haben sollen, um eine einzigartige und wechselnde Sequenz von Plattformen zu erzeugen, über die ein Spieler springen kann.

Befolge diese Schritte, um gültige Plattformen im Raster zufällig auszuwählen:

1. Füge der Verse-Komponente die folgenden bearbeitbaren Eigenschaften hinzu:

   • Eine Ganzzahlvariable mit dem Namen MinCorrectPlatformsPerRow, um die Mindestanzahl von Plattformen mit Kollisionen anzugeben.

   • Eine Ganzzahlvariable mit dem Namen MaxCorrectPlatformsPerRow, um die maximale Anzahl von Plattformen mit Kollisionen anzugeben.

   • Eine Farbvariable mit dem Namen ChosenColor, um die Farbe der Plattform festzulegen, wenn die Kollision aktiviert ist.

   • Eine Farbvariable mit dem Namen NotChosenColor, um die Farbe der Plattform festzulegen, wenn die Kollision nicht aktiviert ist.

     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. Das Ergebnis eines for-Ausdrucks ist ein Array für jede Iteration. Speichere alle für eine Reihe gespawnten Plattformen in einem Array und übergibt dieses Array an eine Funktion zum zufälligen Setzen der Plattformen namens 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. Erstelle eine Funktion mit dem Namen RandomizeCollidablePlatformsPerRow, die zufällig Entitäten auswählt, die kollidieren sollen, und deaktiviere die Kollision für alle Entitäten. Da sich die Punktlichtkomponente auf der Child-Entität des Prefab befindet, kannst du FindComponents verwenden, um in den Children der Entität nach dem Punktlicht zu suchen, um ihre Farbe zu ändern.

   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. Erstelle eine Erweiterungsmethode für Arrays mit dem Namen ChooseOne, um ein zufälliges Element aus dem Array auszuwählen. Das Ergebnis ist ein Tupel, das sowohl das gewählte Element als auch ein Array mit allen anderen Elementen enthält, die nicht ausgewählt wurden.

   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. Rufe ChooseOne von RandomizeCollidablePlatformsPerRow auf, um eine Entität für eine Kollision auszuwählen, um ihre Farbe zu ändern.

   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. Aktualisiere RandomizeCollidablePlatformsPerRow, um mehrere Entitäten für die Kollision basierend auf den bearbeitbaren Eigenschaften auszuwählen. Zuerst holst du dir einen zufälligen Wert zwischen der minimalen und der maximalen Anzahl richtiger Plattformen pro Zeile und wählst eine Entität so oft aus, bis du die gewählte Entität aus der Liste der nächsten Kandidaten entfernst, aus der du wählen kannst.

   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. Speichere und kompiliere deinen Code.

Wenn du jetzt eine Sitzung startest, wird ein Raster von Plattformen in der Welt gespawnt, mit einer einzigartigen Sequenz von Plattformen, die Kollisionen und die gewählte Farbe aufweisen.

Vollständiges Script

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