２Ｄタワーディフェンス　発展９ - i-school

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

発展９　ーステージ機能の実装ー

１４．ステージデータを利用して、ステージの番号に応じた MainMap ゲームオブジェクトを生成して自動的に設定を行う機能を実装する

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

　・１つのシーンを異なる情報を使って運用する方法③
　・処理の読み解き方　ータプルによる分解代入処理ー

１４．ステージデータを利用して、ステージの番号に応じた MainMap ゲームオブジェクトを生成して自動的に設定を行う機能を実装する

１．設計

　Start メソッドを利用して、GameData クラスに設定されている StageNo 変数からステージの情報 StageData クラスを取得します。
この情報を利用して、ステージ、防衛拠点の生成を行い、EnemyGenerator クラスに移動経路と生成するエネミーの情報を提供します。

　DefenseBase クラス、EnemyGenerator クラスの Start メソッドは、GameManager クラスから命令を受けてから実行されるメソッドに変更し、
GameManager クラスから命令を受けてから各クラス内の設定を行うように設計を変更しています。

　そのため、ゲームを開始する際の設定情報については、GameManager クラスの Start メソッドがすべての開始地点となり、
ここから各クラスへ設定を行うように命令を出すようにすることで、順序立てた通りに処理を実行していく作りになっています。

　処理のロジックは、スタート地点からゴール地点へ向かって、コメントを書いていくようにします。
その後、ゴール地点側から、スタート地点へ向かって、コメントに沿ったプログラムを実装するようにします。

　このようにロジックを組み立てていくことで、処理の流れを確認しながらプログラムを実装することが出来ます。

　今回であれば、処理のスタート地点は GameManager クラスです。こちらの Start メソッド内が該当します。
TODO を記述していますので、このようにコメントを書いていくといいでしょう。

　GameManager クラス内にメソッドを追加する場合には、この時点でコメントを作っておきます。
コメントは詳細に、記述したい内容を書いておくことでプログラムを作りやすくなります。

　GameManager クラス内のコメントを書き終わったら、ここから先のクラスへ展開します。
ステージデータを参照して処理をしているクラスを見直し、どのクラスに影響があるかを精査します。

　現時点では、DefenseBase クラスにある耐久力の値、EnemyGenerator クラスにあるエネミーの移動経路の情報が、
ステージデータを参照する部分になりますので、該当する変数の部分にそれぞれのクラスにコメントを記述するようにします。

　変数に代入している部分があるのであればその上にコメントを書いて、ステージデータを参照する値にする、と書いておきましょう。

　このとき重要になるのは、どのようにしてステージの情報から各値を参照するようにするかです。
これにはメソッドの引数を上手く活用していきましょう。GameManager クラスから各クラスにあるメソッドを実行する際に、
必要な情報を提供するためには、どのような処理が必要になるかを検討してみてください。

　DefenseBase クラスのように Start メソッドから始まっていて、GameManager クラスから呼び出すためのメソッドがない場合には、
新しく public 修飾子のメソッドを作成して、それを GameManager クラスから実行し、必要な情報を引数を通じて受け取れるようにしましょう。

　今回は先ほども説明したように Start メソッドは GameManager クラスのみとし、他のクラスはメソッドを実行して処理が始めるようにしてみてください。

　このようにして処理の流れをイメージし、イメージしたものをコメントにしていくことで処理の全体像を意識してください。

　すべての処理がつながったら、今後は、GameManager クラスに向かって、コメントになっている部分をプログラム化していきます。
EnemyGenerator クラス、DefenseBase クラスを修正してから GameManager クラスのコメント部分をプログラムにできれば、
呼び出す対象のメソッドが完成しているため、エラーも出ずに、キレイな処理の実装が完成出来ます。

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

　設計に基づいて処理のロジックを組んでいきます。
設計で提示したロジックの流れと実装していく内容を１つずつ確認しながら、処理の内容を理解していきましょう。

　GenerateEnemy メソッドは、参照する情報を StageData クラスのものに変更します。
そのため修正箇所が多いですので、気を付けて処理の追加をおこなってください。

EnemyGenerator.cs

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

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

public class EnemyGenerator : MonoBehaviour
{
    [SerializeField]
    private EnemyController enemyControllerPrefab;

    [SerializeField]
    private PathData[] pathDatas;

    [SerializeField]
    private DrawPathLine pathLinePrefab;

    private GameManager gameManager;


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


