Puzzle Component

This page guides you through creating a new Scene Graph component named puzzle_component that manages a puzzle built with Scene Graph entities. Once built, place a puzzle_component on a Scene Graph entity to determine whether a puzzle consisting of descendant Scene Graph entities with triggerable components that are specified as puzzle pieces is solved.

For example, the following image is a simple puzzle you will construct in the last section of this tutorial.

The Outliner corresponding to this puzzle is shown in the next image.

Every descendant entity of Prefab_PuzzleManager is part of the puzzle managed by the Prefab_PuzzleManager's corresponding puzzle_component. The puzzle_component:

• Receives events when a puzzle piece has been switched to the solved configuration.

• Determines when the puzzle is solved.

• Sends events down the Scene Graph hierarchy when the puzzle is solved to trigger actions corresponding to the solution.

When the player steps on the platforms and turns on both of the lights, the mesh animates and transforms.

For more information about the Verse language features used on this page, see:

• Scene Events

• Creating Your Own Component Using Verse

Define the Puzzle Solved Event

1. To begin, navigate to the Verse Explorer, right-click the project name, and choose Add new Verse file to project.

   

2. Choose the template Scene Graph Component and change the Component Name to puzzle_component.

   

3. Define the puzzle_solved_event. This is the event that is transmitted through the Scene Graph hierarchy when the puzzle is solved to trigger an action, such as opening a gate or extending a bridge so the player can move beyond the area gated by the puzzle. Define the puzzle_solved_event as a child class of scene_event. This event does not require any parameters passed down the hierarchy.

   Verse

   puzzle_solved_event<public> := class(scene_event){}

   Copy full snippet(1 line long)

Define the Puzzle Component

Next, define the puzzle_component with fields and functions to manage the puzzle and whether or not it is solved.

1. Add fields to track whether or not the puzzle is solved, an array of which puzzle pieces are in the solved configuration, and whether or not puzzle pieces continue to trigger after the puzzle is solved:

   Verse

   puzzle_component := class<final_super>(component):
   
       # Is this puzzle component solved
       var<private> Solved<public>:logic = false
   
       # Map of puzzle pieces and whether they have been "solved"
       var<private> TriggerableEntities<private>:[]entity = array{}
   
       # Disable puzzle pieces triggering once puzzle is solved
       @editable
   
   Expand code Copy full snippet(11 lines long)

2. Add a function named InitializeTriggerableDescendantEntities to initialize the list of all puzzle pieces that are part of this puzzle. This function traverses down the Scene Graph hierarchy to find all triggerable entities marked as being a puzzle piece and adds them to the TriggerableEntities array.

   Verse

       # Initialize array of triggerable entities
       InitializeTriggereableDescendantEntities<private>()<transacts>:void=
           for:
               DescendantEntity : Entity.FindDescendantEntities(entity)
               DescendantEntityComponent : DescendantEntity.GetComponents()
               CastToTriggerable := triggerable[DescendantEntityComponent]
               CastToTriggerable.PuzzlePiece?
           do:
               set TriggerableEntities += array{DescendantEntity}

   Copy full snippet(9 lines long)

3. Add a function named DisableTriggerableComponents to disable any triggerable components on descendant entities.

   Verse

       # Disable puzzle pieces
       DisableTriggerableComponents<private>():void=
           for:
               DescendantEntity : Entity.FindDescendantEntities(entity)
               DescendantEntityComponent : DescendantEntity.GetComponents()
               CastToTriggerable := triggerable[DescendantEntityComponent]
               CastToTriggerable.PuzzlePiece?
               CastToEnableable := enableable[DescendantEntityComponent]
           do:
               CastToEnableable.Disable()

   Copy full snippet(10 lines long)

4. Add a function named IsPuzzleSolved that decides whether the puzzle is in a solved state. This is done by iterating through all previously found descendant entities with a component that implements the triggerable interface, checking whether the associated entity is marked as a puzzle piece, and whether the entity's component that implements triggerable is in a solved state.

   Verse

       # Decides whether puzzle is solved
       IsPuzzleSolved<private>()<decides><transacts>:void=
           for:
               TriggerableEntity : TriggerableEntities
               TriggerableEntityComponent : TriggerableEntity.GetComponents()
               CastToTriggerable := triggerable[TriggerableEntityComponent]
               CastToTriggerable.PuzzlePiece?
           do:
               CastToTriggerable.InSolvedState[]

   Copy full snippet(9 lines long)

5. Add a function named HandlePuzzleSolved to perform all necessary actions once it is determined that the puzzle is solved. This includes setting the Solved field on this class, disabling puzzle triggerables based on the class field DisablePuzzleTriggerablesWhenSolved, and sending the puzzle_solved_event down the Scene Graph hierarchy.

   Verse

       # Handle all necessary actions once puzzle is known to be solved
       HandlePuzzleSolved<private>():void=
           set Solved = true
           if (DisablePuzzleTriggerablesWhenSolved?):
               DisableTriggerableComponents()
           Entity.SendDown(puzzle_solved_event{})

   Copy full snippet(6 lines long)

6. Next, add a function named CheckPuzzleSolution. This is an asynchronous wrapper function for determining if the puzzle is solved with IsPuzzleSolved and, if it is, also calls HandlePuzzleSolved to perform the necessary actions when the puzzle is solved.

   Verse

       # Async wrapper for determining whether puzzle is solved
       CheckPuzzleSolved()<suspends>:void=
           Sleep(0.25)
           if (not Solved?, IsPuzzleSolved[]):
               HandlePuzzleSolved()

   Copy full snippet(5 lines long)

7. Add an override for the Scene Graph component class OnReceive function.

   Verse

       # Handle triggered events sent through the Scene Graph hierarchy
       OnReceive<override>(SceneEvent:scene_event):logic=
           if (TriggeredEvent := triggered_event[SceneEvent], TriggeredEntity := TriggeredEvent.TriggeredEntity?):
               spawn{CheckPuzzleSolved()}
               true
           false

   Copy full snippet(6 lines long)

8.  Add a call to InitializeTriggerableDescendantEntities to the component OnBeginSimulation function.

   Verse

       # Runs when the component should start simulating in a running game.
       OnBeginSimulation<override>():void =
           # Run OnBeginSimulation from the parent class before
           # running this component's OnBeginSimulation logic
           (super:)OnBeginSimulation()
           InitializeTriggereableDescendantEntities()

   Copy full snippet(6 lines long)

Next Steps

Next, create the Trigger Component and the Triggerable components that implement the Triggerable interface.

Final Code for Puzzle.verse

using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /Verse.org/SceneGraph }
using { Logging }

puzzle_solved_event<public> := class(scene_event){}

# Scene Graph component handling puzzle component triggered events and when the puzzle is solved.
puzzle_component := class<final_super>(component):

• 

  Trigger Component and Triggerable Child Classes

  Create a component that triggers triggerable Scene Graph entities.