1. Epic GamesDeveloper
  3. シーン イベント

シーン イベント

シーン イベントを作成してコンポーネントの動作を変更し、シーンに興味深いイベントを追加する方法について学習します。

シーン イベント

この Scene Graph は、実験段階の機能です。 [Project Settings (プロジェクト設定)] でチェックボックスをオンにして、[Experimental Scene Graph Features (シーン グラフの実験的機能)] 設定を有効にし、Scene Graph 内のこれら実験的機能にアクセスします。

プロジェクトに Scene Graph の実験的機能が含まれている場合、クリエイター ポータルの検証プロセス中に検出されます 島の公開を制限するアセットに関する通知が届きます。 島を公開するには、[Project Settings] で実験的機能を無効にします。

[Project Settings] で [Experimental Scene Graph Features] を有効または無効にします。
[Project Settings] で [Experimental Scene Graph Features] を有効または無効にします。

Scene Graph には、すべてのエンティティとコンポーネントに組み込まれた、シーン イベントと呼ばれる、Scene Graph 内に単一のイベントまたは一連のイベントを作成する機能があります。 シーン イベントは、エンティティとコンポーネントの新しい動作をオーバーライドおよび定義することで、Scene Graph のさまざまな部分が相互に通信する方法を提供する通信プロトコルです。 

シーン イベントはプロジェクト間で再利用できます。追加のイベントを追加したり、一連のイベント内のエンティティとコンポーネントの動作を微調整したりして、少し異なる動作を行うことで、シーン イベントを拡張できます。

複数のコンポーネントがシーン イベントに応答し、イベントは Scene Graph 階層の上位または下位に送信できます。 これらは Scene Graph 上を渡るメッセージで、各コンポーネントにメッセージに応答する機会を与えるものである、と考えてください。 

たとえば、Scene Graph を使用して墓地を設定する場合、シーン イベントを使用すると、スタティックメッシュの墓地の門が開いたときに開始される一連のイベントを定義できます。 門が開くと、墓石の後ろから幽霊が飛び出すパーティクル エフェクトや不気味な音楽が流れ始めるといった一連の出来事を開始させることができます。 

墓地で複数回使用できるシーン イベントにすることもできます。または、シーン イベントの基本機能 (何らかのスタティックメッシュ ドアが開かれ、一連のイベントが発生する) を使用できるように、イベントを微調整することも可能です。

シーン イベントは、シーン グラフの各部分を互いに分離します。それにより、各部分が直接結合するのではなく、メッセージを介して通信できるようにします。

シーン イベントの仕組み

Verse は、Scene Graph 全体のイベントを特定のエンティティおよびコンポーネントにブロードキャストするために使用されます。 コンポーネントでシーン イベントを処理するには、コンポーネント内の既存の OnReceive(scene_event):logic 関数をオーバーライドします。 コンポーネントを通過するすべてのシーン イベントはこの関数を呼び出し、イベントに応答する方法を提供します。

シーン イベントは、scene_event インターフェースを実装する任意のクラスです。 シーン イベントは、SendUp、SendDown、SendDirect の 3 つの方法のいずれかで送信できます。

SendUp

SendUp を使うと、イベントは指定されたエンティティとその親エンティティに送信されます。 その後、親エンティティはさらに自分の親へとイベントを伝播させ、最終的にはすべてのエンティティの親であるシミュレーション エンティティに到達するまで伝わっていきます。

この仕組みでは、イベントを送った側 (送信元) は、どのエンティティがそのイベントを処理するか、あるいは誰も処理しないのかを知ることはできません。 このようなイベント送信は、テレメトリの送信、高レベルのシステムへのシグナル送信、または処理されるかどうかわからないようなリクエストの送信に適しています。

たとえば、キャラクターの足を剣で攻撃した場面を考えてみましょう。足はキャラクターの階層構造の深い位置にあります。 足や脚のエンティティがダメージイベントを処理しない場合、そのイベントはさらに上位のエンティティへと送られます。最終的にキャラクターのベースとなるエンティティに到達し、そこに配置された damage_receiever_component がイベントを受信し、ダメージ処理を行う仕組みです。 

以下の図では、階層内の「Parent」エンティティが 1 とラベルが付いたイベントを発生させた位置 (緑のエンティティ) であり、 SendUp の呼び出しはそこから始まり、最上位のシミュレーション エンティティへとイベントが伝播していきます。

シーン イベントが対象の親エンティティに送信される様子を示す SendUp を表す図。
シーン イベントが対象の親エンティティに送信される様子を示す SendUp を表す図。

SendDown

