Trigger Component and Triggerable Child Classes

This page guides you through creating a new Scene Graph component named trigger_component. This component triggers actions on entities that have a Scene Graph component that implements the triggerable interface. The trigger_component provides agents a way to interact with Scene Graph through a volume_device. When an agent enters or exits the volume_device, the corresponding AgentEnteredEvent and AgentExitedEvent is signaled and corresponding callbacks are called to perform actions on Scene Graph components and entities.

In the following image, the white pedestal on the ground is a Scene Graph entity with the trigger_component and an invisible volume_device around the pedestal.

When the player steps on the pedestal, the trigger_component triggers the two lights farthest to the right.

When the player steps off the pedestal and leaves the volume_device, the lights remain in the on state.

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

• Interface in Verse

• Creating your own Component using Verse

Define the Trigger Component

1. 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 trigger_component.

   

3. Define the trigger_component class and add fields that reference the associated volume_device, whether or not this component only triggers children or all triggerable descendants, and an array referencing all agents interacting with this component.

   Verse

   trigger_component := class<final_super>(component):
   
       # volume_device associated with this trigger_component
       @editable
       InteractionVolume<private>:volume_device = volume_device{}
   
       # whether or not this triggers on components on child entities
       @editable
       OnlyTriggerChildren:logic = false
   
   
   Expand code Copy full snippet(12 lines long)

4. Add functions named OnAgentEntersVolume and OnAgentExitsVolume that define what happens when an agent enters and exits this component's associated volume_device. When an agent enters the volume, record the interacting agent and look for descendant entities that have a component that implements the triggerable interface then trigger the component on those entities. When an agent enters the volume, remove the interacting agent from the list of agents interacting with this volume.

   Verse

       # Event that is triggered when an Agent enters the InteractionVolume
       OnAgentEntersVolume(Agent:agent):void=
           for:
               ChosenEntity : Entity.FindDescendantEntities(entity)
               ChosenEntityComponent : ChosenEntity.GetComponents()
               CastToInterface := triggerable[ChosenEntityComponent]
           do:
               if (OnlyTriggerChildren?):
                   if (Entity = ChosenEntity.GetParent[]):
                       CastToInterface.Trigger()
   
   Expand code Copy full snippet(17 lines long)

5. Connect the OnAgentEntersVolume and OnAgentExitsVolume functions to the volume_device by registering them as the callback functions for the AgentEntersEvent and AgentExitsEvent in this component's OnSimulate 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()
   
       # Runs when the component should start simulating in a running game.
       # Can be suspended throughout the lifetime of the component. Suspensions
       # will be automatically cancelled when the component is disposed or the
       # game ends.
   
   Expand code Copy full snippet(15 lines long)

Define the Triggerable Components

Next, define components that implement the previously created triggerable interface. These are components that are added to Scene Graph entities that are descendants of an entity with a puzzle_component and are triggered by an ancestor entity with a trigger_component. This tutorial defines three different triggerable components:

• triggerable_mesh_component: Toggles the visibility of the entity's mesh_component.

• triggerable_light_component: Toggles the entity's sphere_light_component on and off and exchanges the entity`s mesh_component for one with or without emissive color, depending on whether the light is on or off.