    private StageData stageData;


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



////*  ここから２か所、処理を追加  *////


　　/// <summary>
    /// 敵の生成準備
    /// </summary>
    /// <returns></returns>
    public IEnumerator PreparateEnemyGenerate(GameManager gameManager, StageData stageData) {　　　//　<=　☆１　第２引数を追加する

        this.stageData = stageData;　　　//　<=　☆２　処理を追加する


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


        this.gameManager = gameManager;

        // 生成用のタイマー用意
        int timer = 0;

        // isEnemyGenetate が true の間はループする
        while (gameManager.isEnemyGenerate) {

            if (this.gameManager.currentGameState == GameManager.GameState.Play) {

                // タイマーを加算
                timer++;

                // タイマーの値が敵の生成待機時間を超えたら
                if (timer > gameManager.generateIntervalTime) {

                    // 次の生成のためにタイマーをリセット
                    timer = 0;

                    // 敵の生成し、敵の生成数のカウントアップと List への追加
                    gameManager.AddEnemyList(GenerateEnemy(gameManager.generateEnemyCount));

                　　// 最大生成数を超えたら生成停止
                　　gameManager.JudgeGenerateEnemysEnd();
                }                                                 
            }

            // 1フレーム中断
            yield return null;
        }

        // TODO 生成終了後の処理を記述する

    }

    /// <summary>
    /// 敵の生成
    /// </summary>
    /// <param name="generateNo"></param>
    /// <returns></returns>
    public EnemyController GenerateEnemy(int generateNo = 0) {


////*  ここから処理をコメントアウト  *////


　　　　// ランダムな値を配列の最大要素数内で取得
        //int randomValue = Random.Range(0, pathDatas.Length);   //  コメントアウトします

        // 指定した位置に敵を生成
        //EnemyController enemyController = Instantiate(enemyControllerPrefab, pathDatas[randamValue].generateTran.position, Quaternion.identity);    //  コメントアウトします

        // 移動する地点を取得
        //Vector3[] paths = pathDatas[randamValue].pathTranArray.Select(x => x.position).ToArray();   //  コメントアウトします

  　　　// 敵の種類をランダムに決定
　　　　//enemyNo = Random.Range(0, DataBaseManager.instance.enemyDataSO.enemyDatasList.Count);   //  コメントアウトします


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


////*  ここから処理を追加  *////


        // 生成位置(基本的には Element の番号と同じ。-1 の場合はランダム)
        int posNo = generateNo;

        // 生成位置がランダムか確認
        if (stageData.mapInfo.appearEnemyInfos[generateNo].isRandomPos) {
            posNo = Random.Range(0, stageData.mapInfo.appearEnemyInfos.Length);
        }

        // 敵の生成
        EnemyController enemyController = Instantiate(enemyControllerPrefab, stageData.mapInfo.appearEnemyInfos[posNo].enemyPathData.generateTran.position, Quaternion.identity);

        // 敵の種類
        int enemyNo = stageData.mapInfo.appearEnemyInfos[generateNo].enemyNo;

        // 敵がランダムか確認
        if (stageData.mapInfo.appearEnemyInfos[generateNo].enemyNo == -1) {
            enemyNo = Random.Range(0, DataBaseManager.instance.enemyDataSO.enemyDatasList.Count);
        }

        // 経路の作成
        Vector3[] paths = stageData.mapInfo.appearEnemyInfos[posNo].enemyPathData.pathTranArray.Select(x => x.position).ToArray();


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


        // 敵の情報の設定(第3引数を追加)
        enemyController.SetUpEnemyController(paths, gameManager, DataBaseManager.instance.enemyDataSO.enemyDatasList[enemyNo]);

        // 敵の移動経路のライン表示を生成の準備
        StartCoroutine(PreparateCreatePathLine(paths));

        return enemyController;
    }

    /// <summary>
    /// ライン生成の準備
    /// </summary>
    /// <param name="paths"></param>
    /// <returns></returns>
    private IEnumerator PreparateCreatePathLine(Vector3[] paths) {

　　　　// ラインの生成と削除。この処理が終了するまでは、この処理より下の処理は実行されない
        yield return StartCoroutine(CreatePathLine(paths));

　　　　// ゲームの進行状態が Play になるまで処理を中断して待機
　　　　yield return new WaitUntil(() => gameManager.currentGameState == GameManager.GameState.Play);

　　　　// 敵の移動を再開
        enemyController.ResumeMove();
    }

