２Ｄタップシューティングゲーム　拡張２

　Exp が加算されたり、減算される際に、Exp 表示の数字を一瞬で更新するのではなく、徐々にカウントアップ、カウントダウンさせるアニメ演出を追加します。

＜実装動画　Exp 加算時＞

動画ファイルへのリンク

　以下の内容で順番に実装を進めていきます。

拡張２　－Exp 増減時の数字のアニメ演出の追加－

　３．どのような演出にするか検討し、ロジックを考える
　４．修正が必要なスクリプトを特定し、Exp のアニメ演出処理を実行する処理を追加する

　新しい学習内容は、以下の通りです。

　・DOTweenの補間機能の実装例⑫　ーDOTween.TO メソッドを利用した数字の変動アニメ演出処理ー

３．どのような演出にするか検討し、ロジックを考える

１．設計

　製作したゲームを遊びましょう。

　従来のゲームにあって、このゲームにない演出はどんなものなのか、どの部分か、それを分析してみましょう。
気づいた部分を書き留めておいて、どのようなロジックで動いているのか、表面的な動作だけではなくて
その動作はどんなプログラムのロジックなのか、その部分に着目して考えてみてください。

　ポートフォリオとしてゲームを製作する上で大切なのは、自分の気付き、そしてどんな処理であるかを考えることです。
そうすることによって、自分のスキルで実装できる内容なのか、新しい技術の習得が必要なのか、イメージをしていくことが出来ます。
　
　見栄え良く作品を作ることにこだわりを持つ必要はありません。(良いに越したことはないですが)

　その作品を作成するために、どのような学習を行ったのか、どんな風に調べたのか、果たして実装が出来たのか、
苦労した部分や、考え抜いた部分をしっかりと第三者へと説明できること、自分自身の学習の過程と、成長するための向上心が重要です。

２．実装例

　今回は Exp の値が更新される際の演出を考えて実装を行います。
これはあくまでも実装例ですので、自分で実装したい内容があれば、そちらを優先してください。

＜実装例＞

　・Exp が加算されるたびに、Exp の表示を徐々にカウントアップして表示する

　・Exp が減算されるたびに、Exp の表示を徐々にカウントダウンして表示する

　こちらを実装していきます。

３．ロジックを考える

　今までの実装例を元に、どのようなロジックを組むことが出来れば処理が実装できるのかを考えてみてください。

　また、どのような手順で実装を進めていったのかも一緒に考えてみましょう。
多くの場合、必要な処理が判明した時点で、該当するスクリプトに変数やメソッドの形で処理を実装し、
それをタイミングに合わせて呼び出すことによって処理を動作させていたと思います。

　この手順を振りかえってみて、どのようなロジックの流れが必要なのか、
メソッド、変数を用意するのが適切であるのか、自分で深く考えていってみましょう。

４．修正が必要なスクリプトを特定し、Exp のアニメ演出処理を実行する処理を追加する

１．設計

　どのスクリプトにどのような処理を追加すればよいか、ロジックを含めて考えてみましょう。
処理のゴール地点とスタート地点、繋がりをどのように構築すればよいか、など、今までの処理の実装例を思い出してみてください。

　今回であれば、Exp の表示制御を行っているスクリプト、その値を操作する命令を出しているスクリプトが対象になります。
Exp の加算と減算はそれぞれ別のスクリプト内で実行されていますので、まずはどのタイミングで処理が行われているかを把握します。

　数字のアニメ演出は、DOTween の To メソッドを利用することで実装可能です。
この処理では、変化前の値と変化後の値の両方の変数が必要になります。
この部分も変更が必要になります。

　現在の処理は以下のようなロジックです。

＜現在の処理の流れ＞

　１．Exp への加算、あるいは減算が発生する
　２．GameData クラスの UpdateTotalExp メソッドを実行して、Exp の値を増減する
　３．増減後の値を UIManager クラスの DisplayTotalExp メソッドへと引数で渡して、ゲーム画面に表示する

　先ほどもお伝えしたように、２の段階で GameData に Exp を加算してしまう処理を利用すると、
DOTween.To メソッドを活用して処理の実装ができません。そのため、ゲーム画面に表示する計算処理と、
実際に GameData クラスの Exp を増減する処理とは分けて考えていく必要があります。

　これを踏まえて実装したい処理の流れとしては、次のようになります。

＜修正して実装したい処理の流れ＞

　１．Exp への加算、あるいは減算が発生する
　２．増減させる値を UIManager クラスの DisplayTotalExp メソッドへと引数で渡して、この中で DOTween の機能を利用して、アニメ演出をしながらゲーム画面に表示する
　３．GameData クラスの UpdateTotalExp メソッドを実行して、Exp の値を増減する

　処理の順番、および、メソッドに対して渡す引数の値が変わることになります。

２．該当するスクリプトを修正する

<=　実装例を表示します。

２－１．UIManager スクリプトを修正する

　DisplayTotalExp メソッドにて Exp の値を画面に表示しています。
このメソッド内の処理を修正して、Exp の値をカウントアップ、カウントダウンさせながら変更するようにします。

　Exp の値を変更する処理に DOTween の To メソッドを利用します。
この部分では Text コンポーネントに数字のアニメ演出を行うこともできますので、
いままでの Text コンポーネントへの処理は一度コメントアウトしてください。

UIManager.cs

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

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

public class UIManager : MonoBehaviour
{
    [SerializeField]
    private CanvasGroup canvasGroupGameClear;

    [SerializeField]
    private CanvasGroup canvasGroupGameOver;

