ターン制RPGの作り方#24｜自動プレイでバランスを決めよう：同じシードで何回も戦って数える

using System.Collections.Generic;

// 自動プレイ：仲間の行動を、決まった考え方で選ぶ（バランスを確かめるとき用）
// どうぐ・補助のまほう は使わない（使わずに勝てるなら、使う人はもっと楽に勝てる）
public static class AutoPlayer
{
    public static BattleAction Decide(BattleUnit unit, BattleContext context)
    {
        // 1. ちからを ためている敵がいたら、ぼうぎょ（次のターンに、大きな攻撃が来る）
        List<BattleUnit> enemies = context.LivingOpponents(unit);
        if (IsAnyoneCharging(enemies))
        {
            return new BattleAction(FindCommand<GuardCommand>(unit), null);
        }

        // 2. 倒れた仲間がいたら、起こす
        BattleUnit down = FindDownAlly(context);
        ReviveSpellCommand revive = FindSkill<ReviveSpellCommand>(unit, false);
        if (down != null && revive != null)
        {
            return new BattleAction(revive, down.View);
        }

        // 3. HP が半分より少ない仲間がいたら、回復する（2人以上なら、全体の回復を先に探す）
        List<BattleUnit> hurt = FindHurtAllies(context);
        HealSpellCommand allHeal = FindSkill<HealSpellCommand>(unit, true);
        if (hurt.Count >= 2 && allHeal != null)
        {
            return new BattleAction(allHeal, null);
        }
        HealSpellCommand heal = FindSkill<HealSpellCommand>(unit, false);
        if (hurt.Count >= 1 && heal != null)
        {
            return new BattleAction(heal, hurt[0].View);
        }

        // 4. 敵が2体以上なら、全体の攻撃まほう
        AttackSpellCommand allSpell = FindSkill<AttackSpellCommand>(unit, true);
        if (enemies.Count >= 2 && allSpell != null)
        {
            return new BattleAction(allSpell, null);
        }

        // 5. ボスがいたら、どく（まだかかっていなければ）と、1体に使う わざ・まほう
        BattleUnit weakest = FindWeakest(enemies); // HP がいちばん少ない敵をねらう
        BattleUnit boss = context.Lineup.FindBoss();
        if (boss != null)
        {
            StatusSpellCommand poison = FindSkill<StatusSpellCommand>(unit, false);
            if (poison != null && poison.Effect.PoisonRate > 0f && !HasEffect(boss, poison.Effect))
            {
                return new BattleAction(poison, boss.View);
            }
            SkillCommand skill = FindSkill<AttackSpellCommand>(unit, false);
            if (skill == null)
            {
                skill = FindSkill<MultiHitSkillCommand>(unit, false);
            }
            if (skill != null)
            {
                return new BattleAction(skill, weakest.View);
            }
        }

        // 6. それ以外は、たたかう
        return new BattleAction(FindCommand<AttackCommand>(unit), weakest.View);
    }

    // 順番に行動する敵のうち、前の行動が ためる だった敵がいるか（ボス・ぶあつい辞書）
    private static bool IsAnyoneCharging(List<BattleUnit> enemies)
    {
        foreach (BattleUnit enemy in enemies)
        {
            EnemyMove[] moves = enemy.EnemyData.Moves;
            if (!enemy.EnemyData.UsesMovesInOrder || enemy.MoveCount == 0)
            {
                continue;
            }
            EnemyMove lastMove = moves[(enemy.MoveCount - 1) % moves.Length];
            if (lastMove.command is ChargeCommand)
            {
                return true;
            }
        }
        return false;
    }

    // unit が覚えていて、今使える（MP が足りる）T のまほうを探す。targetsAll は、全体のものか
    // あとに覚えたものほど強いので、後ろから探す。無ければ null
    private static T FindSkill<T>(BattleUnit unit, bool targetsAll) where T : SkillCommand
    {
        for (int i = unit.Skills.Count - 1; i >= 0; i--)
        {
            if (unit.Skills[i] is T skill && skill.TargetsAll == targetsAll && skill.CanUse(unit))
            {
                return skill;
            }
        }
        return null;
    }

    // コマンドのボタンから、T のコマンドを探す（たたかう）
    private static T FindCommand<T>(BattleUnit unit) where T : BattleCommand
    {
        foreach (BattleCommand command in unit.Commands)
        {
            if (command is T found)
            {
                return found;
            }
        }
        return null;
    }

    // 倒れている仲間（いなければ null）
    private static BattleUnit FindDownAlly(BattleContext context)
    {
        foreach (UnitView view in context.Party)
        {
            if (view.Unit.IsDead)
            {
                return view.Unit;
            }
        }
        return null;
    }

