ターン制RPGの作り方#21｜地下へ進もう：階ごとの敵と、先へ進む・ロビーへ帰る

using UnityEngine;

// 1回のバトルに出てくる敵の組み合わせ
[System.Serializable]
public class EnemyGroup
{
    public EnemyData[] enemies; // 出てくる敵（1〜4体）
}

// 地下の1つの階のデータ：名前・背景と、戦う順番に並べた敵の組み合わせ
[CreateAssetMenu(fileName = "NewFloor", menuName = "TurnBasedRpg/Floor Data")]
public class FloorData : ScriptableObject
{
    [SerializeField] private string floorName;     // 画面に出す名前（ちか1かい）
    [SerializeField] private Sprite background;    // バトルの背景
    [SerializeField] private EnemyGroup[] battles; // 戦う順番に、出てくる敵の組み合わせ（この数だけ戦う）

    public string FloorName => floorName;
    public Sprite Background => background;
    public int BattleCount => battles.Length;

    // battleIndex 番目（0 から）のバトルに出てくる敵
    public EnemyData[] GetEnemies(int battleIndex)
    {
        return battles[battleIndex].enemies;
    }
}

    [SerializeField] private FloorData[] floors;         // 地下の階（上から 地下1・地下2・地下3）

    public FloorData[] Floors => floors;
    public int ClearedFloorCount { get; set; } // クリアした階の数（地下1階をクリアしたら 1）
    public int ReachedFloorCount => Mathf.Min(ClearedFloorCount + 1, floors.Length); // 行ける階の数（クリアした階の、1つ下まで）
    public int FloorIndex { get; set; }  // 今いる階（0 が地下1階）
    public int BattleIndex { get; set; } // その階の、何回目のバトルか（0 から）
    public FloorData CurrentFloor => floors[FloorIndex];

    [SerializeField] private EnemyData[] enemies;    // 確認用：Battle シーンから再生したときの敵（1〜4体）
    [SerializeField] private Image background;       // バトルの背景（階ごとに変える）

        EnemyData[] enemyGroup = LoadEnemies();
        for (int i = 0; i < enemyGroup.Length; i++)
        {
            EnemyData enemy = enemyGroup[i];
            UnitView view = Instantiate(enemyPrefab, enemyArea);
            // 真ん中をそろえて横に並べ、1体おきに上下へずらす
            float x = (i - (enemyGroup.Length - 1) / 2f) * enemySpacing;
            float y = (i % 2 == 0) ? 60f : -60f;
            ((RectTransform)view.transform).anchoredPosition = new Vector2(x, y);
            view.SetupEnemy(enemy);
            EnemyUnits.Add(new BattleUnit(enemy, view));
        }

    // ロビーから来たら、今いる階の背景にして、その階の何回目かのバトルの敵を出す
    // Battle シーンから再生したとき（GameSession が無い）は、確認用に Inspector の敵を出す
    private EnemyData[] LoadEnemies()
    {
        GameSession session = GameSession.Instance;
        if (session == null)
        {
            return enemies;
        }
        FloorData floor = session.CurrentFloor;
        background.sprite = floor.Background;
        return floor.GetEnemies(session.BattleIndex);
    }

    [SerializeField] private GameObject floorWindow; // 右上の、今いる階のウインド
    [SerializeField] private TMP_Text floorText;     // 今いる階と、何回目のバトルか（ちか1かい  2/3）

        ShowFloor();

    // 右上に、今いる階と、何回目のバトルか（Battle シーンから再生したときは、ウインドを隠す）
    private void ShowFloor()
    {
        GameSession session = GameSession.Instance;
        floorWindow.SetActive(session != null);
        if (session != null)
        {
            FloorData floor = session.CurrentFloor;
            floorText.text = $"{floor.FloorName}  {session.BattleIndex + 1}/{floor.BattleCount}";
        }
    }

using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

