Eventos de cena

Este recurso do Scene Graph está em um estado experimental. Em Configurações de Projeto, marque a caixa para habilitar a configuração de Recursos Experimentais do Scene Graph para acessar esses recursos Experimentais no Scene Graph.

Caso o seu projeto contenha funcionalidades experimentais do Scene Graph, elas serão capturadas durante o processo de validação no Portal de Criadores. Você receberá um aviso sobre ativos que restringem sua capacidade de publicar sua ilha. Desative os recursos experimentais nas Configurações do Projeto para publicar sua ilha.

O Scene Graph tem uma funcionalidade integrada em todas as entidades e componentes que cria eventos únicos ou uma cadeia de eventos no seu Scene Graph chamada Eventos de Cena. Os eventos de cena são protocolos de comunicação que permitem que diferentes partes de um Scene Graph conversem entre si através da substituição e definição de novos comportamentos para entidades e componentes. 

Os eventos de cena podem ser reutilizados em seus projetos, e você pode expandir os eventos de cena adicionando eventos adicionais ou ajustando o comportamento de entidades e componentes em uma cadeia de eventos para fazer algo ligeiramente diferente

Vários componentes podem responder a um evento de cena, e os eventos podem ser movidos para cima ou para baixo na hierarquia do Scene Graph. Pode ser útil imaginá-los como mensagens que passam pelo Scene Graph, dando a cada componente a oportunidade de responder à mensagem. 

Por exemplo, se você configurar um cemitério usando o Scene Graph, poderá usar eventos de cena para definir uma cadeia de eventos que começa quando os portões do cemitério da malha estática se abrem. A abertura dos portões pode ser o ponto de partida de uma cadeia de eventos que causa um efeito de partículas de fantasmas voando por trás de pedras de tumbas e o início da reprodução de uma música assustadora. 

Pode ser um evento de cena que você usa várias vezes no cemitério, ou você pode ajustar o evento para poder usar as funções básicas do evento de cena — algum tipo de porta da malha estática sendo aberta e causando uma série de eventos em sequência.

Os eventos de cena consistem em desacoplar as partes do Scene Graph umas das outras, permitindo que se comuniquem por meio de mensagens em vez de se vincularem diretamente.

Como funcionam os eventos de cena

A linguagem Verse é usada para transmitir eventos pelo Scene Graph para entidades e componentes específicos. Para manipular um evento de cena em um component, substitua a função OnReceive(scene_event):logic existente no component. Cada evento de cena que passar pelo seu componente invocará essa função, fornecendo uma maneira de responder ao evento.

Um evento de cena é qualquer classe que implementa a interface scene_event. Eventos de cena podem ser enviados de uma das três maneiras: SendUp, SendDown ou SendDirect.

SendUp

SendUp enviará o evento para a entidade-alvo e seu pai. A entidade pai então repassará esse evento para sua própria entidade pai e assim por diante, até alcançar a Entidade de Simulação à qual as entidades do seu mundo estão vinculadas.

O remetente não sabe exatamente qual receptor manipulará o evento ou se algo responderá ao evento. Esse tipo de envio é ótimo para o envio de telemetria, a sinalização para sistemas de nível superior ou outros diversos tipos de solicitações que podem ou não ser manipuladas.

Por exemplo, imagine que você atinge os pés de um personagem com uma espada, sendo o pé uma parte profunda da hierarquia. A pernas podem não manipular o danos de nenhuma forma, então o evento se propaga até a base do personagem, onde você colocou um damage_receiever_component que é capaz de receber o evento de dano e processar o acerto. 

No diagrama abaixo, a entidade pai é o evento rotulado como 1 que é acionado na primeira entidade verde. A chamada SendUp começa na entidade pai na hierarquia e envia o evento para cima, para a Entidade de Simulação.

SendDown

