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

　前回の手順に引き続き、ムービーを再生する機能を実装します。
この手順でもスクリプトの修正を行い、処理を完成させていきます。

発展１１ームービー再生機能②ー

＜完成動画①＞

設計

　前回の手順では修正できていないスクリプトがあと３つありますので、そちらを順次修正していきます。

＜この手順での修正＞

　３．GameManager 各地点に到着した際に RailPathData の情報よりムービー再生の有無を判定し、ムービー再生を行う制御を追加します
　　　処理の流れを変更し、ムービー再生有無 → ミッションの有無という順番に修正します

　４．RailMoveControlller 各地点に到着した際の判定方法を修正し、ミッションの判定方法を処理の流れを変更します。GameManager にも関連します

　５．RayControlller ムービー再生中には画面をタップしても弾を発射しないようにする制御を追加します

　以上になります。
自分で考えて処理を修正できる部分は、なるべく教材を見る前にプログラムを書くことに挑戦してください。

GameManager スクリプトを修正する

　変数の宣言を１つ追加し、新しいメソッドを２つ追加しています。
また処理を追加している部分もありますので、全体の処理の流れを把握できるようにスクリプトを修正しながら読み解くようにしてください。

　今までは経路の移動が終了するたびに、RailMoveController 側から、ミッションが発生するかどうかを判定するように命令を受けていました。
この部分を修正し、ミッションが発生するかどうかを判定ではなく、ムービーの再生が発生するかを判定するように命令を受けられるようにします。

　その上で、ムービーの再生が発生しない場合に限り、ミッションが発生するかどうかを判定するように修正しています。
よってムービーの再生が発生する場合にはミッションは発生しないようになっていますので、この部分は適宜、修正を考えてみてください。

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;

    [SerializeField]
    private WeaponChanger weaponChanger;

    [SerializeField]
    private CameraController cameraController;


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


    [SerializeField]   　　//　Debug 用に SerializeField属性を付与しています。確認が済んだら SerializeField属性 は削除してください。
    private bool[] isMoviePlays;


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


    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]);

        // 初期武器のモデル表示
        weaponChanger.InitWeaponModel();

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


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


        // ムービー再生情報用の配列を初期化
        isMoviePlays = new bool[originRailPathData.GetIsMoviePlays().Length];

        // ムービー再生有無の情報を登録
        isMoviePlays = originRailPathData.GetIsMoviePlays();


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


    }

    /// <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("ゲーム終了");

            // プレイヤー側のクリアの準備
            playerController.PrepareClearSettings();

            // すべての武器を非表示
            weaponChanger.InactiveWeapons();

            // カメラの演出
            cameraController.ClearCameraRoll(playerController.transform.position + new Vector3(0, 0, 10), new Vector3(0, 180, 0), new float[2] { 1.5f, 2.0f });

            yield break;
        }

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

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

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

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

            // 分岐がある場合、分岐イベントを発生させて、画面上に矢印のボタンを表示
            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;
    }


    ////*　メソッドを２つ追加します　*////


    /// <summary>
    /// ムービーを再生するか確認
    /// </summary>
    /// <param name="index"></param>
    public void CheckMoviePlay(int index) {

        Debug.Log(index);

        if (!isMoviePlays[index]) {

            Debug.Log("ムービー再生 なし");

            // ミッション発生有無の確認
            CheckMissionTrigger(index);
        } else {

            // ムービー再生の準備
            StartCoroutine(PrepareMoviePlay(index));
        }
    }

    /// <summary>
    /// ムービー再生の準備
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    private IEnumerator PrepareMoviePlay(int index) {

        Debug.Log("ムービー準備開始");

        // Canvas を非表示
        uiManager.SwitchActivateCanvas(false);

        // 弾を発射をできないようにする
        playerController.IsShootPerimission = false;

        yield return StartCoroutine(PlayMovie());


        /// ムービー再生
        IEnumerator PlayMovie() {

            Debug.Log("ムービー再生開始");

            // ムービー再生の準備と再生
            VideoClipManager.instance.PrepareVideoClip(originRailPathData.pathDataDetails[index].missionEventDetail.videoNo, originRailPathData.pathDataDetails[index].missionEventDetail.videoClip);

            // ムービーの準備時間だけ待機
            yield return new WaitForSeconds(1.5f);

            Debug.Log("ムービー準備待機 終了");

            // ムービー再生が終了するまで待機（どちらの処理でも待機できます）
            yield return new WaitUntil(() => !VideoClipManager.instance.IsVideoPlaying);
            //yield return new WaitForSeconds((float)originRailPathData.pathDataDetails[index].missionEventDetail.videoClip.length);

            Debug.Log("ムービー再生　終了");

            // 画面のフェードインが戻るまでの間、待機してから
            yield return new WaitForSeconds(1.0f);

            // Canvas を表示
            uiManager.SwitchActivateCanvas(true);

            // ムービーが終了したので弾の発射を許可
            playerController.IsShootPerimission = true;

            // ミッション発生有無の確認
            CheckMissionTrigger(index);
        }
    }


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

}

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

