Composant de déclenchement et classes enfants déclenchables

Dans cette page, nous vous expliquons comment créer un nouveau composant Scene Graph nommé trigger_component. Ce composant déclenche des actions sur les entités possédant un composant Scene Graph qui implémente l'interface déclenchable. Le composant trigger_component fournit aux agents un moyen d'interagir avec Scene Graph via un appareil volume_device. Lorsqu'un agent entre ou sort du volume_device, les événements l'AgentEnteredEvent et l'AgentExitedEvent correspondants sont signalés, et les rappels correspondants sont appelés pour exécuter des actions sur les composants et entités Scene Graph.

Dans l'image suivante, le socle blanc posé sur le sol est une entité Scene Graph avec le composant trigger_component et un appareil volume_device invisible autour du socle.

Lorsque le joueur marche sur le socle, le composant trigger_component déclenche les deux lumières les plus à droite.

Lorsque le joueur descend du socle et quitte l'appareil volume_device, les lumières restent allumées.

Pour en savoir plus sur les fonctionnalités du langage Verse utilisées sur cette page, consultez les rubriques suivantes :

• Interface dans Verse

• Créer votre propre composant à l'aide de Verse

Définir le composant de déclenchement

1. Accédez à l'explorateur Verse, faites un clic droit sur le nom du projet et choisissez Ajouter un nouveau fichier Verse au projet.

   

2. Choisissez le modèle Composant Scene Graph et remplacez le nom du composant par trigger_component.

   

3. Définissez la classe trigger_component et ajoutez des champs qui référencent le volume_device associé, que ce composant déclenche uniquement les enfants ou tous les descendants déclenchables, et une matrice référençant tous les agents interagissant avec ce composant.

   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. Ajoutez des fonctions nommées OnAgentEntersVolume et OnAgentExitsVolume qui définissent ce qui se passe lorsqu'un agent entre et sort de l'appareil volume_device associé à ce composant. Lorsqu'un agent entre dans le volume, enregistrez l'agent en interaction et recherchez les entités descendantes possédant un composant qui implémente l'interface déclenchable, puis déclenchez le composant sur ces entités. Lorsqu'un agent entre dans le volume, supprimez l'agent en interaction de la liste des agents interagissant avec ce 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. Connectez les fonctions OnAgentEntersVolume et OnAgentExitsVolume à l'appareil volume_device en les enregistrant comme fonctions de rappel pour AgentEntersEvent et AgentExitsEvent dans la fonction OnSimulate de ce composant.

   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)

Définir les composants déclenchables

Ensuite, définissez les composants qui implémentent l'interface déclenchable précédemment créée. Il s'agit de composants ajoutés aux entités Scene Graph qui sont les descendants d'une entité avec un composant puzzle_component et qui sont déclenchés par une entité ancêtre avec un composant trigger_component. Dans ce tutoriel, trois composants déclenchables différents sont définis :

• triggerable_mesh_component : active/désactive la visibilité du composant mesh_component de l'entité.

• triggerable_light_component : active/désactive le composant sphere_light_component de l'entité et échange le composant mesh_component de l'entité contre un composant avec ou sans couleur émissive, selon que la lumière est allumée ou éteinte.

• triggerable_movement_component : déclenche une transformation du composant mesh_component de l'entité à l'aide du composant keyframed_movement_component.

Ces trois composants différents partagent un grand nombre de fonctionnalités, et de nombreuses fonctions sont définies de la même manière. Pour commencer, créez un nouveau fichier Verse vide nommé TriggerableComponents.verse.

1. Incluez les modules suivants :

   • /Verse.org/SceneGraph, car ce fichier utilise des composants Scene Graph et des événements de scène.

   • /Verse.org/SceneGraph/KeyframedMovement, car ce fichier utilise keyframed_movement_delta.

   • /Verse.org/Simulation, car ce fichier utilise l'attribut @editable.

   • /Verse.org/SpatialMath, car ce fichier utilise les transformations Verse.

   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. Définissez les composants triggerable_mesh_component, triggerable_light_component et triggerable_movement_component. Tous ces composants héritent de la classe de composant de base et implémentent l'interface déclenchable.

3. Les trois composants implémentent les trois mêmes événements :

   • OnReceive : appelé lorsque ce composant reçoit un événement de scène.

   • OnBeginSimulation : appelé lorsque le composant doit commencer la simulation.

   • OnSimulate : appelé lorsque le composant démarre la simulation.

   Ajoutez les implémentations suivantes aux trois composants.

   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. Les trois composants implémentent également l'interface déclenchable PostTrigger de la même manière en envoyant un événement triggered_event si le composant déclenchable est une clé de l'énigme. Vous ne pouvez pas effectuer cette action au sein de l'interface déclenchable proprement dite, car Verse doit savoir quelle entité est déclenchée, et le champ Entité fait partie de la classe composant et n'est pas disponible pour l'interface déclenchable sans la dépendance supplémentaire à la classe composant.

   Verse

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

   Copy full snippet(6 lines long)

Composant de maillage déclenchable

