Eventos de escena

Esta función de Scene Graph está en un estado experimental. En Configuración del proyecto, marca la casilla para habilitar la configuración de Funciones experimentales de Scene Graph y acceder a estas funciones experimentales dentro de Scene Graph.

Si tu proyecto contiene alguna función experimental de Scene Graph, esta se detectará durante el proceso de validación en el portal de creadores. Recibirás un aviso sobre los recursos que restringen tu capacidad para publicar tu isla. Desactiva las funciones experimentales en la configuración del proyecto para publicar tu isla.

Scene Graph tiene una función integrada en todas las entidades y los componentes que crea eventos únicos o una cadena de eventos en tu Scene Graph llamados Eventos de escena. Los eventos de escena son protocolos de comunicación que proporcionan una manera para que las distintas partes de Scene Graph se comuniquen entre sí al anular y definir un nuevo comportamiento para las entidades y los componentes. 

Los eventos de escena pueden reutilizarse en tus proyectos, puedes ampliar los eventos de escena añadiendo eventos adicionales o ajustando el comportamiento de las entidades y los componentes en una cadena de eventos para hacer algo un poco diferente.

Es posible que varios componentes respondan a un evento de escena, y los eventos pueden subir o bajar dentro de la jerarquía de Scene Graph. Resultaría útil imaginarlos como mensajes que se transmiten a lo largo de Scene Graph, permitiendo que cada componente responda al mensaje. 

Por ejemplo, si defines un cementerio usando Scene Graph, puedes usar eventos de escena para definir una cadena de eventos que comiencen cuando las puertas de malla estática del cementerio se abran. La apertura de las puertas podría actuar como el punto de partida de una cadena de eventos que provocaría un efecto de partículas con fantasmas que salen volando desde detrás de las lápidas y música escalofriante que comienza a sonar. 

Esto podría ser un evento de escena que uses varias veces en el cementerio, o podrías modificar el evento para poder usar las funciones básicas de este: una puerta de malla estática de algún tipo que se abre y provoca una serie de eventos a continuación.

Los eventos de escena consisten en desacoplar partes de Scene Graph entre sí, lo que les permite comunicarse a través de mensajes en lugar de vincularse directamente entre sí.

Cómo funcionan los eventos de escena

Verse se utiliza para transmitir eventos a través de Scene Graph a entidades y componentes específicos. Para controlar un evento de escena en un componente, anula la función OnReceive(scene_event):logic existente en el componente . Cada evento de escena que pase a través de tu componente invocará esta función, lo que te brindará una forma de responder al evento.

Un evento de escena es cualquier clase que implementa la interfaz scene_event. Los eventos de escena se pueden enviar de una de estas tres maneras: SendUp, SendDown o SendDirect.

SendUp

SendUp enviará el evento a la entidad de destino y su base. La entidad base pasará ese evento a su base y así sucesivamente, hasta llegar a la entidad de simulación a la que están vinculadas las entidades de tu entorno.

El emisor no sabe exactamente qué receptor controlará el evento, o si algo responderá al evento. Este tipo de envío es ideal para enviar telemetría, señalización a sistemas de nivel superior o varios tipos de solicitudes que pueden controlarse o no.

Por ejemplo, imagina que golpeas los pies de un personaje con una espada, y que el pie está en la parte inferior de su jerarquía. Es posible que la pierna no maneje el daño de ninguna manera, por lo que el evento se propaga hasta la base del personaje, donde colocaste un Damage_receiever_component que puede recibir el evento de daño y procesar el golpe. 

En el siguiente diagrama, la entidad base es el evento etiquetado como 1 que activa la primera entidad verde. La llamada SendUp comienza en la entidad base de la jerarquía y envía el evento hacia arriba hasta la entidad de simulación.

SendDown

De manera alternativa, podrías usar la entidad de simulación como catalizador y enviar una serie de cambios hacia abajo en el árbol de entidades. SendDown envía el evento a la entidad de destino y a todos sus elementos derivados. Luego, cada derivado pasa ese evento a sus derivados.

