ターン制RPGの作り方#22｜地下2・3階の敵：ためてから大技・全員に当たる・まほうを使う敵

using UnityEngine;

// 敵の行動1つ分：使うコマンドと、選ばれやすさ
[System.Serializable]
public class EnemyMove
{
    public BattleCommand command;
    [Min(1)] public int weight = 1; // 選ばれやすさ（ほかの行動の2倍にすると、2倍よく使う）
}

    [SerializeField] private EnemyMove[] moves;      // 使う行動（この中から選ぶ）
    [SerializeField] private bool usesMovesInOrder; // チェックすると、上から順番に使う（選ばれやすさは見ない）

    public EnemyMove[] Moves => moves;
    public bool UsesMovesInOrder => usesMovesInOrder;

    public BattleCommand[] Commands { get; } // 選べるコマンド（仲間だけ。敵は EnemyData の行動から選ぶ）

    public EnemyData EnemyData { get; }      // 敵のデータ（敵だけ。仲間は null）
    public int MoveCount { get; set; }       // 行動を決めた回数（順番に使う敵が、次の行動を調べるのに使う）

        EnemyData = data;

using System.Collections.Generic;

// 敵が、使う行動と相手を選ぶ
public static class EnemyBrain
{
    public static BattleAction Decide(BattleUnit enemy, BattleUnit[] party)
    {
        BattleCommand command = ChooseCommand(enemy);

        // 相手は、まだ倒れていない仲間から選ぶ
        List<BattleUnit> living = new List<BattleUnit>();
        foreach (BattleUnit member in party)
        {
            if (!member.IsDead)
            {
                living.Add(member);
            }
        }
        BattleUnit target = living[GameRandom.Index(living.Count)];

        BattleAction action = new BattleAction(command, target.View);
        action.User = enemy;
        return action;
    }

    // 使う行動を選ぶ。順番に使う敵は上から順に、ほかの敵は選ばれやすさで
    private static BattleCommand ChooseCommand(BattleUnit enemy)
    {
        EnemyMove[] moves = enemy.EnemyData.Moves;
        if (enemy.EnemyData.UsesMovesInOrder)
        {
            // 最後まで使ったら、最初に戻る（2つなら、ためる → のしかかり → ためる …）
            EnemyMove next = moves[enemy.MoveCount % moves.Length];
            enemy.MoveCount++;
            return next.command;
        }

        // 選ばれやすさを全部足した数の中から1つ引いて、どの行動の分に入ったかを調べる
        int total = 0;
        foreach (EnemyMove move in moves)
        {
            total += move.weight;
        }
        int roll = GameRandom.Index(total);
        foreach (EnemyMove move in moves)
        {
            if (roll < move.weight)
            {
                return move.command;
            }
            roll -= move.weight;
        }
        return moves[0].command; // 選ばれやすさがどれも1以上なら、ここには来ない
    }
}

    // user の相手（仲間なら敵、敵なら仲間）のうち、まだ倒れていない全員
    public List<BattleUnit> LivingOpponents(BattleUnit user)
    {
        UnitView[] opponents = user.IsEnemy ? Party : Enemies;
        List<BattleUnit> living = new List<BattleUnit>();
        foreach (UnitView view in opponents)
        {
            if (!view.Unit.IsDead)
            {
                living.Add(view.Unit);
            }
        }
        return living;
    }

using System.Collections.Generic;
using UnityEngine;

// 相手の全員に当たる攻撃（とびだす地球儀の ころがりアタック）：くるっと回りながら前に出て、立っている全員にダメージ
[CreateAssetMenu(fileName = "NewAllAttack", menuName = "TurnBasedRpg/Commands/All Attack")]
public class AllAttackCommand : BattleCommand
{
    [SerializeField] private float damageRate = 0.7f; // 1人あたりのダメージの倍率

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        List<BattleUnit> targets = context.LivingOpponents(user);

        await context.Message.ShowAsync($"{user.Name}の {CommandName}！");
        Awaitable spin = user.View.SpinAsync(0.4f); // 回るのと、前に出るのを、いっしょに始める
        await user.View.StepAsync(true);
        await spin;

        // 全員いっしょに当たる
        UnitView[] views = new UnitView[targets.Count];
        int[] damages = new int[targets.Count];
        for (int i = 0; i < targets.Count; i++)
        {
            BattleUnit target = targets[i];
            views[i] = target.View;
            damages[i] = DamageCalculator.Physical(user, target, damageRate);
            target.TakeDamage(damages[i]);
        }
        await context.Effects.PlayHitAllAsync(views, damages);
        await user.View.StepAsync(false);