    [SerializeField]
    private Text txtGameOver;

    [SerializeField]
    private Text txtDurability;

    [SerializeField]
    private Slider slider;

    [SerializeField]
    private Text txtTotalExp;

    [SerializeField]
    private FloatingMessage floatingMessagePrefab;   // FloatingMessageObj プレファブ・ゲームオブジェクトをインスペクターよりアサインして登録する 

    [SerializeField]
    private Image imgGameClear;

    [SerializeField]
    private CanvasGroup canvasGroupRestartImage;

    [SerializeField]
    private CanvasGroup canvasGroupOpeningFilter;

    [SerializeField]
    private Image imgGameStart;

    [SerializeField]
    private CanvasGroup canvasGroupBossAlert;


    /// <summary>
    /// ゲームクリア表示を隠す
    /// </summary>
    public void HideGameClearSet() {

　　　　// GameClearSet ゲームオブジェクトの透明度を 0 にして見えなくする
        canvasGroupGameClear.alpha = 0;
    }

    /// <summary>
    /// ゲームクリア表示を行う
    /// </summary>
    public void DisplayGameClearSet() {     

        // GameClearSet ゲームオブジェクトの透明度を徐々に 1 してゲームクリア表示
        canvasGroupGameClear.DOFade(1.0f, 0.25f)     

　　　　　　// DOFade メソッドの処理が終了したら
            .OnComplete(() => {

                 // ゲームクリアの画像を DOPunchScale メソッドで揺らす
                 imgGameClear.transform.DOPunchScale(Vector3.one * 2.5f, 0.5f)

                    // DOPunchScale メソッドの処理が終了したら
                   　.OnComplete(() => {

                          // ゲームクリアの画像を DOShakeScale メソッドで揺らす
                          imgGameClear.transform.DOShakeScale(0.5f);

　　　　　　　　　　　　　// ゲームクリアの画像のサイズを 1.5倍 にする
                          imgGameClear.transform.localScale = Vector3.one * 1.5f;

                          // 画面タップを許可
                          canvasGroupGameClear.blocksRaycasts = true;

                          // Restartの点滅表示
                          canvasGroupRestartImage.DOFade(1.0f, 1.5f).SetEase(Ease.Linear).SetLoops(-1, LoopType.Yoyo);
                      }); 

           });
    }

    /// <summary>
    /// ゲームオーバー表示を隠す
    /// </summary>
    public void HideGameOverSet() {
        canvasGroupGameOver.alpha = 0;
    }

    /// <summary>
    /// ゲームオーバー表示を行う
    /// </summary>
    public void DisplayGameOverSet() {

　　　　// GameClearSet ゲームオブジェクトの透明度を徐々に 1 してゲームクリア表示
        canvasGroupGameOver.DOFade(1.0f, 1.0f);

　　　　// ゲーム画面に表示する文字列を用意して代入
        string txt = "Game Over";

　　　　// DOTween の DOText メソッドを利用して文字列を１文字ずつ順番に同じ表示時間で表示
        txtGameOver.DOText(txt, 1.5f).SetEase(Ease.Linear);
    }

    /// <summary>
    /// 耐久度の表示更新
    /// </summary>
    public void DisplayDurability(int durability, int maxDurability) {

        // 画面に耐久力の値を　現在値 / 最大値　の形式で表示する
        txtDurability.text = durability + "  / " + maxDurability;

        // ゲージの表示を耐久力の値に合わせて更新(最初は durability / maxDurability の結果が 1.0f になるので、ゲージは最大値になる)
        slider.DOValue((float)durability / maxDurability, 0.25f);
    }


////*  ☆①、☆②を修正、その下に処理を追加  *////


    /// <summary>
    /// TotalExp の表示更新
    /// </summary>
    /// <param name="exp"></param>
    public void UpdateDisplayTotalExp(int exp) {     //  <=  ☆①  引数の名前を変更します。

        //txtTotalExp.text = totalExp.ToString();    //  <=　☆②  処理を下に移すため、コメントアウトします

　　　　// 現在の Exp を取得
        int currentExp = GameData.instance.GetTotalExp();

        // 計算後の Exp を取得
        int updateExp = currentExp + exp;

        // Exp の表示を DOTween を使って更新してアニメ演出     
        DOTween.To(
            () => currentExp,
            (x) => {
                currentExp = x;
                txtTotalExp.text = x.ToString();　　　　　　　// ゲーム画面に数字の表示を更新します
            },
            updateExp,
            1.0f);


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


    }

    /// <summary>
    /// EXP 値用のフロート表示の生成
    /// </summary>
    /// <param name="exp"></param>
    public void CreateFlotingMessageToExp(int exp, FloatingMessage.FloatingMessageType floatingMessageType) {

　　　　// フロート表示の生成。生成位置は TotalExpSet ゲームオブジェクト内の txtTotalExp ゲームオブジェクトの位置(子オブジェクト)
        FloatingMessage floatingMessage = Instantiate(floatingMessagePrefab, txtTotalExp.transform, false);

　　　　// 生成したフロート表示の設定用メソッドを実行。引数として、Exp 値とフロート表示の種類を指定して渡す
        floatingMessage.DisplayFloatingMessage(exp, floatingMessageType);
    }