    // HP が半分より少ない仲間。減っている割合が大きい順に並べる
    private static List<BattleUnit> FindHurtAllies(BattleContext context)
    {
        List<BattleUnit> hurt = new List<BattleUnit>();
        foreach (UnitView view in context.LivingParty())
        {
            BattleUnit ally = view.Unit;
            if (ally.Hp < ally.Stats.maxHp / 2f)
            {
                hurt.Add(ally);
            }
        }
        hurt.Sort((a, b) => HpRate(a).CompareTo(HpRate(b)));
        return hurt;
    }

    // HP の残りの割合（0〜1）
    private static float HpRate(BattleUnit unit)
    {
        return (float)unit.Hp / unit.Stats.maxHp;
    }

    // HP がいちばん少ない人
    private static BattleUnit FindWeakest(List<BattleUnit> units)
    {
        BattleUnit weakest = units[0];
        foreach (BattleUnit unit in units)
        {
            if (unit.Hp < weakest.Hp)
            {
                weakest = unit;
            }
        }
        return weakest;
    }

    // unit が effect にかかっているか
    private static bool HasEffect(BattleUnit unit, StatusEffectData effect)
    {
        foreach (ActiveEffect active in unit.Effects)
        {
            if (active.Data == effect)
            {
                return true;
            }
        }
        return false;
    }
}

    public StatusEffectData Effect => effect;

    [SerializeField] private bool autoPlay;      // チェックすると、仲間のコマンドを自動で選ぶ（確かめるとき用）

    // 自動プレイか
    private bool IsAutoPlay => autoPlay;

            if (IsAutoPlay)
            {
                // 自動プレイ：メニューを出さずに、AutoPlayer に決めてもらう
                BattleAction autoAction = AutoPlayer.Decide(unit, context);
                autoAction.User = unit;
                selected[index] = autoAction;
                index++;
                continue;
            }

    // 一瞬だけ時間を止める
    private async Awaitable HitStopAsync()
    {
        float timeScale = Time.timeScale; // 止める前の速さ（自動プレイで速くしているときは 1 ではない）
        Time.timeScale = 0f;
        try
        {
            // timeScale が 0 の間も進む unscaledDeltaTime で数える
            float time = 0f;
            while (time < hitStopSeconds)
            {
                await Awaitable.NextFrameAsync(destroyCancellationToken);
                time += Time.unscaledDeltaTime;
            }
        }
        finally
        {
            // 途中で止まっても、必ず時間を戻す
            Time.timeScale = timeScale;
        }
    }

    // level になるのに必要な、経験値の合計
    public static int TotalExpFor(int level)
    {
        return totalExp[level - 1];
    }

using UnityEngine;
using UnityEngine.SceneManagement;

// バランスを確かめる：決まったレベル・装備の3人で、1つの階を自動プレイで何回も通して、結果を Console に出す
// ロビーのシーンに置く。Run On Play をチェックして再生すると始まる
public class BalanceTester : MonoBehaviour
{
    [SerializeField] private bool runOnPlay;          // チェックして再生すると、確かめ始める
    [SerializeField] private int floorIndex = 2;      // 確かめる階（0 が地下1階）
    [SerializeField] private int level = 7;           // 仲間のレベル
    [SerializeField] private CharacterData[] party;   // バトルに出る3人
    [SerializeField] private EquipmentData weapon;    // 3人に付ける ぶき（空なら無し）
    [SerializeField] private EquipmentData armor;     // 3人に付ける ぼうぐ（空なら無し）
    [SerializeField] private int runCount = 10;       // 何回通すか（シードを 1, 2, 3 … と変える）
    [SerializeField, Range(1f, 20f)] private float speed = 10f; // 何倍の速さで進めるか

    public static BalanceTester Instance { get; private set; }
    public static bool IsRunning => Instance != null && Instance.isRunning;

    private bool isRunning;
    private int seed;        // 今の回のシード
    private int[] turns;     // 今の回の、バトルごとのターン数
    private int clearCount;  // クリアした回数

    private void Awake()
    {
        // ロビーに戻ってくると、もう1つ作られる。先にあるほうを使い、新しいほうは消す（GameSession と同じ）
        if (Instance != null)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }

    private void Start()
    {
        if (Instance != this || !runOnPlay)
        {
            return;
        }
        isRunning = true;
        Time.timeScale = speed;
        SceneManager.sceneLoaded += OnSceneLoaded;
        seed = 1;
        StartRun();
    }