RailMoveController スクリプトを修正する

　いままでは各地点へ移動が完了したタイミングで GameManager 側に対して、ミッションが発生するかどうかを判定するように命令していました。
この部分を修正し、まず、ムービーの再生が発生するかどうかを判定するように変更します。

　あとは、先ほど作成した GameManager 側で、ムービーの再生判定をおこない、その後、ムービーの再生が発生しない場合には
いままでと同じようにミッションが発生するかどうかを判定させています。

　処理の変更に伴う修正が多いため、自分でも処理の内容を理解しながら修正していってください。

RailMoveController.cs

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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using System.Linq;

public class RailMoveController : MonoBehaviour {

    [SerializeField]
    private Transform railMoveTarget;

    [SerializeField]
    private RailPathData currentRailPathData;

    private Tween tweenMove;
    private Tween tweenRotation;

    private Vector3[] paths;
    private float[] moveDurations;
    private int pathCount;

    private GameManager gameManager;
    private int moveCount;


    /// <summary>
    /// RailMoveController の初期設定
    /// </summary>
    /// <param name="gameManager"></param>
    public void SetUpRailMoveController(GameManager gameManager) {　　　　　//　<=　GameManager より呼び出されます
        this.gameManager = gameManager;

        // TODO 他にもある場合には追記。必要に応じて引数を通じて外部から情報をもらうようにする

    }

    /// <summary>
    /// 次に再生するレール移動の目的地と経路のパスを取得して設定
    /// </summary>
    /// <param name="nextPathDataList"></param>
    public void SetNextRailPathData(RailPathData nextRailPathData) {　　　　　//　<=　GameManager より呼び出されます
        // 目的地取得
        currentRailPathData = nextRailPathData; ;

        // 移動開始
        StartCoroutine(StartRailMove());
    }

    /// <summary>
    /// レール移動の開始
    /// </summary>
    /// <returns></returns>
    public IEnumerator StartRailMove() {

        yield return null;

        // パスのカウントを初期化
        pathCount = 0;

        // 移動する地点を取得するための配列の初期化と情報の取得
        paths = currentRailPathData.GetPathTrans().Select(x => x.position).ToArray();

        // 移動先のパスの移動時間を合計
        float totalTime = currentRailPathData.GetRailMoveDurations().Sum();

        // 各パスごとの移動時間を取得
        moveDurations = currentRailPathData.GetRailMoveDurations();

        // パスによる移動開始
        RailMove();

        // 移動を一時停止
        PauseMove();

        // ゲームの進行状態が移動中になるまで待機
        yield return new WaitUntil(() => gameManager.currentGameState == GameState.Play_Move);

        // 移動開始
        ResumeMove();

        Debug.Log("移動開始");
    }

    /// <summary>
    /// レール移動の一時停止
    /// </summary>
    public void PauseMove() {
        // 一時停止
        tweenMove.Pause();
        tweenRotation.Pause();
    }

    /// <summary>
    /// レール移動の再開
    /// </summary>
    public void ResumeMove() {
        // 移動再開
        tweenMove.Play();
        tweenRotation.Play();
    }

    /// <summary>
    /// パスのカウントアップ(パスごとに動かす場合)
    /// </summary>
    public void CountUp() {
        pathCount++;
        Debug.Log(pathCount);

        // 移動
        RailMove();
    }