    /// <summary>
    /// 移動経路用のラインの生成と破棄
    /// </summary>
    private IEnumerator CreatePathLine(Vector3[] paths) {

  　　　// List の宣言と初期化
        List<DrawPathLine> drawPathLinesList = new List<DrawPathLine>();

        // １つの Path ごとに１つずつ順番にラインを生成
        for (int i = 0; i < paths.Length - 1; i++) {
            DrawPathLine drawPathLine = Instantiate(pathLinePrefab, transform.position, Quaternion.identity);

            Vector3[] drawPaths = new Vector3[2] { paths[i], paths[i + 1] };

            drawPathLine.CreatePathLine(drawPaths);

            drawPathLinesList.Add(drawPathLine);

            yield return new WaitForSeconds(0.1f);
        }

        // すべてのラインを生成して待機
        yield return new WaitForSeconds(0.5f);

        // １つのラインずつ順番に削除する
        for (int i = 0; i < drawPathLinesList.Count; i++) {
            Destroy(drawPathLinesList[i].gameObject);

            yield return new WaitForSeconds(0.1f);
        }
    }


////*  ここからメソッドを１つ追加  *////


    /// <summary>
    /// ステージに応じた PathDatas をセット
    /// </summary>
    public void SetUpPathDatas(PathData[] pathDatas) {
 
        // 初期化して代入
        this.pathDatas = new PathData[pathDatas.Length];
        this.pathDatas = pathDatas;
    }


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


}

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

３．DefenseBase スクリプトを修正する

　StageData クラスに設定されている耐久力の値を参照して、防衛拠点の耐久力を設定するように処理を修正します。

　Start メソッドを public 修飾子を持つ SetUpDefenseBase メソッドに書き換えて、引数も追加します。
このメソッドを GameManager クラス側から実行してもらって、引数を通じて情報をもらいつつ、設定を行うようにします。

DefenseBase.cs

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

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

public class DefenseBase : MonoBehaviour
{
    [SerializeField, Header("耐久値")]
    private int maxDefenseBaseDurability;

    private int defenseBaseDurability;      // 耐久力の現在値


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


    private GameManager gameManager;

    private UIManager uiManager;


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


////*  Start メソッドを変更する。ここから処理を追加  *////


    /// <summary>
    /// 設定
    /// </summary>
    /// <param name="gameManager"></param>
    public void SetUpDefenseBase(GameManager gameManager, int defenseBaseDurability, UIManager uiManager) {

        this.gameManager = gameManager;
        this.uiManager = uiManager;


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


        // 耐久力の最大値を決定する
　　　　// デバッグモードを適用している場合
        if (GameData.instance.isDebug) {

　　　　　　// GameData に設定している defenseBaseDurability を利用する
            maxDefenseBaseDurability = GameData.instance.defenseBaseDurability;

        } else {

　　　　　　// デバッグモードを適用していない場合には、この引数の値を利用する
            maxDefenseBaseDurability = defenseBaseDurability;
        }


////*  ここから修正  *////


        // 耐久力の初期値の設定
　　    this.defenseBaseDurability = maxDefenseBaseDurability;


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


    }

    private void OnTriggerEnter2D(Collider2D collision) {

        // 侵入してきたゲームオブジェクトの確認と敵キャラの情報の取得
        if (collision.gameObject.TryGetComponent(out EnemyController enemyController)) {

            // 敵キャラの攻撃力分だけ耐久力を減算し、耐久力の値の下限と上限内に収まるように制御した上で更新
            defenseBaseDurability = Mathf.Clamp(defenseBaseDurability - enemyController.attackPower, 0, maxDefenseBaseDurability);

            // TODO ダメージ演出生成


            // TODO ゲーム画面に耐久力の表示がある場合、その表示を更新


////*  条件式を追加  *////


            // 耐久力の残りを確認
            if (defenseBaseDurability <= 0 && gameManager.currentGameState == GameManager.GameState.Play) {   // <=  ☆　条件を追加します


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


                Debug.Log("Game Over");

                // TODO ゲームオーバー処理
                
            }

            // 敵の破壊
            enemyController.DestroyEnemy();
        }
    }

    // TODOダメージ演出生成用のメソッドの作成

}

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

４．CharaGenerator スクリプトを修正する

　いままではステージがヒエラルキーにあり、かつ固定であったため、grid 変数と tilemaps 変数も最初からアサインしておくことが出来ました。

　ただし、これからはステージ自体がプレハブとなり、ゲームの実行後に生成されることになりましたので、
ステージの情報である MapInfo も動的に変化するようになりました。

　そのため、CharaGenerator において利用する Grid と Tilemap の情報も、今回のステージの情報を利用する方式に変更する必要があります。

