Trigger-Komponente und Triggerable-Child-Klassen

Diese Seite führt dich durch die Erstellung einer neuen Scene-Graph-component mit dem Namen trigger_component. Diese Komponente löst Aktionen für entities aus, die über eine Scene-Graph-Komponente verfügen, die das triggerable-Interface implementiert. Die trigger_component bietet Agents eine Möglichkeit, über ein volume_device mit Scene Graph zu interagieren. Wenn ein Agent das volume_device betritt oder verlässt, wird das entsprechende AgentEnteredEvent und AgentExitedEvent signalisiert und entsprechende Callbacks werden aufgerufen, um Actions für Scene-Graph-Komponenten und -Entitäten durchzuführen.

In dem folgenden Bild ist der weiße Sockel auf dem Boden eine Scene-Graph-Entität mit der trigger_component und einem unsichtbaren volume_device um den Sockel herum.

Wenn der Spieler auf den Sockel tritt, löst die trigger_component die beiden Lichter ganz rechts aus.

Wenn der Spieler vom Sockel tritt und das volume_device verlässt, bleiben die Lichter im eingeschalteten Zustand.

Mehr Informationen zu den auf dieser Seite verwendeten Verse-Sprachfunktionen findest du unter:

• Interface in Verse

• Creating your own Component using Verse

Trigger-Komponente definieren

1. Navigiere zum Verse-Explorer, klicke mit der rechten Maustaste auf den Projektnamen und wähle Neue Verse-Datei zum Projekt hinzufügen.

   

2. Wähle die Vorlage Scene-Graph-Komponente aus und ändere Komponentenname in trigger_component.

   

3. Definiere die trigger_component-class und füge Felder hinzu, die auf das zugehörige volume_device verweisen, unabhängig davon, ob diese Komponente nur Children oder alle auslösbaren Descendants auslöst, und ein Array, das auf alle agents verweist, die mit dieser Komponente interagieren.

   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. Füge die Funktionen OnAgentEntersVolume und OnAgentExitsVolume hinzu, die definieren, was passiert, wenn ein Agent das zugehörige volume_device dieser Komponente betritt und verlässt. Wenn ein Agent das Volumen betritt, wird der interagierende Agent aufgezeichnet und nach Child-Entitäten gesucht, die eine Komponente haben, die das triggerable-Interface implementiert, und dann die Komponente für diese Entitäten auslösen. Wenn ein Agent das Volumen betritt, entferne den interagierenden Agenten aus der Liste der Agents, die mit diesem Volumen interagieren.

   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. Verbinde die Funktionen OnAgentEntersVolume und OnAgentExitsVolume mit dem volume_device, indem du sie als Callback-Funktionen für AgentEntersEvent und AgentExitsEvent in der OnSimulate-Funktion dieser Komponente registrierst.

   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)

Die auslösbaren Komponenten definieren

Als nächstes definierst du Komponenten, die das zuvor erstellte triggerable Interface implementieren. Dies sind Komponenten, die zu Scene-Graph-Entitäten hinzugefügt werden, die Descendants einer Entität mit einer puzzle_component sind, und von einer Ancestor-Entität mit einer trigger_component ausgelöst werden. Dieses Tutorial definiert drei verschiedene triggerable-Komponenten:

• triggerable_mesh_component: Schaltet die Sichtbarkeit der mesh_component der Entität um.

• triggerable_light_component: Schaltet die sphere_light_component der Entität ein und aus und tauscht die mesh_component der Entität gegen eine mit oder ohne emissive-Farbe aus, je nachdem, ob das Licht an oder aus ist.

• triggerable_movement_component: Löse eine Transformation der mesh_component der Entität unter Verwendung der keyframed_movement_component aus.

Diese drei verschiedenen Komponenten teilen einen großen Teil der Funktionalität, und viele der Funktionen sind auf die gleiche Weise definiert. Erstelle zunächst eine neue, leere Verse-Datei namens TriggerableComponents.verse.