あるいは、シミュレーション エンティティを触媒として使用し、一連の変更をエンティティのツリーに送信することもできます。 SendDown は、対象のエンティティとそのすべての子にイベントを送信します。 そして、それぞれの子がそのイベントを自分の子に伝えます。

これは、グローバル イベントが発生し、シーン内のあらゆるものにそれに対応する機会を付与する必要がある場合に使用できます。

親エンティティがシーン イベントを送信する方法を示す図。
親エンティティがシーン イベントを送信する方法を示す図。

SendDirect

SendDirect は、イベントを対象のエンティティに直接送信しますが、親または子にイベントを渡しません。 これは、下の図に示すように、特定のエンティティまたはコンポーネントをターゲットにするために使用されます。

1 つのエンティティを対象とする直接送信イベントを示す図。
1 つのエンティティを対象とする直接送信イベントを示す図。

イベントを消費する

イベントがエンティティ階層の上または下に送信される場合、個々のコンポーネントがイベントに応答しないようにすることが可能です。 コンポーネントはイベントを完了としてマークし、そのイベントを子または親に送信しません。基本的にはオフスイッチとして機能します。

イベントを消費することで、イベントの影響の範囲を制御できます。 これは、2 つの方法で機能します。

  • イベントを、エンティティの子や親ではなく、1 つのエンティティのみに関連付けます。

  • 子エンティティや親エンティティに対して、関連するイベントを直接送信しないようにします。

イベントを子や親にそのまま送らないことで、そのイベントがそのエンティティの親や子にとってどのような意味を持つかを開発者が自由に決められるようになり、必要に応じて異なるイベントを手動で送ることができます。

たとえば、あるエンティティが SendDown によってダメージ イベントを受け取ったとします。 このとき、エンティティにアタッチされたコンポーネントが体力を減らす処理を行い、それ以上このイベントを子エンティティに伝播させない、という判断が可能です。子エンティティまでダメージ処理を行う必要がないからです。

一方で、もしそのエンティティの親階層にスコアリング システムが存在する場合は、ダメージの情報を親に伝えて、プレイヤーにスコア (例：メダル) を与える必要があります。 このような場合、受け取ったエンティティから SendUp を使って、スコア情報を含む特別なイベントを親のコンポーネントに送信することで、適切なスコアリング処理が行えます。

SendUp と SendDown 中のイベントを使用する

コンポーネントの OnReceive(SceneEvent:scene_event):logic 実装から true を返すことにより、SendUp または SendDown によってトリガーされたイベント伝播中にイベントを消費できます。

SendUp の際に、あるエンティティ上のいずれかのコンポーネントがイベントを消費するとしても、そのエンティティに属するすべてのコンポーネントは、それぞれの OnRecieve コールバックを実行します。 ただし、その後はイベントの伝播が止まり、親エンティティには渡されません。

同様に、SendDown の場合でも、いずれかのコンポーネントがイベントを消費しても、同一エンティティ内のすべてのコンポーネントは OnRecieve を実行します。 ただし、イベントはその子エンティティへは伝わりません。 ただし、同じ階層にいる他のエンティティには引き続きイベントが伝わります。

下の図を見ればわかるように、シーン イベント 4 はイベント チェーンに沿って伝播していますが、シーン イベント 3 はある地点で伝播が停止しているのがわかります。

SendDown イベントを消費するイベントを示す図。
SendDown イベントを消費するイベントを示す図。

シーン イベントを作成する

シーン イベントを作成する前に、いくつかの初期設定とシーケンス作業を行う必要があります。 まず、以下に示すアセットを作成し、それらを使用してメッシュ コンポーネントに木を配置し、パーティクル エフェクトに適切なエフェクトを設定してください。  パーティクル エフェクトのアセットを保存すると、それらは自動的に「Assets.digest.verse」という Verse ファイルに保存され、Verse オブジェクトとしてコード内で参照できるようになります。

  1. ライトニング ボルト VFX

    次に、雷のエフェクトがエンティティの上空のランダムな位置から始まり、地面上のシーン グラフ エンティティで終わるようにするには、以下のようにライトニング ボルト VFX を修正します。

    • [Beam Emitter Setup (ビーム エミッタ設定)] > [Beam Start (ビーム開始)] を [Add Vector to Position (位置に追加ベクトル)] に設定し、[Position (位置)] を [SimulationPosition] に設定し、[Vector (ベクトル)] を [Random Range Vector (ランダム範囲ベクトル)] に設定し、[Minimum (最小値)] を (-200.0,-200.0,1000)、[Maximum (最大値)] は (200.0,200.0, 2000.0) に設定します。

    • [Beam Emitter Setup] > [Beam End (ビーム終了)] を [SimulationPosition] に設定します。

    これで、雷はエンティティの上空のどこかから始まり、particle_system_component がアタッチされているエンティティで終わるようになります。

  2. 火の VFX

  3. スタティックメッシュの木と草

      モデリング モードを使用して独自の木をモデル化します。