　SetUpCharaGenerator メソッド内に TODO で残っている部分を追加して、メソッドの引数を利用して今回利用するステージの情報を受け取り、
それを使って、grid 変数と tilemaps 変数に情報を代入してステージ情報を参照して利用する方式に変更していきます。

CharaGenerator.cs

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

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

public class CharaGenerator : MonoBehaviour
{
    [SerializeField]
    private CharaController charaControllerPrefab;

    [SerializeField]
    private Grid grid;     　　　　// Base 側の Grid を指定する 

    [SerializeField]
    private Tilemap tilemaps;　　　// Walk 側の Tilemap を指定する

    [SerializeField]
    private PlacementCharaSelectPopUp placementCharaSelectPopUpPrefab;　　　//　PlacementCharaSelectPopUp プレファブゲームオブジェクトをアサイン用

    [SerializeField]
    private Transform canvasTran;　　　　　　　　　　　　　　　　　　　　　 //　PlacementCharaSelectPopUp ゲームオブジェクトの生成位置の登録用

    [SerializeField, Header("キャラのデータリスト")]
    private List<CharaData> charaDatasList = new List<CharaData>();

    private PlacementCharaSelectPopUp placementCharaSelectPopUp;　　　　　　//　生成された PlacementCharaSelectPopUp ゲームオブジェクトを代入するための変数

    private GameManager gameManager;

    private Vector3Int gridPos;


    void Update()
    {
        // 配置できる最大キャラ数に達している場合には配置できない
        if (gameManager.GetPlacementCharaCount() >= GameData.instanc.maxCharaPlacementCount) {
            return;
        }

        // 画面をタップ(マウスクリック)し、かつ、配置キャラポップアップが非表示状態なら
        if (Input.GetMouseButtonDown(0) && !placementCharaSelectPopUp.gameObject.activeSelf && gameManager.currentGameState == GameManager.GameState.Play) {

            // タップ(マウスクリック)の位置を取得してワールド座標に変換し、それをさらにタイルのセル座標に変換
            gridPos = grid.WorldToCell(Camera.main.ScreenToWorldPoint(Input.mousePosition));

            // タップした位置のタイルのコライダーの情報を確認し、それが None であるなら
            if (tilemaps.GetColliderType(gridPos) == Tile.ColliderType.None) {

                // 配置キャラ選択用ポップアップの表示
                ActivatePlacementCharaSelectPopUp();
            }
        }
    }

    /// <summary>
    /// 設定
    /// </summary>
    /// <param name="gameManager"></param>
    /// <returns></returns>
    public IEnumerator SetUpCharaGenerator(GameManager gameManager, Mapinfo mapInfo) {  // ←　☆　第２引数を追加

        this.gameManager = gameManager;


////*　ここから TODO を実装　*////


　　　　// ステージのデータを取得
　　　　(tilemaps, grid) = currentMapInfo.GetMapInfo();


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


        // キャラのデータをリスト化
        CreateHaveCharaDatasList();

　　　　// キャラ配置用のポップアップの生成
        yield return StartCoroutine(CreatePlacementCharaSelectPopUp());
    }


    /// <summary>
    /// 配置キャラ選択用ポップアップ生成
    /// </summary>
    /// <returns></returns>
    private IEnumerator CreatePlacementCharaSelectPopUp() {

　　　　// ポップアップを生成
        placementCharaSelectPopUp = Instantiate(placementCharaSelectPopUpPrefab, canvasTran, false);

        // ポップアップの設定。キャラ設定用の情報も渡す
        placementCharaSelectPopUp.SetUpPlacementCharaSelectPopUp(this, charaDatasList);

　　　　// ポップアップを非表示にする
        placementCharaSelectPopUp.gameObject.SetActive(false);

        yield return null;
    }

    /// <summary>
    /// 配置キャラ選択用のポップアップの表示
    /// </summary>
    public void ActivatePlacementCharaSelectPopUp() {

        // ゲームの進行状態をゲーム停止に変更
        gameManager.SetGameState(GameManager.GameState.Stop);

        // すべての敵の移動を一時停止
        gameManager.PauseEnemies();

        // 配置キャラ選択用のポップアップの表示
        placementCharaSelectPopUp.gameObject.SetActive(true);
        placementCharaSelectPopUp.ShowPopUp();
    }

