Componente de gatilho e classes de filhos acionáveis

Esta página orienta você na criação de um novo componente do Scene Graph chamado trigger_component. Esse componente aciona ações em entidades que têm um componente do Scene Graph que implementa a interface triggerable. O trigger_component oferece aos agentes uma maneira de interagir com o Scene Graph por meio de um volume_device. Quando um agente entra ou sai do volume_device, o AgentEnteredEvent e AgentExitedEvent correspondentes são sinalizados, e os retornos de chamada correspondentes são chamados para executar ações nos componentes e entidades do Scene Graph.

Na imagem a seguir, a base branca no chão é uma entidade do Scene Graph com o trigger_component e um volume_device invisível ao redor da base.

Quando o jogador pisa na base, o trigger_component aciona as duas luzes mais à direita.

Quando o jogador pisa fora da base e sai do volume_device, as luzes permanecem no estado aceso.

Para obter mais informações sobre as funcionalidades da linguagem Verse usadas nesta página, consulte:

• Interface em Verse

• Como criar seu próprio componente usando Verse

Defina o componente de gatilho

1. Acesse o Explorador Verse, clique com o botão direito do mouse no nome do projeto e escolha Adicionar novo arquivo Verse ao projeto.

   

2. Escolha o modelo Componente do Scene Graph e altere o Nome do Componente para trigger_component.

   

3. Defina a classe trigger_component e adicione campos que referenciam o volume_device associado, se esse componente aciona apenas filhos ou todos os descendentes acionáveis e uma matriz que faz referência a todos os agentes que interagem com esse 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. Adicione funções chamadas OnAgentEntersVolume e OnAgentExitsVolume que definem o que acontece quando um agente entra e sai do volume_device associado desse componente. Quando um agente entrar no volume, registre o agente que interage e procure as entidades descendentes que tenham um componente que implementa a interface triggerable e acione o componente nessas entidades. Quando um agente entrar no volume, remova o agente de interação da lista de agentes que interagem com esse 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. Conecte as funções OnAgentEntersVolume e OnAgentExitsVolume ao volume_device registrando-as como as funções de retorno de chamada para AgentEntersEvent e AgentExitsEvent na função OnSimulate desse 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)

Defina os componentes acionáveis (triggerable)

Em seguida, defina os componentes que implementam a interface triggerable criada anteriormente. São os componentes adicionados às entidades do Scene Graph que são descendentes de uma entidade com um puzzle_component e são acionados por uma entidade ancestral com um trigger_component. Este tutorial define três componentes triggerable diferentes:

• triggerable_mesh_component: alterna a visibilidade do mesh_component da entidade.

• triggerable_light_component: alterna o sphere_light_component da entidade e troca o mesh_component da entidade por um com ou sem cor emissiva, dependendo se a luz está acesa ou apagada.

• triggerable_movement_component: aciona uma transformação do mesh_component da entidade usando o keyframed_movement_component.

Esses três componentes diferentes compartilham um grande número de funcionalidades, e muitas das funções são definidas da mesma maneira. Para começar, crie um novo arquivo Verse vazio chamado TriggerableComponents.verse.

1. Inclua os seguintes módulos:

   • /Verse.org/SceneGraph, pois este arquivo usa componentes do Scene Graph e Eventos de Cena.

   • /Verse.org/SceneGraph/KeyframedMovement, pois este arquivo usa keyframed_movement_delta.

   • /Verse.org/Simulation, pois este arquivo usa o atributo @editable.

   • /Verse.org/SpatialMath, pois este arquivo usa transformações 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. Defina os componentes triggerable_mesh_component, triggerable_light_component e triggerable_movement_component. Todos esses componentes herdam da classe component base e implementam a interface acionável.

3. Todos os três componentes implementam os mesmos três eventos:

   • OnReceive: chamado quando o componente recebe um Evento de Cena.

   • OnBeginSimulation: chamado quando o componente deve iniciar a simulação.

   • OnSimulate: chamado quando o componente inicia a simulação.

   Adicione as seguintes implementações a todos os três 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. Todos os três componentes também implementam a substituição de PostTrigger da interface triggerable da mesma maneira, enviando um triggered_event se o componente triggerable for uma peça de quebra-cabeça. Não é possível fazer isso dentro da própria interface triggerable, porque a linguagem Verse precisa saber qual entity é acionada, e o campo Entity faz parte da classe component e não está disponível para a interface triggerable sem a dependência adicional da classe component.

   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 malha acionável

