３Ｄレールガンシューティング　発展６

　前回の手順で作成した分岐用ポップアップウインドウを利用し、経路の分岐処理の実装を行います。

＜実装動画＞

発展６ー経路分岐機能ー

＜学習内容＞

　・タプル型の実装例

設計

　複数のスクリプトを修正して、経路分岐機能を設計し、実装を行います。

　作成した分岐用ポップアップウインドウをどのスクリプトが管理すればいいのか、
表示されたポップアップウインドウ内のボタンにはどのような情報があれば分岐の処理として機能するのか、
そういった部分に着目して処理の設計を検討します。

　分岐先のボタンについては、経路のない方向のボタンはプレイヤーを混乱させる原因になるため表示させない方がいいでしょう。

　ここでもやはり、自分がユーザーの目線や立場に立って、遊びやすいポップアップウインドウになるように考えていく必要があります。

UIManager スクリプトを修正する

　表示された分岐用ポップアップウインドウ内にボタンを生成し、ボタンに役割(どの方向に分岐する)のかを与えます。
分岐に利用するボタン用のゲームオブジェクトのプレファブは１つしかありませんが、このゲームオブジェクトにはスクリプトがアタッチされていますので、
このスクリプトに「方向」の情報を与えることにより、同じゲームオブジェクトではありますが、異なる分岐のボタンとして振る舞わせることが出来ます。

UIManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class UIManager : MonoBehaviour {

    [SerializeField]
    private Transform lifeTran;

    [SerializeField]
    private GameObject lifePrefab;

    [SerializeField]
    private List<GameObject> lifesList = new List<GameObject>();

    [SerializeField]
    private GameObject playerInfoSet;


    ////*  新しい変数の宣言を７つ追加  *////


    [SerializeField]
    private SubmitBranchButton submitBranchButtonPrefab;

    [SerializeField]
    private List<SubmitBranchButton> submitBranchButtonsList = new List<SubmitBranchButton>();

    [SerializeField]
    private Transform rightBranchTran;

    [SerializeField]
    private Transform leftBranchTran;

    [SerializeField]
    private Transform centerBranchTran;

    [SerializeField]
    private bool isSubmitBranch;

    private BranchDirectionType chooseBranchDirectionType;


    ////*  ここまで  *////


    /// <summary>
    /// プレイヤー用のUI設定(ライフ用アイコンの生成など)
    /// </summary>
    /// <param name="maxHp"></param>
    public void SetPlayerInfo(int maxHp) {

        StartCoroutine(GenerateLife(maxHp));

        // TODO 弾数の最大値を設定

    }

    /// <summary>
    /// ライフ用アイコンのゲームオブジェクトを生成
    /// </summary>
    /// <param name="lifeCount"></param>
    /// <returns></returns>
    public IEnumerator GenerateLife(int lifeCount) {

        for (int i = 0; i < lifeCount; i++) {

            yield return new WaitForSeconds(0.25f);
            lifesList.Add(Instantiate(lifePrefab, lifeTran, false));
        }
    }

    /// <summary>
    /// ライフ用アイコンの再表示
    /// </summary>
    /// <param name="amout"></param>
    public void UpdateDisplayLife(int amount) {

        for (int i = 0; i < lifesList.Count; i++) {

            if (i < amount) {
                lifesList[i].SetActive(true);
            } else {
                lifesList[i].SetActive(false);
            }
        }
    }


    ////*  新しくメソッドを３つ追加  *////


    /// <summary>
    /// 分岐ボタンの生成
    /// </summary>
    /// <param name="branchDirectionTypes"></param>
    public void GenerateBranchButtons(BranchDirectionType[] branchDirectionTypes) {
        isSubmitBranch = false;
        Debug.Log("分岐のボタン作成");

        // 分岐の数だけボタンを生成
        for (int i = 0; i < branchDirectionTypes.Length; i++) {

            // ボタンの生成位置を設定
            Transform branchTran = BranchDirectionType.Right == branchDirectionTypes[i] ? rightBranchTran : BranchDirectionType.Left == branchDirectionTypes[i] ? leftBranchTran : centerBranchTran;

            // ボタン生成
            SubmitBranchButton submitBranchButton = Instantiate(submitBranchButtonPrefab, branchTran, false);

            // ボタン設定
            submitBranchButton.SetUpSubmitBranchButton(branchDirectionTypes[i], this);

            // List に追加
            submitBranchButtonsList.Add(submitBranchButton);
        }
    }

    /// <summary>
    /// 分岐先の決定
    /// </summary>
    /// <param name="branchDirectionType"></param>
    public void SubmitBranch(BranchDirectionType branchDirectionType) {
        for (int i = 0; i < submitBranchButtonsList.Count; i++) {
            // 分岐のボタンを非活性化して重複タップを防止
            submitBranchButtonsList[i].InactivateSubmitButton();
            Destroy(submitBranchButtonsList[i].gameObject);
        }
        submitBranchButtonsList.Clear();

        chooseBranchDirectionType = branchDirectionType;
        isSubmitBranch = true;
    }

    /// <summary>
    /// 分岐情報の取得
    /// </summary>
    /// <returns></returns>
    public (bool, BranchDirectionType) GetSubmitBranch() {
        return (isSubmitBranch, chooseBranchDirectionType);
    }


    ////*  ここまで  *////


}