    /// <summary>
    /// オープニング演出の実行
    /// </summary>
    /// <returns></returns>
    public IEnumerator PlayOpening() {

        // 黒いフィルター画像を徐々に非表示にして、ゲーム画面を見えるようにする
        canvasGroupOpeningFilter.DOFade(0.0f, 1.0f)

　　　　　　// 上記の処理が終了したら
            .OnComplete(() => {

　　　　　　　　// ゲームスタートのロゴ画像を跳ねさせながら、画面の画面外の左端からゲーム画面の中央へ移動
                imgGameStart.transform.DOLocalJump(Vector3.zero, 300.0f, 3, 1.5f).SetEase(Ease.Linear);
            });

　　　　// 一時処理を中断　=>　ゲームスタートのロゴが画面の中央で停止したままになる
        yield return new WaitForSeconds(3.5f);

　　　　// ゲームスタートのロゴ画像を跳ねさせながら、ゲーム画面の中央から画面の右端へ移動して画面外に
        imgGameStart.transform.DOLocalJump(new Vector3(1500, 0, 0), 200.0f, 3, 1.5f).SetEase(Ease.Linear);
    }

    /// <summary>
    /// ボスの警告用の表示を隠す
    /// </summary>
    public void HideBossAlertSet() {
        canvasGroupBossAlert.transform.parent.gameObject.SetActive(false);
    }

    /// <summary>
    /// ボスの警告演出を実行
    /// </summary>
    public IEnumerator PlayBossAlert() {

        // ボス用の BGM 再生
        SoundManager.instance.PlayBGM(SoundDataSO.BgmType.Boss);

        // TODO ボス前の警告ボイス再生

        canvasGroupBossAlert.transform.parent.gameObject.SetActive(true);
        canvasGroupBossAlert.DOFade(1.0f, 0.5f).SetLoops(6, LoopType.Yoyo);
        yield return new WaitForSeconds(3.0f);
        canvasGroupBossAlert.DOFade(0.0f, 0.25f);
        yield return new WaitForSeconds(0.25f);
        canvasGroupBossAlert.transform.parent.gameObject.SetActive(false);
    }
}

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

２－２．＜DOTweenの補間機能の実装例⑫　ーDOTween.TO メソッドを利用した数字の変動アニメ演出処理ー＞

　DOTween には多くのメソッドが用意されていますが、そのメソッドでは処理が実装できないものもあります。
今回の数字の変更処理もその１つで、これは、DOTween が持つメソッドでは Tween 処理ができません。

　そういったケースに備えて用意されているものが、DOTween.To メソッドです。
こちらのメソッドを利用すると、自作した int 型の exp 変数のような、従来のメソッドに定義されていないクラスの変数であっても制御することが出来ます。

＜DOTween.To メソッドの引数の設定＞

DOTween.To 
(
    // 何に(getter),
    // 何を(setter)　この x は変数なので自由な名前に設定できる,
    // 最終的な値(end value),
    // 最終値に変化するまでの時間(duration)
);

　処理はラムダ式で記述します。引数のオーバーロードが非常に多いメソッドですが、この４つの引数を指定すれば問題なく処理が動きます。

　今回は、Exp の値を現在値を基準値として、加算・減算を行い、最終値をゲーム画面に表示する、という処理になります。
この加算と減算の処理はあくまでも表示上の計算だけですので、Exp 本来の値の更新は、GameData クラスで行う必要があります。

// Exp の表示を DOTween を使って更新してアニメ演出     
DOTween.To(
　　() => currentExp,
    (x) => {
    　　　      currentExp = x;
                txtTotalExp.text = x.ToString();
            },
    updateExp,
    1.0f);

２－３．EnemyGenerator スクリプトを修正する

　Exp の加算処理について処理の内容を修正します。

　ポイントは処理の順番です。
今までは先にExp を加算してから、その結果を UIManager 側へと送って表示を行っていました。
今回は UIManager 内で計算処理を行っていますが、これは GameData に加算する処理とは別になりますので、
GameData が管理している Exp への加算処理を先に行ってしまうと処理のつじつまが合わなくなります。

　そのため、UIManager の処理を行ってから、GameData の Exp の値を更新する必要がありますので、
いままで EnemyController スクリプトにおいて行っていた GameData への Exp の加算処理をこちらのスクリプトへ移動します。

　この処理を移動させないと、Exp 加算後の値でバレット選択ボタンの使用可否のタイミングがズレます。
その理由を考えてみてください。まずは修正せずに試してみてもいいでしょう。

EnemyGenerator.cs

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

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

public class EnemyGenerator : MonoBehaviour
{
    [SerializeField, Header("エネミーのプレファブ")]
    private EnemyController enemyObjPrefab;

    [SerializeField, Header("エネミー生成までの準備時間")]
    public float preparateTime;

    private int generateCount;     // 生成したエネミーの数をカウントするための変数

    private float timer;           // 準備時間の計測用の変数

    private GameManager gameManager;

    [Header("エネミーの最大生成数")]
    public int maxGenerateCount;

    [Header("エネミーの生成完了管理用")]
    public bool isGenerateEnd;

    [Header("ボス討伐管理用")]
    public bool isBossDestroyed;

    [Header("エネミーのスクリプタブル・オブジェクト")]
    public EnemyDataSO enemyDataSO;

    // Normal タイプのエネミーのデータだけ代入されている List
    private List<EnemyDataSO.EnemyData> normalEnemyDatas = new List<EnemyDataSO.EnemyData>();

    // Boss タイプのエネミーのデータだけ代入されている List
    private List<EnemyDataSO.EnemyData> bossEnemyDatas = new List<EnemyDataSO.EnemyData>(); 

    [Header("エネミー移動用のスクリプタブル・オブジェクト")]
    public MoveEventSO moveEventSO;

    [SerializeField, Header("生成したエネミーのリスト")]
    private List<EnemyController> enemiesList = new List<EnemyController>();