Esto podría usarse en una situación en la que ocurrió un evento global, y todo lo que esté en la escena debería poder responder a ello.

SendDirect

SendDirect envía un evento directamente a la entidad de destino, pero no pasa el evento a los elementos principales o derivados. Esto se utiliza para apuntar a una entidad o componente específico, como se ilustra en el diagrama a continuación.

Consumo de eventos

Cuando se envía un evento hacia arriba o hacia abajo en una jerarquía de entidades, los componentes individuales pueden elegir no responder al evento. El componente marca el evento como completo y no envía el evento a sus elementos derivados o principales; básicamente, actúa como un interruptor de apagado.

Consumir eventos te permite controlar el alcance del efecto de un evento. Funciona de dos maneras:

• Hace que el evento sea relevante solo para una entidad, no para los elementos derivados de la entidad ni para sus elementos principales.

• Evita enviar el evento relevante directamente a los elementos derivados o principales de una entidad.

Al evitar enviar un evento a un elemento derivado o principal, puedes decidir qué significa este evento para los elementos principales y derivados de la entidad, y hacer que puedas enviarles manualmente un evento diferente en respuesta para tener más control sobre cómo esas entidades responden al evento inicial.

Por ejemplo, una entidad recibe un evento de daño a través de SendDown. Un componente de una entidad podría decidir responder a esto restando vida y no enviaría este evento más allá en la jerarquía de entidades, ya que no es necesario que las entidades derivadas reciban daño.

Sin embargo, en el caso de que exista un sistema de puntuación por encima de la entidad receptora, la cadena de bases de la entidad necesitaría enviar la información de daño para otorgar una medalla al jugador por dañar a los enemigos. En esta situación, se podría llamar a SendUp en la entidad receptora con un evento especial que envíe la puntuación de daño a un componente principal que escuche la información de puntuación.

Eventos de consumo durante SendUp y SendDown

Los eventos pueden consumirse durante la propagación de eventos desencadenada por SendUp o SendDown si se devuelve true desde la implementación OnReceive(SceneEvent:scene_event):logic de un componente.

Si algún componente de una entidad elige consumir un evento durante un evento SendUp, todos los componentes de la entidad seguirán invocando sus respectivas devoluciones de llamada OnRecieve. La propagación se detiene y no pasa al elemento principal de la entidad.

Si algún componente de una entidad elige consumir un evento durante un evento SendDown, todos los componentes de la entidad seguirán invocando sus respectivas devoluciones de llamada OnRecieve. El evento no se transmite a los elementos derivados de la entidad. Sin embargo, el evento aún se pasará al resto de las entidades en el mismo nivel.

En el siguiente diagrama, notarás que mientras el evento de escena 4 continúa en la cadena de eventos, el evento de escena 3 no.

Cómo crear un evento de escena

Hay algunas tareas de configuración inicial y de secuenciación que deben realizarse antes de crear eventos de escena. Crea los recursos que se enumeran a continuación para propagar los componentes de malla con árboles y los efectos de partículas con el efecto apropiado.  Cuando guardas los recursos de efectos de partículas, se guardan automáticamente en un archivo de Verse llamado Assets.digest.verse como objetos de Verse a los que puedes hacer referencia en tu código.

1. Efectos visuales de rayos

   Para hacer que el relámpago comience en un punto aleatorio del cielo sobre una entidad y termine en una entidad de Scene Graph en el suelo, modifica los efectos visuales (VFX) del rayo de la siguiente manera:

   • Establece Configuración de emisor de haz > Inicio de haz como Añadir vector a posición; establece Posición en SimulationPosition y Vector en Vector de rango aleatorio con Mínimo como (-200.0, -200.0, 1000) y Máximo como (200.0, 200.0, 2000.0).

   • Establece Configuración de emisor de haz > Final del haz como SimulationPosition.

   Ahora el rayo comenzará en algún lugar del cielo sobre la entidad y terminará en la entidad en la que se adjunta elarticle_system_component.

2. Efectos visuales de fuego