　スクリプトが完成したらセーブします。

　最後に追加したメソッドの戻り値はタプル型で記述されています。
こちらは後程、利用例を交えて説明します。

UIManager ゲームオブジェクトの設定を行う

　インスペクターを確認し、新しく追加した変数に必要な情報をアサインして登録します。
どの情報が必要になるか、自分で考えてアサインしてみてください。

インスペクター画像

　以上で設定は完了です。

GameManager スクリプトを修正する

　TODO で用意しておいた分岐の処理を実装します。

　分岐の発生するタイミングで UIManager スクリプトに用意した分岐の矢印を生成するメソッドへ命令を出す必要があるため、
新しい変数を追加しています。

GameManager.cs

<= クリックすると開きます。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameManager : MonoBehaviour {

    [SerializeField]
    private RailMoveController railMoveController;

    [SerializeField, Header("経路用のパス群の元データ")]
    private RailPathData originRailPathData;                      // 後程 List 化して複数のルートを管理できるようにします

    [SerializeField, Header("パスにおけるミッションの発生有無")]  // Debug 用
    private bool[] isMissionTriggers;

    [SerializeField]
    private PlayerController playerController;

    [SerializeField]
    private EventGenerator eventGenerator;

    [SerializeField, Header("ミッションで発生している敵のリスト")]
    private List<EnemyController> enemiesList = new List<EnemyController>();

    private int currentMissionDuration;

    [Header("現在のゲームの進行状態")]
    public GameState currentGameState;

    [SerializeField]
    private WeaponEventInfo weaponEventInfo;


    ////*  ここから変数の宣言を１つ追加  *////


    [SerializeField]
    private UIManager uiManager;


    ////*  ここまで  *////


    private IEnumerator Start() {

        // ゲームの状態を準備中にする
        currentGameState = GameState.Wait;

        // ルート用の経路情報を設定
        originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(0, BranchDirectionType.NoBranch);

        // イベント生成機能の準備
        eventGenerator.SetUpEventGenerator(this, playerController);

        // 初期武器登録
        GameData.instance.AddWeaponData(DataBaseManager.instance.GetWeaponData(0));

        // 武器取得イベント用の設定
        weaponEventInfo.InitializeWeaponEventInfo();

        // 初期武器設定
        playerController.ChangeBulletData(GameData.instance.weaponDatasList[0]);

        // RailMoveController の初期設定
        railMoveController.SetUpRailMoveController(this);

        // パスデータよりミッションの発生有無情報取得
        SetMissionTriggers();

        // 次に再生するレール移動の目的地と経路のパスを設定
        railMoveController.SetNextRailPathData(originRailPathData);

        // 経路の準備が完了するのを待つ
        yield return new WaitUntil(() => railMoveController.GetMoveSetting());

        // ゲームの状態をプレイ中に変更する
        currentGameState = GameState.Play_Move;
    }

    /// <summary>
    /// パスデータよりミッションの発生有無情報取得
    /// </summary>
    private void SetMissionTriggers() {

        // 配列の初期化
        isMissionTriggers = new bool[originRailPathData.GetIsMissionTriggers().Length];

        // ミッション発生有無の情報を登録
        isMissionTriggers = originRailPathData.GetIsMissionTriggers();
    }

    /// <summary>
    /// ミッションの発生有無の判定
    /// </summary>
    /// <param name="index"></param>
    public void CheckMissionTrigger(int index) {

        if (isMissionTriggers[index]) {

            // ミッション発生
            PreparateMission(originRailPathData.pathDataDetails[index].missionEventDetail);

            Debug.Log("ミッション発生");

        } else {
            // ミッションなし。次のパスへ移動を再開
            railMoveController.CountUp();
        }
    }

    /// <summary>
    /// ミッションの準備
    /// </summary>
    /// <param name="missionEventDetail"></param>
    private void PreparateMission(MissionEventDetail missionEventDetail) {

        // ミッションの時間設定
        currentMissionDuration = missionEventDetail.missionDuration;

        // 武器取得イベントか判定
        if (missionEventDetail.eventTypes[0] == EventType.Weapon) {
            // 武器の情報を取得してセット
            weaponEventInfo.SetWeaponData(DataBaseManager.instance.GetWeaponData(missionEventDetail.eventNos[0]));
            weaponEventInfo.Show();
        } else {

            // ミッション内の各イベントの生成(敵、ギミック、トラップ、アイテムなどを生成)
            eventGenerator.PrepareGenerateEnemies(missionEventDetail.enemyPrefabs, missionEventDetail.eventTrans);
        }

        // ミッション開始
        StartCoroutine(StartMission(missionEventDetail.clearConditionsType));
    }

    /// <summary>
    /// ミッション開始
    /// </summary>
    /// <param name="clearConditionsType"></param>
    /// <returns></returns>
    private IEnumerator StartMission(ClearConditionsType clearConditionsType) {

        // ゲームの進行状態をミッション中に変更
        currentGameState = GameState.Play_Mission;

        // ミッションの監視
        yield return StartCoroutine(ObservateMission(clearConditionsType));

        // ミッション終了
        EndMission();
    }

    /// <summary>
    /// ミッションの監視
    /// 各イベントの状態を監視
    /// </summary>
    /// <param name="clearConditionsType"></param>
    /// <returns></returns>
    private IEnumerator ObservateMission(ClearConditionsType clearConditionsType) {

        // クリア条件を満たすまで監視(currentMissionDuration 変数には、敵の数か、残り時間が入る)
        while (currentMissionDuration > 0) {

            // クリア条件が時間経過の場合
            if (clearConditionsType == ClearConditionsType.TimeUp) {

                // カウントダウン
                currentMissionDuration--;
            }

            // 武器取得イベントかつ、武器選択のいずれかのボタンを押したら
            if (weaponEventInfo.gameObject.activeSelf && weaponEventInfo.isChooseWeapon) {
                // イベント終了
                currentMissionDuration = 0;

                weaponEventInfo.Hide();

                Debug.Log("武器取得イベント終了");
                yield break;
            }
            yield return null;
        }
        Debug.Log("ミッション終了");
    }

    /// <summary>
    /// ミッション終了
    /// </summary>
    public void EndMission() {

        // 武器の取得イベントの場合には武器を取得せずにポップアップを閉じる
        if (weaponEventInfo.gameObject.activeSelf) {
            weaponEventInfo.Hide();
        }

        // 今回分の敵の情報をクリア
        ClearEnemiesList();

        // ゲームの進行状態を移動中に変更
        currentGameState = GameState.Play_Move;

        // カメラの移動再開
        railMoveController.CountUp();
    }

    /// <summary>
    /// 敵の List をクリア
    /// </summary>
    private void ClearEnemiesList() {
        if (enemiesList.Count > 0) {
            for (int i = 0; i < enemiesList.Count; i++) {
                Destroy(enemiesList[i]);
            }
        }

        enemiesList.Clear();
    }

    /// <summary>
    /// 敵の情報を List から削除し、ミッション内の敵の残数を減らす
    /// </summary>
    /// <param name="enemy"></param>
    public void RemoveEnemyList(EnemyController enemy) {

        currentMissionDuration--;

        enemiesList.Remove(enemy);
    }

    /// <summary>
    /// 敵の情報をリストに追加
    /// </summary>
    /// <param name="enemy"></param>
    public void AddEnemyList(EnemyController enemy) {
        enemiesList.Add(enemy);
    }

    /// <summary>
    /// ルートの分岐確認の準備
    /// </summary>
    /// <param name="nextbranchNo">moveCount</param>
    public void PreparateCheckNextBranch(int nextbranchNo) {

        StartCoroutine(CheckNextBranch(nextbranchNo));

    }
    /// <summary>
    /// ルートの分岐判定
    /// </summary>
    /// <param name="nextStagePathDataNo"></param>
    /// <returns></returns>
    private IEnumerator CheckNextBranch(int nextStagePathDataNo) {
        if (nextStagePathDataNo >= DataBaseManager.instance.GetStagePathDetasListCount()) {
            // 終了
            Debug.Log("ゲーム終了");

            yield break;
        }

        // ルートに分岐があるかどうかの判定
        if (DataBaseManager.instance.GetBranchDatasListCount(nextStagePathDataNo) == 1) {

            Debug.Log("分岐なしで次のルートへ");

            // 分岐なしの場合、次の経路を登録
            originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(nextStagePathDataNo, BranchDirectionType.NoBranch);
        } else {
            // 分岐がある場合、UI に分岐を表示し、選択を待つ

            Debug.Log("ルートの分岐発生");


            ////*　TODO の実装　*////


            // 分岐がある場合、分岐イベントを発生させて、画面上に矢印のボタンを表示
            uiManager.GenerateBranchButtons(DataBaseManager.instance.GetBranchDirectionTypes(nextStagePathDataNo));

            // 分岐を選択するまで待機(while でもOK)
            yield return new WaitUntil(() => uiManager.GetSubmitBranch().Item1 == true);

            // 選択した分岐のルートを設定
            originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(nextStagePathDataNo, uiManager.GetSubmitBranch().Item2);


            ////*　ここまで　*////


        }

        // ルート内のミッション情報を設定
        SetMissionTriggers();

        // 経路を移動先に設定
        railMoveController.SetNextRailPathData(originRailPathData);

        // レール移動の経路と移動登録が完了するまで待機
        yield return new WaitUntil(() => railMoveController.GetMoveSetting());

        // ゲームの進行状態を移動中に変更する
        currentGameState = GameState.Play_Move;
    }
}

