Eventi di scena

Questa funzionalità di Scene Graph è attualmente in uno stato sperimentale. In Impostazioni progetto, seleziona la casella per abilitare l'opzione Funzionalità sperimentali di Scene Graph, così da poter accedere a queste funzioni all'interno del sistema Scene Graph.

Se il tuo progetto contiene funzionalità sperimentali di Scene Graph, queste verranno rilevate durante il processo di convalida nel Portale creatori. Riceverai un avviso relativo agli asset che presentano limitazioni non consentendoti di pubblicare la tua isola. Disabilita le funzionalità sperimentali in Impostazioni progetto per pubblicare la tua isola.

Scene Graph ha una funzionalità integrata in tutte le entità e componenti che crea singoli eventi o una catena di eventi nel tuo Scene Graph, chiamata Eventi di scena. Gli eventi di scena sono protocolli di comunicazione che consentono a diverse parti di un Scene Graph di comunicare tra loro sovrascrivendo e definendo nuovi comportamenti per entità e componenti. 

Gli eventi di scena possono essere riutilizzati nei tuoi progetti, puoi ampliare gli eventi di scena aggiungendo eventi aggiuntivi o modificando il comportamento di entità e componenti in una catena di eventi per fare qualcosa di leggermente diverso

Più componenti possono rispondere a un evento di scena e gli eventi possono essere inviati verso l'alto o verso il basso nella gerarchia di Scene Graph. Potrebbe essere utile immaginarli come messaggi che attraversano Scene Graph, dando a ciascun componente l'opportunità di rispondere al messaggio. 

Ad esempio, se imposti un cimitero utilizzando Scene Graph, puoi usare gli eventi di scena per definire una catena di eventi che inizia quando i cancelli del cimitero della mesh statica si aprono. L'apertura dei cancelli potrebbe fungere da punto di partenza per una catena di eventi che causano un effetto particellare con fantasmi che volano fuori da dietro le lapidi e l'inizio della riproduzione di una musica inquietante. 

Questo potrebbe essere un evento di scena da riutilizzare più volte nel cimitero, oppure potresti modificarlo in modo da usare le funzioni di base dell'evento di scena: una porta di mesh statica di qualche tipo che si apre e provoca una serie di eventi a catena.

Gli eventi di scena servono principalmente a disaccoppiare le parti del scene graph, permettendo loro di comunicare tramite messaggi invece di essere collegate direttamente tra loro.

Come funzionano gli eventi di scena

Verse viene utilizzato per trasmettere eventi attraverso Scene Graph a entità e componenti specifici. Per gestire un evento di scena in un component, esegui l'override della funzione OnReceive(scene_event):logic esistente in component. Ogni evento di scena che attraversa il componente invocherà quindi questa funzione, fornendo un modo per rispondere all'evento.

Un evento di scena è qualsiasi classe che implementa l'interfaccia scene_event. Gli eventi di scena possono essere inviati in tre modi: SendUp, SendDown o SendDirect.

SendUp

SendUp, invia l'evento all'entità di destinazione e al suo genitore. L'entità genitore trasmetterà quindi l'evento al proprio genitore, e così via, fino a raggiungere l'entità di simulazione a cui sono collegate le entità del tuo mondo.

Il mittente non sa esattamente quale ricevente gestirà l'evento, o se qualcuno risponderà all'evento. Questo tipo di invio è ideale per inviare dati di telemetria, segnalazioni a sistemi di livello superiore o vari tipi di richieste che possono essere gestite o meno.

Ad esempio, immagina di colpire i piedi di un personaggio con una spada, con il piede che si trova in profondità nella sua gerarchia. La gamba potrebbe non gestire i danni in alcun modo, quindi l'evento si propaga fino alla base del carattere, dove hai posizionato un damage_receiever_component in grado di ricevere l'evento di danno ed elaborare il colpo. 

Nel diagramma seguente, l'entità genitore è l'evento etichettato come 1 che si attiva nella prima entità verde. La chiamata SendUp parte dall'entità genitore nella gerarchia e manda l'evento verso l'alto all'entità di simulazione.

SendDown

In alternativa, potresti usare l'entità di simulazione come catalizzatore e inviare una serie di modifiche lungo l'albero delle entità. SendDown invia l'evento all'entità di destinazione e a tutti i suoi figli. Ogni figlio trasmette l'evento ai propri figli.