3. Árboles y césped de malla estática

     Modela tus propios árboles con el modo de modelado.

Añade estos recursos a las entidades y, a continuación, coloca varias entidades objetivo de rayos por todo Scene Graph donde pueda caer un rayo. Cada una de estas entidades objetivo de rayos tiene un particle_system_component de rayo listo para recibir las instrucciones que definirás en tu evento de escena. No se requiere configuración adicional.

Las entidades pueden anidarse en un prefabricado o estar completamente separadas y dispersas en la escena.

Con las entidades en su lugar, piensa en la secuencia de eventos que provocan el incendio forestal, y luego piensa en los nombres de los eventos que describen lo que el evento está haciendo. Después, sigue el tutorial de Verse en la sección Cómo codificar el comportamiento. 

Convenciones de nomenclatura de los eventos de escena

Puedes utilizar tantos personajes como necesites al nombrar un evento de escena. La nomenclatura debe describir tu evento y dejar en claro la intención del evento, por ejemplo, damage_taken_event, health_power_up_event, etc.

Hay dos eventos principales en la secuencia de eventos de un incendio forestal:

• Relámpago

• Propagación de incendio

Para describir lo que hacen estos eventos, asigna al evento de rayo el nombre de struck_by_lightning_event y al evento de propagación de incendio, el nombre de fire_propagation_event.

Secuencia de eventos

Al crear un evento de escena, míralo como una interfaz que tiene efectos hacia arriba y hacia abajo en una jerarquía de entidades y componentes. Además, debido a que los eventos de escena pueden ser utilizados por otras personas, considera cómo otro desarrollador podría crear a partir de tu evento o utilizar tu evento en su propio Scene Graph.

El evento de escena que estás creando informará sobre los eventos principales que ocurran antes de iniciar otro evento relacionado con el evento base. Así que la secuencia de eventos es la siguiente:

1. En el entorno, se produce un evento de escena llamado struck_by_lightning_event.

2. Las entidades informan si fueron alcanzadas por el evento struck_by_lightning_event o no. Las entidades alcanzadas por un rayo activan fire_propagation_event.

3. fire_propagation_event hace que otras entidades decidan si están o no lo suficientemente cerca de fire_propagation_event para prenderse fuego también.

4. fire_propagation_event se propaga a los otros componentes de malla.

fire_propagation_event continúa ejecutándose hasta que cada componente de malla que decide que estaba lo suficientemente cerca de fire_propagation_event se incendia. Debe parecerse a un incendio forestal real cuando se ejecuta en la escena.

Cómo expandir una secuencia

Si bien struck_by_lightning_event provoca fire_propagation_event, puedes extender el juego añadiendo elementos nuevos que propaguen el fuego. Por ejemplo, pueden añadir un explosive_event que envía un fire_propagation_event cuando explota.

Otro aspecto interesante de los eventos de escena es que las entidades que controlan fire_propagation_event no necesitan saber qué provocó el incendio, solo que algo les hace considerar si deben prenderse fuego o no. Esto hace que el código sea más fácil de mantener por dos razones:

• En el entorno, se produce un evento de escena llamado struck_by_lightning_event.

  Es más fácil cambiar el comportamiento de struck_by_lightning_event sin dividir las entidades que solo se preocupan por fire_propagation_event.

• Es más fácil escribir un explosive_event, porque a los objetos inflamables solo les importa el fire_propagation_event.

Cómo codificar el comportamiento

Cuando Scene Graph esté completo con todas las entidades necesarias, utiliza el siguiente código para crear un evento de escena que comience con un rayo y provoque un incendio en los árboles y cause daño por fuego.

Assets.digest.verse busca automáticamente los objetos de Verse para hacer referencia a ellos en la escena. Los efectos de partículas que creaste se referencian en un módulo de VFX.

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):

Paso 1: Crea un componente de Scene Graph

Para crear un evento de escena en UEFN, abre el menú de Verse en la barra de menús y selecciona Explorador de Verse en el menú desplegable. Se abrirá el panel del explorador de Verse en el editor, que contiene la lista de archivos de Verse asociados a tu proyecto.