    /// <summary>
    /// EnemyGenerator の設定
    /// </summary>
    /// <param name="gameManager"></param>
    public void SetUpEnemyGenerator(GameManager gameManager) {

        // EnemyGenerator スクリプトの gameManager 変数に、引数で届いた GameManager スクリプトの情報を代入
        this.gameManager = gameManager;

        // 引数で指定したエネミーのタイプのリストを作成
        normalEnemyDatas = GetEnemyTypeList(EnemyType.Normal);

        bossEnemyDatas = GetEnemyTypeList(EnemyType.Boss);

        // GameData よりエネミーの最大生成数を取得
        maxGenerateCount = GameData.instance.GetMaxGenerateCount();
    }

    /// <summary>
    /// エネミー生成の準備
    /// </summary>
    private void PreparateGenerateEnemy() {

        // 時間の計測
        timer += Time.deltaTime;

        // 準備時間を超えたら
        if (timer >= preparateTime) {

            // 次回の時間の計測を行うためにリセット
            timer = 0;

            // エネミーの生成
            GenerateEnemy();

            // 生成したエネミーの数をカウントアップ
            generateCount++;
            
            Debug.Log("生成したエネミーの数 : " + generateCount);
            
　　　　　　// 今までに生成したエネミーの数が、エネミーの最大生成数の値と同じか超えたら
　　　　　　if (generateCount >= maxGenerateCount) {

　　　　　　　　// 生成完了の状態にする = Update メソッドでこの値を利用して、生成完了状態になったら生成の準備処理が実行されないように制御する
                isGenerateEnd = true;

                Debug.Log("生成完了");

                // ボスの生成
                StartCoroutine(GenerateBoss());
            }
        }
    }

    /// <summary>
    /// エネミーの生成
    /// </summary>
    private void GenerateEnemy(EnemyType enemyType = EnemyType.Normal) {

　　　　// ランダムな値を代入するための変数を宣言
　　　　int randomEnemyNo;

　　　　// EnemyData を代入するための変数を宣言
        EnemyDataSO.EnemyData enemyData = null;

        // EnemyType に合わせて生成するエネミーの種類を決定し、そのエネミーの種類ごとのリストからランダムな EnemyData を取得
        switch (enemyType) {
            case EnemyType.Normal:
                randomEnemyNo = Random.Range(0, normalEnemyDatas.Count);
                enemyData = normalEnemyDatas[randomEnemyNo];
                break;
            case EnemyType.Boss:
                randomEnemyNo = Random.Range(0, bossEnemyDatas.Count);
                enemyData = bossEnemyDatas[randomEnemyNo];
                break;
        }

        // プレファブからエネミーのクローンを生成する。生成位置は EnemyGenerator の位置。戻り値の値は EnemyController 型になる
        EnemyController enemyController = Instantiate(enemySetPrefab, transform, false);    //  <=  ☆　左辺に EnemyController 型の変数を用意して、インスタンスされたエネミーの情報を戻り値で受け取る

        // EnemyController スクリプトの SetUpEnemy メソッドを実行する　=>　Start メソッドの代わりになる処理
        enemyController.SetUpEnemy(enemyData);

        // Boss 以外でも追加設定を行う
        enemyController.AdditionalSetUpEnemy(this, gameManager.bulletSelectManager.GetBulletData(enemyData.bulletType);

        // List に生成したエネミーの情報を追加
        enemiesList.Add(enemyController);
    }

    void Update() {

        // 生成完了の状態になったら生成処理を行わないようにする
        if (isGenerateEnd) {
            return;
        }

　　　　// GameManager スクリプトの準備が完了していないうちは生成処理を行わないようにする
        if (!gameManager.isSetUpEnd) {
            return;
        }

　　　　// ゲーム終了の状態ではないなら
        if (!gameManager.isGameUp) {

            // エネミー生成の準備
            PreparateGenerateEnemy();               
        }
    }

    /// <summary>
    /// ボスの生成
    /// </summary>
    private IEnumerator GenerateBoss() {

        // ボス出現の警告演出
        yield return StartCoroutine(gameManager.uiManager.PlayBossAlert());

        // ボス生成
        GenerateEnemy(EnemyType.Boss);
    }

    /// <summary>
    /// ボス討伐状態の切り替え
    /// </summary>
    /// <param name="isSwitch"></param>
    public void SwitchBossDestroyed(bool isSwitch) {
        // ボスの討伐状態を切り替え
        isBossDestroyed = isSwitch;

        Debug.Log("ボス討伐");

        // ボス討伐に合わせて、ゲーム終了の状態に切り替える
        gameManager.SwitchGameUp(isBossDestroyed);

        // ゲームクリアの準備
        gameManager.PreparateGameClear();
    }

    /// <summary>
    /// 引数で指定されたエネミーの種類のListを作成し、作成した値を戻す
    /// </summary>
    /// <param name="enemyType"></param>
    /// <returns></returns>
    private List<EnemyDataSO.EnemyData> GetEnemyTypeList(EnemyType enemyType) {

        List<EnemyDataSO.EnemyData> enemyDatas = new List<EnemyDataSO.EnemyData>();

        // 引数のタイプのエネミーのデータだけを抽出して enemyDatas リストに EnemyData を追加して、List を作成していく
        for (int i = 0; i < enemyDataSO.enemyDataList.Count; i++) {
            if (enemyDataSO.enemyDataList[i].enemyType == enemyType) {
                enemyDatas.Add(enemyDataSO.enemyDataList[i]);
            }
        }

        // 抽出処理の結果を戻す
        return enemyDatas;
    }

    /// <summary>
    /// TotalExp の表示更新準備
    /// </summary>
    /// <param name="exp"></param>
    public void PreparateDisplayTotalExp(int exp) {

        // GameManager スクリプトから UIManager スクリプトの UpdateDisplayTotalExp メソッドを実行する
        gameManager.uiManager.UpdateDisplayTotalExp(exp);

        // GameManager スクリプトから UIManager スクリプトの CreateFlotingMessageToExp メソッドを実行する。引数として exp とフロート表示の種類を渡す
        gameManager.uiManager.CreateFlotingMessageToExp(exp, FloatingMessage.FloatingMessageType.GetExp);


////*  処理を追加する  *////


        // Exp を TotalExp に加算
        GameData.instance.UpdateTotalExp(exp);


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


        //  使用可能バレット選択ボタンの確認と更新
        gameManager.bulletSelectManager.JugdeOpenBullets();
    }

    /// <summary>
    /// プレイヤーとエネミーとの位置から方向を判定する準備
    /// </summary>
    /// <returns></returns>
    public Vector3 PreparateGetPlayerDirection(Vector3 enemyPos) {
        return gameManager.GetPlayerDirection(enemyPos);
    }

    /// <summary>
    /// enemiesList に登録されているエネミーのうち、リストに残っているエネミーのゲームオブジェクトを破壊し、enemiesList をクリアする
    /// </summary>
    public void ClearEnemiesList() {

        // enemiesList の要素(中身)を１つずつ順番に、要素の最大値になるまで判定していく
        for (int i = 0; i < enemiesList.Count; i++) {

　　　　　　// 要素が空ではない(プレイヤーに破壊されずにゲーム画面に残っている)なら
            if (enemiesList[i] != null) {

　　　　　　　　// そのエネミーのゲームオブジェクトを破壊する
                Destroy(enemiesList[i].gameObject);
            }
        }

　　　　// リストをクリア(要素が何もない状態)にする
        enemiesList.Clear();
    }

    /// <summary>
    /// 一時オブジェクト(バレット、エフェクトなど)をすべて破棄(利用状況に応じて、①か②のいずれかの処理を実装する)
    /// </summary>
    public void DestroyTemporaryObjectContainer() {

        // ① TemporaryObjectContainer ゲームオブジェクトを破壊する(プロパティを利用している場合)
        Destroy(TransformHelper.TemporaryObjectContainerTran.gameObject);

        // ② TemporaryObjectContainer ゲームオブジェクトを破壊する(プロパティを利用していない場合)
        Destroy(TransformHelper.GetTemporaryObjectContainerTran().gameObject);
    }
}

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

２－４．EnemyController スクリプトを修正する

　Exp の加算処理を EnemyGenerator スクリプトへ移動させましたので、重複加算されないように、こちらの処理を削除します。

EnemyController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using DG.Tweening;
using UnityEngine.Events;

[RequireComponent(typeof(CapsuleCollider2D))]
public class EnemyController : MonoBehaviour