Questo potrebbe essere usato in una situazione in cui si verifica un evento globale e qualsiasi elemento nella scena dovrebbe avere l'opportunità di rispondervi.

Invia diretto

SendDirect invia un evento direttamente all'entità di destinazione, ma non lo trasmette né ai genitori né ai figli. Ciò viene utilizzato per indirizzare un'entità o un componente specifico, come illustrato nel diagramma seguente.

Consumo degli eventi

Quando un evento viene inviato in alto o in basso nella gerarchia di entità, i singoli componenti possono scegliere di non rispondere all'evento. Il componente segna l'evento come completato e non lo trasmette ai suoi figli o genitori, agendo essenzialmente come un interruttore di spegnimento.

Il consumo degli eventi ti permette di controllare l'ambito dell'effetto di un evento. Funziona in due modi:

• Rende l'evento rilevante per un'unica entità, non per i relativi figli, né per i suoi genitori.

• Evita di inviare l'evento rilevante direttamente ai figli o ai genitori di un'entità.

Evitando di inviare un evento a un figlio o a un genitore, puoi decidere cosa significhi quell'evento per i genitori e i figli dell'entità, e scegliere di inviare loro manualmente un evento diverso in risposta, per avere un controllo maggiore su come tali entità rispondono all'evento iniziale.

Ad esempio, un'entità riceve un evento di danno tramite SendDown. Un componente su un'entità potrebbe decidere di rispondere sottraendo salute e non trasmettere ulteriormente l'evento nella gerarchia, poiché non è necessario che le entità figlie subiscano danni.

Tuttavia, nel caso in cui sia presente un sistema di punteggio sopra l'entità ricevente, la catena dei genitori dell'entità deve inviare le informazioni sul danno per assegnare una medaglia al giocatore per aver danneggiato i nemici. In questa situazione, si può usare una chiamata SendUp sull'entità ricevente con un evento speciale che invia il punteggio del danno a un componente genitore in ascolto delle informazioni sul punteggio.

Consumo degli eventi durante SendUp e SendDown

Gli eventi possono essere consumati durante la propagazione degli eventi, attivata da SendUp o SendDown restituendo true nell'implementazione OnReceive(SceneEvent:scene_event):logic di un componente.

Se un componente di un'entità sceglie di consumare un evento durante un SendUp, tutti i componenti dell'entità invocano comunque i rispettivi callback OnRecieve. La propagazione quindi si interrompe e non passa al genitore dell'entità.

Se un componente di un'entità sceglie di consumare un evento durante un SendDown, tutti i componenti dell'entità invocano comunque i rispettivi callback OnRecieve. L'evento non viene trasmesso ai figli dell'entità. Tuttavia, l'evento verrà comunque trasmesso al resto delle entità allo stesso livello.

Nel diagramma seguente, noterai che mentre l'evento di scena 4 continua lungo la catena di eventi, l'evento di scena 3 no.

Creazione di un evento di scena

È necessario eseguire alcune operazioni di configurazione iniziale e di sequenza prima di creare gli eventi di scena. Compila gli asset elencati di seguito per popolare i componenti mesh con alberi e gli effetti particellari con l'effetto appropriato.  Quando salvi gli asset degli effetti particellari, vengono salvati automaticamente in un file di Verse denominato Assets.digest.verse come oggetti Verse a cui puoi fare riferimento nel codice.

1. VFX del fulmine

   Per fare in modo che il fulmine inizi da un punto casuale nel cielo sopra un'entità e termini su un'entità di Scene Graph al suolo, modifica il VFX del fulmine nel modo seguente:

   • Imposta Configurazione emettitore raggio > Inizio raggio come Aggiungi vettore a posizione, imposta Posizione su SimulationPosition, imposta Vettore su Vettore con intervallo casuale con Minimo come (-200,0, -200,0, 1000) e Massimo come (200,0, 200,0, 2000,0).

   • Imposta Configurazione emettitore raggio > Fine raggio come SimulationPosition.

   Ora il fulmine inizierà da qualche parte nel cielo sopra l'entità e terminerà in corrispondenza dell'entità a cui è collegato particle_system_component.

