ターン制RPGの作り方#9｜バトルの流れを作ろう：すばやさ順に動いて、次のターンへ

// バトルの場面
public enum BattlePhase
{
    Start,   // 始まり（敵があらわれる）
    Command, // 3人のコマンドを選ぶ
    Action,  // すばやさの順に行動する
    Victory, // 勝った
    End,     // バトルが終わった
}

    public BattleCommand[] Commands { get; } // 選べるコマンド（仲間だけ。敵は null）
    public bool IsGuarding { get; set; }     // ぼうぎょ しているか（ターンの始めに戻す）

        Commands = data.Commands;

using System.Collections.Generic;
using UnityEngine;

// データから仲間と敵を並べて、バトル中の1人ずつ（BattleUnit）を作る
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;

    public BattleUnit[] PartyUnits { get; private set; } // 仲間（上から順に）
    public StatusRow[] StatusRows { get; private set; }  // 仲間のステータスの行（上から順に）
    public List<BattleUnit> EnemyUnits { get; } = new List<BattleUnit>(); // 敵（左から順に）
    public UnitView[] PartyViews => partyViews;

    // 並べる（BattleManager が、バトルの始めに呼ぶ）
    public void Setup()
    {
        PartyUnits = new BattleUnit[party.Length];
        StatusRows = new StatusRow[party.Length];
        for (int i = 0; i < party.Length; i++)
        {
            CharacterData character = party[i];
            UnitView view = partyViews[i];
            view.SetupCharacter(character);
            StatusRows[i] = statusWindow.AddRow(character);
            PartyUnits[i] = new BattleUnit(character, view);
        }

        for (int i = 0; i < enemies.Length; i++)
        {
            EnemyData enemy = enemies[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(enemy);
            EnemyUnits.Add(new BattleUnit(enemy, view));
        }
    }
}

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

// バトルの流れ：コマンドを選ぶ → すばやさ順に動く → 勝ったかを調べる、をくり返す
public class BattleManager : MonoBehaviour
{
    [SerializeField] private BattleLineup lineup;
    [SerializeField] private CommandMenu commandMenu;
    [SerializeField] private TMP_Text messageText;
    [SerializeField] private MessageWindow messageWindow;
    [SerializeField] private TargetSelector targetSelector;
    [SerializeField] private BattleEffects battleEffects;
    [SerializeField] private int randomSeed = 0; // 0以外にすると、毎回同じ結果になる（確かめるとき用）
    [SerializeField] private BattlePhase phase;  // 今の場面（再生中に Inspector で見られるように）

    private BattleContext context;
    private BattleAction[] actions; // このターンに選んだ、3人の行動

    private async void Start()
    {
        try
        {
            await RunAsync();
        }
        catch (System.OperationCanceledException)
        {
            // オブジェクトが消えたら、そこで終わり
        }
    }

    // バトルの流れ。今の場面のことをして、次の場面を決める
    private async Awaitable RunAsync()
    {
        phase = BattlePhase.Start;
        while (phase != BattlePhase.End)
        {
            switch (phase)
            {
                case BattlePhase.Start:
                    await StartBattleAsync();
                    phase = BattlePhase.Command;
                    break;

                case BattlePhase.Command:
                    actions = await SelectActionsAsync();
                    phase = BattlePhase.Action;
                    break;

                case BattlePhase.Action:
                    await ExecuteActionsAsync();
                    if (LivingEnemyViews().Length == 0)
                    {
                        phase = BattlePhase.Victory;
                    }
                    else
                    {
                        phase = BattlePhase.Command; // 次のターン
                    }
                    break;

                case BattlePhase.Victory:
                    await messageWindow.ShowAsync("てきを ぜんぶ たおした！");
                    phase = BattlePhase.End;
                    break;
            }
        }
    }

    // 始まり：並べて、コマンドに渡す道具をまとめる
    private async Awaitable StartBattleAsync()
    {
        if (randomSeed != 0)
        {
            GameRandom.SetSeed(randomSeed);
        }
        lineup.Setup();

        context = new BattleContext();
        context.MessageText = messageText;
        context.Message = messageWindow;
        context.TargetSelector = targetSelector;
        context.Effects = battleEffects;
        context.Party = lineup.PartyViews;

        await messageWindow.ShowAsync($"{lineup.EnemyUnits[0].Name}たちが あらわれた！");
    }

    // 3人のコマンドを順に選ぶ（キャンセルで前の人に戻る）
    private async Awaitable<BattleAction[]> SelectActionsAsync()
    {
        // 新しいターン：ぼうぎょ を解いて、ねらえる敵を調べ直す
        foreach (BattleUnit unit in lineup.PartyUnits)
        {
            unit.IsGuarding = false;
        }
        context.Enemies = LivingEnemyViews();

        BattleUnit[] party = lineup.PartyUnits;
        BattleAction[] selected = new BattleAction[party.Length];
        int index = 0;
        while (index < party.Length)
        {
            BattleUnit unit = party[index];
            StatusRow row = lineup.StatusRows[index];
            messageText.text = $"{unit.Name}は どうする？";
            unit.View.SetHighlight(true);
            row.SetHighlight(true);
            DimPartyExcept(index);

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

            unit.View.SetHighlight(false);
            row.SetHighlight(false);

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

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

            action.User = unit;
            selected[index] = action;
            index++;
        }

        BrightenParty();
        return selected;
    }