　スクリプトを修正したらセーブします。

＜タプル型の実装例＞

　タプル(tuple)型は C# の持つ機能の１つです。複数のオブジェクトのデータをひとまとめにして管理することができます。
また、戻り値として利用する場合には、複数のオブジェクトのデータを同じようにまとめて戻してくれることが出来ます。

　タプル型の宣言の書式は複数ありますので、それぞれ紹介します。今回は②の書式で実装しています。

＜記述例①＞

(int, bool) damage = (0, false);

(Sprite, MoveTimeScale) nextTimeScaleValue;

上記の例の場合、damage 変数や nextTimeScaleValue 変数には、２つの型の情報が含まれていることになります。
より丁寧に書く場合には、今回のように、通常の変数のように型に対して宣言も可能です。
出来るだけタプル内のオブジェクトの型にも変数の宣言をつけて利用することをおすすめします。

＜記述例②＞

(int value, bool isWeakness) = (0, false);

(Sprite nextSprite, MoveTimeScale nextMoveTimeScaleType);

＜記述例③＞

(int value, bool isWeakness) damage = (0, false);

(Sprite nextSprite, MoveTimeScale nextMoveTimeScaleType) nextTimeScaleValue;

　タプル型の情報を扱う場合、タプル内のオブジェクトに対して 変数の宣言を行っているか、いないかによって、参照する場合の記述が変わります 。