Como alternativa, você pode usar a Entidade de Simulação como catalisador e enviar uma série de alterações para baixo na árvore de entidades. SendDown envia o evento para a entidade-alvo e todos os seus filhos. Cada filho então passa esse evento para seus filhos.

Ele pode ser usado em uma situação em que um evento global ocorreu, e qualquer coisa na cena deve ter a oportunidade de responder a ele.

SendDirect

SendDirect envia um evento diretamente para a entidade-alvo, mas não o passa para pais ou filhos. É usado para atingir uma entidade ou um componente específico, conforme ilustrado no diagrama abaixo.

Consumindo eventos

Quando um evento está sendo enviado para cima ou para baixo em uma hierarquia de entidades, componentes individuais podem optar por não responder ao evento. O componente marca o evento como concluído e não o envia para seus filhos ou pais, atuando essencialmente como um botão de desligar.

Consumir eventos permite controlar o escopo do efeito de um evento. Isso funciona de duas maneiras:

• Torna o evento relevante para apenas uma entidade, não para os filhos ou pais da entidade.

• Evita enviar o evento relevante diretamente aos filhos ou pais de uma entidade.

Ao evitar enviar um evento para um filho ou pai, você pode decidir o que esse evento significa para os pais e filhos da entidade e, assim, enviar manualmente um evento diferente em resposta, obtendo mais controle sobre como essas entidades reagem ao evento inicial.

Por exemplo, uma entidade recebe um evento de dano por meio de SendDown. Um componente em uma entidade poderia decidir responder a isso removendo um pouco de vida, sem enviar esse evento adiante na hierarquia da entidade, pois não é necessário que as entidades filho sofram danos.

No entanto, caso haja um sistema de pontuação acima da entidade recebedora, a cadeia de pais da entidade precisaria enviar as informações de dano para conceder uma medalha ao jogador por causar dano a inimigos. Nessa situação, uma chamada SendUp poderia ser usada na entidade receptora com um evento especial que envia a pontuação de dano para um componente pai que escuta as informações de pontuação.

Consumindo eventos durante SendUp e SendDown

Os eventos podem ser consumidos durante a propagação de eventos acionada por SendUp ou SendDown, retornando true da implementação OnReceive(SceneEvent:scene_event):logic de um componente.

Se algum componente em uma entidade optar por consumir um evento durante um SendUp, todos os componentes na entidade ainda invocarão seus respectivos retornos de chamada OnReceive. Em seguida, a propagação é interrompida e não é transmitida ao pai da entidade.

Se algum componente em uma entidade optar por consumir um evento durante um SendDown, todos os componentes na entidade ainda invocarão seus respectivos retornos de chamada OnReceive. O evento não é transmitido para os filhos da entidade. No entanto, o evento ainda será transmitido para o restante das entidades do mesmo nível.

No diagrama abaixo, você notará que, enquanto o evento de cena 4 continua na cadeia de eventos, o evento de cena 3 não.

Criando um evento de cena

É necessário fazer uma configuração inicial e organizar a sequência antes de criar eventos de cena. Compile os ativos listados abaixo para popular os componentes de malha com árvores e os efeitos de partículas com o efeito apropriado.  Ao salvar os recursos de efeito de partículas, eles são salvos automaticamente em um arquivo Verse chamado Assets.digest.verse como objetos Verse que você pode referenciar no seu código.

1. Efeitos visuais de relâmpago

   Para fazer com que o raio comece em um ponto aleatório no céu acima de uma entidade e termine em uma entidade do Scene Graph no chão, modifique os efeitos visuais do relâmpago da seguinte forma:

   • Defina Configuração do Emissor do Feixe > Início do Feixe como Adicionar Vetor à Posição, defina Posição como SimulationPosition, defina Vetor como Vetor de Alcance Aleatório com Mínimo como (-200.0, -200.0, 1000) e Máxima como (200.0, 200.0, 2000.0).

   • Defina Configuração do Emissor do Feixe > Fim do Feixe como SimulationPosition.

   Agora, o raio começará em algum lugar no céu acima da entidade e terminará na entidade à qual o particle_system_component está anexado.