    // 選んだ行動を、すばやさの順に実行する
    private async Awaitable ExecuteActionsAsync()
    {
        ActionOrder.Sort(actions);
        foreach (BattleAction action in actions)
        {
            if (LivingEnemyViews().Length == 0)
            {
                // 途中で敵がいなくなったら、残りの行動はしない
                break;
            }
            await action.Command.ExecuteAsync(action.User, action, context);
        }
    }

    // まだ倒れていない敵の見た目
    private UnitView[] LivingEnemyViews()
    {
        List<UnitView> living = new List<UnitView>();
        foreach (BattleUnit unit in lineup.EnemyUnits)
        {
            if (!unit.IsDead)
            {
                living.Add(unit.View);
            }
        }
        return living.ToArray();
    }

    // index の人以外の仲間を暗くする
    private void DimPartyExcept(int index)
    {
        for (int i = 0; i < lineup.PartyViews.Length; i++)
        {
            lineup.PartyViews[i].SetDimmed(i != index);
        }
    }

    // 仲間を全員、もとの明るさに戻す
    private void BrightenParty()
    {
        foreach (UnitView view in lineup.PartyViews)
        {
            view.SetDimmed(false);
        }
    }
}

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

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

using System;

// 行動の順番を決める：すばやさ × 0.8〜1.2 の大きい順
public static class ActionOrder
{
    public static void Sort(BattleAction[] actions)
    {
        // 1人ずつ、この順番を決めるための速さを出す
        float[] speeds = new float[actions.Length];
        for (int i = 0; i < actions.Length; i++)
        {
            BattleAction action = actions[i];
            float speed = action.User.Stats.speed * GameRandom.Range(0.8f, 1.2f);
            if (action.Command.ActsFirst)
            {
                speed += 1000f; // ぼうぎょ などは、だれよりも先に動く
            }
            speeds[i] = speed;
        }

        // speeds を小さい順に並べると、actions も同じように並びかわる。それを逆にして大きい順に
        Array.Sort(speeds, actions);
        Array.Reverse(actions);
    }
}

    // true なら、すばやさに関係なく、ターンの最初に動く（ぼうぎょ など）
    public virtual bool ActsFirst => false;

using UnityEngine;

// ぼうぎょ：そのターンに受けるダメージを半分にする
[CreateAssetMenu(fileName = "Guard", menuName = "TurnBasedRpg/Commands/Guard")]
public class GuardCommand : BattleCommand
{
    // 敵より先に構えるので、ターンの最初に動く
    public override bool ActsFirst => true;

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        user.IsGuarding = true;
        await context.Message.ShowAsync($"{user.Name}は みを まもっている。");
    }
}

using UnityEngine;

// ダメージの計算（式はここだけに書く）
public static class DamageCalculator
{
    // たたかう：（こうげき − ぼうぎょ ÷ 2）× 0.9〜1.1。ぼうぎょ 中は半分。最低でも1
    public static int Physical(BattleUnit attacker, BattleUnit defender)
    {
        float baseDamage = attacker.Stats.attack - defender.Stats.defense / 2f;
        float damage = baseDamage * GameRandom.Range(0.9f, 1.1f);
        if (defender.IsGuarding)
        {
            damage /= 2f;
        }
        return Mathf.Max(1, Mathf.RoundToInt(damage));
    }
}

using TMPro;

// コマンドが相手を選んだり、メッセージを出したりするときに使う、バトルの道具をまとめたもの
public class BattleContext
{
    public TMP_Text MessageText;          // 上のメッセージ（すぐに書き換えるとき）
    public MessageWindow Message;         // 上のメッセージ（1文字ずつ出して待つとき）
    public TargetSelector TargetSelector; // 相手を選ぶ道具
    public BattleEffects Effects;         // 当たったときの演出
    public UnitView[] Party;              // 仲間の見た目
    public UnitView[] Enemies;            // 敵の見た目（ターンの始めに、倒れていない敵）

    // まだ倒れていない敵を、左から探して1体返す（いなければ null）
    public UnitView FindLivingEnemy()
    {
        foreach (UnitView view in Enemies)
        {
            if (!view.Unit.IsDead)
            {
                return view;
            }
        }
        return null;
    }
}

    // 前に出て、振って、当てて、戻る。HPが0になったら、しぼんで消える
    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        UnitView targetView = action.Target;
        if (targetView.Unit.IsDead)
        {
            // ねらっていた敵が、先に倒れていた。まだ立っている敵に、ねらいを変える
            targetView = context.FindLivingEnemy();
        }
        BattleUnit target = targetView.Unit;

        await context.Message.ShowAsync($"{user.Name}の こうげき！");