ターン制RPGの作り方#4｜コマンドをデータにして、メニューに並べよう

// 1人分の「どのコマンドを・だれに」使うか（バトルの流れで、すばやさ順に実行する）
public class BattleAction
{
    public BattleCommand Command { get; }
    public UnitView Target { get; } // 相手がいないコマンド（ぼうぎょ など）は null

    public BattleAction(BattleCommand command, UnitView target)
    {
        Command = command;
        Target = target;
    }
}

using TMPro;

// コマンドが相手を選んだり、メッセージを出したりするときに使う、バトルの道具をまとめたもの
public class BattleContext
{
    public TMP_Text MessageText; // 上のメッセージ
}

using UnityEngine;

// コマンド1つ分の共通の形（たたかう・まほう・どうぐ・ぼうぎょ・にげる は、これを受け継いで作る）
public abstract class BattleCommand : ScriptableObject
{
    [SerializeField] private string commandName; // ボタンに出す名前

    public string CommandName => commandName;

    // コマンドを選んだあとに、相手などを選ぶ。キャンセルされたら null を返す
    // 何も選ばないコマンドは、このまま決まる
    public virtual async Awaitable<BattleAction> SelectAsync(BattleContext context)
    {
        // ほかのコマンドと同じ「待って答えを返す」形にそろえるため、1フレームだけ待つ
        await Awaitable.NextFrameAsync();
        return new BattleAction(this, null);
    }
}

using UnityEngine;

// たたかう（#6 で、相手を選ぶようにする）
[CreateAssetMenu(fileName = "Attack", menuName = "TurnBasedRpg/Commands/Attack")]
public class AttackCommand : BattleCommand
{
}

using UnityEngine;

// まほう・わざ（#13 で、まほうの一覧を開くようにする）
[CreateAssetMenu(fileName = "Magic", menuName = "TurnBasedRpg/Commands/Magic")]
public class MagicCommand : BattleCommand
{
}

using UnityEngine;

// どうぐ（#16 で、持ち物の一覧を開くようにする）
[CreateAssetMenu(fileName = "Item", menuName = "TurnBasedRpg/Commands/Item")]
public class ItemCommand : BattleCommand
{
}

using UnityEngine;

// ぼうぎょ（何も選ばない。実行は #9 で作る）
[CreateAssetMenu(fileName = "Guard", menuName = "TurnBasedRpg/Commands/Guard")]
public class GuardCommand : BattleCommand
{
}

using UnityEngine;

// にげる（何も選ばない。実行は #11 で作る）
[CreateAssetMenu(fileName = "Run", menuName = "TurnBasedRpg/Commands/Run")]
public class RunCommand : BattleCommand
{
}

    [SerializeField] private BattleCommand[] commands; // コマンドのボタンに並べるもの（上から順に）

    public BattleCommand[] Commands => commands;

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

// 選ばれているあいだだけ、▶のカーソルを出す
public class MenuCursor : MonoBehaviour, ISelectHandler, IDeselectHandler, IPointerEnterHandler
{
    [SerializeField] private GameObject cursor;

    private Selectable selectable;

    private void Awake()
    {
        selectable = GetComponent<Selectable>();
        cursor.SetActive(false);
    }

    private void OnDisable()
    {
        // 選ばれたまま隠れたときに、▶が残らないようにする
        cursor.SetActive(false);
    }

    // 選ばれたとき（キーボード・ゲームパッド・クリック）
    public void OnSelect(BaseEventData eventData)
    {
        cursor.SetActive(true);
    }

    // 選択が外れたとき
    public void OnDeselect(BaseEventData eventData)
    {
        cursor.SetActive(false);
    }

    // マウスを乗せたら、そのボタンを選ぶ（マウスとキーボードで、▶の場所をそろえる）
    public void OnPointerEnter(PointerEventData eventData)
    {
        if (selectable.IsInteractable())
        {
            EventSystem.current.SetSelectedGameObject(gameObject);
        }
    }
}

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

// 左下のコマンドのウインド。仲間のコマンドからボタンを作り、押されたコマンドを返す
public class CommandMenu : MonoBehaviour
{
    [SerializeField] private Button buttonPrefab; // CommandButton のプレハブ

    // 選ばれたコマンドが入る箱（キャンセルなら null が入る）
    private readonly AwaitableCompletionSource<BattleCommand> commandSource = new AwaitableCompletionSource<BattleCommand>();
    private readonly List<Button> buttons = new List<Button>();
    private InputSystem_Actions inputActions;
    private bool isWaiting;
    private GameObject lastSelected;

    private void Awake()
    {
        inputActions = new InputSystem_Actions();
    }

    private void OnEnable()
    {
        inputActions.Enable();
    }

    private void OnDisable()
    {
        inputActions.Disable();
    }