2. Efeitos visuais de fogo

3. Árvores e grama de malha estática

     Modele suas próprias árvores com o Modo de Modelagem.

Adicione esses ativos a entidades e, em seguida, coloque várias entidades Alvo do Raio em todo o Scene Graph onde um raio poderia atingir. Cada uma dessas entidades Alvo do Raio tem um particle_system_component de relâmpago pronto para receber as instruções que você definir em seu evento de cena. Nenhuma configuração adicional é necessária.

As entidades podem ser aninhadas em uma estrutura pré-fabricada ou totalmente separadas e espalhadas na cena.

Com as entidades posicionadas, pense na sequência de eventos que causa o fogo na floresta e, em seguida, pense nos nomes para os eventos que descrevem o que esse evento está fazendo. Em seguida, siga o tutorial sobre Verse no segmento Como codificar o comportamento. 

Convenções de nomenclatura para eventos de cena

Você pode usar quantos caracteres forem necessários ao nomear um evento de cena. A nomenclatura deve descrever seu evento e deixar clara a intenção do evento, por exemplo damage_taken_event, health_power_up_event e assim por diante.

Existem dois eventos principais na sequência de eventos para um incêndio na floresta:

• Caída do raio

• Propagação do fogo

Para descrever o que esses eventos estão fazendo, chame o evento do relâmpago de struck_by_lightning_event, e chame o evento de propagação de fogo de fire_propagation_event.

Sequência de eventos

Ao criar um evento de cena, visualize-o como uma interface que tem efeitos para cima e para baixo em uma hierarquia de entidades e componentes. Além disso, como eventos de cena podem ser usados por outras pessoas, considere como outro desenvolvedor poderia complementar seu evento ou usá-lo em seu próprio Scene Graph.

O evento de cena que você está criando irá relatar os principais acontecimentos antes de iniciar outro evento relacionado ao evento pai. Portanto, a sequência de eventos é a seguinte:

1. Um evento de cena ocorre no mundo chamado struck_by_lightning_event.

2. As entidades informam se foram atingidas pelo struck_by_lightning_event ou não. As entidades atingidas por um raio acionam o fire_propagation_event.

3. O fire_propagation_event faz com que outras entidades decidam se estão ou não perto o suficiente do fire_propagation_event para também pegar fogo.

4. O fire_propagation_event se espalha para os outros componentes da malha

O fire_propagation_event continua sendo executado até cada componente da malha que decidiu que estava próximo o suficiente de fire_propagation_event tenha pegado fogo. O evento deve se assemelhar a um incêndio florestal real quando estiver em execução na cena.

Como expandir uma sequência

Apesar de struck_by_lightning_event causarem fire_propagation_event, você pode optar por estender o jogo adicionando novas coisas que propagam o fogo. Por exemplo, você adiciona um explosive_event que envia um fire_propagation_event quando explode.

Outro ponto interessante sobre eventos de cena é que as entidades que manipulam fire_propagation_event não precisam saber o que causou o fogo, apenas que algo as está fazendo considerar se devem ou não estar em chamas. Isso facilita a manutenção do código por dois motivos:

• Um evento de cena ocorre no mundo chamado struck_by_lightning_event.

  É mais fácil alterar o comportamento de struck_by_lightning_event sem quebrar entidades que se importam apenas com fire_propagation_event.

• É mais fácil escrever um explosive_event, porque coisas incendiáveis só se importam com fire_propagation_event.

Como codificar o comportamento

Quando o Scene Graph estiver completo com todas as entidades necessárias, use o código abaixo para criar um evento de cena que começa com um raio e, em seguida, faz com que um indêndio comece nas árvores e cause danos por fogo.