Crea un nuevo archivo de Verse haciendo lo siguiente:

1. Haz clic derecho en el nombre del proyecto en la parte superior de la lista.

2. Selecciona Añadir nuevo archivo de Verse al proyecto en el menú desplegable. Se abrirá la ventana Crear secuencia de comandos de Verse.

3. Selecciona el componente Scene Graph de la lista de archivos de Verse y asigna al archivo el nombre de fire_event_component.

4. Haz clic en Crear. El archivo se abre automáticamente en Visual Studio Code (VS Code) y contiene las API repetitivas necesarias para crear el comportamiento del nuevo componente.

   

Cuando tengas todo listo para probar tu secuencia de comandos, abre el menú de Verse y selecciona Compilar código de Verse en el menú desplegable. Luego, selecciona el botón de Verse para ejecutar tu código.

Paso 2: Añade las bibliotecas de Verse

Comienza tu evento de escena creando primero la secuencia de eventos y condiciones que hacen que caiga el rayo. Después de definir el evento de rayo, crea el evento de incendio forestal mediante la definición de las propiedades de daño por fuego, los protocolos de propagación del fuego y los protocolos de extinción de incendios.

1. Añade las siguientes bibliotecas a tu componente para asegurarte de que puedes utilizar matemáticas espaciales para la ubicación de tus rayos e incendios, crear concurrencia y otras características de 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)

Paso 3: Define la clase de evento de rayo

Esta clase de evento determina la ubicación de origen del rayo, la ubicación del impacto del rayo y el DamageRadius de la ubicación del impacto.

1. Crea una clase de evento llamada struck_by_lightning_event := class(scene_event):. La clase define las propiedades del evento de escena en expresiones constantes que describen dónde ocurre el evento de rayo en la escena mediante el uso de un vector para la información de ubicación y el radio de daño del rayo utilizando un 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)

Paso 4: Crea un componente de clima y agrega propiedades editables con variables

Utiliza propiedades y variables editables para establecer si el rayo aparece en la escena, impactos aleatorios del rayo, el tiempo entre impactos y el radio de daño del impacto del rayo.

1. Define cómo se comporta el rayo; para ello, añade propiedades editables a una clase de componente denominada lightning_weather_component := component ():. Resalta la cantidad mínima y máxima en las propiedades editables para el tiempo entre los rayos y el radio de daño de esos rayos en 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)

Paso 5: Define el evento de rayo

Utiliza un método para comprobar los efectos visuales (VFX) y usa sus propiedades de haz inicial y final para determinar qué tan cerca están los componentes de la malla de los VFX, y transmite esta información a lo largo del evento.

1. Crear un método OnSimulate condicional.

   Verse

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

   Copy full snippet(1 line long)

2. Crea y añade un bucle que reproduzca y detenga aleatoriamente el componente de iluminación mediante una constante que utilice valores de retraso mínimos y máximos para el tiempo de reproducción.

   Verse

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

   Copy full snippet(4 lines long)

3. Añade una expresión if que utilice la entidad de simulación para buscar otras entidades en la simulación, ya que todas las demás entidades son derivadas de la entidad de simulación. De esta forma, se puede seleccionar una entidad aleatoria para que la alcance un rayo, en lugar de utilizar la colisión para encontrar entidades en la escena.

   Verse

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

   Copy full snippet(2 lines long)

   A continuación, el código debe proporcionar un objetivo para que alcance el rayo.