    /// <summary>
    /// 配置キャラ選択用のポップアップの非表示
    /// </summary>
    public void InactivatePlacementCharaSelectPopUp() {

　　　　// 配置キャラ選択用のポップアップの非表示
        placementCharaSelectPopUp.gameObject.SetActive(false);

        // ゲームオーバーやゲームクリアではない場合
        if (gameManager.currentGameState == GameManager.GameState.Stop) {

　　　　    // ゲームの進行状態をプレイ中に変更して、ゲーム再開
            gameManager.SetGameState(GameManager.GameState.Play);
            
　　　　    // すべての敵の移動を再開
            gameManager.ResumeEnemies();

            // カレンシーの加算処理を再開
            StartCoroutine(gameManager.TimeToCurrency());
        }
    }

    /// <summary>
    /// キャラのデータをリスト化
    /// </summary>
    private void CreateHaveCharaDatasList() {

　　　　// CharaDataSO スクリプタブル・オブジェクト内の CharaData を１つずつリストに追加
        // TODO スクリプタブル・オブジェクトではなく、実際にプレイヤーが所持しているキャラの番号を元にキャラのデータのリストを作成
        for (int i = 0; i < DataBaseManager.instance.charaDataSO.charaDatasList.Count; i++) {
            charaDatasList.Add(DataBaseManager.instance.charaDataSO.charaDatasList[i]));
        }
    }

    /// <summary>
    /// 選択したキャラを生成して配置
    /// </summary>
    /// <param name="charaData"></param>
    public void CreateChooseChara(CharaData charaData) {

        // コスト支払い
        GameData.instance.currency -= charaData.cost;

        // カレンシーの画面表示を更新
        gameManager.uiManager.UpdateDisplayCurrency();

        // キャラをタップした位置に生成
        CharaController chara = Instantiate(charaControllerPrefab, gridPos, Quaternion.identity);

        // 位置が左下を 0,0 としているので、中央にくるように調整
        chara.transform.position = new Vector2(chara.transform.position.x + 0.5f, chara.transform.position.y + 0.5f);

        // キャラの設定
        chara.SetUpChara(charaData, gameManager);

　　　　Debug.Log(charaData.name);   // 選択しているキャラのデータがとどいているかを確認するためのログ表示

        // キャラを List に追加
        gameManager.AddCharasList(chara);
    }
}

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

＜処理の読み解き方　ータプルによる分解代入処理ー＞

　今回追加した処理では、SetUpCharaGenerator メソッドに第２引数を追加して、MapInfo クラスの参照を受け取っています。

　MapInfo クラスには、Timemap 型と Grid 型が宣言されていますが、どちらも private の情報です。
そのため、MapInfo クラスに用意してあるゲッターメソッドを利用して、これらの情報を取得するようにしています。

　この GetMapInfo()メソッドの戻り値はタプル型であるため、既に宣言されている変数にタプルを分解することができます。
その結果、今回のような処理を記述することで、２つの型の情報をまとめて代入することが出来ます。

＜MapInfo.GetMapInfo() メソッド＞

    /// <summary>
    /// マップの情報を取得
    /// </summary>
    /// <returns></returns>
    public (Tilemap, Grid) GetMapInfo() {
        return (tilemaps, grid);
    }

　SetUpCharaGenerator メソッド内では、GetMapInfo() メソッドを実行することで、
Timemap 型と Grid 型の両方の情報を取得し、変数にまとめて代入処理しています。

＜今回実装している処理＞

// ステージのデータを取得
(tilemaps, grid) = currentMapInfo.GetMapInfo();

　型で見ると分かりやすくなります。

// ステージのデータを取得
(Tilemap 型, Grid 型) = GetMapInfo() メソッドの戻り値 (Tilemap 型, Grid 型);

　同じ型同士の代入処理が行われていることが分かります。

　また、タプルの値を別々に受け取る書式でも取得出来ます。

＜今回実装している処理の別の書式＞

// ステージのデータをそれぞれに分けて取得
tilemaps = currentMapInfo.GetMapInfo().item1;　　//　<=　item1 は、タプルの最初の値

grid = currentMapInfo.GetMapInfo().item2;　　　　//　<=　item2 は、タプルの２番目の値

　この例では、必要な Timemap と Grid の値を１つの情報として取り出して、代入処理を行っています。

　どちらの処理でも問題ありません。

　また、タプルの書式には、他の方法もあります。

　例えば、ローカル変数を用意して、GetMapInfo() メソッドを１回だけ実行するケースです。

＜別の実装例①＞

(Tilemap, Grid) currentTileData = currentMapInfo.GetMapInfo();

// ステージのデータを取得
tilemaps = currentTileData.item1;

grid = currentTileData.item2;