    [Header("エネミーのデータ情報")]
    public EnemyDataSO.EnemyData enemyData; // SetUpEnemy メソッドにて引数として受けとったエネミーのデータを代入する。これにより、振る舞いが変わる

    [SerializeField]
    private Image imgEnemy;                 // エネミーの画像の設定用　　　 

    [SerializeField]
    private Slider slider;

    [SerializeField]
    private GameObject bulletEffectPrefab;      // ヒット演出用のエフェクトのプレファブをインスペクターよりアサインして登録する

    [SerializeField]
    private GameObject enemybulletPrefab;       // EnemyBullet プレファブ・ゲームオブジェクトをインスペクターよりアサインして登録する 

    [SerializeField, Header("フロート表示を行う位置情報")]
    private Transform floatingDamageTran;

    [SerializeField]
    private FloatingMessage floatingMessagePrefab;   // FloatingMessageObj プレファブ・ゲームオブジェクトをインスペクターよりアサインして登録する 

    private int maxHp;                               // HPの最大値を代入する変数
 
    private int hp;                                  // エネミーのHP。EnemyData でHpの値が取得できるので、それを代入する。public にしてインスペクターで設定する必要なし

    private EnemyGenerator enemyGenerator;           // EnemyGenerator を利用するための変数

    private UnityAction<Transform, float> moveEvent;    // UnityAction<Transform, float> 型の moveEvent 変数と読む。ここにエネミーの移動方法に応じた移動用のメソッドを登録する


    /// <summary>
    /// エネミーの設定
    /// </summary>
　　public void SetUpEnemy(EnemyDataSO.EnemyData enemyData) {

　　　　// 引数で届いた EnemyData を代入する
        this.enemyData = enemyData;

        // ボスではない場合
        if (this.enemyData.enemyType != EnemyType.Boss) {

            // エネミーの X 軸(左右)の位置を、ゲーム画面に収まる範囲でランダムな位置に変更
            transform.localPosition = new Vector3(transform.localPosition.x + Random.Range(-650, 650), transform.localPosition.y, 0);
        } else {
          
            // ボスの位置を徐々に下方向に変更
            transform.DOLocalMoveY(transform.localPosition.y - 500, 3.0f);

            // ボスの場合、サイズを大きくする
            transform.localScale = Vector3.one * 2.0f;

            // Hpゲージの位置を高い位置にする
            slider.transform.localPosition = new Vector3(0, 150, 0);
        }
    
        // 画像を EnemyData の画像にする　=>　ここでエネミーごとの画像に変更する
        imgEnemy.sprite = this.enemyData.enemySprite;

        // EnemyData より Hp の値を最大値として代入
        maxHp = this.enemyData.hp;
        
        // hp を設定
        hp = maxHp;

　　　　// Hpゲージの表示更新
　　　　DisplayHpGauge();
    }

