ターン制RPGの作り方#11｜勝ち負けと、にげる：喜ぶポーズ・暗くなる画面・逃げる確率

    [SerializeField] private Sprite[] winFrames; // 喜ぶポーズ（win_01・02・03）

    public Sprite[] WinFrames => winFrames;

    private Sprite[] winFrames;  // 喜ぶポーズ（仲間だけ）

        winFrames = data.WinFrames;

    // 勝った：喜ぶ絵を 01 → 02 → 03 と切りかえて、03 のまま止める（仲間だけ）
    public async Awaitable PlayWinAsync()
    {
        idleBounce.enabled = false; // 待機の弾みが絵を上書きしないように止める
        foreach (Sprite frame in winFrames)
        {
            image.sprite = frame;
            await Awaitable.WaitForSecondsAsync(0.15f, destroyCancellationToken);
        }
    }

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

// バトルが終わったときのウインド（勝った・負けた・にげた）。「もういちど」が押されるまで待つ
public class ResultWindow : MonoBehaviour
{
    [SerializeField] private TMP_Text titleText;
    [SerializeField] private TMP_Text bodyText;
    [SerializeField] private Button retryButton;

    // 「もういちど」が押されたら、待っているところに知らせる
    private readonly AwaitableCompletionSource retrySource = new AwaitableCompletionSource();

    private void Awake()
    {
        retryButton.onClick.AddListener(OnRetryClicked);
        gameObject.SetActive(false); // 最初は隠しておく
    }

    // ウインドを出して、「もういちど」が押されるまで待つ
    public async Awaitable ShowAsync(string title, string body)
    {
        titleText.text = title;
        bodyText.text = body;
        retrySource.Reset();
        gameObject.SetActive(true);

        // 最後のメッセージを読んだときの決定が、このフレームに残っていることがあるので、1フレーム待ってから選ぶ
        await Awaitable.NextFrameAsync(destroyCancellationToken);
        EventSystem.current.SetSelectedGameObject(retryButton.gameObject);

        await retrySource.Awaitable;
    }

    private void OnRetryClicked()
    {
        retrySource.TrySetResult();
    }
}

using UnityEngine;
using UnityEngine.UI;

// 画面を、黒い板の濃さでゆっくり暗くする
[RequireComponent(typeof(Image))]
public class ScreenFade : MonoBehaviour
{
    private Image image;

    private void Awake()
    {
        image = GetComponent<Image>();
        SetAlpha(0f); // 最初は透明
    }

    // seconds 秒かけて、濃さを targetAlpha（0〜1）にする
    public async Awaitable FadeAsync(float targetAlpha, float seconds)
    {
        float startAlpha = image.color.a;
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            SetAlpha(Mathf.Lerp(startAlpha, targetAlpha, time / seconds));
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        SetAlpha(targetAlpha);
    }

    private void SetAlpha(float alpha)
    {
        Color color = image.color;
        color.a = alpha;
        image.color = color;
    }
}

    // true なら、パーティみんなの行動。選んだら、ほかの人のコマンドは取り消す（にげる など）
    public virtual bool IsForWholeParty => false;

    public bool IsEscaped;                // にげきれたら true

    // にげる：左を向いて、画面の外へ走っていく
    public async Awaitable RunAwayAsync()
    {
        transform.localScale = new Vector3(-1f, 1f, 1f); // 左右を反転して、左を向く
        Vector2 from = rectTransform.anchoredPosition;
        Vector2 to = from + new Vector2(-900f, 0f);
        const float seconds = 0.5f;
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            rectTransform.anchoredPosition = Vector2.Lerp(from, to, time / seconds);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
    }

using System.Collections.Generic;
using UnityEngine;

// にげる：パーティみんなで逃げる。確率は すばやさで決まる
[CreateAssetMenu(fileName = "Run", menuName = "TurnBasedRpg/Commands/Run")]
public class RunCommand : BattleCommand
{
    public override bool ActsFirst => true;       // 敵より先に逃げる
    public override bool IsForWholeParty => true; // 選んだら、ほかの人のコマンドは取り消す

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        await context.Message.ShowAsync($"{user.Name}たちは にげだした！");