　タプルには各変数名をつけることが出来るため、下記の方法でも実装出来ます。

＜別の実装例②＞

(Tilemap currentTilemap, Grid currentGrid) currentTileData = currentMapInfo.GetMapInfo();

// ステージのデータを取得
tilemaps = currentTileData.currentTilemap;

grid = currentTileData.currentGrid;

　その場合、item ではなく、タプル内で作成した変数を使うことが出来ます。

　バリュータプルの機能が利用できる場合、MapInfo の GetMapInfo() メソッドの戻り値に変数を定義できます。

＜MapInfo.GetMapInfo() メソッドの戻り値にバリュータプルを利用した場合＞

    /// <summary>
    /// マップの情報を取得
    /// </summary>
    /// <returns></returns>
    public (Tilemap currentTilemap, Grid currentGrid) GetMapInfo() {    //  ←　戻り値に変数名を定義できる
        return (tilemaps, grid);
    }

　その場合、情報を取り出すときに、item ではなく、変数名で指定できます。

// ステージのデータを取得
tilemaps = currentMapInfo.GetMapInfo().currentTilemap;

grid = currentMapInfo.GetMapInfo().currentGrid;

　いずれの方法でも実装可能ですので、実際に使う処理は１つですが、読み解き方は覚えておくとよいでしょう。

参考サイト

MicroSoft
タプルとその他の型の分解

５．GameManager を修正する

　Start メソッドを利用して、GameData クラスに設定されている StageNo 変数からステージの情報 StageData クラスを取得します。
この情報を利用して、キャラ配置用のポップアップにステージの情報を引数を通じて提供します。(そのため、メソッドの引数を追加しています。)

　また、ステージ、防衛拠点の生成を行い、EnemyGenerator クラスに移動経路と生成するエネミーの情報を提供します。

　DefenseBase クラス、EnemyGenerator クラスの Start メソッドは、GameManager クラスから命令を受けてから実行されるメソッドに変更し、
あくまでも、GameManager クラスから命令を受けてから設定を行うように設計を変更しています。

　そのため、ゲームを開始する際の設定情報については、GameManager クラスの Start メソッドがすべての開始地点となり、
ここから各クラスへ設定を行うように命令を出すようにすることで、順序立てた通りに処理を実行していくようになっています。

　処理の追加・修正が多く、また多くのクラスにまたがって処理が進んでいくため、
しっかりと処理の流れを追いかけて読み解き、どのようにして処理が動いているかを把握するようにしてください。

GameManager.cs

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

public class GameManager : MonoBehaviour
{
    [SerializeField]
    private EnemyGenerator enemyGenerator;

    [SerializeField]
    private CharaGenerator charaGenerator;

    public bool isEnemyGenerate;

    public int generateIntervalTime;

    public int generateEnemyCount;

    public int maxEnemyCount;

    /// <summary>
    /// ゲームの状態
    /// </summary>
    public enum GameState {
        Preparate,       // ゲーム開始前の準備中
        Play,            // ゲームプレイ中
        Stop,            // ゲーム内の処理の一時停止中
        GameUp           // ゲーム終了(ゲームオーバー、クリア両方)
    }

    public GameState currentGameState;    // 現在の GameState の状態。上記の GameState の列挙子が１つだけ代入されるので、他の GameState と競合しない

    [SerializeField]
    private List<EnemyController> enemiesList = new List<EnemyController>();　　　//　敵の情報を一元化して管理するための変数。EnemyController 型で扱う

    private int destroyEnemyCount;                //  敵を破壊した数のカウント用

    public UIManager uiManager;

    [SerializeField]
    private List<CharaController> charasList = new List<CharaController>();　　　 // 配置したキャラの情報を一元化して管理するための変数。CharaController 型で扱う


////*  ここから変数の宣言を４つ追加する  *////


    [SerializeField]
    private DefenseBase defenseBase;          // 生成した防衛拠点の情報を代入するための変数

    [SerializeField]　　　　　　　　　　　　　// デバッグのために SerializeField 属性を利用してインスペクターで確認できるようにしている
    private MapInfo currentMapInfo;　　　　　 // 生成したステージのゲームオブジェクト(MapInfo クラスのアタッチされている MainMap ゲームオブジェクト)を代入するための変数

    [SerializeField]
    private DefenseBase defenseBasePrefab;　　// 防衛拠点のプレファブをアサインするための変数

    [SerializeField]
    private StageData currentStageData;　　　 // 今回のバトルで使用するステージのデータ情報


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



////*  Start メソッド内の処理を３箇所(☆①～③)追加  *////