　記述例①のように、タプル内で型のみしか宣言していない場合には、タプル内の情報は Item1、Item2 というように自動的に採番されます。
その場合は、「タプルの変数名.タプル内のオブジェクトの宣言順のItemの番号」の書式で記述できます。

＜記述例①の場合の参照例＞

Hoge(damage.Item1);  // int 型の引数を参照して渡しています

Hpge(nextTimeScaleValue.Item2)

変数の宣言を行っている場合には、通常の変数のように「タプルの変数名.タプル内のオブジェクトの変数名」の書式で記述できます。
そのため、タプルの変数名から、値の推測が可能です。

＜記述例②の場合の参照例＞

Hoge(damage.value);  // int 型の引数を参照して渡しています

Hoge(nextTimeScaleValue.nextSprite);   // Sprite 型の引数を参照して渡しています

Item1、Item2 でも処理は動きますが、プログラムは処理を見て、誰でもすぐに内容が理解できる設計が理想です。
なるべく変数名をつけてタプルの宣言をした方がいいというのは、このようにプログラムの可読性に関わるためです。
damage.Item1 よりも、damage.value の方が、変数名だけ見てもどのような値が代入されているか判断がつきやすいので、処理を読み解きやすいということです。

　今回の実装では、メソッドの戻り値としてタプル型を利用し、２つの型の情報を戻す処理を実装しています。
この値を受け取る側では、同じ内容のタプル型を準備しておくことにより、戻り値の情報を２つまとめて受け取れるようにしています。