1. Füge die folgenden Module hinzu:

   • /Verse.org/SceneGraph, da diese Datei Scene-Graph-Komponenten und Szenen-Events verwendet.

   • /Verse.org/SceneGraph/KeyframedMovement, da diese Datei keyframed_movement_delta verwendet.

   • /Verse.org/Simulation hinzufügen, da diese Datei das Attribut @editable verwendet.

   • /Verse.org/SpatialMath hinzufügen, da diese Datei Verse-Transformationen verwendet.

   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. Definiere die Komponenten triggerable_mesh_component, triggerable_light_component und triggerable_movement_component. Alle diese Komponenten erben von der component-Basisklasse und implementieren das triggerable-Interface.

3. Alle drei Komponenten implementieren die gleichen drei Events:

   • OnReceive: Wird aufgerufen, wenn diese Komponente ein Szenen-Event empfängt.

   • OnBeginSimulation: Wird aufgerufen, wenn die Komponente mit der Simulation beginnen soll.

   • OnSimulate: Wird aufgerufen, wenn die Komponente mit der Simulation beginnt.

   Füge die folgenden Implementierungen zu allen drei Komponenten hinzu.

   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. Alle drei Komponenten implementieren auch den PostTrigger-Override des triggerable-Interfaces auf die gleiche Weise, indem sie ein triggered_event senden, wenn die triggerable-Komponente ein Puzzleteil ist. Du kannst dies nicht innerhalb des triggerable-Interfaces selbst erreichen, weil Verse wissen muss, welche entity ausgelöst wird, und das Entity-Feld ist Teil der component klasse und für das triggerable-Interface ohne die zusätzliche Abhängigkeit von der component-Klasse nicht verfügbar.

   Verse

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

   Copy full snippet(6 lines long)

Auslösbare Mesh-Komponente

Die triggerable_mesh_component schaltet die Sichtbarkeit einer mesh_component auf einer Entität um. Das erfordert die Bereitstellung von Overrides für die folgenden triggerable-Interface-Funktionen:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. Der anfänglich ausgelöste Zustand wird bestimmt, indem geprüft wird, ob das Mesh in der Spielwelt so sichtbar beginnt, wie es im Details-Panel der Mesh-Komponente festgelegt ist.

2. Die Aktion für die triggerable_mesh_component besteht darin, das Mesh der mesh_component sichtbar zu machen. Dazu rufst du die mesh_component für die entsprechende Entität ab, setzt das Mesh auf sichtbar und dann die triggerable_mesh_component auf den ausgelösten Zustand.

   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. Die umgekehrte Aktion für die triggerable_mesh_component besteht darin, das Mesh der mesh_component unsichtbar zu machen. Dazu rufst du die mesh_component für die entsprechende Entität ab, setzt das Mesh auf nicht sichtbar und dann die triggerable_mesh_component auf den nicht ausgelösten Zustand.

   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)

Auslösbare Bewegungskomponente

Die triggerable_movement_component veranlasst eine Entität dazu, sich von einem Standort aus nacheinander an eine Reihe von anderen Orten zu bewegen, indem sie den keyframed_movement_component verwendet. Das erfordert die Bereitstellung von Overrides für die folgenden triggerable-Interface-Funktionen:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

Darüber hinaus verwendet diese Komponente einige Hilfsfunktionen:

• GetMovementStates: Rufe die Transformationen von Child-Entitäten ab, die die Reihe von Transformationen für diese Entität definieren.

• MakeDeltaTransform: Erstelle eine Delta-Transformation zwischen zwei Input-Transformationen.

• ConstructKeyframeDeltas: Erstelle ein Array von keyframed_movement_delta-Objekten als Input für die keyframed_movement_component.

• SetAndPlayAnimation: Weist die Keyframes zu und gibt die Bewegungsanimation wieder.

1. Füge einen bearbeitbaren float zu dieser Klasse hinzu, der bestimmt, wie lange die Keyframe-Animation dauert.

   Verse

       @editable
       Duration:float = 2.0
   

   Copy full snippet(2 lines long)