    void Start() {

        // ゲームの進行状態を準備中に設定
        SetGameState(GameState.Preparate);


        // TODO ゲームデータを初期化


////*  ☆①　ここから TODO を実装①と SetUpCharaGenerator メソッドの第２引数の情報を追加  *////


        // ステージの設定 + ステージごとの PathData を設定(ここで MapInfo が確定されている)
        SetUpStageData();


        // キャラ配置用ポップアップの生成と設定
        StartCoroutine(charaGenerator.SetUpCharaGenerator(this, currentMapInfo));  // ←　☆第２引数を追加。今回のマップの情報を渡す


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


////*  ☆②　ここから TODO を実装②  *////


        // TODO 拠点の設定
        defenseBase.SetUpDefenseBase(this, currentStageData.defenseBaseDurability, uiManager);


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


        // TODO オープニング演出再生


        isEnemyGenerate = true;

        // ゲームの進行状態をプレイ中に変更
        SetGameState(GameState.Play);


////*  ☆③　ここから処理を修正  *////


        // 敵の生成準備開始
        StartCoroutine(enemyGenerator.PreparateEnemyGenerate(this, currentStageData));　　//　<=　第２引数を追加


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


        // カレンシーの自動獲得処理の開始
        StartCoroutine(TimeToCurrency());
   }

    /// <summary>
    /// 敵の情報を List に追加
    /// </summary>
    /// <param name="enemy"></param>
    public void AddEnemyList(EnemyController enemy) {

        enemiesList.Add(enemy);

　　　　// 敵の生成数をカウントアップ
        generateEnemyCount++;
    }

    /// <summary>
    /// 敵の生成を停止するか判定
    /// </summary>
    public void JudgeGenerateEnemysEnd() {
        if (generateEnemyCount >= maxEnemyCount) {
            isEnemyGenerate = false;
        }
    }

    /// <summary>
    /// GameState の変更
    /// </summary>
    /// <param name="nextGameState"></param>
    public void SetGameState(GameState nextGameState) {
        currentGameState = nextGameState;
    }

    /// <summary>
    /// すべての敵の移動を一時停止
    /// </summary>
    public void PauseEnemies() {
        for (int i = 0; i < enemiesList.Count; i++) {
            enemiesList[i].PauseMove();
        }
    }

    /// <summary>
    /// すべての敵の移動を再開
    /// </summary>
    public void ResumeEnemies() {
        for (int i = 0; i < enemiesList.Count; i++) {
            enemiesList[i].ResumeMove();
        }
    }

    /// <summary>
    /// 敵の情報を List から削除
    /// </summary>
    /// <param name="removeEnemy"></param>
    public void RemoveEnemyList(EnemyController removeEnemy) {
        enemiesList.Remove(removeEnemy);
    }

    /// <summary>
    /// 破壊した敵の数をカウント(このメソッドを外部のクラスから実行してもらう)
    /// </summary>
    public void CountUpDestoryEnemyCount(EnemyController enemyController) {

        // List から破壊された敵の情報を削除
        RemoveEnemyList(enemyController);

　　　　// 敵を破壊した数を加算
        destroyEnemyCount++;

        Debug.Log("破壊した敵の数 : " + destroyEnemyCount);

        // ゲームクリア判定
        JudgeGameClear();
    }


    /// <summary>
    /// ゲームクリア判定
    /// </summary>
    public void JudgeGameClear() {
        // 生成数を超えているか
        if (destroyEnemyCount >= maxEnemyCount) {

            Debug.Log("ゲームクリア");
           

            // TODO ゲームクリアの処理を追加

        }
    }

    /// <summary>
    /// 時間の経過に応じてカレンシーを加算
    /// </summary>
    /// <returns></returns>
    public IEnumerator TimeToCurrency() {

        int timer = 0;

        // ゲームプレイ中のみ加算
        while (currentGameState == GameState.Play) {
            timer++;

            // 規定の時間が経過し、カレンシーが最大値でなければ
            if (timer > GameData.instance.currencyIntervalTime && GameData.instance.currency < GameData.instance.maxCurrency) {
                timer = 0;

                // 最大値以下になるようにカレンシーを加算
                GameData.instance.currency = Mathf.Clamp(GameData.instance.currency += GameData.instance.addCurrencyPoint, 0, GameData.instance.maxCurrency);

　　　　　　　　// カレンシーの画面表示を更新
                uiManager.UpdateDisplayCurrency();
            }

            yield return null;
        }
    }