Le composant triggerable_mesh_component active/désactive la visibilité d'un composant mesh_component sur une entité. Il est pour cela nécessaire de fournir des remplacements pour les fonctions d'interface déclenchable suivantes :

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. L'état déclenché initial est déterminé en vérifiant si le maillage commence ou non comme étant visible dans le monde du jeu, tel que défini dans le panneau Détails du composant de maillage.

2. L'action du composant triggerable_mesh_component est de rendre le maillage mesh_component visible. Pour ce faire, récupérez le mesh_component pour l'entité correspondante, définissez le maillage sur Visible, puis définissez le composant triggerable_mesh_component sur l'état déclenché.

   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. L'action inverse du composant triggerable_mesh_component est de rendre le maillage mesh_component invisible. Pour ce faire, récupérez le mesh_component pour l'entité correspondante, définissez le maillage sur Non visible, puis définissez le composant triggerable_mesh_component sur l'état non déclenché.

   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)

Composant de mouvement déclenchable

Le composant triggerable_movement_component déclenche le déplacement d'une entité d'une position vers une série d'autres positions en séquence à l'aide du composant keyframed_movement_component. Il est pour cela nécessaire de fournir des remplacements pour les fonctions d'interface déclenchable suivantes :

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

De plus, ce composant utilise certaines fonctions d'assistance :

• GetMovementStates : récupère les transformations des entités enfants en définissant la série de transformations pour cette entité.

• MakeDeltaTransform : crée une transformation delta entre deux transformations d'entrée.

• ConstructKeyframeDeltas : crée une matrice d'objets keyframed_movement_delta pour l'entrée du composant keyframed_movement_component.

• SetAndPlayAnimation : attribue les images clés et lit l'animation de mouvement.

1. Ajoutez un float modifiable à cette classe qui détermine la durée de l'animation par images clés.

   Verse

       @editable
       Duration:float = 2.0
   

   Copy full snippet(2 lines long)

2. Étant donné que cette classe implémente l'interface déclenchable, des remplacements doivent être fournis pour les fonctions PerformAction et PerformReverseAction, car celles-ci n'ont pas d'implémentations par défaut. Dans la mesure où il n'y a pas d'état déclenché initial et où l'action est un mouvement entre des emplacements, l'état déclenché initial par défaut est défini sur false. Cette action étant effectuée par l'implémentation de base dans l'interface déclenchable, cette fonction ne nécessite pas de remplacement dans cette classe de composant.

3. L'action du composant triggerable_movement_component consiste à déplacer l'entité le long de la série de transformations définies par les entités enfants.

   Verse

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

   Copy full snippet(4 lines long)

4. L'action inverse du composant triggerable_movement_component consiste à déplacer l'entité le long de la série de transformations définies par les entités enfants, dans l'ordre inverse. Cette fonction est similaire à PerformAction, hormis le fait que la matrice de transformation est dans l'ordre inverse.

   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. Définissez les fonctions d'assistance utilisées par ce composant. Commencez par créer une fonction nommée GetMovementStates pour récupérer les transformations vers lesquelles ce mouvement se déplace.

   Verse

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

   Copy full snippet(3 lines long)

6. Définissez une fonction d'assistance nommée MakeDeltaTransform qui construit une transformation delta entre deux transformations. Une transformation delta, D, de la transformation A à la transformation B est la transformation de sorte que, lorsque la transformation D est appliquée à la transformation A, le résultat est la transformation B. 

   Pour approfondir, supposons que vous ayez une entité Scene Graph avec la transformation actuelle A, mais que vous souhaitiez changer l'échelle, faire pivoter et translater votre entité pour obtenir la transformation B. La transformation delta D est la transformation dont vous avez besoin pour qu'un keyframed_movement_delta anime le mouvement de votre entité de la transformation A à la transformation 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. Définissez une classe d'assistance nommée ConstructKeyframeDelta qui crée une matrice d'objets keyframed_movement_delta pour l'entrée dans l'animation keyframed_movement_component.

   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. Créez une fonction nommée SetAndPlayAnimation qui attribue la matrice keyframed_movement_delta à l'animation keyframed_movement_component et la lit.

   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)

Composant d'éclairage déclenchable

Le composant triggerable_light_component allume et éteint une lumière. Il est pour cela nécessaire de fournir des remplacements pour les fonctions d'interface déclenchable suivantes :

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. L'état déclenché initial de la lumière est déterminé par le fait que la lumière est allumée ou non ; ainsi, SetInitialTriggeredState vérifie si la lumière est déjà allumée et, si c'est le cas, la définit comme déclenchée initialement.

   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. L'action effectuée par le composant triggerable_light_component consiste à allumer la lumière et à passer à un maillage indiquant que la lumière est allumée.

   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. L'action effectuée par le composant triggerable_light_component consiste à éteindre la lumière et à définir le mesh_component non émissif comme 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)

Étapes suivantes

Maintenant que tout le code a été écrit, créez votre code Verse. Ensuite, construisez des préfabriqués avec des entités et des composants de base que vous pouvez réutiliser dans l'UEFN pour créer votre expérience de jeu d'énigme.

Code final

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 #>

• 

  Construire des préfabriqués

  Utilisez les composants précédemment définis pour construire des préfabriqués et créer une énigme.