    // 侵入判定
    private void OnTriggerEnter2D(Collider2D col) {

　　　　// バレットが接触したら
        if (col.gameObject.tag == "Bullet") {

            // 侵入してきたコライダーのゲームオブジェクトに Bullet スクリプトがアタッチされていたら取得して bullet 変数に代入して、if 文の中の処理を行う
            if (col.gameObject.TryGetComponent(out Bullet bullet)) {
            
                // HPの更新処理とエネミーの破壊確認の処理を呼び出す
                UpdateHp(bullet);　

                // バレットのヒット演出用エフェクトの生成
                GenerateBulletEffect(col.gameObject.transform);
            }
        }
    }

    /// <summary>
    /// バレットの破壊処理
    /// </summary>
    private void DestroyBullet(Collider2D col)
    {
        // バレットを破壊する
        Destroy(col.gameObject);
    }

    /// <summary>
    /// Hpの更新処理とエネミーの破壊確認処理
    /// </summary>
    private void UpdateHp(Bullet bullet)
    {
　　　　// ダメージ確定用
        int bulletPower = 0;

　　　　// 弱点判定用。弱点の場合には、true に切り替える 
        bool isWeakness = false;

        // バレットの属性とエネミーの属性の情報を利用して相性を判定
        if(ElementCompatibilityHelper.GetElementCompatibility(bullet.bulletData.elementType, enemyData.elementType) == true) {

            Debug.Log("Element 相性　良");

            // バレットの攻撃力をダメージ倍率分掛けた値にして、計算結果を切り上げて int 型にする
            bulletPower = Mathf.FloorToInt(bullet.bulletData.bulletPower * GameData.instance.GetDamageRatio());   

            // 弱点として設定
            isWeakness = true; 
            
        } else {

            // バレットの攻撃力をそのまま利用する
            bulletPower = bullet.bulletData.bulletPower;
        }

　　　　// バレットの攻撃力値用のフロート表示の生成
        CreateFloatingMessageToBulletPower(bulletPower, isWeakness);

        // hpの減算処理
        hp -= bulletPower;

　　    // Hp の値の上限・下限を確認して範囲内に制限
　　　　hp = Mathf.Clamp(hp, 0, maxHp);

        // HPゲージの表示更新
        DisplayHpGauge();

        if (hp <= 0) {
            hp = 0;

            // ボスの場合
            if (enemyData.enemyType == EnemyType.Boss) {

                // ボス討伐済みの状態にする
                enemyGenerator.SwitchBossDestroyed(true);
            }


////*  ここから処理を削除  *////


            // Exp を TotalExp に加算
            //GameData.instance.UpdateTotalExp(enemyData.exp);


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

            // 最新の TotapExp を利用して表示更新
            enemyGenerator.PreparateDisplayTotalExp(enemyData.exp);

            // このゲームオブジェクトを破壊する
            Destroy(gameObject);
        }

        // ノーマル弾の場合
        if (bullet.bulletData.bulletType == BulletDataSO.BulletType.Player_Normal || bullet.bulletData.bulletType == BulletDataSO.BulletType.Player_5ways_Normal) {

            // バレットを破壊
            Destroy(bullet.gameObject);
        }           
    }

    /// <summary>
    /// HPゲージの表示更新
    /// </summary>
    private void DisplayHpGauge() {

　　　　// HPゲージを現在値に合わせて制御
        slider.DOValue((float)hp / maxHp, 0.25f);
    }

    /// <summary>
    /// 被バレット時のヒット演出用のエフェクト生成
    /// </summary>
　　/// <param name="bulletTran"></param>
    private void GenerateBulletEffect(Transform bulletTran) {

　　　　// ヒット演出用のエフェクトを、バレットのぶつかった位置で生成
        GameObject effect = Instantiate(bulletEffectPrefab, bulletTran, false);

        // エフェクトをエネミーの子オブジェクトにする
        effect.transform.SetParent(transform);

        Destroy(effect, 3.0f);
    }

    /// <summary>
    /// エネミーの追加設定
    /// </summary>
    /// <param name="enemyGenerator"></param>
    /// <param name="bulletData"></param>
    public void AdditionalSetUpEnemy(EnemyGenerator enemyGenerator, BulletDataSO.BulletData bulletData) {

        // 引数で届いた情報を変数に代入してスクリプト内で利用できる状態にする
        this.enemyGenerator = enemyGenerator;

        // MoveEventSO スクリプタブル・オブジェクトの GetMoveEvent メソッドを実行し、戻り値で移動用のメソッドを受け取る。ここで移動方法を決定
        moveEvent = this.enemyGenerator.moveEventSO.GetMoveEvent(enemyData.moveType);

        // Invoke メソッドを実行すると、moveEvent 変数に登録されたメソッド(今回は移動用のメソッド)を実行する。UnityActon <Transform, float>型なので、実行にあたって、指定された型の情報を指定する
        moveEvent.Invoke(transform, enemyData.moveDuration);

        // バレットのデータがあり、かつ、バレットの種類が None ではない場合
        if (bulletData != null && bulletData.bulletType != BulletDataSO.BulletType.None) {

　　　　　　// バレットの自動生成処理を実行する
            StartCoroutine(EnemyShot(bulletData));
        }
        Debug.Log("追加設定完了");
    }

