Eventos de escena

Esta función de Scene Graph está en un estado experimental. En Configuración del proyecto, marca la casilla para activar el ajuste 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 para creadores. Recibirás un aviso sobre los recursos que restrinjan 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 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 forma para que diferentes partes de un Scene Graph se comuniquen entre sí, anulando y definiendo nuevos comportamientos para entidades y componentes. 

Los eventos de escena se pueden reutilizar en todos tus proyectos, puedes ampliarlos añadiendo eventos adicionales o ajustando el comportamiento de las entidades y los componentes de una cadena de eventos para hacer algo ligeramente diferente.

Varios componentes pueden responder a un evento de escena, y los eventos pueden enviarse hacia arriba o hacia abajo en la jerarquía de Scene Graph. Puede resultar útil imaginarlos como mensajes que pasan por el Scene Graph, dando a cada componente la oportunidad de responder al mensaje. 

Por ejemplo, si configuras un cementerio con Scene Graph, puedes usar eventos de escena para definir una cadena de eventos que comienzan cuando se abren las puertas del cementerio de malla estática. La apertura de las puertas podría ser el punto de partida de una serie de acontecimientos que provocarían un efecto de partículas fantasmales que saldrían volando de detrás de las lápidas y el inicio de una música espeluznante. 

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 del evento de escena: 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 difundir eventos a través del Scene Graph a entidades y componentes específicos. Para gestionar un evento de escena en un componente, sobrescribe la función OnReceive(scene_event):logic existente en el componente. Cada evento de escena que pase por este componente invocará esta función, proporcionándote una forma de responder al evento.

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

SendUp

SendUp enviará el evento a la entidad de destino y su padre. La entidad padre pasará entonces ese evento a su entidad padre y así sucesivamente, hasta llegar a la entidad de simulación a la que pertenecen las entidades de tu mundo.

El emisor no sabe exactamente qué receptor gestionará el evento, ni si habrá alguna respuesta al evento. Este tipo de envío es idóneo para enviar telemetría, señales a sistemas de nivel superior o diversos tipos de solicitudes que pueden ser gestionadas o no.

Por ejemplo, imagina que golpeas los pies de un personaje con una espada, y que el pie se encuentra en un nivel jerárquico muy profundo. Es posible que la pierna no soporte ningún tipo de daño, por lo que el evento se propaga hasta la base del personaje, donde has colocado un damage_receiever_component capaz de recibir el evento de daño y procesar el golpe. 

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

SendDown

Como alternativa, podrías utilizar la entidad de simulación como catalizador y enviar una serie de cambios a lo largo del árbol de entidades. SendDown envía el evento a la entidad de destino y a todos sus hijos. Posteriormente, cada hijo pasa ese evento a sus hijos.

Esto podría utilizarse en una situación en la que se ha producido un evento global y cualquier elemento de la escena debería tener la oportunidad de responder a él.

SendDirect

SendDirect envía un evento directamente a la entidad de destino, pero no lo transmite a los padres ni a los hijos. Se utiliza para seleccionar una entidad o componente específico, tal y como se ilustra en el siguiente diagrama.

Consumo de eventos

Cuando se envía un evento hacia arriba o hacia abajo en la jerarquía de entidades, los componentes individuales pueden optar por no responder al evento. Este componente marca el evento como completado y no lo envía a sus hijos o padres, actuando esencialmente como un interruptor de apagado.

El consumo de eventos te permite controlar el alcance del efecto de un evento. Funciona de dos formas:

• Hace que el evento sea relevante solo para una entidad, no para los hijos de la entidad ni para sus padres.

• Evita enviar el evento relevante directamente a los hijos o padres de una entidad.

Al evitar enviar un evento a un hijo o padre, puedes decidir qué significa este evento para los padres e hijos de la entidad, y hacer que puedas enviarles manualmente un evento diferente en respuesta para tener más control sobre cómo responden esas entidades 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 quitando salud y no enviaría este evento a través de la jerarquía de entidades, ya que no es necesario que las entidades hijas sufran daños.

Sin embargo, en el caso de que exista un sistema de puntuación por encima de la entidad receptora, la cadena de hijos de la entidad debería enviar la información sobre el daño para que se le conceda una medalla al jugador por dañar a los enemigos. En esta situación, se podría utilizar una llamada a SendUp en la entidad receptora con un evento especial que envíe la puntuación de daño a un componente padre que esté a la escucha de la información de puntuación.

