Activador de componente y clases hijo activables

Esta página te guía a través de la creación de un nuevo componente de Scene Graph denominado trigger_component. Este componente activa acciones en entidades que tienen un componente de Scene Graph que implementa la interfaz activable. El trigger_component proporciona a los agentes una forma de interactuar con Scene Graph a través de un volume_device. Cuando un agente entra o sale de volume_device, se señala el AgentEnteredEvent y el AgentExitedEvent correspondientes y se llama a las devoluciones de llamada aplicables para realizar acciones en los componentes y entidades de Scene Graph.

En la siguiente imagen, el pedestal blanco en el suelo es una entidad de Scene Graph con trigger_component y un volume_device invisible alrededor del pedestal.

Cuando el jugador pisa el pedestal, el trigger_component activa las dos luces más a la derecha.

Cuando el jugador se baja del pedestal y abandona el volume_device, las luces permanecen encendidas.

Para obtener más información sobre las funciones del lenguaje Verse utilizadas en esta página, consulta:

• Interfaz en Verse

• Cómo crear tu propio componente con Verse

Cómo definir el componente de activación

1. Ve al Explorador de Verse, haz clic con el botón derecho en el nombre del proyecto y elige Añadir nuevo archivo de Verse al proyecto.

   

2. Elige la plantilla Componente de Scene Graph y cambia el nombre del componente a trigger_component.

   

3. Define la clase trigger_component y añade campos que hagan referencia al volume_device asociado, independientemente de que este componente active solo los hijos o todos los descendientes activables, y una matriz que haga referencia a todos los agentes que interactúan con este componente.

   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. Añade funciones denominadas OnAgentEntersVolume y OnAgentExitsVolume que definan lo que ocurre cuando un agente entra y sale del volume_device asociado a este componente. Cuando un agente entre en el volumen, registra el agente que interactúa y busca entidades descendientes que tengan un componente que implemente la interfaz activable y, a continuación, activa el componente en esas entidades. Cuando un agente accede al volumen, elimina al agente que interactúa de la lista de agentes que interactúan con este volumen.

   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. Conecta las funciones OnAgentEntersVolume y OnAgentExitsVolume a volume_device registrándolas como funciones de devolución de llamada para AgentEntersEvent y AgentExitsEvent en la función OnSimulate de este componente.

   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)

Cómo definir los componentes activables

A continuación, define los componentes que implementen la interfaz activable creada anteriormente. Son componentes que se añaden a entidades de Scene Graph que son descendientes de una entidad con puzzle_component y son activadas por una entidad ancestro con trigger_component. En este tutorial se definen tres componentes activables diferentes:

• triggerable_mesh_component: alterna la visibilidad del mesh_component de la entidad.

• triggerable_light_component: activa y desactiva el sphere_light_component de la entidad e intercambia el mesh_component de la entidad por uno con o sin color reflectante, dependiendo de si la luz está encendida o apagada.

• triggerable_movement_component: activa una transformación del mesh_component de la entidad utilizando keyframed_movement_component.

Estos tres componentes diferentes comparten una gran cantidad de funciones, y muchas de ellas se definen de la misma manera. Para empezar, crea un archivo de Verse nuevo y vacío llamado TriggerableComponents.verse.

1. Incluye los siguientes módulos:

   • /Verse.org/SceneGraph, ya que este archivo utiliza componentes de Scene Graph y eventos de escena.

   • /Verse.org/SceneGraph/KeyframedMovement, ya que este archivo utiliza keyframed_movement_delta.

   • /Verse.org/Simulation, ya que este archivo utiliza el atributo @editable.

   • /Verse.org/SpatialMath, ya que este archivo utiliza transformaciones de 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. Define los componentes triggerable_mesh_component, triggerable_light_component y triggerable_movement_component. Todos estos componentes heredan de la clase del componente base e implementan la interfaz activable.

3. Los tres componentes implementan los mismos tres eventos:

   • OnReceive: se llama cuando este componente recibe un evento de escena.

   • OnBeginSimulation: se llama cuando el componente debe empezar a simular.

   • OnSimulate: se le llama cuando el componente empieza a simular.

   Añade las siguientes implementaciones a los tres componentes.

   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. Los tres componentes también implementan la anulación PostTrigger de la interfaz activable del mismo modo, enviando un trigger_event si el componente activable es una pieza del rompecabezas. No puedes hacerlo dentro de la propia interfaz activable porque Verse necesita saber qué entidad se activa, y el campo Entidad forma parte de la clase del componente y no está disponible para la interfaz activable sin la dependencia adicional de la clase del componente.

   Verse

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

   Copy full snippet(6 lines long)

Componente de malla activable