UIManager.cs

    /// <summary>
    /// 分岐情報の取得
    /// </summary>
    /// <returns></returns>
    public (bool, BranchDirectionType) GetSubmitBranch() {
    return (isSubmitBranch, chooseBranchDirectionType);
}

GameManager.cs
＜戻り値のあるメソッドを実行する側＞

// 分岐を選択するまで待機(while でもOK)
yield return new WaitUntil(() => uiManager.GetSubmitBranch().Item1 == true);

// 選択した分岐のルートを設定
originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(nextStagePathDataNo, uiManager.GetSubmitBranch().Item2);

　２つの命令文で uiManager.GetSubmitBranch() メソッドを実行し、それぞれ異なる型の情報をタプル型の戻りの中から取得しています。
Item1 の方は bool 型、Item2 の方は BranchDirectionType 型になります。

　この処理の中で登場する WaitUntil クラスは以前の手順で学習済です。(手順１７に実装と解説があります。)
処理をしっかりと読み解けるように、この機会に復習しておいてください。

　なお、タプルも入れ子を作ることができます。通常であれば２つの型ですが、この機能を使えば複数の情報を持たせることが出来ます。

＜入れ子になっているタプル＞

(int x, (string a, int b) y) tuple = (0, ("String", 100));

参考サイト

MicroSoft C#リファレンス
タプル型
https://docs.microsoft.com/ja-jp/dotnet/csharp/lan...

GameManager ゲームオブジェクトの設定を行う

　インスペクターを確認し、新しく追加した変数に UIManager ゲームオブジェクトをドラッグアンドドロップしてアサインして
UIManager スクリプトの情報を登録します。

インスペクター画像

　以上で設定は完了です。

RayController スクリプトを修正する

　分岐用ポップアップウインドウが開いている間は、画面のタップの制御を行い、弾を発射する処理を一時停止するようにします。
この処理がないと、選択肢用のボタンを押下する際に弾を発射してしまうことになるためです。

　弾の発射制御は RayControlller スクリプト内で処理していますので、この中に処理を追加します。
どのような処理があれば、分岐用ポップアップウインドウが開いている間だけ弾を発射しないように制御できるようになるのかを考えてみてください。