O Assets.digest.verse procura automaticamente os objetos Verse para referenciá-los na cena. Os efeitos de partículas que você criou são referenciados em um módulo de efeitos visuais.

VFX := module:
    Fire_NS<scoped {/InvalidDomain/Scene_Events_Test}> := class<final><public>(particle_system_component):


    Lightning_NS<scoped {/InvalidDomain/Scene_Events_Test}> := class<final><public>(particle_system_component):

Passo 1: Como criar um componente do Scene Graph

Para criar um evento de cena no UEFN, abra o menu Verse na barra de menus e selecione o Explorador Verse no menu suspenso. O painel Explorador Verse abre no editor e contém a lista de arquivos Verse associados ao seu projeto.

Crie um novo arquivo Verse fazendo o seguinte:

1. Clique com o botão direito no nome do projeto no topo da lista.

2. Selecione Adicionar novo arquivo Verse ao projeto no menu suspenso. A janela "Criar script Verse" é aberta.

3. Selecione Componente do Scene Graph na lista de arquivos Verse e chame o arquivo de fire_event_component.

4. Clique em Criar. O arquivo é aberto automaticamente no Visual Studio Code (VS Code) e contém APIs de estrutura básica necessárias para criar novos comportamentos de componente.

   

Quando decidir que tudo está pronto para testar seu código, abra o menu Verse e selecione Compilar código Verse no menu suspenso. Em seguida, selecione o botão Verse para executar seu código.

Passo 2: Adicione bibliotecas Verse

Comece seu evento de cena criando primeiro a sequência de eventos e condições que causam a incidência do raio. Depois que o evento do raio for definido, crie o evento do incêndio florestal definindo as propriedades do dano por fogo, protocolos de propagação de fogo e protocolos de extinção de fogo.

1. Adicione as seguintes bibliotecas ao seu componente para garantir que você possa usar matemática espacial para a localização de seus raios e fogo, criar concorrência e utilizar outros recursos em Verse.

   Verse

   using { /Verse.org/SpatialMath }
   using { /Verse.org/Random }
   using { /Verse.org/Concurrency }
   using { /Verse.org/Simulation }
   using { /Verse.org/SceneGraph }

   Copy full snippet(5 lines long)

Passo 3: Defina a classe do evento de raio

Essa classe de evento determina a posição de origem do raio, a posição de incidência do raio e o DamageRadius da posição de incidência.

1. Crie uma classe de evento chamada struck_by_lightning_event := class(scene_event):. A classe define as propriedades do evento de cena em expressões constantes que descrevem onde o evento de raio ocorre na cena usando um vetor para informações de posição e o alcance de dano do relâmpago usando um valor float.

   Verse

   # Event to indicate an entity is struck by lightning
   struck_by_lightning_event<public> := class(scene_event):
   
       # Lightning hit location
       HitLocation:vector3 = vector3{}
   
       # Lightning damage radius
       DamageRadiusCentimeters:float = 100.0
   

   Copy full snippet(8 lines long)

Passo 4: Crie um componente de clima e adicione propriedades editáveis com variáveis

Use propriedades e variáveis editáveis para estabelecer se o raio aparece na cena, incidências de raios aleatórios, o tempo entre as incidências e o alcance de dano da incidência do raio.

1. Defina como o raio se comporta adicionando propriedades editable a uma classe de componente chamada lightning_weather_component := component ():. Descreva o valor mínimo e máximo nas propriedades editáveis para o tempo entre os raios e seu alcance de dano em centímetros.

   Verse

   # Component that lives on an entity, and randomly creates lightning strikes
   lightning_weather_component<public> := class<final_super>(component):
   
       # Minimum random time between lightning strikes
       @editable
       MinRandomLightningDelaySeconds:float = 10.0
   
       # Maximum random time between lightning strikes
       @editable
       MaxRandomLightningDelaySeconds:float = 60.0
   
   Expand code Copy full snippet(22 lines long)