2. Diese Klasse implementiert das triggerable-Interface, daher müssen Overrides für die Funktionen PerformAction und PerformReverseAction bereitgestellt werden, da sie keine Standardimplementierungen haben. Da es keinen anfänglich ausgelösten Zustand gibt und die Action eine Bewegung zwischen Orten ist, ist der standardmäßige anfänglich ausgelöste Zustand False. Das ist die Funktion der Basisimplementierung im triggerable-Interface, sodass für diese Funktion kein Override in dieser Komponentenklasse erforderlich ist.

3. Die Action für die triggerable_movement_component besteht darin, die Entität entlang der Reihe von Transformationen zu bewegen, die durch Child-Entitäten definiert sind.

   Verse

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

   Copy full snippet(4 lines long)

4. Die umgekehrte Action für die triggerable_movement_component besteht darin, die Entität entlang der Reihe von Transformationen zu bewegen, die durch Child-Entitäten in umgekehrter Reihenfolge definiert sind. Diese Funktion ist der PerformAction ähnlich, mit dem Unterschied, dass das Transformation-Array die umgekehrte Reihenfolge hat.

   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. Definiere die Hilfsfunktionen, die diese Komponente verwendet. Erstelle zunächst eine Funktion namens GetMovementStates, um die Transformationen abzurufen, zu denen sich diese Bewegung bewegt.

   Verse

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

   Copy full snippet(3 lines long)

6. Definiere eine Hilfsfunktion namens MakeDeltaTransform, die eine Delta-Transformation zwischen zwei Transformationen erstellt. Eine Delta-Transformation, D, von Transformation A zu Transformation B ist die Transformation, so dass, wenn Transformation D auf Transformation A angewendet wird, das Ergebnis Transformation B ist. 

   Um dies zu verdeutlichen, nimm an, dass du eine Scene-Graph-Entität mit der aktuellen Transformation A hast, aber du möchtest deine Entität skalieren, drehen und verschieben, um Transformation B zu haben. Die Delta-Transformation D ist die Transformation, die du für ein keyframed_movement_delta benötigst, um die Bewegung deiner Entität von Transformation A zu Transformation B zu animieren.  

   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. Definiere eine Hilfsfunktion namens ConstructKeyframeDelta, die ein Array von keyframed_movement_delta-Objekten als Eingabe für die keyframed_movement_component-Animation erstellt.

   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. Erstelle eine Funktion namens SetAndPlayAnimation, die das Array keyframed_movement_delta der Animation keyframed_movement_component zuweist und sie abspielt.

   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)

Auslösbare Licht-Komponente

Die triggerable_light_component schaltet ein Licht ein und aus. Das erfordert die Bereitstellung von Overrides für die folgenden triggerable-Interface-Funktionen:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. Der anfänglich ausgelöste Zustand des Lichts wird davon bestimmt, ob das Licht eingeschaltet ist oder nicht. SetInitialTriggeredState prüft also, ob das Licht bereits eingeschaltet ist, und wenn dies der Fall ist, wird es auf anfänglich ausgelöst gesetzt.

   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. Die von der triggerable_light_component durchgeführte Action besteht darin, das Licht einzuschalten und zu einem Mesh zu wechseln, das anzeigt, dass das Licht eingeschaltet ist.

   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. Die von der triggerable_light_component durchgeführte Action besteht darin, das Licht auszuschalten und die nicht emissive mesh_component sichtbar zu machen.

   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)

Nächste Schritte

Nachdem jetzt der gesamte Verse-Code geschrieben wurde, erstelle deinen Verse-Code. Konstruiere als nächstes Prefabs mit Basis-Entitäten und Komponenten, die du in UEFN wiederverwenden kannst, um dein Rätsel-Erlebnis zu erstellen.

Endgültiger 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 #>

• 

  Prefabs konstruieren

  Verwende die zuvor definierten Komponenten, um Prefabs zu konstruieren und ein Rätsel zu erstellen.