これらのアセットをエンティティに追加し、雷が落ちる可能性のある Scene Graph 全体に複数のライトニング ターゲット エンティティを配置します。 これらのライトニング ターゲット エンティティにはそれぞれ、シーン イベントで定義した指示を受け取る準備ができている雷の particle_system_component があります。 追加設定は必要ありません。

エンティティはプレハブ内にネストすることも、完全に分離してシーン内に分散させることもできます。

シーン内のすべてのカスタム アセットの例。
シーン内のすべてのカスタム アセットの例。

UE スターター コンテンツ パックからアセットを移行して火の VFX を作成するか、UE で雷および火の VFX を作成し、それらのアセットを UEFN プロジェクトに移行することができます。

エンティティをシーンに追加する前にすべてのアセットを作成します。こうすることで、作成したすべてのスタティックメッシュ アセットがメッシュ コンポーネント メニューに表示されます。

エンティティを配置したら、森林火災を引き起こす一連のイベントについて考え、次にイベントが何を行っているかを説明するイベントの名前を考えます。 その後は、動作のコーディング セクションの Verse チュートリアルに従ってください。 

シーン イベントの命名規則

シーン イベントに名前を付けるときには、必要な数の文字を使用できます。 命名規則はイベントを説明し、イベントの意図を明確にする必要があります (例：damage_taken_event、health_power_up_event)。

森林火災の一連のイベントには、2 つの大きなイベントがあります。

  • 雷撃

  • 火災の拡大

これらのイベントの動作を説明するために、雷イベントに「struck_by_lightning_event」という名前を付け、火災延焼イベントに「fire_propagation_event」という名前を付けます。

イベントの順序

シーン イベントを作成するときは、それをエンティティとコンポーネントの階層の上下に影響を及ぼすインターフェースとして見てください。 また、シーン イベントは他の人が使用できることから、他の開発者がイベントを基にしてビルドしたり、独自の Scene Graph でイベントを使用したりする方法についても検討してみてください。

ビルドしているシーン イベントは、親イベントに関連する別のイベントを開始する前に発生する主要なイベントを報告します。 したがって、イベントの順序は次のようになります。

  1. ワールド内で「struck_by_lightning_event」と呼ばれるシーン イベントが発生します。

  2. エンティティは、「struck_by_lightning_event」に当たったかどうかを報告します。 雷に打たれたエンティティは「fire_propagation_event」をトリガーします。

  3. 「fire_propagation_event」により、他のエンティティも「fire_propagation_event」に十分近いかどうかが判断され、同様に火が移ります。

  4. 「fire_propagation_event」が他のメッシュコンポーネントに伝播している

「fire_propagation_event」は、「fire_propagation_event」に十分近いと判断したすべてのメッシュ コンポーネントに火が付くまで実行され続けます。 シーン内で実行すると、実際の森林火災のように見えるはずです。

シーン イベントの失敗フローと成功フローを示す図。
シーン イベントの失敗フローと成功フローを示す図。

シーケンスを拡張する

「struck_by_lightning_event」は「fire_propagation_event」を引き起こしますが、火を伝播させる新しいものを追加してゲームを拡張することもできます。 たとえば、爆発すると「fire_propagation_event」を送信する「explosive_event」を追加したりできます。

シーン イベントに関して興味深い点のひとつは、たとえば「fire_propagation_event」を処理するエンティティは、「火の原因が何か」を知る必要がないということです。重要なのは、「何らかの理由で自分が燃えている (または燃えるべきか) を判断する必要がある」という状態にあることだけです。 この設計により、コードの保守性が高まる理由は主に 2 つあります。

  • ワールド内で「struck_by_lightning_event」と呼ばれるシーン イベントが発生します。

    1 つ目は、「struck_by_lightning_event 」の挙動を変更しても、「fire_propagation_event」だけを気にしているエンティティには影響を与えずに済むため、安心して修正できるようになるためです。

  • 2 つ目は、「explosive_event」のような新しいイベントを実装する際も簡単です。燃えやすいオブジェクトは「fire_propagation_event」だけに反応すればよいため、それ以外のイベントの詳細を考慮する必要がないためです。

動作のコーディング

Scene Graph に必要なエンティティがすべて完成したら、以下のコードを使用して、雷撃で始まり木に火が出て火災が発生し、火災による被害を引き起こすシーン イベントを作成します。