2. VFX di fuoco

3. Alberi ed erba con mesh statica

     Modella i tuoi alberi con la Modalità modellazione.

Aggiungi questi asset alle entità, quindi posiziona più entità destinazione fulmine in tutto il Scene Graph dove può colpire un fulmine. Ciascuna di queste entità destinazione fulmine ha un particle_system_component fulmine pronto a ricevere le istruzioni che definisci nell'evento di scena. Non è richiesta alcuna configurazione aggiuntiva.

Le entità possono essere nidificate in un prefab o completamente separate e distribuite nella scena.

Con le entità posizionate, pensa alla sequenza di eventi che provoca l'incendio della foresta, quindi rifletti sui nomi da assegnare agli eventi che descrivano ciò che l'evento fa. Successivamente, segui il tutorial di Verse nella sezione Codifica del comportamento. 

Convenzioni di denominazione dell'evento di scena

Puoi utilizzare tutti i caratteri che ti servono quando assegni un nome a un evento di scena. La nomenclatura deve descrivere l'evento e chiarirne l'intento, ad esempio damage_taken_event, health_power_up_event e così via.

Ci sono due eventi principali nella sequenza di eventi degli incendi della foresta:

• Colpo di fulmine

• Propagazione del fuoco

Per descrivere l'effetto di questi eventi, denomina l'evento fulmine, struck_by_lightning_event e assegna un nome all'evento di propagazione dell'incendio, fire_propagation_event.

Sequenza di eventi

Quando crei un evento di scena, consideralo come un'interfaccia che ha effetti verso l'alto e verso il basso nella gerarchia di entità e componenti. Inoltre, poiché gli eventi di scena possono essere utilizzati da altre persone, considera come un altro sviluppatore può basarsi sul tuo evento o utilizzarlo nel proprio Scene Graph.

L'evento di scena che stai creando riporterà gli eventi principali che si verificano prima di dare il via a un altro evento correlato all'evento genitore. Quindi la sequenza degli eventi è la seguente:

1. Nel mondo si verifica un evento di scena chiamato strike_by_lightning_event.

2. Le entità segnalano se sono state colpite dall'evento strike_by_lightning_event o meno. Le entità colpite da un fulmine attivano il fire_propagation_event.

3. Il fire_propagation_event induce le altre entità a decidere se si trovano abbastanza vicino all'evento fire_propagation_event da prendere fuoco a loro volta.

4. Il fire_propagation_event si diffonde agli altri componenti mesh

Il fire_propagation_event continua a essere eseguito finché ogni componente mesh che ha deciso di trovarsi abbastanza vicino all'evento fire_propagation_event non abbia preso fuoco. Quando viene eseguito nella scena, deve assomigliare a un vero incendio della foresta.

Espansione di una sequenza

Anche se struck_by_lightning_event causa il fire_propagation_event, puoi decidere di estendere il gioco aggiungendo nuovi elementi che propagano il fuoco. Ad esempio, aggiungi un exploit_event che invia un fire_propagation_event quando esplode.

Un altro aspetto interessante degli eventi di scena è che le entità che gestiscono fire_propagation_event non devono sapere cosa ha causato l'incendio, ma solo che qualcosa le sta inducendo a valutare se devono prendere fuoco. Ciò rende il codice più facile da gestire per due motivi:

• Nel mondo si verifica un evento di scena chiamato strike_by_lightning_event.

  È più facile modificare il comportamento di struck_by_lightning_event senza interrompere le entità che si preoccupano solo di fire_propagation_event.

• È più facile scrivere un exploit_event, perché gli oggetti infiammabili si preoccupano solo di fire_propagation_event.

Codifica del comportamento

Quando lo Scene Graph è completo di tutte le entità necessarie, utilizza il codice seguente per creare un evento di scena che inizi con un fulmine e provochi un incendio tra gli alberi, causando danni da fuoco.

Assets.digest.verse cerca automaticamente gli oggetti Verse per farvi riferimento nella scena. Gli effetti particellari creati sono referenziati in un modulo 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):

Passaggio 1: crea un componente Scene Graph

Per creare un evento di scena in UEFN, apri il menu Verse dalla barra del menu e seleziona Verse Explorer dal menu a discesa. Nell'editor si apre il pannello Verse Explorer che contiene l'elenco dei file di Verse associati al tuo progetto.

