Cette fonctionnalité Scene Graph est expérimentale pour l’instant. Dans les paramètres du projet, cochez la case permettant d’activer le paramètre Fonctionnalités expérimentales de Scene Graph afin d’accéder à ces fonctionnalités expérimentales dans Scene Graph.
Si votre projet contient des fonctionnalités expérimentales de Scene Graph, celles-ci seront détectées lors du processus de validation dans le portail de créateur. Vous recevrez un avis concernant les ressources limitant votre capacité à publier votre île. Désactivez les fonctionnalités expérimentales dans les paramètres du projet pour publier votre île.
Scene Graph dispose d'une fonctionnalité intégrée à tous les composants et entités, permettant de créer des événements uniques ou une chaîne d'événements dans votre graphique de scène appelés événements de scène. Les événements de scène sont des protocoles de communication qui permettent aux différentes parties d'un graphique de scène de communiquer entre elles en remplaçant et en définissant un nouveau comportement pour les entités et les composants.
Il est possible de réutiliser les événements de scène dans vos projets, et de les développer en ajoutant des événements ou en ajustant le comportement des entités et des composants dans une chaîne d'événements pour faire quelque chose de légèrement différent.
Plusieurs composants peuvent répondre à un événement de scène, et les événements peuvent être déplacés vers le haut ou le bas dans la hiérarchie du graphique de scène. Pour vous aider à comprendre ce processus, imaginez que ces événements sont des messages transmis via le graphique de scène, auxquels chaque composant peut répondre.
Par exemple, si vous configurez un cimetière à l'aide de Scene Graph, vous pouvez utiliser des événements de scène pour définir une chaîne d'événements qui commence lorsque les portes du cimetière de maillage statique s'ouvrent. L'ouverture des portes pourrait servir de point de départ à une chaîne d'événements qui provoquerait un effet de particules de fantômes s'envolant de derrière les pierres tombales, puis qui déclencherait la lecture d'une musique effrayante.
Vous pourriez utiliser un même événement de scène plusieurs fois dans le cimetière, ou le modifier afin de pouvoir utiliser ses fonctions de base, par exemple une porte de maillage statique d'un certain type s'ouvrant et provoquant une série d'événements.
Les événements de scène consistent à découpler les parties du graphique de scène les unes des autres, afin qu'elles puissent communiquer via des messages au lieu d'être liées directement les unes aux autres.
Fonctionnement des événements de scène
Nous utilisons Verse pour diffuser les événements du graphique de scène vers des entités et des composants spécifiques. Pour gérer un événement de scène dans un composant, remplacez la fonction OnReceive(scene_event):logic existante dans le composant. Chaque événement de scène qui passe par votre composant invoque alors cette fonction, vous offrant ainsi un moyen de répondre à l'événement.
Un événement de scène est toute classe qui implémente l'interface scene_event. Il existe trois façons d'envoyer des événements de scène : SendUp, SendDown ou SendDirect.
SendUp
SendUp envoie l'événement à l'entité cible et à son parent. L'entité parente transmet ensuite cet événement à son parent et ainsi de suite, jusqu'à ce qu'elle atteigne l'entité de simulation à laquelle les entités de votre monde sont associées.
L'expéditeur ne sait pas exactement quel destinataire sera chargé de gérer l'événement, ni si cet événement obtiendra une réponse. Ce type d'envoi est idéal pour transmettre la télémétrie, avertir les systèmes de niveau supérieur ou envoyer divers types de demandes qui peuvent ou non être traitées.
À titre d'exemple, imaginez que vous frappiez les pieds d'un personnage avec une épée, le pied étant situé profondément dans sa hiérarchie. La jambe ne pouvant en aucun cas supporter les dégâts, l'événement se propage jusqu'à la base du personnage, où vous avez placé un composant damage_receiver_component capable de recevoir l'événement de dégâts et de traiter le coup.
Dans le diagramme ci-dessous, l'entité parente est l'événement 1 qui se déclenche dans la première entité verte. L'appel SendUp commence sur l'entité parente dans la hiérarchie et envoie l'événement vers le haut jusqu'à l'entité de simulation.
SendDown
Alternativement, vous pouvez utiliser l'entité de simulation comme catalyseur et envoyer une série de modifications dans l'arborescence des entités. SendDown envoie l'événement à l'entité cible et à tous ses enfants. Chaque enfant transmet ensuite cet événement à ses enfants.
SendDown peut être utilisé dans une situation où un événement global s'est produit et où tous les éléments de la scène doivent avoir la possibilité d'y répondre.
SendDirect
SendDirect envoie un événement directement à l'entité cible, mais ne le transmet pas aux parents ou aux enfants. SendDirect est utilisé pour cibler une entité ou un composant spécifique, comme le montre le diagramme ci-dessous.
Consommer des événements
Lorsqu'un événement est envoyé vers le haut ou vers le bas au sein d'une hiérarchie d'entités, les composants individuels peuvent choisir de ne pas répondre à cet événement. Le composant marque l'événement comme étant terminé et ne l'envoie pas à ses enfants ou parents ; il fait donc office de dispositif de désactivation.
Consommer des événements vous permet de contrôler la portée de l'effet d'un événement. Cela fonctionne de deux manières :
Rendre l'événement pertinent pour une seule entité, et non pour les enfants de l'entité, ni pour ses parents.
Éviter d'envoyer l'événement concerné directement aux enfants ou aux parents d'une entité.
En évitant d'envoyer un événement à un enfant ou à un parent, vous pouvez décider ce que cet événement signifie pour les parents et les enfants de l'entité, et faire en sorte de leur envoyer manuellement un événement différent en réponse pour mieux contrôler la façon dont ces entités répondent à l'événement initial.
Par exemple, une entité reçoit un événement de dégât via SendDown. Un composant d'une entité pourrait décider de répondre à cet événement en supprimant des PV et de ne pas poursuivre l'envoi de cet événement dans la hiérarchie des entités, car il n'est pas nécessaire que les entités enfants subissent des dégâts.
Cependant, dans le cas où un système de points est en place au sommet de l'entité réceptrice, la chaîne de parents de l'entité devrait envoyer les informations concernant les dégâts afin d'accorder une récompense au joueur pour avoir infligé des dégâts à ses adversaires. Dans ce cas, il est possible d'utiliser un appel SendUp sur l'entité réceptrice avec un événement spécial qui envoie le nombre de dégâts infligés à un composant parent à l'écoute des informations de score.
Consommer des événements pendant les appels SendUp et SendDown
Les événements peuvent être consommés pendant la propagation d'événements déclenchée par SendUp ou SendDown en renvoyant true à partir de l'implémentation de OnReceive(SceneEvent:scene_event):logic d'un composant.
Si un composant d'une entité choisit de consommer un événement pendant un appel SendUp, tous les composants de l'entité continuent d'invoquer leurs rappels OnReceive respectifs. La propagation s'arrête et ne se poursuit pas sur le parent de l'entité.
Si un composant d'une entité choisit de consommer un événement pendant un appel SendDown, tous les composants de l'entité continuent d'invoquer leurs rappels OnReceive respectifs. Bien que l'événement ne soit pas transmis aux enfants de l'entité, il est transmis aux autres entités du même niveau.
Dans le diagramme ci-dessous, vous observez que, tandis que l'événement de scène 4 se poursuit dans la chaîne d'événements, ce n'est pas le cas de l'événement de scène 3.
Créer un événement de scène
Certaines tâches de configuration sont nécessaires avant de créer des événements de scène. Créez les ressources répertoriées ci-dessous pour remplir les composants de maillage avec des arbres et les effets de particules avec l'effet approprié. Lorsque vous enregistrez les ressources d'effet de particules, elles sont automatiquement sauvegardées dans un fichier Verse appelé Assets.digest.verse en tant qu'objets Verse que vous pouvez référencer dans votre code.
Pour que l'impact de foudre commence à un point aléatoire dans le ciel au-dessus d'une entité et se termine à une entité du graphique de scène au sol, modifiez l'effet visuel de l'éclair comme suit :
Définissez Configuration de l'émetteur de rayon > Début du rayon sur Ajouter le vecteur à la position, définissez Position sur Position de simulation, puis définissez Vecteur sur Plage de vecteurs aléatoire en réglant Minimum sur (-200,0, -200,0, 1 000) et Maximum sur (200,0, 200,0, 2 000,0).
Définissez Configuration de l'émetteur de rayon > Fin du rayon sur Position de simulation.
Désormais, l'éclair commence quelque part dans le ciel au-dessus de l'entité et se termine à l'entité sur laquelle le composant
particle_system_componentest lié.Arbres et herbe de maillage statique
Modélisez vos propres arbres grâce au mode Modélisation.
Ajoutez ces ressources aux entités, puis placez plusieurs entités d'éclair cible dans le graphique de scène où la foudre pourrait frapper. Chacune de ces entités d'éclair cible possède un composant particle_system_component en forme d'éclair prêt à recevoir les instructions que vous définissez dans votre événement de scène. Aucune configuration supplémentaire n'est requise.
Les entités peuvent être imbriquées dans un préfabriqué ou entièrement séparées et réparties dans la scène.
Migrez les ressources du pack de contenu de démarrage de l'UE pour créer les effets visuels de feu ; vous pouvez éventuellement créer les effets visuels d'éclair et de feu dans l'UE et migrer ces ressources dans votre projet UEFN.
Créez toutes vos ressources avant d'ajouter des entités à la scène afin que toutes les ressources de maillage statique que vous créez apparaissent dans le menu des composants de maillage.
Une fois les entités en place, pensez à la séquence d'événements qui provoquent l'incendie de forêt, puis pensez aux noms des événements qui décrivent ce que fait l'événement. Ensuite, suivez le tutoriel Verse de la section Coder le comportement.
Conventions d'affectation de noms des événements de scène
Vous pouvez utiliser autant de caractères que nécessaire lorsque vous nommez un événement de scène. La nomenclature doit décrire votre événement et préciser son intention, par exemple damage_taken_event, health_power_up_event, etc.
Il existe deux événements majeurs dans la séquence des incendies de forêt :
Impact de foudre
Propagation du feu
Pour décrire ce que font ces événements, nommez l'événement de foudre struck_by_lightning_event et nommez l'événement de propagation du feu fire_propagation_event.
Séquence d'événements
Lorsque vous créez un événement de scène, considérez-le comme une interface ayant des effets à tous les niveaux d'une hiérarchie d'entités et de composants. Par ailleurs, étant donné que les événements de scène peuvent être utilisés par d'autres personnes, réfléchissez à la manière dont un autre développeur pourrait s'appuyer sur votre événement ou l'utiliser dans son propre graphique de scène.
L'événement de scène que vous créez va rendre compte des événements majeurs qui se produisent avant de lancer un autre événement lié à l'événement parent. La séquence d'événements est donc la suivante :
Un événement de scène se produit dans le monde appelé
struck_by_lightning_event.Les entités indiquent si elles ont été frappées par l'événement
struck_by_lightning_event. Les entités frappées par la foudre déclenchent l'événementfire_propagation_event.L'événement
fire_propagation_eventoblige d'autres entités à déterminer si elles sont suffisamment proches de l'événementfire_propagation_eventpour prendre également feu.L'événement
fire_propagation_eventse propage aux autres composants de maillage.
L'exécution de l'événement fire_propagation_event se poursuit jusqu'à ce que chaque composant de maillage ayant déterminé qu'il est suffisamment proche de l'événement fire_propagation_event ait pris feu. L'exécution de la scène doit ressembler à un véritable feu de forêt.
Développer une séquence
Alors que l'événement struck_by_lightning_event provoque l'événement fire_propagation_event, vous pouvez choisir de prolonger le jeu en ajoutant de nouveaux éléments qui propagent le feu. Par exemple, vous pouvez ajouter un événement explosive_event qui envoie un événement fire_propagation_event lorsqu'il explose.
Autre aspect intéressant des événements de scène : les entités qui gèrent l'événement fire_propagation_event n'ont pas besoin de connaître la cause de l'incendie ; elles sont uniquement tenues de déterminer si elles doivent ou non prendre feu. Cela facilite la maintenance du code pour deux raisons :
Un événement de scène se produit dans le monde appelé
struck_by_lightning_event.Il est plus facile de modifier le comportement de l'événement
struck_by_lightning_eventsans endommager les entités qui ne se soucient que de l'événementfire_propagation_event.Il est plus facile d'écrire un événement
explosive_event, car les objets inflammables ne se soucient que de l'événementfire_propagation_event.
Coder le comportement
Une fois le graphique de scène terminé avec toutes les entités nécessaires, utilisez le code ci-dessous pour créer un événement de scène qui commence par un impact de foudre, entraîne un départ de feu dans les arbres et provoque des dégâts d'incendie.
Assets.digest.verse recherche automatiquement les objets Verse pour les référencer dans la scène. Les effets de particules que vous avez créés sont référencés sous un module d'effets visuels.
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):
Étape 1 : Créer un composant de graphique de scène
Pour créer un événement de scène dans l'UEFN, ouvrez le menu Verse dans la barre de menus et sélectionnez l'Explorateur Verse dans le menu déroulant. Le panneau Explorateur Verse s'ouvre dans l'éditeur ; il contient la liste des fichiers Verse associés à votre projet.
Créez un nouveau fichier Verse en procédant comme suit :
Faites un clic droit sur le nom du projet en haut de la liste.
Sélectionnez Ajouter un nouveau fichier Verse au projet dans le menu déroulant. La fenêtre Créer un script Verse s'ouvre.
Sélectionnez le composant de graphique de scène dans la liste des fichiers Verse et nommez le fichier fire_event_component.
Cliquez sur Créer. Le fichier s'ouvre automatiquement dans Visual Studio Code (VS Code) et contient les API standard nécessaires à la création d'un nouveau comportement de composant.
Créez un nouveau composant de graphique de scène nommé fire_event_component.
Lorsque vous êtes prêt à tester votre script, ouvrez le menu Verse et sélectionnez Générer le code Verse dans le menu déroulant. Sélectionnez ensuite le bouton Verse pour exécuter votre code.
Étape 2 : Ajouter des bibliothèques Verse
Commencez votre événement de scène en créant la séquence d'événements et les conditions à l'origine de l'impact de foudre. Une fois l'événement de foudre défini, créez l'événement d'incendie de forêt en définissant les propriétés des dégâts causés par l'incendie, les protocoles de propagation de l'incendie et les protocoles d'extinction de l'incendie.
Ajoutez les bibliothèques suivantes à votre composant pour pouvoir utiliser les mathématiques spatiales pour l'emplacement de la foudre et du feu, créer une concurrence et d'autres fonctionnalités de Verse.
Verseusing { /Verse.org/SpatialMath } using { /Verse.org/Random } using { /Verse.org/Concurrency } using { /Verse.org/Simulation } using { /Verse.org/SceneGraph }
Étape 3 : Définir la classe d'événement de foudre
Cette classe d'événement détermine l'emplacement source de l'éclair, l'emplacement de l'impact de foudre et le rayon de dégâts de l'emplacement d'impact.
Créez une classe d'événement nommée,
strike_by_lightning_event := class(scene_event):. Cette classe définit les propriétés de l'événement de scène dans des expressions constantes qui décrivent où l'événement de foudre se produit dans la scène à l'aide d'un vecteur pour les informations d'emplacement et le rayon de dégâts de la foudre à l'aide d'une valeurfloat.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
Étape 4 : Créer un composant météorologique et ajouter des propriétés modifiables avec des variables
Utilisez des propriétés et des variables modifiables pour déterminer si la foudre apparaît dans la scène, les impacts de foudre aléatoires, le délai entre les impacts et le rayon de dégâts de la foudre.
Définissez le comportement de la foudre en ajoutant des propriétés
modifiablesà une classe de composant nomméelightning_weather_component := component ():. Indiquez les valeurs minimales et maximales dans les propriétés modifiables concernant le délai entre les impacts de foudre et le rayon de dégâts de ces impacts, en centimètres.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
Étape 5 : Définir l'événement de foudre
Faites appel à une méthode pour vérifier les effets visuels de la foudre et utilisez ses propriétés de rayon de début et de fin pour déterminer la distance entre les composants du maillage et les effets visuels, puis transmettez ces informations vers le haut et vers le bas de l'événement.
Créez une
méthodeconditionnelleOnSimulate.VerseOnSimulate<override>()<suspends>:void=Créez et ajoutez une
bouclequi lit et met en pause de manière aléatoire le composant de foudre à l'aide d'une constante faisant appel à des valeurs de temps de lecture minimales et maximales.Verseloop: # Sleep for a random delay before next lightning strike RandomDelay := GetRandomFloat(MinRandomLightningDelaySeconds, MaxRandomLightningDelaySeconds) Sleep(MaxRandomLightningDelaySecondsAjoutez une expression
ifqui utilise l'entité de simulation pour rechercher d'autres entités dans la simulation, car toutes les autres entités sont des enfants de l'entité de simulation. Il est ainsi possible de sélectionner une entité aléatoire qui subira l'impact de foudre, plutôt que d'utiliser la collision pour rechercher des entités dans la scène.Verse# Randomly hit an entity in the world with lightning if (SimEntity := Entity.GetSimulationEntity[]):Ensuite, le code doit spécifier la cible de la foudre.
Ajoutez une expression
thenqui transmet une demande pour devenir la cible de la foudre depuis l'entité de simulation. Ajoutez ensuite une expression conditionnelleifqui répond à cette transmission et oblige toutes les entités pouvant répondre à renvoyer un événement à l'entité de simulation. Vous devez alors rechercher la source de la foudre, car un émetteur de rayon utilise deux points pour déterminer le début et la fin du rayon.VerseLightningTargets := for (EntityWithLightning : SimEntity.FindDescendantEntitiesWithComponent(particle_system_component)): EntityWithLightning if: LightningTargets.Length > 0 RandomIndex := GetRandomInt(0, LightningTargets.Length - 1) RandomEntity := LightningTargets[RandomIndex]Appelez le composant
LightningVFXComponentà l'emplacement aléatoire à l'aide d'une instruction if. Ajoutez ensuite une expression then qui joue l'effet de particules dans l'emplacement défini pour les emplacements source et cible.L'entité
lightning_entityutilise Configuration de l'émetteur de rayon > Rayon de début pour lire l'événement de foudre à des points aléatoires dans le ciel. Le composantLightningVFXComponentutilise ensuite l'option Particule de rayon dans Configuration de l'émetteur de rayon > Fin du rayon pour déterminer l'emplacement de fin de la particule de rayon dans la scène. Le paramètre est défini sur Position de simulation, qui utilise les coordonnées de fin de l'effet de particules pourlightning_entity.Ensuite, créez et définissez les dégâts causés par l'événement
struck_by_lightning_eventà l'aide des données source et cible afin de localiser l'endroit où les dégâts se produisent sur la cible du composant de maillage à l'aide deDamageRadiuspour décrire la zone affectée par les dégâts de foudre. Cet événement sera ensuite envoyé à l'entité de simulation pour ajouter une durée de foudre aléatoire ; par conséquent, terminez la chaîne d'événements avecSimulationEntity.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
Étape 6 : Définir l'événement d'incendie
Créez des classes d'événements qui définissent le nombre de dégâts causés par l'incendie et qui déterminent si l'incendie doit se propager en fonction des dégâts causés dans la scène.
Créez deux classes. Une classe
fire_damage_eventet une classefire_propagation_eventqui vérifient le nombre de dégâts actuels et déclenchent la particule de feu lorsqueDamageAmountatteint le seuil 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.0Créez une classe
flammable_componentqui détermine qu'un maillage est inflammable et qui spécifie les propriétés modifiables pouvant être définies pour provoquer l'incendie des maillages de la scène.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.0Une variable conditionnelle est ajoutée à l'événement
flammable_event, qui détermine si les effets visuels d'incendie sont en cours de diffusion ou devraient l'être.Verse# Is it on fire? var IsOnFire:logic = falseUne fonction
IsCloseEnoughToBurningEntityToIgnitedétermine si l'incendie est suffisamment proche pour déclencher d'autres événements d'effets visuels d'incendie.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.FireRadiusCentimetersUne fonction
IsCloseEnoughToLightningToIgnitedétermine si la foudre était suffisamment proche du maillage pour que celui-ci prenne feu.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 fonction OnReceive indique quels maillages prennent feu une fois que la fonction IsCloseEnoughToBurningEntityToIgnite détermine la proximité de la propagation du feu, et la variable IsCloseEnoughToLightningToIgnite détermine la proximité de la foudre par rapport au maillage.
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() falseUne méthode
Igniteest utilisée pour déclencher l'effet automatiquement via une instruction conditionnelle if qui recherche le système de particules de feu. Une instructionthendétermine si le composant déclenche effectivement les effets visuels d'incendie.Ajoutez des tâches asynchrones à la méthode pour vérifier le système de particules de feu Fire_NS afin que le feu apparaisse et se propage lorsqu'il est appelé.
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
Étape 7 : Définir la fin de l'événement d'incendie
Vous allez ensuite créer une série de méthodes qui indiquent quand les composants maillage prennent feu et quand les flammes s'éteignent, qui déterminent les dégâts causés par un incendie et qui spécifient quand le feu se propage.
Créez maintenant une méthode
Extinguishqui arrête l'effet d'incendie ; pour cela, recherchez les composants déclenchant l'effet d'incendie à l'aide d'instructions conditionnelles afin d'identifier le système de particules de feu et de supprimer l'effet.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()Créez une méthode
OnFirefaisant appel à une boucle qui surveilleFireDamage, envoie l'événement dans la chaîne d'entités vers la fin de l'événement et provoque l'arrêt de la lecture de l'événement.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)Enfin, créez une méthode
FirePropagationqui utilise unebouclepour propager l'incendie dans la chaîne d'entités et l'éteindre lorsqu'il atteint l'entité de simulation.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)
Une fois le code terminé, compilez-le et ajoutez les entités appropriées au graphique de scène pour prendre en charge les effets de la foudre et des incendies de forêt. Ensuite, ajoutez le composant flammable_component aux entités de la scène qui doivent prendre feu. Vous devez avoir défini une entité de niveau supérieur sous l'entité de simulation avec le composant lightning_weather_component contrôlant la météo.
Une fois toutes les entités mises à jour avec les événements de scène appropriés, lancez une session de modification en direct pour savoir si votre code fonctionne dans la scène.
Résultat
Copiez-collez le code dans votre projet pour savoir si l'événement de scène fonctionne.
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