    /// <summary>
    /// バレットの自動生成
    /// </summary>
    /// <returns></returns>
    private IEnumerator EnemyShot(BulletDataSO.BulletData bulletData) {

        // 条件に true を指定すると無制限のループ処理になる
        while (true) {

            // エネミーのバレットのクローンを生成し、戻り値を bulletObj 変数に代入
            GameObject bulletObj = Instantiate(enemyBulletPrefab, transform);

　　　　　　// クローンのゲームオブジェクトから Bullet スクリプトを取得して、ShotBullet メソッドを実行する
            bulletObj.GetComponent<Bullet>().ShotBullet(enemyGenerator.PreparateGetPlayerDirection(transform.position), bulletData);

            // ボスの場合
            if (enemyData.moveType == MoveType.Boss_Horizontal) {

                // バレットとエネミーの親子関係を解消し、バレットの親を TemporaryObjectContainer ゲームオブジェクトに変更する
                bulletObj.transform.SetParent(TransformHelper.GetTemporaryObjectContainerTran());
            }

　　　　　　// BulletData に設定されている待機時間分だけ処理を中断する(待機する)
            yield return new WaitForSeconds(bulletData.loadingTime);
        }
    }

    /// <summary>
    /// バレットの攻撃力値分のフロート表示の生成
    /// </summary>
    /// <param name="bulletPower"></param>
    /// <param name="isWeakness"></param>
    private void CreateFloatingMessageToBulletPower(int bulletPower, bool isWeakness) {

        // フロート表示の生成。生成位置は EnemySet ゲームオブジェクト内の FloatingMessageTran ゲームオブジェクトの位置(子オブジェクト)
        FloatingMessage floatingMessage = Instantiate(floatingMessagePrefab, floatingDamageTran, false);

        // 生成したフロート表示の設定用メソッドを実行。引数として、バレットの攻撃力値とフロート表示の種類を指定して渡す
        floatingMessage.DisplayFloatingMessage(bulletPower, FloatingMessage.FloatingMessageType.EnemyDamage, isWeakness);
    }
}

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

２－５．BulletSelectManager スクリプトを修正する

　同じく Exp の減算時の処理についても修正を行います。
こちらもやはりポイントは処理の順番と、引数です。

BulletSelectManager.cs

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

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

public class BulletSelectManager : MonoBehaviour
{
    [SerializeField]
    private BulletSelectDetail bulletSelectDetailPrefab;　　// BulletSelectDetail スクリプトがアタッチされている、プレファブの btnBulletSelect ゲームオブジェクトをアサインする

    [SerializeField]
    private Transform bulletTran;                           // バレット選択ボタンの生成位置として利用するゲームオブジェクトをアサインする

    private const int maxBulletBtnNum = 4;                  // バレット選択ボタンの最大数。定数として宣言する

    public List<BulletSelectDetail> bulletSelectDetailList = new List<BulletSelectDetail>();      // 生成されたバレット選択ボタンの List

    [SerializeField]
    private BulletDataSO bulletDataSO;                     // BulletDataSO スクリプタブル・オブジェクトをアサインする

    [SerializeField]
    private ElementDataSO elementDataSO;　　　　　　　 　 // ElementDataSO スクリプタブル・オブジェクトをアサインする

    private GameManager gameManager;　


    /// <summary>
    /// バレット選択用ボタンの生成
    /// </summary>
    /// <param name="gameManager"></param>
    /// <returns></returns>
    public IEnumerator GenerateBulletSelectDetail(GameManager gameManager) {

        this.gameManager = gameManager;

        // BulletDataSO スクリプタブル・オブジェクトのデータから、利用者の種類が Player のバレットの情報だけを代入する List を用意する
        List<BulletDataSO.BulletData> playerBulletDatas = new List<BulletDataSO.BulletData>();

        // バレットの利用者の種類が Player のバレットの情報だけを抽出して List を作成する
        playerBulletDatas = bulletDataSO.bulletDataList.Where(x => x.liberalType == BulletDataSO.LiberalType.Player).ToList();

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

            // バレットボタン生成
            BulletSelectDetail bulletSelectDetail = Instantiate(bulletSelectDetailPrefab, bulletTran, false);

            // TODO バレットボタンの設定。また後で引数に変更があります
            bulletSelectDetail.SetUpBulletSelectDetail(this, playerBulletDatas[i]); 

            // リストに追加
            bulletSelectDetailList.Add(bulletSelectDetail);

　　　　　　// 0.25 秒だけ処理を中断(順番にボタンが生成されるようにする演出)
            yield return new WaitForSeconds(0.25f);
        }