    /// <summary>
    /// 2点間のパスの目標地点を設定して移動
    /// </summary>
    public void RailMove() {

        // 残っているパスがない場合
        if (pathCount >= currentRailPathData.GetPathTrans().Length) {


            ////*  ３つの処理をコメントアウトします  *////


            // DOTween を停止
            //tweenMove.Kill();　　　//　コメントアウトします

            //tweenMove = null;　　　//　コメントアウトします
            //tweenRotation = null;　//　コメントアウトします


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


            // 移動完了に伴い、移動回数をカウントアップ
            moveCount++;

            // 移動先の確認。移動先が残っていない場合には、ゲームマネージャー側で分岐の確認(次のルート選定、移動先の分岐、ボス、クリアのいずれか)
            gameManager.PreparateCheckNextBranch(moveCount);

            Debug.Log("分岐確認");

            return;
        }

        // パスの設定用の配列を宣言
        Vector3[] targetPaths;

        // パスのカウント数に応じて分岐してパスを設定
        if (pathCount == 0) {
            targetPaths = new Vector3[2] { railMoveTarget.position, paths[pathCount] };
        } else {
            targetPaths = new Vector3[2] { paths[pathCount - 1], paths[pathCount] };
        }

        // パスの移動時間を設定
        float duration = moveDurations[pathCount];

        Debug.Log("スタート地点 :" + targetPaths[0]);
        Debug.Log("目標地点 :" + targetPaths[1]);
        Debug.Log("移動にかかる時間 :" + duration);

        // パスの移動
        tweenMove = railMoveTarget.transform.DOPath(targetPaths, duration, pathType).SetEase(Ease.Linear).OnWaypointChange((waypointIndex) => CheckArrivalDestination(waypointIndex));

        // カメラの回転
        tweenRotation = railMoveTarget.transform.DORotate(currentRailPathData.pathDataDetails[pathCount].pathTran.eulerAngles, duration).SetEase(Ease.Linear);
        Debug.Log($" 回転角度 :  {currentRailPathData.pathDataDetails[pathCount].pathTran.eulerAngles} ");
    }

    /// <summary>
    /// パスの目標地点に到着するたびに実行される
    /// </summary>
    /// <param name="waypointIndex"></param>
    private void CheckArrivalDestination(int waypointIndex) {

        if (waypointIndex == 0) {
            return;
        }

        Debug.Log("目標地点 到着 : " + pathCount + " 番目");


        ////*  ２つの処理をコメントアウトし、新しい処理を追加します  *////


        // 移動の一時停止
        //PauseMove();　　　　　//　コメントアウトします

        // ミッションがあるか確認(ミッションが発生するかゲームマネージャー側で判定を行う)
        //gameManager.CheckMissionTrigger(pathCount);　　　//　コメントアウトします


        ///　ここから追加します　///


        // DOTween を停止
        tweenMove.Kill();
        tweenRotation.Kill();

        tweenMove = null;
        tweenRotation = null;


        // ムービーの確認
        gameManager.CheckMoviePlay(pathCount);


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


    }

    /// <summary>
    /// 移動用の処理が登録されたか確認
    /// </summary>
    /// <returns></returns>
    public bool GetMoveSetting() {
        return tweenMove != null ? true : false;
    }
}

RayController スクリプトを修正する

　最後に RayController スクリプトを修正します。

　現在のままではムービーの再生中でも Ray を発射して攻撃する処理が動いてしまうため、
ムービー再生中においては攻撃をしないように制御する処理を追加しています。

　また、ムービーの再生終了に伴い、再度、攻撃できるようにしています。

　このような処理は、２つの処理を作成すればいいのか、と考えがちですが、実際の所は
いずれかの処理を行うようにすれば、排他的な処理が実装できます。

　どうすればこの２つの処理が１つの処理として実装できるようになるのか、設計を考えてみてください。

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;
        }


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


        // 発射許可がない場合
        if (!playerController.IsShootPerimission) {
            // 処理しない
            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);
        }
    }
}

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

　すべての手順が終了しました。多くの修正がありますので、処理を読みなおしてから、ゲームを実行してデバッグを行ってください。
修正したスクリプトが多いということは、即ち、非常に多くの確認すべきポイントがあります ので、こちらを念頭に置いて、すべての挙動の確認を行います。

　・IsMoviePlay 変数にチェックがある地点で正常にムービーが再生されるか
　・再生しているムービーが終了したら、再度、経路の移動が始まるか
　・ムービー再生中で画面をクリックしたらムービーがスキップされるか（その際、クリックしても弾は発射されないかどうかも確認する）
　・ムービー再生中には UI 表示がなくなり、再生終了後に、再度 UI が表示されるか

　これらを順番に確認して、問題がないかを確認してください。
そして今後は、このように確認すべき点を自分で書き出し、順番にチェックしていけるようにデバッグのスキルをアップしましょう。

＜完成動画①＞

動画ファイルへのリンク

＜完成動画②＞

動画ファイルへのリンク

　そのためには、必ず自分で書いた処理を見直す癖をつけて、処理を読み解けているか、復習を行いましょう。

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

　=>　次は　発展１２　ーシーン遷移機能ー　です。

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

印刷する

コメント（0）

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

コメントをかく

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

i-school