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.
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_componentestá anexado.Á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.
Migre ativos do pacote Conteúdo Inicial da UE para criar os efeitos visuais de fogo, ou você pode criar os efeitos visuais de fogo e relâmpago na UE e migrar esses ativos para seu projeto do UEFN.
Crie todos os seus ativos antes de adicionar entidades à cena. Dessa forma, todos os recursos de malha estática que você criar aparecerão no menu de componentes de malha.
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:
Um evento de cena ocorre no mundo chamado
struck_by_lightning_event.As entidades informam se foram atingidas pelo
struck_by_lightning_eventou não. As entidades atingidas por um raio acionam ofire_propagation_event.O
fire_propagation_eventfaz com que outras entidades decidam se estão ou não perto o suficiente dofire_propagation_eventpara também pegar fogo.O
fire_propagation_eventse 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_eventsem quebrar entidades que se importam apenas comfire_propagation_event.É mais fácil escrever um
explosive_event, porque coisas incendiáveis só se importam comfire_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:
Clique com o botão direito no nome do projeto no topo da lista.
Selecione Adicionar novo arquivo Verse ao projeto no menu suspenso. A janela "Criar script Verse" é aberta.
Selecione Componente do Scene Graph na lista de arquivos Verse e chame o arquivo de fire_event_component.
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.
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.
Verseusing { /Verse.org/SpatialMath } using { /Verse.org/Random } using { /Verse.org/Concurrency } using { /Verse.org/Simulation } using { /Verse.org/SceneGraph }
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.
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 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
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.
Defina como o raio se comporta adicionando propriedades
editablea uma classe de componente chamadalightning_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
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.
Crie um
methodcondicionalOnSimulate.VerseOnSimulate<override>()<suspends>:void=Crie e adicione um
loopque 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.Verseloop: # Sleep for a random delay before next lightning strike RandomDelay := GetRandomFloat(MinRandomLightningDelaySeconds, MaxRandomLightningDelaySeconds) Sleep(MaxRandomLightningDelaySecondsAdicione uma expressão
ifque 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[]):Em seguida, o código precisa fornecer um alvo para o raio atingir.
Adicione uma expressão
thenque transmite uma solicitação para ser o alvo do raio a partir de SimEntity. Em seguida, adicione uma expressãoifcondicional 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.VerseLightningTargets := for (EntityWithLightning : SimEntity.FindDescendantEntitiesWithComponent(particle_system_component)): EntityWithLightning if: LightningTargets.Length > 0 RandomIndex := GetRandomInt(0, LightningTargets.Length - 1) RandomEntity := LightningTargets[RandomIndex]Chame
LightningVFXComponentpara 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_entityusa 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, oLightningVFXComponentusa 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 paralightning_entity.Em seguida, crie e defina o dano causado por
struck_by_lightning_eventusando os dados de origem e destino para localizar onde o dano ocorre no alvo do componente de malha usandoDamageRadiuspara 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 comSimulationEntity.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
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.
Crie duas classes. Uma classe
fire_damage_evente uma classefire_propagation_eventque verifica oDamageAmountsendo causado e reproduz a partícula de fogo quando oDamageAmountatinge 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.0Crie uma classe
flammable_componentque 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.0Uma 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 = falseA função
IsCloseEnoughToBurningEntityToIgnitedetermina 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.FireRadiusCentimetersA função
IsCloseEnoughToLightningToIgnitedetermina 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.DamageRadiusCentimetersA 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() falseUm 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çãothendefine 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
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.
Agora crie um método
Extinguishque 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()Crie um método
OnFireque usa um loop que monitoraFireDamagee 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)Por fim, crie um método
FirePropagationque usa umlooppara 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)
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