        // 仲間の平均すばやさ ÷（仲間の平均すばやさ ＋ 敵の平均すばやさ）
        float partySpeed = AverageSpeed(context.Party);
        float enemySpeed = AverageSpeed(context.Enemies);
        float chance = partySpeed / (partySpeed + enemySpeed);

        if (GameRandom.Range(0f, 1f) >= chance)
        {
            await context.Message.ShowAsync("しかし まわりこまれてしまった！");
            return;
        }

        context.IsEscaped = true;
        // 立っている仲間が、いっしょに走り出す（始めておいて、あとで待つ）
        List<Awaitable> runs = new List<Awaitable>();
        foreach (UnitView view in context.Party)
        {
            if (!view.Unit.IsDead)
            {
                runs.Add(view.RunAwayAsync());
            }
        }
        foreach (Awaitable run in runs)
        {
            await run;
        }
        await context.Message.ShowAsync("うまく にげきれた！");
    }

    // まだ倒れていない人の、すばやさの平均
    private float AverageSpeed(UnitView[] views)
    {
        int total = 0;
        int count = 0;
        foreach (UnitView view in views)
        {
            if (!view.Unit.IsDead)
            {
                total += view.Unit.Stats.speed;
                count++;
            }
        }
        return (float)total / count;
    }
}

    Escaped, // にげた

    [SerializeField] private ResultWindow resultWindow;
    [SerializeField] private ScreenFade screenFade;

using UnityEngine.SceneManagement;

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

                case BattlePhase.Victory:
                    await ShowVictoryAsync();
                    phase = BattlePhase.End;
                    break;

                case BattlePhase.Defeat:
                    await messageWindow.ShowAsync("みんな たおれてしまった…");
                    await screenFade.FadeAsync(0.7f, 1f);
                    await resultWindow.ShowAsync("ぜんめつ…", "もういちど ちょうせんしよう！");
                    phase = BattlePhase.End;
                    break;

                case BattlePhase.Escaped:
                    await resultWindow.ShowAsync("にげだした", "こんどは かてるかな？");
                    phase = BattlePhase.End;
                    break;
            }
        }

        // 「もういちど」が押された：今のシーンを読み込み直して、バトルを最初から
        SceneManager.LoadScene(SceneManager.GetActiveScene().name);
    }

    // 勝った：立っている仲間が喜んで、手に入れた経験値とお金を出す
    private async Awaitable ShowVictoryAsync()
    {
        foreach (BattleUnit unit in lineup.PartyUnits)
        {
            if (!unit.IsDead)
            {
                _ = unit.View.PlayWinAsync(); // 喜ぶのは待たずに、メッセージと一緒に進める
            }
        }
        await messageWindow.ShowAsync("てきを ぜんぶ たおした！");

        int exp = 0;
        int gold = 0;
        foreach (BattleUnit enemy in lineup.EnemyUnits)
        {
            exp += enemy.Exp;
            gold += enemy.Gold;
        }
        await resultWindow.ShowAsync("しょうり！", $"けいけんち {exp}ポイント\n{gold}ゴールドを てにいれた");
    }

    public int Exp { get; }  // 倒されたときの経験値（敵だけ）
    public int Gold { get; } // 倒されたときのお金（敵だけ）

        Exp = data.Exp;
        Gold = data.Gold;

            action.User = unit;
            if (command.IsForWholeParty)
            {
                // にげる などは、パーティみんなの行動。ほかの人のコマンドは取り消す
                BrightenParty();
                return new BattleAction[] { action };
            }

            if (context.IsEscaped || LivingEnemyViews().Length == 0 || IsPartyDown())
            {
                // にげきれたり、途中で勝ち負けが決まったりしたら、残りの行動はしない
                break;
            }