// バトルが終わったときのウインド（勝った・負けた・にげた）。「ロビーへ」か「さきへ すすむ」が押されるまで待つ
public class ResultWindow : MonoBehaviour
{
    [SerializeField] private TMP_Text titleText;
    [SerializeField] private TMP_Text bodyText;
    [SerializeField] private Button retryButton; // ロビーへ
    [SerializeField] private Button nextButton;  // さきへ すすむ（まだ先のバトルがあるときだけ出す）

    // どちらかのボタンが押されたら、待っているところに知らせる（さきへ すすむ なら true）
    private readonly AwaitableCompletionSource<bool> choiceSource = new AwaitableCompletionSource<bool>();

    private void Awake()
    {
        retryButton.onClick.AddListener(() => choiceSource.TrySetResult(false));
        nextButton.onClick.AddListener(() => choiceSource.TrySetResult(true));
        gameObject.SetActive(false); // 最初は隠しておく
    }

    // ウインドを出して、ボタンが押されるまで待つ。canGoOn が true なら「さきへ すすむ」も出す
    // 「さきへ すすむ」が押されたら true
    public async Awaitable<bool> ShowAsync(string title, string body, bool canGoOn = false)
    {
        titleText.text = title;
        bodyText.text = body;
        nextButton.gameObject.SetActive(canGoOn);
        choiceSource.Reset();
        gameObject.SetActive(true);

        // 最後のメッセージを読んだときの決定が、このフレームに残っていることがあるので、1フレーム待ってから選ぶ
        await Awaitable.NextFrameAsync(destroyCancellationToken);
        Button firstButton = canGoOn ? nextButton : retryButton; // 先へ進めるなら、そちらを先に選んでおく
        EventSystem.current.SetSelectedGameObject(firstButton.gameObject);

        bool goesOn = await choiceSource.Awaitable;
        gameObject.SetActive(false);
        return goesOn;
    }
}

    // 先へ進む：右を向いたまま、画面の外へ走っていく
    public async Awaitable RunForwardAsync()
    {
        Vector2 from = rectTransform.anchoredPosition;
        Vector2 to = from + new Vector2(1800f, 0f);
        const float seconds = 0.7f;
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            rectTransform.anchoredPosition = Vector2.Lerp(from, to, time / seconds);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
    }

        bool goesOn = false; // 勝って「さきへ すすむ」を選んだら true

                case BattlePhase.Victory:
                    goesOn = await ShowVictoryAsync();

        if (goesOn)
        {
            // 「さきへ すすむ」：みんなで右へ走っていって、同じシーンで次のバトル
            await RunForwardAsync();
            await sceneFader.LoadSceneAsync("Battle");
        }
        else
        {
            // 「ロビーへ」が押された：暗くして、ロビーに戻る
            await sceneFader.LoadSceneAsync("Lobby");
        }

    // 「さきへ すすむ」を選んだら true
    private async Awaitable<bool> ShowVictoryAsync()

        return await ShowVictoryResultAsync($"けいけんち {exp}ポイント\n{gold}ゴールドを てにいれた");

    // 勝ったときのウインド。その階にまだバトルが残っていれば「さきへ すすむ」も出す（選んだら true）
    // 最後のバトルなら、その階をクリアして、次の階へ行けるようにする
    private async Awaitable<bool> ShowVictoryResultAsync(string body)
    {
        GameSession session = GameSession.Instance;
        if (session == null)
        {
            await resultWindow.ShowAsync("しょうり！", body); // Battle シーンから再生したときは、ロビーへ戻るだけ
            return false;
        }

        FloorData floor = session.CurrentFloor;
        session.BattleIndex++;
        if (session.BattleIndex < floor.BattleCount)
        {
            return await resultWindow.ShowAsync("しょうり！", body, true);
        }

        // その階の最後のバトルに勝った：クリア。はじめてなら、次の階へ行けるようになる
        await messageWindow.ShowAsync($"{floor.FloorName}を クリアした！");
        if (session.FloorIndex == session.ClearedFloorCount)
        {
            session.ClearedFloorCount++;
            int nextIndex = session.FloorIndex + 1;
            if (nextIndex < session.Floors.Length)
            {
                await messageWindow.ShowAsync($"{session.Floors[nextIndex].FloorName}へ いけるように なった！");
            }
        }
        await resultWindow.ShowAsync("クリア！", body);
        return false;
    }

    // 先へ進む：立っている仲間が、少しずつずれて右へ走っていく
    private async Awaitable RunForwardAsync()
    {
        List<Awaitable> runs = new List<Awaitable>();
        foreach (BattleUnit unit in lineup.PartyUnits)
        {
            if (unit.IsDead)
            {
                continue; // 倒れている人は、その場で眠ったまま（次のバトルにも、倒れたまま出る）
            }
            unit.View.ResumeIdle(); // 喜ぶポーズから、走る（弾む）すがたに戻す
            runs.Add(unit.View.RunForwardAsync());
            await Awaitable.WaitForSecondsAsync(0.08f, destroyCancellationToken);
        }
        foreach (Awaitable run in runs)
        {
            await run;
        }
    }

    [SerializeField] private CommandMenu floorMenu;   // 行く階の一覧（FloorWindow）

    // 地下へ：行く階を選んで、その階の1回目のバトルへ（キャンセルしたら、メニューに戻る）
    private async void OnDungeonClicked()
    {
        if (isBusy)
        {
            return;
        }
        isBusy = true;
        menuGroup.interactable = false;
        try
        {
            int floorIndex = await ChooseFloorAsync();
            if (floorIndex >= 0)
            {
                GameSession session = GameSession.Instance;
                session.FloorIndex = floorIndex;
                session.BattleIndex = 0;
                await sceneFader.LoadSceneAsync("Battle");
                return;
            }
        }
        catch (System.OperationCanceledException)
        {
            return; // シーンが切り替わったら、そこで終わり
        }
        BackToMenu(dungeonButton);
    }

    // 地下の階の一覧から、行く階を選ぶ（まだ行けない階は灰色）。キャンセルなら -1
    private async Awaitable<int> ChooseFloorAsync()
    {
        GameSession session = GameSession.Instance;
        FloorData[] floors = session.Floors;
        string[] names = new string[floors.Length];
        string[] values = new string[floors.Length];
        bool[] usables = new bool[floors.Length];
        for (int i = 0; i < floors.Length; i++)
        {
            FloorData floor = floors[i];
            names[i] = floor.FloorName;
            values[i] = i < session.ClearedFloorCount ? "クリア" : "";
            usables[i] = i < session.ReachedFloorCount;
        }

        messageText.text = "どの かいへ いく？";
        floorMenu.gameObject.SetActive(true);
        // 最初は、行ける中で一番深い階を選んでおく
        int floorIndex = await floorMenu.WaitForChoiceAsync(names, values, usables, session.ReachedFloorCount - 1);
        floorMenu.gameObject.SetActive(false);
        return floorIndex;
    }

    // ロビーのメニューに戻る（button を選び直す）
    private void BackToMenu(Button button)
    {
        menuGroup.interactable = true;
        messageText.text = "ここは まほう図書館の ロビー。";
        ShowParty(); // 装備で最大HPなどが変わったときのために、出し直す
        EventSystem.current.SetSelectedGameObject(button.gameObject);
        isBusy = false;
    }

    int ShopFloor { get; }    // 売店に並ぶのは、この階まで行けるようになってから（1 なら最初から）

    [SerializeField] private int shopFloor = 1;           // 売店に並ぶようになる階（2 なら、地下2階へ行けるようになってから）

    public int ShopFloor => shopFloor;

        List<IShopGoods> goodsList = new List<IShopGoods>();
        goodsList.AddRange(items);
        goodsList.AddRange(equipments);
        // まだ行けない階の売り物は、並べない
        goodsList.RemoveAll(product => product.ShopFloor > session.ReachedFloorCount);