        // 使用するバレットの情報を初期設定
        GameData.instance.SetBulletData(playerBulletDatas[0]);  
    }

    /// <summary>
    /// すべてのバレット選択ボタンに対して no で照合を行い、装填中と未装填の状態を変更
    /// </summary>
    /// <param name="bulletNo"></param>
    public void ChangeLoadingBulletSettings(int bulletNo) {

　　　　// バレット選択ボタンの List の要素をすべて取り出し、１つずつ順番に処理する
        for (int i = 0; i < bulletSelectDetailList.Count; i++) {

            // この要素のバレット選択ボタンの no の値が bulletNo (選択されたバレット)と同じであるなら
            if (bulletSelectDetailList[i].bulletData.no == bulletNo) {

                // 装填中状態にする
                bulletSelectDetailList[i].ChangeLoadingBullet(true);

                bulletSelectDetailList[i].ChangeColorToBulletBtn(new Color(0.65f, 0.65f, 0.65f));

　　　　　　// それ以外の no の場合には
            } else {

                // 未装填状態にする
                bulletSelectDetailList[i].ChangeLoadingBullet(false);

                bulletSelectDetailList[i].ChangeColorToBulletBtn(new Color(1.0f, 1.0f, 1.0f));
            }
        }
    }

    /// <summary>
    /// 初期バレットを装填中のバレットとして設定
    /// </summary>
    public void ActivateDefaultBullet() {

        // バレット選択ボタンの List から要素を１つずつ取り出す
        foreach (BulletSelectDetail bulletSelectDetail in bulletSelectDetailList) {

            // 初期バレットの設定があるバレットのデータの場合
            if (bulletSelectDetail.isDefaultBullet) {

                // そのバレットを装填中の状態にする
                bulletSelectDetail.OnClickBulletSelect();

                Debug.Log("初期バレットを装填中のバレットとして設定");

                return;
            }
        }
    }

    /// <summary>
    /// 使用可能バレット選択ボタンの確認と更新
    /// </summary>
    public void JugdeOpenBullets() {

　　　　// 繰り返し利用する情報を変数に代入しておく
        int totalExp = GameData.instance.GetTotalExp();

        // バレットごとに使用可能なEXPを超えているか確認
        foreach (BulletSelectDetail bulletData in bulletSelectDetailList) {

            // ゲーム終了の状態になったら
            if (gameManager.isGameUp) {

                // バレット選択ボタンを非活性化の状態にしてタップできない状態にする
                bulletData.SwitchActivateBulletBtn(false);

                continue;
            }

            // コストを支払っているかどうか、戻り値を持つメソッドを利用して確認する
            if (bulletData.GetStateBulletCostPayment()) {

                // コストを支払い済みの場合、そのバレット選択ボタンはオンの状態にする
                bulletData.SwitchActivateBulletBtn(true);

                continue;
            }

            // バレットに設定されているコストの値よりも、Exp の現在値の方が大きいか同じであれば
            if (bulletData.bulletData.openExp <= totalExp) {

                // そのバレット選択ボタンを活性化の状態にしてタップできるようにする
                bulletData.SwitchActivateBulletBtn(true);

                if (!bulletData.IsOpenAnimation) {
                    bulletData.OpenBulletAnimation(true);
                }
            } else {
                // Exp の現在値が超えていないバレット選択ボタンを非活性化の状態にしてタップできないようにする
                bulletData.SwitchActivateBulletBtn(false);

                if (bulletData.IsOpenAnimation) {
                    bulletData.OpenBulletAnimation(false);
                }
            }
        }
    }

    /// <summary>
    /// 選択したバレットのコストの支払いとそれに関連する処理
    /// </summary>
    /// <param name="costExp"></param>
    public void SelectedBulletCostPayment(int costExp) {


////*  ここから処理の順番を入れ替える  *////


        // 画面の Exp 表示減算後の値に更新
        gameManager.uiManager.DisplayTotalExp(-costExp);

        // コストの値のフロート表示を生成
        gameManager.uiManager.CreateFlotingMessageToExp(-costExp, FloatingMessage.FloatingMessageType.BulletCost);

        // TotalExp(Exp の現在値) より、選択したバレットのコストを減算
        GameData.instance.UpdateTotalExp(-costExp);　　　　　//　<=　引数を変更します


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


        // 使用可能バレットの確認と更新
        JugdeOpenBullets();
    }

    /// <summary>
    /// ElementTypeからSprite取得用
    /// </summary>
    /// <param name="elementType"></param>
    /// <returns></returns>
    public Sprite GetElementTypeSprite(ElementType elementType) {

        // elementDataList 変数の要素を１つずつ順番いに取り出して、elementData 変数へ代入
        foreach (ElementDataSO.ElementData elementData in elementDataSO.elementDataList) {

            // 現在代入されている ElementData の ElementType と引数の elementType が同じであるであるか照合
            if (elementData.elementType == elementType) {

                // 照合の結果、合致した ElementData に登録されている画像情報を戻す
                return elementData.elementSprite;
            }
        }

        // どれも合致しない場合は null を戻す
        return null;
    }

    /// <summary>
    /// BulletType より BulletData を検索して取得
    /// </summary>
    /// <param name="bulletType"></param>
    /// <returns></returns>
    public BulletDataSO.BulletData GetBulletData(BulletDataSO.BulletType bulletType) {

        // 引数の bulletType と同じ BulletType が登録されている BulletData を探す
        foreach (BulletDataSO.BulletData bulletData in bulletDataSO.bulletDataList.Where(x => x.bulletType == bulletType)) {

            // 合致した BulletData を戻す
            return bulletData;
        }

        // どれも合致しない場合は null を戻す
        return null;
    }
}

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

２－６．処理にコメントを記述する

　今回の４つのスクリプトにおいて実装している処理についてはコメントを割愛しています。
これらの処理について、ゲーム上での動作としてコメントを記述できるか、挑戦してください。

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

　実装する内容を確認し、デバッグが必要な部分を理解した上で処理を実行してください。
何か所かデバッグを行う必要がありますので、それを自分で１つずつ確認していってみましょう。

＜実装動画　Exp 加算時＞

動画ファイルへのリンク

＜実装動画　Exp 減算時＞

動画ファイルへのリンク

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

　次は　拡張３　－キャラモデルのアニメ演出の追加－　です。

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

印刷する

コメント（0）

２Ｄタップシューティングゲーム　拡張２ - i-school 先頭へ

コメントをかく

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

i-school