O triggerable_mesh_component alterna a visibilidade de um mesh_component em uma entidade. Isso requer o fornecimento de substituições para as seguintes funções de interface triggerable:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. O estado inicial é determinado verificando se a malha começa visível ou não no mundo do jogo, conforme definido no painel de detalhes do componente de malha.

2. A ação para triggerable_mesh_component é tornar a malha mesh_component visível. Para fazer isso, recupere o mesh_component para a entidade correspondente, defina a malha como visível e, em seguida, defina triggerable_mesh_component para o estado acionado.

   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. A ação inversa para o triggerable_mesh_component é tornar a malha do mesh_component invisível. Para fazer isso, recupere o mesh_component para a entidade correspondente, defina a malha como não visível e, em seguida, defina triggerable_mesh_component para o estado não acionado.

   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 movimento acionável

O triggerable_movement_component aciona uma entidade para se mover de um local para uma série de outros locais em sequência usando o keyframed_movement_component. Isso requer o fornecimento de substituições para as seguintes funções de interface triggerable:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

Além disso, esse componente usa algumas funções auxiliares:

• GetMovementStates: recupera transformações de entidades filhas definindo a série de transformações para a entidade.

• MakeDeltaTransform: cria uma transformação delta entre duas transformações de entrada.

• ConstructKeyframeDeltas: cria uma matriz de objetos keyframed_movement_delta para a entrada do keyframed_movement_component.

• SetAndPlayAnimation: atribui os keyframes e reproduz a animação de movimento.

1. Adicione um float editável a essa classe que determina quanto tempo dura a animação do keyframe.

   Verse

       @editable
       Duration:float = 2.0
   

   Copy full snippet(2 lines long)

2. Como essa classe implementa a interface triggerable, é necessário fornecer substituições para as funções PerformAction e PerformReverseAction, pois elas não têm implementações padrão. Como não há estado de acionamento inicial e a ação é um movimento entre locais, o estado de acionamento inicial padrão é falso. Isso é o que a implementação base faz na interface triggerable, portanto, essa função não requer uma substituição nessa classe de componente.

3. A ação para o triggerable_movement_component é mover a entidade ao longo da série de transformações definidas pelas entidades filhas.

   Verse

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

   Copy full snippet(4 lines long)

4. A ação inversa para o triggerable_movement_component é mover a entidade ao longo da série de transformações definidas pelas entidades filhas na ordem inversa. Essa função é semelhante à PerformAction, exceto que a matriz de transformação está na ordem inversa.

   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. Defina as funções auxiliares que esse componente usa. Primeiro, crie uma função chamada GetMovementStates para recuperar as transformações para as quais esse movimento se move.

   Verse

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

   Copy full snippet(3 lines long)

6. Defina uma função auxiliar chamada MakeDeltaTransform que cria uma transformação delta entre duas transformações. Uma transformação delta, D, da transformação A para a transformação B é a transformação tal que quando a transformação D é aplicada à transformação A, o resultado é a transformação B. 

   Para exemplificar, suponha que você tenha uma entidade do Scene Graph com a transformação A atual, mas deseja escalar, girar e transladar sua entidade para alcançar a transformação B. A transformação delta D é a transformação necessária para um keyframed_movement_delta animar o movimento da sua entidade da transformação A para a transformação 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. Defina um auxiliar chamado ConstructKeyframeDelta que cria uma matriz de objetos keyframed_movement_delta para a entrada da animação 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. Crie uma função chamada SetAndPlayAnimation que atribui a matriz keyframed_movement_delta à animação keyframed_movement_component e a reproduz.

   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 acionável

O triggerable_light_component acende e apaga uma luz. Isso requer o fornecimento de substituições para as seguintes funções de interface triggerable:

• SetInitialTriggeredState

• PerformAction

• PerformReverseAction

1. O estado de acionamento inicial da luz é determinado pelo fato de a luz estar acesa ou não, portanto, o SetInitialTriggeredState verifica se a luz já está acesa e, se estiver, define o estado como acionado 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. A ação executada pelo triggerable_light_component é acender a luz e alternar para uma malha indicando que a luz está acesa.

   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. A ação executada pelo triggerable_light_component é apagar a luz e definir o mesh_component não emissivo como visível.

   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)

Próximas etapas

Agora que todo o código Verse foi escrito, compile-o. Em seguida, construa estruturas pré-fabricadas com entidades e componentes básicos que você possa reutilizar no UEFN para criar sua própria experiência de quebra-cabeça.

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

• 

  Como construir estruturas pré-fabricadas

  Use os componentes definidos anteriormente para construir estruturas pré-fabricadas e criar um quebra-cabeça.