Passo 5: Defina o evento de raio

Use um método para verificar o efeito visual de um raio e use suas propriedades de feixe inicial e final para determinar o quão próximos os componentes de malha estão do efeito visual e transmita essas informações acima e abaixo do evento.

1. Crie um method condicional OnSimulate.

   Verse

   	    OnSimulate<override>()<suspends>:void=

   Copy full snippet(1 line long)

2. Crie e adicione um loop que reproduz e interrompe aleatoriamente o componente de raio usando uma constante que usa valores de atraso mínimo e máximo para o tempo de reprodução.

   Verse

          loop:
               # Sleep for a random delay before next lightning strike
               RandomDelay := GetRandomFloat(MinRandomLightningDelaySeconds, MaxRandomLightningDelaySeconds)
               Sleep(MaxRandomLightningDelaySeconds
   

   Copy full snippet(4 lines long)

3. Adicione uma expressão if que usa a entidade de simulação para encontrar outras entidades na simulação, pois todas as outras entidades são filhas da entidade de simulação. Dessa forma, uma entidade aleatória pode ser selecionada para ser atingida por um raio, em vez de usar a colisão para encontrar entidades na cena.

   Verse

              # Randomly hit an entity in the world with lightning
               if (SimEntity := Entity.GetSimulationEntity[]):
   

   Copy full snippet(2 lines long)

   Em seguida, o código precisa fornecer um alvo para o raio atingir.

4. Adicione uma expressão then que transmite uma solicitação para ser o alvo do raio a partir de SimEntity. Em seguida, adicione uma expressão if condicional que responde a essa transmissão e faça com que todas as entidades que possam responder enviem um evento de volta para o SimEntity. Em seguida, você precisará encontrar a fonte do raio, porque um Emissor de Feixe usa uma posição de dois pontos para o início e o fim do feixe.

   Verse

                  LightningTargets := for (EntityWithLightning : SimEntity.FindDescendantEntitiesWithComponent(particle_system_component)):
                       EntityWithLightning
   
                   if:
                       LightningTargets.Length > 0
                       RandomIndex := GetRandomInt(0, LightningTargets.Length - 1)
                       RandomEntity := LightningTargets[RandomIndex]
   

   Copy full snippet(7 lines long)

5. Chame LightningVFXComponent para a posição aleatória usando uma instrução if. Em seguida, adicione uma expressão que reproduz o efeito de partículas do feixe na posição definida para as posições de origem e destino.

   A lightning_entity usa Configuração do Emissor do Feixe > Início do Feixe para reproduzir o evento de raio em pontos aleatórios no céu. Em seguida, o LightningVFXComponent usa  a opção de partícula do feixe em Configuração do Emissor do Feixe > Fim do Feixe para determinar onde o final da partícula de feixe aparece na cena. A configuração é definida como Posição de Simulação, que usa as coordenadas finais do efeito de partículas para lightning_entity.   

   Em seguida, crie e defina o dano causado por struck_by_lightning_event usando os dados de origem e destino para localizar onde o dano ocorre no alvo do componente de malha usando DamageRadius para descrever a área afetada pelo dano do raio. Esse evento será enviado à Entidade de Simulação para adicionar uma duração aleatória ao raio, portanto, encerre a cadeia de eventos com SimulationEntity.SendDown(Event).

   Verse

                      if (VFX := RandomEntity.GetComponent[particle_system_component]):
                           RandomDurationOfStrike := GetRandomFloat(MinRandomLightningDurationSeconds, MaxRandomLightningDurationSeconds)
                           VFX.Play()
                           Sleep(RandomDurationOfStrike)
                           VFX.Stop()
                       else:
                           Print("Could not find particle_system_component on this entity")
   
                       Event := struck_by_lightning_event:
                           HitLocation := Entity.GetGlobalTransform().Translation
   
   Expand code Copy full snippet(13 lines long)

Passo 6: Defina o evento de fogo

Crie classes de eventos que definem a quantidade de dano que o fogo causa e se o fogo deve se propagar com base nos danos de fogo na cena.

1. Crie duas classes. Uma classe fire_damage_event e uma classe fire_propagation_event que verifica o DamageAmount sendo causado e reproduz a partícula de fogo quando o DamageAmount atinge o limite do float.

   Verse

   # Event indicating an entity was damaged by fire
   fire_damage_event<public> := class(scene_event):
       BurningEntity:entity = entity{}
       DamageAmount:float = 100.0
   
   # Event indicating an entity propagates fire
   fire_propagation_event<public> := class(fire_damage_event):
       FireRadiusCentimeters:float = 100.0
   

   Copy full snippet(8 lines long)

2. Crie uma classe flammable_component que determine que uma malha é inflamável e as propriedades editáveis que podem ser definidas para fazer com que as malhas na cena peguem fogo.

   Verse

   # Component that makes something flammable
   flammable_component<public> := class<final_super>(component):
   
       # Fire damage amount applied every second
       @editable
       FireDamageAmount:float = 10.0
   
       # Fire tries to propagate on this interval
       @editable
       FirePropagationIntervalSeconds:float = 10.0
   

   Copy full snippet(10 lines long)

3. Uma variável condicional é adicionada ao flammable_event, que decide se os efeitos visuais de fogo estão sendo reproduzidos ou devem ser reproduzidos.

   Verse

       # Is it on fire?
       var IsOnFire:logic = false
   

   Copy full snippet(2 lines long)

4. A função IsCloseEnoughToBurningEntityToIgnite determina se o fogo está próximo o suficiente para acionar mais eventos de efeitos visuais de fogo.

   Verse

      # Is this component close enough to the source of a fire propagation event to burst into flames?
       IsCloseEnoughToBurningEntityToIgnite(FirePropogationEvent:fire_propagation_event)<decides><transacts>:void =
           EntityLocation := Entity.GetGlobalTransform().Translation
           FirePropogationLocation := FirePropogationEvent.BurningEntity.GetGlobalTransform().Translation
           DistanceToFire := Distance(EntityLocation, FirePropogationLocation)
           DistanceToFire <= FirePropagationEvent.FireRadiusCentimeters
   

   Copy full snippet(6 lines long)

5. A função IsCloseEnoughToLightningToIgnite determina se o raio caiu próximo o suficiente da malha para fazer com que ela explodisse em chamas.

   Verse

      # Is this component close enough to a lightning strike to burst into flames?
   
   IsCloseEnoughToLightningToIgnite(LightningEvent:struck_by_lightning_event)<decides><transacts>:void =
           EntityLocation := Entity.GetGlobalTransform().Translation
           LightningStrikeLocation := LightningEvent.HitLocation
           DistanceToFire := Distance(EntityLocation, LightningStrikeLocation)
           DistanceToFire <= LightningEvent.DamageRadiusCentimeters
   

   Copy full snippet(7 lines long)

6. A função OnReceive determina quais malhas pegam fogo quando a função IsCloseEnoughToBurningEntityToIgnite determina a proximidade da propagação do fogo, e a variável IsCloseEnoughToLightningToIgnite determina a proximidade da incidência do raio com a malha.

   Verse

      # Receive scene events
       OnReceive<override>(SceneEvent:scene_event):logic =
           # Burst into flames if lightning hit close enough
           if (LightningEvent := struck_by_lightning_event[SceneEvent], IsCloseEnoughToLightningToIgnite[LightningEvent]):
               Ignite()
           # Burst into flames if something close enough is burning
           if (FireEvent := fire_propagation_event[SceneEvent], IsCloseEnoughToBurningEntityToIgnite[FireEvent]):
               Ignite()
           false
   

   Copy full snippet(9 lines long)

7. Um método Ignite é usado para reproduzir o efeito automaticamente por meio de uma instrução condicional if que procura o sistema de partículas de fogo. Uma instrução then define se é verdade que o componente está reproduzindo o efeito visual de fogo. 

   Adicione tarefas assíncronas ao método para verificar o sistema de partículas de fogo Fire_NS, para que o fogo seja gerado e se espalhe quando chamado.

   Verse

      # Burst into flames
       Ignite():void =
           if (not IsOnFire?):
               set IsOnFire = true
   
               # Add a new fire VFX component
               FireVFX := VFX.Fire_NS{Entity := Entity}
               Entity.AddComponents(array{FireVFX})
   
               # Spawn async tasks to implement the state of being on fire
   
   Expand code Copy full snippet(12 lines long)

Passo 7: Defina o fim do evento de fogo

Em seguida, você criará uma série de métodos que determinam quando os componentes da malha explodem em chamas, quando as chamas se extinguem, os danos que o fogo causa e quando fazer o fogo se espalhar.

1. Agora crie um método Extinguish que interrompa o efeito de fogo, buscando os componentes que estão reproduzindo o efeito usando instruções condicionais para localizar o sistema de partículas de fogo e remover o efeito.

   Verse

      # Put out the flames
       Extinguish():void=
           if (IsOnFire?):
               set IsOnFire = false
   
               # Remove the fire VFX component
               if (FireVFX := Entity.GetComponent[particle_system_component]):
                   FireVFX.RemoveFromEntity()
   

   Copy full snippet(8 lines long)

2. Crie um método OnFire que usa um loop que monitora FireDamage e envia o evento para baixo da cadeia de entidades em direção ao final do evento, fazendo com que a reprodução do evento seja interrompida.

   Verse

       # Suspends function called when we're on fire
       OnFire()<suspends>:void=
           # Damage self every second
           loop:
               # Fill out a fire damage event - replace this with whatever properties should go here
               FireDamage := fire_damage_event:
                   DamageAmount := FireDamageAmount
   
               Entity.SendDown(FireDamage)
               Sleep(1.0)
   
   Expand code Copy full snippet(16 lines long)

3. Por fim, crie um método FirePropagation que usa um loop para espalhar o fogo pela cadeia de entidades e faz com que elas se apaguem ao atingir a Entidade de Simulação.

   Verse

       # Propagate fire to other entities
       FirePropagation()<suspends>:void=
           loop:
               Sleep(FirePropagationIntervalSeconds)
               if:
                   SimulationEntity := Entity.GetSimulationEntity[]
                   FirePropagationEvent := fire_propagation_event{ BurningEntity := Entity }
               then:
                   # Broadcast fire propagation event down from simulation entity
                   SimulationEntity.SendDown(FirePropagationEvent)
   
   Expand code Copy full snippet(16 lines long)

Ao concluir o código, compile-o e adicione as entidades apropriadas ao Scene Graph para viabilizar os efeitos de raios e incêndio florestal. Em seguida, adicione o flamable_component às entidades na cena que devem pegar fogo. É necessário haver uma entidade de nível superior sob a Entidade de Simulação com o lightning_weather_component controlando o clima.

Assim que todas as entidades estiverem atualizadas com os eventos de cena apropriados, inicialize uma sessão de Edição ao Vivo para ver seu código funcionando na cena.

Resultado

Copie e cole o código no seu projeto para ver o evento de cena funcionando.

lightning.verse

using { /Verse.org }
using { /Verse.org/Native }
using { /Verse.org/Random }
using { /Verse.org/SceneGraph }
using { /Verse.org/Simulation }
using { /Verse.org/SpatialMath }

# Event to indicate an entity is struck by lightning
struck_by_lightning_event<public> := class(scene_event):

fire.verse

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

# Event indicating an entity was damage by fire
fire_damage_event<public> := class(scene_event):
    BurningEntity:entity = entity{}
    DamageAmount:float = 100.0