4. Añade una expresión then que transmita una solicitud para ser el objetivo del rayo hacia abajo desde SimEntity. Luego, añade una expresión condicionalif que responda a esta transmisión y haga que todas las entidades que puedan responder envíen un evento de regreso a SimEntity. A continuación, tendrás que encontrar la fuente del rayo porque un emisor de haz utiliza una ubicación de dos puntos para el inicio y el fin del haz.

   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. Llama a LightningVFXComponent a la ubicación aleatoria mediante una declaración if. A continuación, añade una expresión then que reproduzca el efecto de partículas del haz en la ubicación definida para las ubicaciones de origen y destino.

   lightning_entity utiliza Configuración de emisor de haz > Inicio de haz para reproducir el evento de rayo en puntos aleatorios del cielo. Luego, LightningVFXComponent utiliza  la opción de partícula de haz Configuración de emisor de haz > Final del haz para determinar dónde aparece el final de la partícula de haz en la escena. La configuración se establece en Posición de simulación, que utiliza las coordenadas finales del efecto de partículas para lightning_entity.   

   Después, crea y define el daño causado por struck_by_lightning_event utilizando los datos de origen y destino para localizar dónde ocurre el daño en el destino del componente de malla mediante DamageRadius para describir el área afectada por el daño del rayo. Este evento se enviará a la entidad de simulación para añadir una duración aleatoria de rayo, así que finaliza la cadena de eventos con 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)

Paso 6: Define el evento de incendio

Crea clases de eventos que definan la cantidad de daño que causa el fuego y si el fuego debe propagarse en función del daño del fuego en la escena.

1. Crea dos clases. Una clase fire_damage_event y una clase fire_propagation_event que comprueben la DamageAmount que se está realizando y reproduzca la partícula de fuego cuando DamageAmount alcance el umbral de 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. Crea una clase flammable_component que determine que una malla es inflamable y las propiedades editables que se pueden definir para hacer que las mallas de la escena se incendien.

   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. Se añade una variable condicional a flammable_event que decide si los VFX de fuego se están reproduciendo o deberían reproducirse.

   Verse

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

   Copy full snippet(2 lines long)

4. Una función IsCloseEnoughToBurningEntityToIgnite determina si el incendio está lo suficientemente cerca como para activar más eventos de efectos visuales de incendio.

   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. Una función IsCloseEnoughToLightningToIgnite determina si el rayo cayó lo suficientemente cerca de la malla como para provocar que se incendiara.

   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. La función OnRecieve determina qué mallas se incendian una vez que la función IsCloseEnoughToBurningEntityToIgnite determina la proximidad de la propagación del fuego, y la variable IsCloseEnoughToLightningToIgnite determina la proximidad del impacto del rayo a la malla.

   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. Se utiliza un método Ignite para reproducir el efecto automáticamente a través de una instrucción condicional if que busca el sistema de partículas de fuego. Una instrucción then define si es cierto que el componente está reproduciendo los VFX de fuego. 

   Añade tareas asíncronas al método para comprobar el sistema de partículas de fuego Fire_NS para que el fuego se genere y se propague cuando se le llame.

   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)

Paso 7: Define el fin del evento de incendio

A continuación, crearás una serie de métodos que determinan cuándo estallan en llamas los componentes de la malla, cuándo se extinguen las llamas, el daño que provoca el fuego y cuándo hacer que el fuego se propague.

1. Ahora crea un método extintor que detenga el efecto de fuego mediante la búsqueda de componentes que reproduzcan dicho efecto, con las instrucciones condicionales para encontrar el sistema de partículas de fuego y eliminar el efecto.

   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. Crea un método OnFire que use un bucle que monitoree el FireDamage y envíe el evento por la cadena de entidades hacia el final del evento, y haga que el evento deje de reproducirse.

   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 último, crea un método FirePropagation que utilice un bucle para propagar el fuego a lo largo de la cadena de entidades y hacer que se extingan cuando alcanzan la entidad de simulación.

   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)

Cuando el código esté completo, compila el código y añade las entidades adecuadas a Scene Graph para admitir los efectos de los rayos y los incendios forestales. Después, añade el flammable_component a las entidades de la escena que deberían incendiarse. Es necesario que haya una entidad de nivel superior debajo de la entidad de simulación con el lightning_weather_component que controla el clima.

Una vez que todas las entidades se actualicen con los eventos de escena apropiados, inicia una sesión de edición en vivo para ver cómo funciona tu código en la escena.

Resultado

Copia y pega el código en tu proyecto para ver cómo funciona el evento de escena.

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