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.
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.Á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.
Migra recursos del paquete de contenido de inicio de UE para crear los efectos visuales (VFX) de fuego, o puedes crear los VFX de rayo y fuego en UE y migrar esos recursos a tu proyecto UEFN.
Crea todos tus recursos antes de añadir entidades a la escena; de esta forma, todos los recursos de malla estática que crees aparecerán en el menú del componente de malla.
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:
En el entorno, se produce un evento de escena llamado
struck_by_lightning_event.Las entidades informan si fueron alcanzadas por el evento
struck_by_lightning_event o no. Las entidades alcanzadas por un rayo activanfire_propagation_event.fire_propagation_eventhace que otras entidades decidan si están o no lo suficientemente cerca defire_propagation_eventpara prenderse fuego también.fire_propagation_eventse 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_eventsin dividir las entidades que solo se preocupan porfire_propagation_event.Es más fácil escribir un
explosive_event, porque a los objetos inflamables solo les importael 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:
Haz clic derecho en el nombre del proyecto en la parte superior de la lista.
Selecciona Añadir nuevo archivo de Verse al proyecto en el menú desplegable. Se abrirá la ventana Crear secuencia de comandos de Verse.
Selecciona el componente Scene Graph de la lista de archivos de Verse y asigna al archivo el nombre de fire_event_component.
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.
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.
Verseusing { /Verse.org/SpatialMath } using { /Verse.org/Random } using { /Verse.org/Concurrency } using { /Verse.org/Simulation } using { /Verse.org/SceneGraph }
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.
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 valorFloat.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
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.
Define cómo se comporta el rayo; para ello, añade propiedades
editablesa una clase de componente denominadalightning_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
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.
Crear un método
OnSimulatecondicional.VerseOnSimulate<override>()<suspends>:void=Crea y añade un
bucleque 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.Verseloop: # Sleep for a random delay before next lightning strike RandomDelay := GetRandomFloat(MinRandomLightningDelaySeconds, MaxRandomLightningDelaySeconds) Sleep(MaxRandomLightningDelaySecondsAñade una expresión
ifque 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[]):A continuación, el código debe proporcionar un objetivo para que alcance el rayo.
Añade una expresión
thenque transmita una solicitud para ser el objetivo del rayo hacia abajo desde SimEntity. Luego, añade una expresión condicionalifque 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.VerseLightningTargets := for (EntityWithLightning : SimEntity.FindDescendantEntitiesWithComponent(particle_system_component)): EntityWithLightning if: LightningTargets.Length > 0 RandomIndex := GetRandomInt(0, LightningTargets.Length - 1) RandomEntity := LightningTargets[RandomIndex]Llama a
LightningVFXComponenta 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_entityutiliza Configuración de emisor de haz > Inicio de haz para reproducir el evento de rayo en puntos aleatorios del cielo. Luego,LightningVFXComponentutiliza 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 paralightning_entity.Después, crea y define el daño causado por
struck_by_lightning_eventutilizando los datos de origen y destino para localizar dónde ocurre el daño en el destino del componente de malla medianteDamageRadiuspara 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 conSimulationEntity.SendDown(Event).Verseif (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
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.
Crea dos clases. Una clase
fire_damage_eventy una clasefire_propagation_eventque comprueben laDamageAmountque se está realizando y reproduzca la partícula de fuego cuandoDamageAmountalcance 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.0Crea una clase
flammable_componentque 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.0Se añade una variable condicional a
flammable_eventque decide si los VFX de fuego se están reproduciendo o deberían reproducirse.Verse# Is it on fire? var IsOnFire:logic = falseUna función
IsCloseEnoughToBurningEntityToIgnitedetermina 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.FireRadiusCentimetersUna función
IsCloseEnoughToLightningToIgnitedetermina 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.DamageRadiusCentimetersLa 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() falseSe utiliza un método
Ignitepara 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ónthendefine 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
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.
Ahora crea un
método extintorque 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()Crea un
método OnFireque use un bucle que monitoree elFireDamagey 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)Por último, crea un
método FirePropagationque utilice unbuclepara 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)
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