    private void Update()
    {
        if (!isWaiting)
        {
            return;
        }

        // キャンセル（Esc・ゲームパッドの右のボタン）
        if (inputActions.UI.Cancel.WasPressedThisFrame())
        {
            Choose(null);
            return;
        }

        // 何もないところをクリックして選択が外れたら、前に選んでいたボタンを選び直す
        GameObject current = EventSystem.current.currentSelectedGameObject;
        if (current == null)
        {
            if (lastSelected != null)
            {
                EventSystem.current.SetSelectedGameObject(lastSelected);
            }
        }
        else
        {
            lastSelected = current;
        }
    }

    // 仲間のコマンドでボタンを作り、どれかが押されるまで待つ（キャンセルなら null）
    public async Awaitable<BattleCommand> WaitForCommandAsync(BattleCommand[] commands)
    {
        // 前の人の決定（Enter など）が、まだこのフレームに残っていることがあるので、1フレーム待ってから始める
        await Awaitable.NextFrameAsync(destroyCancellationToken);
        CreateButtons(commands);
        commandSource.Reset();
        isWaiting = true;
        lastSelected = buttons[0].gameObject;
        EventSystem.current.SetSelectedGameObject(lastSelected);

        BattleCommand command = await commandSource.Awaitable;

        isWaiting = false;
        return command;
    }

    // コマンドの数だけボタンを作る（前のボタンは消す）
    private void CreateButtons(BattleCommand[] commands)
    {
        foreach (Button oldButton in buttons)
        {
            // Destroy はフレームの最後に消えるので、先に隠して、並びから外しておく
            oldButton.gameObject.SetActive(false);
            Destroy(oldButton.gameObject);
        }
        buttons.Clear();

        foreach (BattleCommand command in commands)
        {
            Button button = Instantiate(buttonPrefab, transform);
            button.GetComponentInChildren<TMP_Text>().text = command.CommandName;
            button.onClick.AddListener(() => Choose(command));
            buttons.Add(button);
        }
    }

    private void Choose(BattleCommand command)
    {
        // 待っていないときに押されても、何もしない
        if (isWaiting)
        {
            commandSource.TrySetResult(command);
        }
    }
}

using TMPro;
using UnityEngine;

// データから仲間と敵を並べる（バトルの流れは #9 で BattleManager に移す）
public class BattleLineup : MonoBehaviour
{
    [SerializeField] private CharacterData[] party;  // バトルに出る3人
    [SerializeField] private UnitView[] partyViews;  // PartyArea の3人
    [SerializeField] private EnemyData[] enemies;    // 出てくる敵（1〜4体）
    [SerializeField] private UnitView enemyPrefab;
    [SerializeField] private RectTransform enemyArea;
    [SerializeField] private float enemySpacing = 300f; // 敵の横の間隔
    [SerializeField] private StatusWindow statusWindow;
    [SerializeField] private CommandMenu commandMenu;
    [SerializeField] private TMP_Text messageText;

    private StatusRow[] statusRows;
    private BattleContext context;

    private async void Start()
    {
        statusRows = new StatusRow[party.Length];
        for (int i = 0; i < partyViews.Length; i++)
        {
            CharacterData character = party[i];
            partyViews[i].SetupCharacter(character);
            statusRows[i] = statusWindow.AddRow(character);
        }

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

        // コマンドに渡す道具をまとめる
        context = new BattleContext();
        context.MessageText = messageText;

        try
        {
            while (true)
            {
                await SelectActionsAsync();
                await Awaitable.WaitForSecondsAsync(2f, destroyCancellationToken);
            }
        }
        catch (System.OperationCanceledException)
        {
            // オブジェクトが消えたら、そこで終わり
        }
    }

    // 3人のコマンドを順に選ぶ（キャンセルで前の人に戻る）
    private async Awaitable SelectActionsAsync()
    {
        BattleAction[] actions = new BattleAction[party.Length];
        int index = 0;
        while (index < party.Length)
        {
            messageText.text = $"{party[index].CharacterName}は どうする？";

            BattleCommand command = await commandMenu.WaitForCommandAsync(party[index].Commands);
            BattleAction action = null;
            if (command != null)
            {
                action = await command.SelectAsync(context);
            }

            if (command == null)
            {
                // コマンドでキャンセルしたら、前の人に戻る（1人目なら、そのまま1人目）
                if (index > 0)
                {
                    index--;
                }
                continue;
            }

            if (action == null)
            {
                // 相手選びなどでキャンセルしたら、同じ人のコマンドを選び直す
                continue;
            }

            actions[index] = action;
            index++;
        }

        messageText.text = $"コマンドが きまった！（{ActionText(actions[0])}・{ActionText(actions[1])}・{ActionText(actions[2])}）";
    }

    // 画面に出す説明（相手がいれば、相手の名前も付ける）
    private string ActionText(BattleAction action)
    {
        if (action.Target != null)
        {
            return $"{action.Command.CommandName}（{action.Target.name}）";
        }
        return action.Command.CommandName;
    }
}