　ちょっとした気配りではありますが、いつも遊んでいるゲームにも盛り込まれている内容になります。
自分でも処理の内容を読み解いていって、「この処理は、この時にはどのような制御になっていることがよりよい状態なのか」を考え、検討していく姿勢が重要です。

RayController.cs

<= クリックすると開きます。

using System.Collections;
using UnityEngine;
using UnityEngine.EventSystems;　　//　<=　☆　追加します

/// <summary>
/// Ray による弾の発射処理の制御クラス
/// </summary>
public class RayController : MonoBehaviour {

    [Header("発射口用のエフェクトのサイズ調整")]
    public Vector3 muzzleFlashScale;

    private bool isShooting;

    private GameObject muzzleFlashObj;　　　// 生成したエフェクトの代入用
    private GameObject hitEffectObj;

    private GameObject target;              // Ray で補足した対象の代入用

    [SerializeField, Header("Ray 用のレイヤー設定")]
    private int[] layerMasks;

    [SerializeField]   //Debug用。確認できたら、SerializeField 属性を削除して private にしておく
    private string[] layerMasksStr;

    [SerializeField]
    private PlayerController playerController;

    private EnemyController enemy;


    void Start() {
        // Layer の情報を文字列に変換し、Raycast メソッドで利用しやすい情報を変数として作成しておく
        layerMasksStr = new string[layerMasks.Length];
        for (int i = 0; i < layerMasks.Length; i++) {
            layerMasksStr[i] = LayerMask.LayerToName(layerMasks[i]);
        }
    }

    void Update() {
        // TODO ゲーム状態がプレイ中でない場合には処理を行わない制御をする


        ////*　ここから処理を追加します　*////


        // UI がタップされたときは処理しない(UI のボタンを押したらそちらのみを反応させる)
        if (EventSystem.current.IsPointerOverGameObject()) {
            return;
        }


        ////*　ここまで　*////


        // リロード判定(弾数 0 でリロード機能ありの場合)
        if (playerController.BulletCount == 0 && playerController.isReloadModeOn && Input.GetMouseButtonDown(0)) {
            StartCoroutine(playerController.ReloadBullet());
        }

        // 発射判定(弾数が残っており、リロード実行中でない場合)　押しっぱなしで発射できる
        if (playerController.BulletCount > 0 && !playerController.isReloading && Input.GetMouseButton(0)) {

            // 発射時間の計測
            StartCoroutine(ShootTimer());
        }
    }

    /// <summary>
    /// 継続的な弾の発射処理
    /// </summary>
    /// <returns></returns>
    private IEnumerator ShootTimer() {
        if (!isShooting) {
            isShooting = true;

            // 発射エフェクトの表示。初回のみ生成し、２回目はオンオフで切り替える
            if (muzzleFlashObj == null) {
                // 発射口の位置に RayController ゲームオブジェクトを配置する
                muzzleFlashObj = Instantiate(EffectManager.instance.muzzleFlashPrefab, transform.position, transform.rotation);
                muzzleFlashObj.transform.SetParent(gameObject.transform);
                muzzleFlashObj.transform.localScale = muzzleFlashScale;

            } else {
                muzzleFlashObj.SetActive(true);
            }

            // 発射
            Shoot();

            yield return new WaitForSeconds(playerController.shootInterval);

            muzzleFlashObj.SetActive(false);

            if (hitEffectObj != null) {
                hitEffectObj.SetActive(false);
            }

            isShooting = false;

        } else {
            yield return null;
        }
    }