El triggerable_mesh_component activa la visibilidad de un mesh_component en una entidad. Esto requiere proporcionar anulaciones para las siguientes funciones de interfaz activables:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. El estado activado inicial se determina comprobando si la malla comienza o no siendo visible en el mundo del juego según lo establecido en el panel de detalles del componente de la malla.

2. La acción de triggerable_mesh_component es hacer visible la malla mesh_component. Para ello, recupera mesh_component para la entidad correspondiente, establece la malla como visible y, a continuación, establece triggerable_mesh_component en el estado activado.

   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. La acción inversa para triggerable_mesh_component es hacer invisible la malla mesh_component. Para ello, recupera el mesh_component de la entidad correspondiente, establece la malla como no visible y, a continuación, establece triggerable_mesh_component en el estado no activado.

   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)

Componente de movimiento activable

El triggerable_movement_component activa una entidad para que se mueva de una ubicación a una serie de otras ubicaciones en secuencia utilizando el keyframed_movement_component. Esto requiere proporcionar anulaciones para las siguientes funciones de interfaz activables:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

Además, este componente utiliza algunas funciones auxiliares:

• GetMovementStates: recupera las transformaciones de las entidades hijo que definen la serie de transformaciones de esta entidad.

• MakeDeltaTransform: crea una transformación delta entre dos transformaciones de entrada.

• ConstructKeyframeDeltas: crea una matriz de objetos keyframed_movement_delta para la entrada de keyframed_movement_component.

• SetAndPlayAnimation: asigna los fotogramas clave y reproduce la animación de movimiento.

1. Añade un float editable a esta clase que determine la duración de la animación con fotogramas clave.

   Verse

       @editable
       Duration:float = 2.0
   

   Copy full snippet(2 lines long)

2. Esta clase implementa la interfaz activable, por lo que es necesario proporcionar anulaciones para las funciones PerformAction y PerformReverseAction, ya que no tienen implementaciones predeterminadas. Como no hay un estado inicial y la acción es un movimiento entre posiciones, el estado inicial predeterminado es falso. Esto es lo que hace la implementación base en la interfaz activable, por lo que esta función no requiere una anulación en esta clase de componente.

3. La acción de triggerable_movement_component es mover la entidad a lo largo de la serie de transformaciones definidas por las entidades hijo.

   Verse

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

   Copy full snippet(4 lines long)

4. La acción inversa para triggerable_movement_component es mover la entidad a lo largo de la serie de transformaciones definidas por las entidades hijo en orden inverso. Esta función es similar a PerformAction, salvo que la matriz de transformación está en orden inverso.

   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 las funciones auxiliares que utiliza este componente. Primero, crea una función nombrada GetMovementStates para recuperar las transformaciones a las que se mueve este movimiento.

   Verse

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

   Copy full snippet(3 lines long)

6. Define una función auxiliar llamada MakeDeltaTransform que construya una transformación delta entre dos transformaciones. Una transformación delta, D, de la transformación A a la transformación B es la transformación tal que cuando la transformación D se aplica a la transformación A, el resultado es la transformación B. 

   Para profundizar más, supón que tienes una entidad de Scene Graph con transformación A, pero quieres escalar, rotar y trasladar tu entidad para que tenga transformación B. La transformación delta D es la transformación que necesitas para que un keyframed_movement_delta anime el movimiento de tu entidad desde la transformación A a la transformación 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 un ayudante denominado ConstructKeyframeDelta que cree una matriz de objetos keyframed_movement_delta para la entrada de la animación 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. Crea una función llamada SetAndPlayAnimation que asigne la matriz keyframed_movement_delta a la animación keyframed_movement_component y la reproduzca.

   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)

Componente de luz activable

El triggerable_light_component enciende y apaga una luz. Esto requiere proporcionar anulaciones para las siguientes funciones de interfaz activables:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. El estado activado inicial de la luz viene determinado por si la luz está encendida o no, por lo que SetInitialTriggeredState comprueba si la luz ya está encendida y, en caso afirmativo, la establece como activada inicialmente.

   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. La acción que realiza triggerable_light_component es encender la luz y cambiar a una malla que indica que la luz está encendida.

   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. La acción que realiza triggerable_light_component es apagar la luz y hacer visible el mesh_component no emisor.

   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)

Siguientes pasos

Ahora que se ha escrito todo el código de Verse, vamos a compilarlo. A continuación, construye prefabricados con entidades y componentes básicos que puedas reutilizar en UEFN para crear tu experiencia de rompecabezas.

Código 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 #>

• 

  Cómo construir prefabricados

  Utiliza los componentes definidos anteriormente para construir prefabricados y crear un rompecabezas.