        // 倒れた相手は全員いっしょに、そのあとで1人ずつメッセージ（#14 の全体のまほうと同じ）
        List<Awaitable> falls = new List<Awaitable>();
        foreach (BattleUnit target in targets)
        {
            if (target.IsDead)
            {
                falls.Add(PlayFallAsync(target));
            }
        }
        foreach (Awaitable fall in falls)
        {
            await fall;
        }
        for (int i = 0; i < targets.Count; i++)
        {
            await context.Message.ShowAsync($"{targets[i].Name}に {damages[i]}の ダメージ！");
        }
        foreach (BattleUnit target in targets)
        {
            if (target.IsDead)
            {
                await context.Message.ShowAsync(FallMessage(target));
            }
        }
    }
}

    // くるっと1回転する（ころがりアタック）。前の向きへ転がるように回す
    public async Awaitable SpinAsync(float seconds)
    {
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            float angle = -360f * forward * Mathf.Clamp01(time / seconds);
            transform.localRotation = Quaternion.Euler(0f, 0f, angle);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        transform.localRotation = Quaternion.identity;
    }

    // 待機の弾みを止めて、ポーズの絵を順に出す（最後の絵のまま止まる）
    // ポーズの絵が無い敵は、かわりに ふくらんで、もとに戻る
    private async Awaitable PlayFramesAsync(Sprite[] frames)
    {
        if (frames == null)
        {
            await SwellAsync();
            return;
        }
        idleBounce.enabled = false;

    // ふくらんで、もとの大きさに戻る（敵が まほうを使う・力をためるとき）
    private async Awaitable SwellAsync()
    {
        const float seconds = 0.4f;
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            // Sin で 0 → 1 → 0 と変えて、いちばん大きいときに 1.15 倍
            float wave = Mathf.Sin(Mathf.Clamp01(time / seconds) * Mathf.PI);
            transform.localScale = Vector3.one * (1f + 0.15f * wave);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        transform.localScale = Vector3.one;
    }

    public bool IsPaused { get; set; } // true の間は、コマを進めない（せきか などで動けないとき）

        if (IsPaused)
        {
            // 止まっている間も、痛がる絵などのあとは、今の待機のコマに戻しておく
            image.sprite = frames[frameOrder[orderIndex]];
            return;
        }

    public void ShowEffects(List<ActiveEffect> effects)
    {
        if (effectIcons != null)
        {
            effectIcons.Show(effects);
        }
        tint = Color.white;
        bool canAct = true;
        foreach (ActiveEffect effect in effects)
        {
            if (effect.Data.Tint != Color.white)
            {
                tint = effect.Data.Tint;
            }
            if (!effect.Data.CanAct)
            {
                canAct = false;
            }
        }
        SetDimmed(isDimmed);

        // せきか などで動けない間は、待機の弾みを止める（仲間だけ）
        if (idleBounce != null)
        {
            idleBounce.IsPaused = !canAct;
        }
    }

            BattleUnit unit = party[index];
            if (!CanChoose(unit))
            {
                // 倒れている人・せきか などで動けない人は、コマンドを選ばない
                selected[index] = null;

                // コマンドでキャンセルしたら、前の人に戻る（選べない人は飛ばす）
                index = PreviousChoosableIndex(index);

    // コマンドを選べるか（倒れている人と、せきか などで動けない人は選ばない）
    private bool CanChoose(BattleUnit unit)
    {
        return !unit.IsDead && unit.CanAct;
    }

    // index より前で、コマンドを選べる一番近い人の番号（いなければ index のまま）
    private int PreviousChoosableIndex(int index)
    {
        for (int i = index - 1; i >= 0; i--)
        {
            if (CanChoose(lineup.PartyUnits[i]))
            {
                return i;
            }
        }
        return index;
    }

using UnityEngine;

// ためる：その番は攻撃しないで、力をためる（次の大きな攻撃の予告）
[CreateAssetMenu(fileName = "NewCharge", menuName = "TurnBasedRpg/Commands/Charge")]
public class ChargeCommand : BattleCommand
{
    [SerializeField] private string message = "ちからを ためている！"; // 「〇〇は 」のあとに出す

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        Awaitable cast = user.View.PlayCastAsync(); // 力をためる（ポーズの絵が無い敵は、ふくらむ）
        await context.Message.ShowAsync($"{user.Name}は {message}");
        await cast;
        user.View.ResumeIdle();
    }
}