• triggerable_movement_component: Triggers a transformation of the entity`s mesh_component using the keyframed_movement_component.

These three different components share a large amount of functionality, and many of the functions are defined the same way. To begin, create a new, empty Verse file named TriggerableComponents.verse.

1. Include the following modules:

   • /Verse.org/SceneGraph since this file uses Scene Graph components and Scene Events.

   • /Verse.org/SceneGraph/KeyframedMovement since this file uses keyframed_movement_delta.

   • /Verse.org/Simulation since this file uses the @editable attribute.

   • /Verse.org/SpatialMath since this file uses Verse transforms.

   Verse

   using { /Verse.org/SceneGraph }
   using { /Verse.org/SceneGraph/KeyframedMovement }
   using { /Verse.org/Simulation }
   using { /Verse.org/SpatialMath }
   

   Copy full snippet(4 lines long)

2. Define the components triggerable_mesh_component, triggerable_light_component, and triggerable_movement_component. All of these components inherit from the base component class and implement the triggerable interface.

3. All three components implement the same three events:

   • OnReceive: Called when this component receives a Scene Event.

   • OnBeginSimulation: Called when the component should start simulating.

   • OnSimulate: Called when the component starts simulating.

   Add the following implementations to all three components.

   Verse

       # Runs when this component receives a scene event
       OnReceive<override>(SceneEvent:scene_event):logic=
           if (PuzzleSolvedEvent := puzzle_solved_event[SceneEvent], not PuzzlePiece?):
               Trigger()
               true
           false
     
       # Runs when the component should start simulating in a running game.
       OnBeginSimulation<override>():void =
           # Run OnBeginSimulation from the parent class before
   
   Expand code Copy full snippet(20 lines long)

4. All three components also implement the triggerable interface PostTrigger override in the same way by sending up a triggered_event if the triggerable component is a puzzle piece. You cannot accomplish this inside the triggerable interface itself because Verse needs to know which entity is triggered, and the Entity field is part of the component class and not available to the triggerable interface without the additional dependence on the component class.

   Verse

       PostTrigger<override>():void =
           if (PuzzlePiece?):
               Event := triggered_event:
                   Triggered := Triggered
                   TriggeredEntity := option{Entity}
               Entity.SendUp(Event)

   Copy full snippet(6 lines long)

Triggerable Mesh Component

The triggerable_mesh_component toggles the visibility of a mesh_component on an entity. This requires providing overrides for the following triggerable interface functions:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. The initial triggered state is determined by checking whether or not the mesh starts as visible in the game world as set in the mesh component’s details panel.

2. The action for the triggerable_mesh_component is to make the mesh_component mesh visible. To do this, retrieve the mesh_component for the corresponding entity, set the mesh to visible, then set the triggerable_mesh_component to the triggered state.

   Verse

       # Determine the initial triggered state of this component
       SetInitialTriggeredState<override>():void=
           if (MeshComponent := Entity.GetComponent[mesh_component], MeshComponent.Visible?):
                   set Triggered = true

   Copy full snippet(4 lines long)

3. The reverse action for the triggerable_mesh_component is to make the mesh_component mesh invisible. To do this, retrieve the mesh_component for the corresponding entity, set the mesh to not visible, then set the triggerable_mesh_component to the not-triggered state.

   Verse

       PerformReverseAction<override>():void =
           if (MeshComponent := Entity.GetComponent[mesh_component]):
               if (MeshComponent.Visible?):
                   set MeshComponent.Visible = false
                   set Triggered = false

   Copy full snippet(5 lines long)

Triggerable Movement Component

The triggerable_movement_component triggers an entity to move from one location to a series of other locations in sequence using the keyframed_movement_component. This requires providing overrides for the following triggerable interface functions:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

In addition, this component uses a few helper functions:

• GetMovementStates: Retrieve transforms of child entities defining the series of transformations for this entity.

• MakeDeltaTransform: Create a delta transform between two input transforms.

• ConstructKeyframeDeltas: Create an array of keyframed_movement_delta objects for input to the keyframed_movement_component.

• SetAndPlayAnimation: Assign the keyframes and play the movement animation.

1. Add an editable float to this class that determines how long the keyframed animation lasts.

   Verse

       @editable
       Duration:float = 2.0
   

   Copy full snippet(2 lines long)

2. This class implements the triggerable interface, so overrides need to be provided for the PerformAction and PerformReverseAction functions since they have no default implementations. Since there is no initial triggered state and the action is a movement between locations, the default initial triggered state is false. This is what the base implementation does in the triggerable interface, so this function does not require an override in this component class.

3. The action for the triggerable_movement_component is to move the entity along the series of transforms defined by child entities.

   Verse

       PerformAction<override>():void =
           MovementStates := GetMovementStates()
           AnimationFrames:[]keyframed_movement_delta = ConstructKeyframeDeltas(MovementStates)
           SetAndPlayAnimation(AnimationFrames)
   

   Copy full snippet(4 lines long)

4. The reverse action for the triggerable_movement_component is to move the entity along the series of transforms defined by child entities in reverse order. This function is similar to the PerformAction except that the transform array is in reverse order.

   Verse

       PerformReverseAction<override>():void =
           MovementStates := GetMovementStates()
           ReversedMovementStates := for:
               Index := 0..MovementStates.Length - 1
               ReversedElement := MovementStates[MovementStates.Length - 1 - Index]
           do:
               ReversedElement
           AnimationFrames := ConstructKeyframeDeltas(ReversedMovementStates)
           SetAndPlayAnimation(AnimationFrames)
   

   Copy full snippet(9 lines long)

5. Define the helper functions that this component uses. First, create a function named GetMovementStates to retrieve the transforms that this movement moves to.

   Verse

       GetMovementStates():[]transform=
           for (ChildEntity : Entity.FindDescendantEntities(entity), Entity = ChildEntity.GetParent[]):
               ChildEntity.GetGlobalTransform()
   

   Copy full snippet(3 lines long)

6. Define a helper function named MakeDeltaTransform that constructs a delta transform between two transforms. A delta transform, D, from transform A to transform B is the transform such that when transform D is applied to transform A, the result is transform B. 

   To expand upon this, suppose that you have a Scene Graph entity with current transform A, but you want to scale, rotate, and translate your entity to have transform B. The delta transform D is the transform you need for a keyframed_movement_delta to animate the motion of your entity from transform A to transform B.  

   Verse

       MakeDeltaTransform(InTransformOne:transform, InTransformTwo:transform):transform =
           transform:
               Translation := InTransformTwo.Translation - InTransformOne.Translation
               Rotation := MakeComponentWiseDeltaRotation(InTransformOne.Rotation, InTransformTwo.Rotation)
               Scale := vector3:
                   Forward := InTransformTwo.Scale.Forward / InTransformOne.Scale.Forward
                   Right := InTransformTwo.Scale.Right / InTransformOne.Scale.Right
                   Up := InTransformTwo.Scale.Up / InTransformTwo.Scale.Up
   

   Copy full snippet(8 lines long)

7. Define a helper named ConstructKeyframeDelta that creates an array of keyframed_movement_delta objects for input to the keyframed_movement_component animation.

   Verse

       ConstructKeyframeDeltas<public>(MovementStates:[]transform):[]keyframed_movement_delta =
           var LastTransform:transform = Entity.GetGlobalTransform()
           for (EntityIndex -> CurrentTransform : MovementStates):
               DeltaTransform := MakeDeltaTransform(LastTransform, CurrentTransform)
               set LastTransform = CurrentTransform
               keyframed_movement_delta:
                   Transform := DeltaTransform
                   Duration := Duration
                   Easing := if (MovementStates.Length > 1):
                       if (EntityIndex = 0):
   
   Expand code Copy full snippet(17 lines long)

8. Create a function named SetAndPlayAnimation that assigns the keyframed_movement_delta array to the keyframed_movement_component animation and plays it.

   Verse

       SetAndPlayAnimation<private>(Frames:[]keyframed_movement_delta):void =
           if (KeyframedMovementComponent := Entity.GetComponent[keyframed_movement_component]):
               KeyframedMovementComponent.SetKeyframes(Frames, oneshot_keyframed_movement_playback_mode{})
               KeyframedMovementComponent.Play()
   

   Copy full snippet(4 lines long)

Triggerable Light Component

The triggerable_light_component turns a light on and off. This requires providing overrides for the following triggerable interface functions:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. The initial triggered state of the light is determined by whether or not the light is on, so the SetInitialTriggeredState checks if the light is already on, and if it is, sets it to initially triggered.

   Verse

       # Determine the initial triggered state of this light
       SetInitialTriggeredState<override>():void=
           for:
               DescendantEntity : Entity.FindDescendantEntities(entity)
               Entity = DescendantEntity.GetParent[]
               MeshComponent := DescendantEntity.GetComponent[mesh_component]
               LightComponent := DescendantEntity.GetComponent[light_component]
               MeshComponent.IsEnabled[]
               LightComponent.IsEnabled[]
           do:
   
   Expand code Copy full snippet(11 lines long)

2. The action performed by the triggerable_light_component is to turn the light on and switch to a mesh indicating that the light is on.

   Verse

       PerformAction<override>():void=
           if (not IsLightOn?):
               for (DescendantEntity:Entity.FindDescendantEntities(entity), Entity = DescendantEntity.GetParent[]):
                   if (MeshComponent := DescendantEntity.GetComponent[mesh_component]):
                       if (LightComponent := DescendantEntity.GetComponent[light_component]):
                           MeshComponent.Enable()
                           LightComponent.Enable()
                       else:
                           MeshComponent.Disable()
               set IsLightOn = true
   
   Expand code Copy full snippet(11 lines long)

3. The action performed by the triggerable_light_component is to turn the light off and set the non-emissive mesh_component to visible.

   Verse

       PerformReverseAction<override>():void=
           if (IsLightOn?):
               for (DescendantEntity:Entity.FindDescendantEntities(entity), Entity = DescendantEntity.GetParent[]):
                   if (MeshComponent := DescendantEntity.GetComponent[mesh_component]):
                       if (LightComponent := DescendantEntity.GetComponent[light_component]):
                           MeshComponent.Disable()
                           LightComponent.Disable()
                       else:
                           MeshComponent.Enable()
               set IsLightOn = false
   
   Expand code Copy full snippet(11 lines long)

Next Steps

Now that all of the Verse code has been written, build your Verse code. Next, construct prefabs with base entities and components that you can reuse in UEFN to create your puzzle experience.

Final Code

TriggerComponent.verse

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Verse.org/SceneGraph }
using { Logging }

trigger_component<public> := class<final_super>(component):

    @editable
    InteractionVolume<private>:volume_device = volume_device{}

TriggerableComponents.verse

using { /Verse.org/SceneGraph }
using { /Verse.org/SceneGraph/KeyframedMovement }
using { /Verse.org/Simulation }
using { /Verse.org/SpatialMath }

EnabledToolTip<public><localizes>:message = "Whether or not this component is enabled."

triggerable_mesh_component<public> := class<final_super>(component, triggerable):

    <# Triggerable interface #>

• 

  Construct Prefabs

  Use the previously defined components to construct prefabs and create a puzzle.