Consumo de eventos durante SendUp y SendDown

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

Si algún componente de una entidad decide consumir un evento durante un SendUp, todos los componentes de la entidad siguen invocando sus respectivas devoluciones de llamada OnReceive. La propagación se detiene y no pasa al padre de la entidad.

Si algún componente de una entidad decide consumir un evento durante un SendDown, todos los componentes de la entidad siguen invocando sus respectivas devoluciones de llamada OnReceive. El evento no se pasa a los hijos de la entidad. Sin embargo, el evento se seguirá pasando al resto de las entidades del mismo nivel.

En el siguiente diagrama, verá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 que realizar algunos ajustes iniciales y trabajar en la secuencia antes de crear eventos de escena. Crea los recursos que se enumeran a continuación para rellenar los componentes de malla con árboles y los efectos de partículas con el efecto adecuado.  Cuando guardas los recursos del efecto 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 que el rayo comience en un punto aleatorio del cielo sobre una entidad y termine en una entidad de Scene Graph en el suelo, modifica el efecto visual del rayo de la siguiente manera:

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

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

   Ahora, el rayo comenzará en algún punto del cielo sobre la entidad y terminará en la entidad a la que está asociado particle_system_component.

2. Efectos visuales de fuego

3. Árboles y hierba de malla estática

     Modela tus propios árboles con el modo de modelado.

Añade estos recursos a entidades y, a continuación, coloca varias entidades de objetivo de rayo por todo el Scene Graph donde pueda caer un rayo. Cada una de estas entidades de objetivo de rayo 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 se pueden anidar en un prefabricado o separar por completo y distribuir por la escena.

Con las entidades en su lugar, piensa en la secuencia de eventos que causan el incendio forestal, luego piensa en nombres para los eventos que describan lo que está haciendo el evento. A continuación, sigue el tutorial de Verse en la sección Codificación del comportamiento. 

Convenciones de nomenclatura de eventos de escena

Puedes utilizar tantos caracteres como necesites para nombrar un evento de escena. La nomenclatura debe describir tu evento y dejar clara la intención del mismo, por ejemplo, Damage_taken_event, Health_power_up_event, etc.

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

• Impacto del rayo

• Propagación del fuego

Para describir lo que hacen estos eventos, nombra el evento de rayo struck_by_lightning_event y el evento de propagación de fuego fire_propagation_event.

Secuencia de eventos

Al crear un evento de escena, considéralo como una interfaz que tiene efectos ascendentes y descendentes en una jerarquía de entidades y componentes. Además, dado que los eventos de escena pueden ser utilizados por otras personas, ten en cuenta cómo otro desarrollador podría basarse en tu evento o utilizarlo en su propio Scene Graph.

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

1. Se produce un evento de escena en el mundo llamado strike_by_lightning_event.

2. Las entidades informan de si han sido alcanzadas o no por el evento strike_by_lightning_event. 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 incendiarse también.

4. fire_propagation_event se propaga a los demás componentes de la malla.

fire_propagation_event continúa ejecutándose hasta que todos los componentes de la malla que deciden que estaba lo suficientemente cerca de fire_propagation_event se han incendiado. Debe parecerse a un incendio forestal real cuando se ejecuta en la escena.

Cómo expandir una secuencia

Mientras que strike_by_lightning_event provoca fire_propagation_event, puedes ampliar el juego añadiendo nuevos elementos que propaguen el fuego. Por ejemplo, añadir un explosive_event que envíe un fire_propagation_event cuando explote.

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

• Se produce un evento de escena en el mundo llamado strike_by_lightning_event.

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

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

Codificación del comportamiento

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

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

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ú Verse desde la barra de menús y selecciona el explorador de Verse en el menú desplegable. En el editor se abre el panel del explorador de Verse, 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 abre la ventana Crear secuencia de comandos de Verse.

3. Selecciona el componente Scene Graph de la lista de archivos de Verse y nombra el archivo 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 un nuevo comportamiento del componente.

   

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

Paso 2: Añade bibliotecas de Verse