「Assets.digest.verse」は、シーン内で Verse オブジェクトを参照するためにそれらを自動的に検索します。 作成したパーティクル エフェクトは、VFX モジュールで参照されます。

Verse 
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):

ステップ 1：Scene Graph コンポーネントを作成する

UEFN でシーン イベントを作成するには、メニュー バーから Verse メニューを開き、ドロップダウン メニューから Verse Explorer を選択します。 エディタで Verse Explorer パネルが開き、プロジェクトに関連付けられた Verse ファイルのリストが表示されます。

次の手順に従って、新しい Verse ファイルを作成します。

  1. リストの上部にあるプロジェクト名を右クリックします。

  2. ドロップダウン メニューから [Add new Verse file to project (新規 Verse ファイルをプロジェクトに追加する)] を選択します。 [Create Verse Script (Verse スクリプトを作成)] ウィンドウが開きます。

  3. Verse ファイルのリストから [Scene Graph Component] を選択し、ファイルに「fire_event_component」という名前を付けます。

  4. [Create (作成)] をクリックします。 ファイルは Visual Studio Code (VS Code) で自動的に開き、新しいコンポーネントの動作を作成するために必要な定型 API が含まれています。

    「fire_event_component」という名前の新しい Scene Graph コンポーネントを作成します。
    「fire_event_component」という名前の新しい Scene Graph コンポーネントを作成します。

スクリプトをテストする準備ができたら、Verse メニューを開き、ドロップダウン メニューから [Build Verse Code (Verse コードをビルド)] を選択します。 その後、[Verse] ボタンを選択してコードを実行します。

ステップ 2：Verse ライブラリを追加する

シーン イベントを開始するには、まず、雷撃が発生する一連のイベントと条件をビルドします。 雷イベントを定義した後、火災による被害、延焼プロトコル、消火プロトコルのプロパティを定義して、森林火災イベントをビルドします。

  1. コンポーネントに次のライブラリを追加して、雷と火の位置の空間計算、同時実行の作成、その他の Verse 機能の使用を確実に行えるようにします。

    Verse 
    using { /Verse.org/SpatialMath }
using { /Verse.org/Random }
using { /Verse.org/Concurrency }
using { /Verse.org/Simulation }
using { /Verse.org/SceneGraph }

ステップ 3：雷イベント クラスを定義する

このイベント クラスは、雷の発生場所、雷のヒット場所、ヒット場所の DamageRadius を決定します。

  1. 「struck_by_lightning_event := class(scene_event):」という名前のイベント クラスを作成します。 このクラスは、位置情報のベクトルを使用してシーン内で雷撃イベントが発生した場所を記述し、浮動小数値を使用して雷撃の被害半径を記述する定数式でシーン イベントのプロパティを定義します。

    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

ステップ 4：天気コンポーネントを作成し、変数を使用して編集可能なプロパティを追加する

編集可能なプロパティと変数を使用して、シーンに雷が表示されるかどうか、ランダムな雷撃、雷撃の間隔、雷撃のダメージ半径を設定します。

  1. 「lightning_weather_component := component ():」という名前のコンポーネント クラスに編集可能なプロパティを追加して、雷の動作を定義します。 編集可能なプロパティで、雷撃の間隔と雷撃による被害半径 (センチメートル単位) の最小値と最大値を指定します。

    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

ステップ 5：雷イベントを定義する