    /// <summary>
    /// 選択したキャラの情報を List に追加
    /// </summary>
    public void AddCharasList(CharaController chara) {
        charasList.Add(chara);
    }

    /// <summary>
    /// 選択したキャラを破棄し、情報を List から削除
    /// </summary>
    /// <param name="chara"></param>
    public void RemoveCharasList(CharaController chara) {
        Destroy(chara.gameObject);
        charasList.Remove(chara);
    }

    /// <summary>
    /// 現在の配置しているキャラの数の取得
    /// </summary>
    /// <returns></returns>
    public int GetPlacementCharaCount() {
        return charasList.Count;
    }

    /// <summary>
    /// 配置解除を選択するポップアップ作成の準備(CharaController から呼び出される)
    /// </summary>
    /// <param name="chara"></param>
    public void PreparateCreateReturnCharaPopUp(CharaController chara) {

        // ゲームの進行状態をゲーム停止に変更
        SetGameState(GameState.Stop);

        // すべての敵の移動を一時停止
        PauseEnemies();

        // 配置解除を選択するポップアップを作成
        uiManager.CreateReturnCharaPopUp(chara, this);
    }

    /// <summary>
    /// 選択したキャラの配置解除の確認(ReturnSelectCharaPopUp から呼び出される)
    /// </summary>
    /// <param name="isReturnChara"></param>
    /// <param name="chara"></param>
    public void JudgeReturnChara(bool isReturnChara, CharaController chara) {

        // キャラの配置を解除する場合
        if (isReturnChara) {

            // 選択したキャラを破棄し、情報を List から削除
            RemoveCharasList(chara);
        }

        //  ゲームの進行状態をプレイ中に変更して、ゲーム再開
        SetGameState(GameState.Play);

        // すべての敵の移動を再開
        ResumeEnemies();

        // カレンシーの加算処理を再開
        StartCoroutine(TimeToCurrency());
    }


////*  ここからメソッドを１つ追加  *////


    /// <summary>
    /// ステージデータの設定
    /// </summary>
    private void SetUpStageData() {

        // GameData の stageNo から StageData を取得
        currentStageData = DataBaseManager.instance.stageDataSO.stageDatasList[GameData.instance.stageNo];

        // 各情報を StageData クラスを参照して設定
        generateIntervalTime = currentStageData.generateIntervalTime;
        maxEnemyCount = currentStageData.mapInfo.appearEnemyInfos.Length;

        // ステージ用のマップと防衛拠点の生成
        currentMapInfo = Instantiate(currentStageData.mapInfo);
        defenseBase = Instantiate(defenseBasePrefab, currentMapInfo.GetDefenseBaseTran());

        // PathDatas の移動経路情報を StageData クラスを参照して設定
        PathData[] pathDatas = new PathData[currentStageData.mapInfo.appearEnemyInfos.Length];
        for (int i = 0; i < currentStageData.mapInfo.appearEnemyInfos.Length; i++) {
            pathDatas[i] = currentStageData.mapInfo.appearEnemyInfos[i].enemyPathData;
        }

        // 移動経路の情報を引数で渡して、EnemyGenerator クラスの設定を行う
        enemyGenerator.SetUpPathDatas(pathDatas);

　　　　// TODO 他にもあれば追加

    }


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


}

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

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

　DefenseBasePrefab 変数に、Prefabs フォルダ内にある DefenseBase ゲームオブジェクトのプレファブをドラッグアンドドロップしてアサインしてください。

　currentMapInfo 変数と currentStageData 変数は、ゲームの実行時に GameData クラスに設定した StageNo 変数から参照された StageData クラスから情報が代入されますので、
この部分は空のままで問題ありません。

インスペクター画像

　以上で設定は完了です。

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

　GameData クラスの StageNo 変数を設定し、ゲームを実行します。
空になっていた GameManager クラスの currentStageData 変数にステージの情報が、スクリプタブル・オブジェクトより参照されて代入されれば制御成功です。
その後、その情報を参照して MainMap ゲームオブジェクトと DefenseBase ゲームオブジェクトが生成されて、EnemyGenerator クラスに移動経路の情報が登録されれば制御成功です。

　複数のクラスに情報が設定されるようになりますので、何度もゲームの実行をして、どの部分の処理が制御されているかをしっかり把握しておいてください。

GameManager ゲームオブジェクト　インスペクター画像①

GameManager ゲームオブジェクト　インスペクター画像②

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

　次は　発展１０　ーエフェクト機能の準備－　です。