Crea un nuovo file di Verse procedendo come segue:

1. Fai clic con il tasto destro del mouse sul nome del progetto in cima all'elenco.

2. Seleziona Aggiungi nuovo file Verse al progetto dal menu a discesa. Si apre la finestra Crea script Verse.

3. Seleziona Componente Scene Graph dall'elenco dei file di Verse e nomina il file fire_event_component.

4. Fai clic su Crea. Il file si apre automaticamente in Visual Studio Code (VS Code) e contiene le API standard necessarie per creare il comportamento di un nuovo componente.

   

Quando vuoi testare il tuo script, apri il menu Verse e seleziona Compila il codice Verse dal menu a discesa. Successivamente, seleziona il pulsante Verse per eseguire il codice.

Passaggio 2: aggiungi le librerie Verse

Inizia il tuo evento di scena costruendo prima la sequenza di eventi e condizioni che causano il fulmine. Una volta definito l'evento fulmine, crea l'evento incendio della foresta definendo le proprietà del danno da incendio, i protocolli di propagazione dell'incendio e i protocolli di estinzione degli incendi.

1. Aggiungi le seguenti librerie al tuo componente per assicurarti di poter utilizzare la matematica spaziale per la posizione del fulmine e del fuoco, creare concorrenza e sfruttare altre funzionalità di 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)

Passaggio 3: definisci la classe evento fulmine

Questa classe evento determina la posizione di origine del fulmine, il punto in cui colpisce e il DamageRadius del punto d'impatto.

1. Crea una classe evento denominata struck_by_lightning_event := class(scene_event):. La classe definisce le proprietà dell'evento di scena tramite espressioni costanti che descrivono dove si verifica l'evento di fulmine nella scena, utilizzando un vettore per le informazioni di posizione e un valore float per il raggio di danno del fulmine.

   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)

Passaggio 4: crea un componente meteo e aggiungi proprietà modificabili con variabili

Usa proprietà e variabili modificabili per stabilire se il fulmine appare nella scena, se ci sono scariche di fulmine casuali, il tempo tra una scarica e l'altra e il raggio di danno del fulmine.

1. Definisci il comportamento del fulmine aggiungendo proprietà editable a una classe di componenti denominata lightning_weather_component := component ():. Definisci nelle proprietà modificabili la quantità minima e massima per il tempo tra le scariche di fulmine e il raggio di danno di tali scariche, in centimetri.

   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)

Passaggio 5: definisci l'evento fulmine

Usa un metodo per verificare la presenza dei VFX fulmine e utilizza le sue proprietà di inizio e fine del raggio per determinare la vicinanza dei componenti mesh agli VFX, trasmettendo queste informazioni verso l'alto e verso il basso nell'evento

1. Crea un method condizionale OnSimulate.

   Verse

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

   Copy full snippet(1 line long)

2. Crea e aggiungi un loop che riproduca e interrompa casualmente il componente fulmine utilizzando una costante con valori minimo e massimo di delay per il tempo di riproduzione.

   Verse

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

   Copy full snippet(4 lines long)

3. Aggiungi un'espressione if che utilizza l'entità di simulazione per trovare altre entità nella simulazione, poiché tutte le altre entità sono figlie dell'entità di simulazione. In questo modo è possibile selezionare un'entità casuale per essere colpita da un fulmine, invece di utilizzare la collisione per trovare le entità nella scena.

   Verse

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

   Copy full snippet(2 lines long)

   Successivamente, il codice deve fornire un bersaglio che il fulmine possa colpire.