Comienza tu evento de escena construyendo primero la secuencia de eventos y condiciones que hacen que el rayo impacte. Una vez definido el evento de rayo, construye el evento de incendio forestal definiendo las propiedades de los daños de 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 garantizar que puedas utilizar matemáticas espaciales para la posición de tus rayos e incendios, crear simultaneidad y otras funciones 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 posición del origen del rayo, la posición del impacto del rayo y el radio de daño de la posición del impacto.

1. Crea una clase de evento nombrada strike_by_lightning_event := class(scene_event):. La clase define las propiedades del evento de la escena en expresiones constantes que describen dónde se produce el evento de rayo en la escena utilizando un vector para la información de posició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 meteorológico y añade propiedades editables con variables

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

1. Define cómo se comporta el rayo añadiendo propiedades editables a una clase de componente llamada lightning_weather_component := component ():. Indica la cantidad mínima y máxima en las propiedades editables para el tiempo entre el impacto de un rayo y el radio de daño de ese impacto 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 de rayos y utiliza sus propiedades de haz inicial y final para determinar lo cerca que están los componentes de la malla de los efectos visuales y retransmitir esta información a lo largo del evento.

1. Crea un método condicional OnSimulate.

   Verse

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

   Copy full snippet(1 line long)

2. Crea y añade un loop que se reproduzca aleatoriamente y alivie al componente del rayo mediante una constante que utilice valores de retraso mínimo y máximo 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 hijos de la entidad de simulación. De este modo, se puede seleccionar una entidad aleatoria para que sea alcanzada por 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 emita una solicitud para ser el objetivo del rayo desde SimEntity. A continuación, añade una expresión if condicional que responda a esta retransmisión y haga que todas las entidades que puedan responder envíen un evento de vuelta a SimEntity. A continuación, tendrás que encontrar el origen del rayo, porque un emisor de haz utiliza una posición de dos puntos para el inicio y el final 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 utilizando una declaración `if`. A continuación, añade una expresión `then` que reproduzca el efecto de partículas en la posición establecida para las posiciones de origen y de objetivo.

   lightning_entity utiliza Configuración del emisor de haz > Inicio del haz para reproducir el evento de rayo en puntos aleatorios del cielo. A continuación, LightningVFXComponent utiliza  la opción de la partícula del haz Configuración del emisor de haz > Fin del haz para determinar dónde aparece el final de la partícula del 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.   

   A continuación, crea y define el daño hecho por strike_by_lightning_event utilizando los datos de origen y objetivo para localizar dónde se produce el daño en el componente de destino de la malla utilizando 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 del rayo, así que termina 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 evento que definan la cantidad de daño que causa el incendio y si el fuego debe propagarse en función del daño de fuego en la escena.

1. Crea dos clases. Una clase fire_damage_event y una clase fire_propagation_event que comprueban la cantidad de daño (DamageAmount) que se está realizando y reproduce la partícula de fuego cuando DamageAmount alcanza 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 establecer 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 se reproducen o deben reproducirse los efectos visuales de fuego.

   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 fuego.

   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 ha caído lo suficientemente cerca de la malla como para hacer que estalle en llamas.

   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 en 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 `if` condicional que busca el sistema de partículas de fuego. Una instrucción then define si es cierto que el componente está reproduciendo los efectos visuales de fuego. 

   Añade tareas asíncronas al método para comprobar el sistema de partículas de fuego Fire_NS, de modo 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 apagan las llamas, el daño que causa un fuego y cuándo hacer que el fuego se propague.

1. Ahora crea un método Extinguish que detenga el efecto de fuego buscando componentes que lo reproduzcan utilizando 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 utilice un `loop` que supervise el daño por fuego (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 loop para propagar el fuego por la cadena de entidades y haga que se extingan cuando alcance 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, compílalo y añade las entidades adecuadas al Scene Graph para que se puedan reproducir los efectos de los rayos y los incendios forestales. Después, añade flammable_component a las entidades de la escena que deben incendiarse. Tiene que haber una entidad de nivel superior debajo de la entidad de simulación con lightning_weather_component controlando el tiempo.

Una vez que todas las entidades se hayan actualizado con los eventos de escena adecuados, inicia una sesión de edición en tiempo real para ver cómo funciona tu código en la escena.

Resultado

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

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