雷の VFX をチェックするメソッドを使用し、その開始ビームと終了ビームのプロパティを使用してメッシュ コンポーネントが VFX にどれだけ近いかを判断し、この情報をイベントの上下にブロードキャストします。

  1. OnSimulate 条件メソッドを作成します。

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

  2. 再生時間の最小および最大遅延値を使用する定数を使用して、雷コンポーネントをランダムに再生および休止するループを作成して追加します。

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

  3. 他のすべてのエンティティはシミュレーション エンティティの子であるため、シミュレーション エンティティを使用してシミュレーション内の他のエンティティを検索する if 式を追加します。 この方法により、コリジョンを使用してシーン内のエンティティを見つけるのではなく、ランダムなエンティティを選択して雷を打つことができます。

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

    次に、コードで雷が当たるターゲットを指定する必要があります。

  4. SimEntity から雷のターゲットとなるリクエストをブロードキャストする then 式を追加します。 次に、このブロードキャストに応答し、応答できるすべてのエンティティが SimEntity にイベントを送り返すようにする条件付き if 式を追加します。 次に、ビーム エミッタはビームの開始と終了に 2 点の位置を使用するため、雷の発生源を見つける必要があります。

    Verse 
                   LightningTargets := for (EntityWithLightning : SimEntity.FindDescendantEntitiesWithComponent(particle_system_component)):
                    EntityWithLightning

                if:
                    LightningTargets.Length > 0
                    RandomIndex := GetRandomInt(0, LightningTargets.Length - 1)
                    RandomEntity := LightningTargets[RandomIndex]

  5. if ステートメントを使用して、LightningVFXComponent をランダムな場所に呼び出します。 次に、ソースとターゲットの場所に設定された場所でビーム パーティクル エフェクトを再生する then 式を追加します。

    lightning_entity は、[Beam Emitter Setup (ビーム エミッタ セットアップ)] > [Beam Start (ビーム開始)] を使用して、空のランダムなポイントで雷イベントを再生します。 LightningVFXComponent は、  ビーム パーティクル オプションを使用しており、その中の [Beam Emitter Setup] > [Beam End] の設定によって、シーン内でビーム パーティクルの終点を決定します。 設定は、lightning_entity のパーティクル エフェクトの終了座標を使用するシミュレーション位置にセットされます。   

    その後、ソース データとターゲット データを使用して struck_by_lightning_event によるダメージを作成および定義し、メッシュ コンポーネント ターゲット上でダメージが発生した場所を特定し、DamageRadius を使用して雷によるダメージの影響を受ける領域を記述します。 このイベントはシミュレーション エンティティに送信され、ランダムな雷の持続時間が追加されます。そのため、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

ステップ 6：火災イベントを定義する

火災によって発生する損害の量と、シーン内の火災による損害に基づいて火災が広がるかどうかを定義するイベント クラスを作成します。

  1. 2 つのクラスを作成します。 実行中の DamageAmount をチェックし、DamageAmount が float しきい値に達したときに火のパーティクルを再生する fire_damage_event クラスと fire_propagation_event クラス。

    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

  2. メッシュが可燃性であることを決定する flammable_component クラスと、シーン内のメッシュに火をつけるために設定できる編集可能なプロパティを作成します。

    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

  3. flammable_event に条件変数が追加され、火の VFX が再生されているか、再生されるべきかが決定されます。

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

  4. IsCloseEnoughToBurningEntityToIgnite 関数は、火がさらに火 VFX イベントをトリガーするのに十分近いかどうかを判断します。

    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

  5. IsCloseEnoughToLightningToIgnite 関数は、雷撃がメッシュに十分近かったためにメッシュが炎上したかどうかを判断します。

    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

  6. OnRecieve 関数は、IsCloseEnoughToBurningEntityToIgnite 関数が火の伝播の近さを判定すると、どのメッシュが発火するかを判定し、IsCloseEnoughToLightningToIgnite 変数はメッシュへの雷撃の近さを判定します。

    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

  7. Ignite メソッドは、火のパーティクル システムを検索する条件付き if ステートメントを通じてエフェクトを自動的に再生するために使用されます。 then ステートメントは、コンポーネントが火の VFX を再生しているかどうかを定義します。 

    呼び出されたときに火が生成されて広がるように、火のパーティクル システム Fire_NS をチェックする非同期タスクをメソッドに追加します。

    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

ステップ 7：火災イベントの終了を定義する

次に、メッシュ コンポーネントがいつ炎上するか、いつ火炎が消えるか、火災による損害はどの程度か、いつ火が広がるかなどを決定する一連のメソッドを作成します。

  1. 次に、条件文を使用して火のエフェクトを再生しているコンポーネントを検索し、火のパーティクル システムを見つけてエフェクトを削除することで、火のエフェクトを停止する Extinguish メソッドを作成します。

    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()

  2. FireDamage を監視し、イベントをエンティティのチェーンに沿ってイベントの終わりまで送信し、イベントの再生を停止するループを使用する OnFire メソッドを作成します。

    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)

  3. 最後に、ループを使用してエンティティのチェーンに沿って火を広げ、シミュレーション エンティティに到達したときに消火する FirePropagation メソッドを作成します。

    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)

コードが完成したら、コードをコンパイルし、適切なエンティティをシーン グラフに追加して、雷撃や森林火災のエフェクトをサポートします。 その後、シーン内の発火するエンティティに flammable_component を追加します。 シミュレーション エンティティの下に、天候を制御する lightning_weather_component を持つトップレベルのエンティティが必要です。

すべてのエンティティが適切なシーン イベントで更新されたら、ライブ編集セッションを起動して、シーンでコードが動作していることを確認します。

結果

コードをコピーしてプロジェクトに貼り付け、シーン イベントが機能していることを確認します。

lightning.verse

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

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

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page