4. Aggiungi un'espressione then trasmetta una richiesta per essere il bersaglio del fulmine verso il basso a partire dalla SimEntity. Quindi aggiungi un'espressione condizionale if che risponda a questa trasmissione e faccia sì che tutte le entità in grado di rispondere inviino un evento verso l'alto alla SimEntity. Successivamente, dovrai trovare la sorgente del fulmine, poiché un emettitore a raggio utilizza una posizione a due punti per l'inizio e la fine del raggio.

   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. Chiama il LightningVFXComponent nella posizione casuale utilizzando un'istruzione if. Quindi aggiungi un'espressione then che riproduca l'effetto particellare del raggio nella posizione impostata per la sorgente e il bersaglio.

   lightning_entity utilizza Configurazione emettitore raggio > Inizio raggio fascio per riprodurre l'evento fulmine in punti casuali nel cielo. LightningVFXComponent utilizza quindi  l'opzione particellare del raggio Configurazione emettitore raggio > Fine raggio per determinare dove appare l'estremità particellare del raggio nella scena. L'impostazione è configurata su posizione di simulazione, che utilizza le coordinate finali dell'effetto particellare per lightning_entity.   

   Successivamente, crea e definisci il danno causato da struck_by_lightning_event utilizzando i dati di origine e destinazione per individuare dove si verifica il danno sul componente mesh bersaglio, usando DamageRadius per descrivere l'area interessata dal danno del fulmine. Questo evento verrà inviato verso il basso all'entità di simulazione per aggiungere una durata casuale del fulmine, quindi termina la catena di eventi 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)

Passaggio 6: definisci l'evento fuoco

Crea classi evento che definiscano la quantità di danno causato dal fuoco e se il fuoco deve propagarsi in base al danno da fuoco presente nella scena.

1. Crea due classi. Una classe fire_damage_event e una classe fire_propagation_event che controlla l'esecuzione del DamageAmount e riproduce la particella di fuoco quando il DamageAmount raggiunge la soglia di 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 classe flammable_component che stabilisca se una mesh è infiammabile e le proprietà modificabili che possono essere impostate per far prendere fuoco alle mesh nella scena.

   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. Una variabile condizionale viene aggiunta a flammable_event per determinare se i VFX di fuoco sono in riproduzione o dovrebbero esserlo.

   Verse

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

   Copy full snippet(2 lines long)

4. Una funzione IsCloseEnoughToBurningEntityToIgnite determina se il fuoco è abbastanza vicino da attivare ulteriori eventi VFX di fuoco.

   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 funzione IsCloseEnoughToLightningToIgnite determina se il fulmine è caduto abbastanza vicino alla mesh da farla prendere fuoco.

   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 funzione OnRecieve determina quali mesh prendono fuoco una volta che la funzione IsCloseEnoughToBurningEntityToIgnite stabilisce la prossimità della propagazione del fuoco e che la variabile IsCloseEnoughToLightningToIgnite determina la vicinanza del fulmine caduto alla mesh.

   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. Un Ignite method viene utilizzato per riprodurre automaticamente l'effetto attraverso un'istruzione if condizionale che cerca il sistema particellare del fuoco. Un'istruzione then definisce se è vero che il componente sta riproducendo i VFX di fuoco. 

   Aggiungi task asincrone al metodo per verificare la presenza del sistema particellare del fuoco Fire_NS, in modo che il fuoco venga generato e si propaghi quando chiamato.

   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)

Passaggio 7: definisci la fine dell'evento fuoco

Successivamente, creerai una serie di metodi che determinano quando i componenti mesh prendono fuoco, quando le fiamme si spengono, il danno causato dal fuoco e quando provocare la propagazione dell'incendio.

1. Ora crea un Extinguish method che interrompa l'effetto del fuoco cercando i componenti che stanno riproducendo l'effetto tramite istruzioni condizionali, per individuare il sistema particellare del fuoco e rimuovere l'effetto.

   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 OnFire method che utilizzi un loop per monitorare il FireDamage, invii l'evento lungo la catena di entità verso la fine dell'evento e ne causi l'interruzione.

   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. Infine, crea un FirePropagation method che utilizzi un loop per propagare il fuoco lungo la catena di entità e le faccia spegnere quando raggiunge l'entità di simulazione.

   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)

Quando il codice è completo, compilalo e aggiungi a Scene Graph le entità appropriate per supportare i fulmini e gli effetti dell'incendio della foresta. Successivamente, aggiungi flammable_component alle entità della scena che devono prendere fuoco. Deve esserci un'entità di livello superiore sotto l'entità di simulazione con il lightning_weather_component che controlla il tempo.

Una volta che tutte le entità sono state aggiornate con gli eventi di scena appropriati, avvia una sessione di Modifica live per vedere il codice al lavoro nella scena.

Risultato

Copia e incolla il codice nel tuo progetto per vedere l'evento di scena in funzione.

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