    /// <summary>
    /// 弾の発射
    /// </summary>
    private void Shoot() {
        // カメラの位置からクリック(タップ)した地点に Ray を投射
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        Debug.DrawRay(ray.origin, ray.direction, Color.red, 3.0f);

        RaycastHit hit;

        if (Physics.Raycast(ray, out hit, playerController.shootRange, LayerMask.GetMask(layerMasksStr))) {

            Debug.Log(hit.collider.gameObject.name);

            // 同じ対象を攻撃しているか確認。対象がいなかったか、同じ対象でない場合
            if (target == null || target != hit.collider.gameObject) {

                target = hit.collider.gameObject;

                Debug.log(target.name);

                // TryGetComponent の処理で敵の情報を取得できるか判定をする
                if (target.TryGetComponent(out enemy)) {

                    // 敵の情報を取得できた場合、ダメージの情報を敵のクラスに渡す 
                    enemy.TriggerEvent(playerController.bulletPower);

                    // 演出
                    PlayHitEffect(hit.point, hit.normal);
                }
                //　同じ対象の場合
            } else if (target == hit.collider.gameObject) {

                // ダメージの情報を敵のクラスに渡す 
                enemy.TriggerEvent(playerController.bulletPower);

                // 演出
                PlayHitEffect(hit.point, hit.normal);
            }
        }

        // 弾数を減らす
        playerController.CalcBulletCount(-1);
    }

    /// <summary>
    /// ヒット演出
    /// </summary>
    /// <param name="effectPos"></param>
    /// <param name="surfacePos"></param>
    private void PlayHitEffect(Vector3 effectPos, Vector3 surfacePos) {

        // ヒット用のエフェクトが生成されているかを確認する
        if (hitEffectObj == null) {

            // まだ生成されていない場合には、ヒット用のエフェクトを生成
            hitEffectObj = Instantiate(EffectManager.instance.hitEffectPrefab, effectPos, Quaternion.identity);
        } else {

            // 生成されている場合には、エフェクトを表示する位置と回転情報を更新
            hitEffectObj.transform.position = effectPos;
            hitEffectObj.transform.rotation = Quaternion.FromToRotation(Vector3.forward, surfacePos);

            // エフェクトを表示
            hitEffectObj.SetActive(true);
        }
    }
}

StageDataSO スクリプタブル・オブジェクトに分岐用のデータを追加する

　分岐機能は、スクリプタブル・オブジェクト内のデータをプログラムが確認して、
分岐がある場合に自動的に分岐用ポップアップウインドウを表示する設計になっています。
(どの部分でこの処理を行っているのか、プログラムを読み解いて確認しておいてください。)

　StageDataSO スクリプタブル・オブジェクトでは、分岐も含めて登録出来るようになっています。
各 Element に含まれる BranchDatasList の情報がそれに当たります。
両方とも Element によって List 内部の情報が提示されていますので、混同しないようにしてください。

　StagePathDatasList の Element 0 では分岐なしでゲームが進行するように、Element 0 内の BranchDatasList の Element は１つとし、BranchDirectionType を NoBranch に設定します。

　StagePathDatasList の Element 1 では分岐が発生するように、Element 1 内の BranchDatasList の Element は２つとし、それぞれの BranchDirectionType に NoBranch 以外の設定を行います。
また、移動経路の異なる RailPathData ゲームオブジェクトを作成してプレファブにしておき、それを登録します。

参考例　インスペクター画像

　以下のようにならないように気を付けてください。

Element を追加する場所を間違えている場合の参考例　インスペクター画像

　以上で設定は完了です。

ゲームを実行して動作を確認する

　ゲームを実行し、移動経路の最終地点(StageDataSO スクリプタブル・オブジェクトの Element 0 に登録してある RailPathData の最終地点)まで到達した際に、
Element1 に登録した内容で分岐用ポップアップウインドウが開き、分岐の処理が起動すれば制御成功です。

　ポップアップウインドウが正常に動作したら、分岐もボタンも押して、分岐先の経路に移動するかを確認してください。

＜実装動画＞

動画ファイルへのリンク

　
　以上でこの手順は終了です。

　=>　次は　発展７　ー使用している武器のゲームオブジェクト表示の切替機能ー　です。

このページを編集するこのページを元に新規ページを作成

印刷する

コメント（0）

３Ｄレールガンシューティング　発展６ - i-school 先頭へ

コメントをかく

名前	ユーザIDを使用しないで書き込む	ユーザーIDを使う	ログインする
画像コード	画像に記載されている文字を下のフォームに入力してください。
備考	「http://」を含む投稿は禁止されています。
本文
利用規約をご確認のうえご記入下さい

i-school