ターン制RPGの作り方#7｜たたかう：ダメージを計算してメッセージを出そう

using UnityEngine;

// バトル中の1人（仲間も敵も）。データは読むだけにして、今のHPはここで持つ
public class BattleUnit
{
    public string Name { get; }
    public Stats Stats { get; }  // 能力（データのものを読むだけ）
    public int Hp { get; private set; }
    public UnitView View { get; } // 画面の見た目
    public bool IsDead => Hp <= 0;

    // 仲間のデータから作る（今はLv1の能力）
    public BattleUnit(CharacterData data, UnitView view)
    {
        Name = data.CharacterName;
        Stats = data.BaseStats;
        Hp = Stats.maxHp;
        View = view;
        view.Unit = this;
    }

    // 敵のデータから作る
    public BattleUnit(EnemyData data, UnitView view)
    {
        Name = data.EnemyName;
        Stats = data.Stats;
        Hp = Stats.maxHp;
        View = view;
        view.Unit = this;
    }

    // ダメージを受ける（0より下にはしない）
    public void TakeDamage(int damage)
    {
        Hp = Mathf.Max(0, Hp - damage);
    }
}

    public BattleUnit Unit { get; set; } // この見た目が表している、バトル中の1人

// ゲームの中身に関わる乱数（ダメージのばらつき・行動の順番など）をまとめたもの
// シードを決めると、毎回同じ順番で同じ数が出る
public static class GameRandom
{
    private static System.Random random = new System.Random();

    // シードを決める（同じシードなら、同じ結果を再現できる）
    public static void SetSeed(int seed)
    {
        random = new System.Random(seed);
    }

    // min 以上 max 未満の小数
    public static float Range(float min, float max)
    {
        return min + (float)random.NextDouble() * (max - min);
    }
}

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);
        return Mathf.Max(1, Mathf.RoundToInt(damage));
    }
}

using TMPro;
using UnityEngine;

// 上のメッセージ。1文字ずつ出して、読み終わるまで待つ（決定キーで早送り）
public class MessageWindow : MonoBehaviour
{
    [SerializeField] private TMP_Text messageText;
    [SerializeField] private float charSeconds = 0.03f; // 1文字を出す間隔
    [SerializeField] private float holdSeconds = 0.8f;  // 出し終わってから待つ時間

    private InputSystem_Actions inputActions;

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

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

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

    // メッセージを1文字ずつ出して、読み終わるまで待つ
    public async Awaitable ShowAsync(string message)
    {
        // 前の決定（Enter）がまだこのフレームに残っていることがあるので、1フレーム待ってから始める
        await Awaitable.NextFrameAsync(destroyCancellationToken);

        messageText.text = message;
        messageText.maxVisibleCharacters = 0;

        // 1文字ずつ出す（決定キーで、全部出す）
        float timer = 0f;
        int shown = 0;
        while (shown < message.Length)
        {
            if (inputActions.UI.Submit.WasPressedThisFrame())
            {
                break;
            }
            timer += Time.deltaTime;
            shown = Mathf.Min(message.Length, Mathf.FloorToInt(timer / charSeconds));
            messageText.maxVisibleCharacters = shown;
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        // 全部見せる（このあとほかの文字に書き換えても、途中で切れないように大きな数にしておく）
        messageText.maxVisibleCharacters = int.MaxValue;

        // 読む時間（決定キーで早送り）
        float waited = 0f;
        while (waited < holdSeconds)
        {
            await Awaitable.NextFrameAsync(destroyCancellationToken);
            if (inputActions.UI.Submit.WasPressedThisFrame())
            {
                break;
            }
            waited += Time.deltaTime;
        }
    }
}

    // 選んだコマンドを実行する（まだ中身を作っていないコマンドは、このメッセージだけ）
    public virtual async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        await context.Message.ShowAsync($"{user.Name}は ようすを みている。");
    }

using TMPro;

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

using UnityEngine;

// たたかう：敵を1体選んで、ダメージを与える
[CreateAssetMenu(fileName = "Attack", menuName = "TurnBasedRpg/Commands/Attack")]
public class AttackCommand : BattleCommand
{
    // 敵を1体選ぶ。キャンセルされたら null を返す
    public override async Awaitable<BattleAction> SelectAsync(BattleContext context)
    {
        context.MessageText.text = "だれを ねらう？";
        UnitView target = await context.TargetSelector.SelectTargetAsync(context.Enemies, context.Party);
        if (target == null)
        {
            return null;
        }
        return new BattleAction(this, target);
    }

    // 選んだ敵にダメージを与えて、HPが0になったら消す
    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        BattleUnit target = action.Target.Unit;
        if (target.IsDead)
        {
            // ほかの仲間が先に倒していた（ねらい直すのは #9 で作る）
            await context.Message.ShowAsync($"{target.Name}は もう たおれている！");
            return;
        }

        await context.Message.ShowAsync($"{user.Name}の こうげき！");
        int damage = DamageCalculator.Physical(user, target);
        target.TakeDamage(damage);
        await context.Message.ShowAsync($"{target.Name}に {damage}の ダメージ！");

        if (target.IsDead)
        {
            // 消える演出は #8 で作る。今はすぐに消す
            target.View.gameObject.SetActive(false);
            await context.Message.ShowAsync($"{target.Name}を たおした！");
        }
    }
}

using System.Collections.Generic;
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;
    [SerializeField] private MessageWindow messageWindow;
    [SerializeField] private TargetSelector targetSelector;
    [SerializeField] private int randomSeed = 0; // 0以外にすると、毎回同じ結果になる（確かめるとき用）

    private StatusRow[] statusRows;
    private BattleUnit[] partyUnits;
    private readonly List<BattleUnit> enemyUnits = new List<BattleUnit>();
    private BattleContext context;

    private async void Start()
    {
        if (randomSeed != 0)
        {
            GameRandom.SetSeed(randomSeed);
        }

        statusRows = new StatusRow[party.Length];
        partyUnits = new BattleUnit[party.Length];
        for (int i = 0; i < partyViews.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));
        }

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

        try
        {
            while (true)
            {
                // ねらえるのは、まだ倒れていない敵だけ
                context.Enemies = LivingEnemyViews();
                if (context.Enemies.Length == 0)
                {
                    await messageWindow.ShowAsync("てきを ぜんぶ たおした！");
                    break;
                }

                BattleAction[] actions = await SelectActionsAsync();
                await ExecuteActionsAsync(actions);
            }
        }
        catch (System.OperationCanceledException)
        {
            // オブジェクトが消えたら、そこで終わり
        }
    }

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

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

            partyViews[index].SetHighlight(false);
            statusRows[index].SetHighlight(false);

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

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

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

        BrightenParty();
        return actions;
    }

    // 決まったコマンドを、仲間の並び順に実行する（すばやさ順にするのは #9）
    private async Awaitable ExecuteActionsAsync(BattleAction[] actions)
    {
        for (int i = 0; i < actions.Length; i++)
        {
            BattleAction action = actions[i];
            await action.Command.ExecuteAsync(partyUnits[i], action, context);
        }
    }

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

    // index の人以外の仲間を暗くする（index が -1 なら、全員暗くする）
    private void DimPartyExcept(int index)
    {
        for (int i = 0; i < partyViews.Length; i++)
        {
            partyViews[i].SetDimmed(i != index);
        }
    }

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