    private void OnDestroy()
    {
        // 途中で再生を止めたときも、イベントの登録を外して、速さを戻す（外さないと、次の再生でも呼ばれてしまう）
        if (Instance == this)
        {
            SceneManager.sceneLoaded -= OnSceneLoaded;
            Time.timeScale = 1f;
        }
    }

    // 1回分を始める：仲間のレベル・装備・並びをそろえて、シードを決め、その階の1回目のバトルへ
    private void StartRun()
    {
        GameSession session = GameSession.Instance;
        for (int i = 0; i < party.Length; i++)
        {
            CharacterData data = party[i];
            PartyMember member = session.Members.Find(m => m.Data == data);
            session.Members.Remove(member);
            session.Members.Insert(i, member); // 上から3人がバトルに出る
        }
        foreach (PartyMember member in session.Members)
        {
            member.TotalExp = LevelTable.TotalExpFor(level);
            member.Equip(EquipSlot.Weapon, weapon);
            member.Equip(EquipSlot.Armor, armor);
            member.RestoreAll();
        }
        session.FloorIndex = floorIndex;
        session.BattleIndex = 0;
        session.ClearedFloorCount = floorIndex;

        turns = new int[session.CurrentFloor.BattleCount];
        GameRandom.SetSeed(seed); // 同じシードなら、毎回同じ結果になる
        SceneManager.LoadScene("Battle");
    }

    // バトルのターンが始まるたびに、BattleManager から呼ぶ
    public static void CountTurn()
    {
        if (IsRunning)
        {
            Instance.turns[GameSession.Instance.BattleIndex]++;
        }
    }

    // ロビーに戻ってきた＝1回分が終わった（クリアしたか、ぜんめつした）。結果を出して、次の回へ
    private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        if (scene.name != "Lobby")
        {
            return;
        }
        LogRun();
        seed++;
        if (seed <= runCount)
        {
            StartRun();
            return;
        }

        // 全部終わった
        string floorName = GameSession.Instance.CurrentFloor.FloorName;
        Debug.Log($"【{floorName} Lv{level}】{runCount}回中 {clearCount}回 クリア");
        SceneManager.sceneLoaded -= OnSceneLoaded;
        Time.timeScale = 1f;
        isRunning = false;
    }

    // 1回分の結果を Console に出す（ターン数は、バトルごとにカンマで区切る）
    private void LogRun()
    {
        GameSession session = GameSession.Instance;
        int battleIndex = session.BattleIndex; // クリアしたら、バトルの数と同じになっている
        bool isCleared = battleIndex >= session.CurrentFloor.BattleCount;
        int foughtCount = isCleared ? battleIndex : battleIndex + 1;
        string turnText = TurnText(foughtCount);
        if (!isCleared)
        {
            Debug.Log($"シード{seed}：{battleIndex + 1}回目で ぜんめつ（ターン {turnText}）");
            return;
        }

        clearCount++;
        int hp = 0;
        int maxHp = 0;
        foreach (PartyMember member in session.Party)
        {
            hp += member.Hp;
            maxHp += member.Stats.maxHp;
        }
        Debug.Log($"シード{seed}：クリア（ターン {turnText}）のこりHP {hp}/{maxHp}");
    }

    // 戦ったバトルのターン数を「3, 4, 9」のように並べる
    private string TurnText(int foughtCount)
    {
        string text = turns[0].ToString();
        for (int i = 1; i < foughtCount; i++)
        {
            text += $", {turns[i]}";
        }
        return text;
    }
}

        if (BalanceTester.IsRunning)
        {
            return canGoOn; // バランスを確かめている間は、出さずに進む（先へ進めなければ、ロビーへ）
        }

    // 自動プレイか（チェックしたとき・バランスを確かめているとき）
    private bool IsAutoPlay => autoPlay || BalanceTester.IsRunning;

                case BattlePhase.Command:
                    BalanceTester.CountTurn();

    [SerializeField] private int maxPoisonDamage = 0;   // そのダメージの上限（0 なら上限なし。HP の多いボスに効きすぎないように）

    // 最大HP が maxHp の人が、ターンのおわりに受けるダメージ（最低でも1、上限があればそこまで）
    public int PoisonDamage(int maxHp)
    {
        int damage = Mathf.Max(1, Mathf.RoundToInt(maxHp * poisonRate));
        if (maxPoisonDamage > 0)
        {
            damage = Mathf.Min(damage, maxPoisonDamage);
        }
        return damage;
    }

                    damages.Add(effect.Data.PoisonDamage(unit.Stats.maxHp));