ターン制RPGの作り方#8｜攻撃の手応えを作ろう：前に出る・光る・のけぞる・数字・火花

    [SerializeField] private Sprite[] attackFrames; // 攻撃のポーズ（attack_61・62）

    public Sprite[] AttackFrames => attackFrames;

using UnityEngine;
using UnityEngine.UI;

// 仲間や敵の見た目。データを受け取って、絵を表示する
public class UnitView : MonoBehaviour
{
    [SerializeField] private Image image;
    [SerializeField] private IdleBounce idleBounce;  // 仲間だけ。敵は空のまま
    [SerializeField] private Material flashMaterial; // 白く光らせるマテリアル（WhiteFlash）
    [SerializeField] private Color flashColor = new Color(1f, 0.92f, 0.5f); // 光る色（白い敵でも分かるよう、少し黄色）
    [SerializeField] private float blinkSpeed = 6f;  // 点滅の速さ
    [SerializeField] private float minFlash = 0.15f; // 一番弱いときの白さ
    [SerializeField] private float maxFlash = 0.45f; // 一番強いときの白さ
    [SerializeField] private Color dimColor = new Color(0.4f, 0.4f, 0.45f); // 暗くするときの色
    [SerializeField] private float stepDistance = 120f;     // 攻撃するときに前に出る距離
    [SerializeField] private float stepSeconds = 0.12f;     // 前に出る・戻るのにかける時間
    [SerializeField] private float knockbackDistance = 40f; // のけぞる距離
    [SerializeField] private float hitFlashSeconds = 0.08f; // 当たったときに真っ白になる時間
    [SerializeField] private float recoverSeconds = 0.25f;  // のけぞってから元の位置に戻るまでの時間

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

    private Image flashImage; // 自分の絵の上に重ねる、白いシルエット
    private bool isHighlighted;
    private RectTransform rectTransform;
    private Vector2 homePosition; // もとの位置
    private float forward = 1f;   // 前の向き（仲間は右＝1、敵は左＝-1）
    private Sprite[] attackFrames; // 攻撃のポーズ（仲間だけ）

    private void Awake()
    {
        rectTransform = (RectTransform)transform;

        // 自分の絵と同じ大きさの Image を子に作って、白く光らせるのに使う
        GameObject flash = new GameObject("Flash", typeof(RectTransform), typeof(Image));
        flash.transform.SetParent(transform, false);
        RectTransform flashRect = (RectTransform)flash.transform;
        flashRect.anchorMin = Vector2.zero;
        flashRect.anchorMax = Vector2.one;
        flashRect.offsetMin = Vector2.zero;
        flashRect.offsetMax = Vector2.zero;
        flashImage = flash.GetComponent<Image>();
        flashImage.material = flashMaterial;
        flashImage.preserveAspect = true;
        flashImage.raycastTarget = false;
        flashImage.enabled = false;
    }

    private void Start()
    {
        // 敵は Instantiate のあとで位置を決めるので、Start で覚える
        homePosition = rectTransform.anchoredPosition;
    }

    private void Update()
    {
        if (isHighlighted)
        {
            UpdateFlash();
        }
    }

    // 光る絵を、体と同じ形・今の白さにする
    private void UpdateFlash()
    {
        // 待機のコマが変わっても、同じ形で光るようにする
        flashImage.sprite = image.sprite;
        // Sin で 0〜1 をくり返し、白さを minFlash〜maxFlash の間で変える
        float wave = (Mathf.Sin(Time.time * blinkSpeed) + 1f) / 2f;
        Color color = flashColor;
        color.a = Mathf.Lerp(minFlash, maxFlash, wave);
        flashImage.color = color;
    }

    // 仲間のデータで見た目を作る
    public void SetupCharacter(CharacterData data)
    {
        name = data.CharacterName;
        idleBounce.SetFrames(data.IdleFrames);
        attackFrames = data.AttackFrames;
    }

    // 敵のデータで見た目を作る
    public void SetupEnemy(EnemyData data)
    {
        name = data.EnemyName;
        image.sprite = data.Sprite;
        forward = -1f; // 敵は左を向いている
    }

    // 選ばれている間、白く点滅させる
    public void SetHighlight(bool isOn)
    {
        isHighlighted = isOn;
        if (isOn)
        {
            // 表示する前に、形と色を入れておく（入れる前に表示すると、1フレームだけ白い四角が出る）
            UpdateFlash();
        }
        flashImage.enabled = isOn;
    }

    // 暗くする（false で、もとの色に戻す）
    public void SetDimmed(bool isDimmed)
    {
        image.color = isDimmed ? dimColor : Color.white;
    }

    // 前に出る（isForward が false なら、もとの位置に戻って、待機の弾みに戻す）
    public async Awaitable StepAsync(bool isForward)
    {
        Vector2 from = rectTransform.anchoredPosition;
        Vector2 to = isForward ? homePosition + new Vector2(stepDistance * forward, 0f) : homePosition;
        float time = 0f;
        while (time < stepSeconds)
        {
            time += Time.deltaTime;
            rectTransform.anchoredPosition = Vector2.Lerp(from, to, time / stepSeconds);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        rectTransform.anchoredPosition = to;

        if (!isForward && idleBounce != null)
        {
            idleBounce.enabled = true;
        }
    }

    // 攻撃のポーズ：振りかぶって（61）、振る（62）。ポーズの絵が無い敵は、何もしない
    public async Awaitable PlayAttackPoseAsync()
    {
        if (attackFrames == null || attackFrames.Length < 2)
        {
            return;
        }
        idleBounce.enabled = false; // 待機のコマが上書きしないように止める
        image.sprite = attackFrames[0];
        await Awaitable.WaitForSecondsAsync(0.1f, destroyCancellationToken);
        image.sprite = attackFrames[1];
    }

    // 当たった：一瞬だけ真っ白に光って、後ろへのけぞり、元に戻る
    public async Awaitable HitAsync()
    {
        flashImage.sprite = image.sprite;
        flashImage.color = Color.white;
        flashImage.enabled = true;
        Vector2 pushed = homePosition - new Vector2(knockbackDistance * forward, 0f);
        rectTransform.anchoredPosition = pushed;

        await Awaitable.WaitForSecondsAsync(hitFlashSeconds, destroyCancellationToken);
        flashImage.enabled = isHighlighted;

        float time = 0f;
        while (time < recoverSeconds)
        {
            time += Time.deltaTime;
            rectTransform.anchoredPosition = Vector2.Lerp(pushed, homePosition, time / recoverSeconds);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        rectTransform.anchoredPosition = homePosition;
    }

    // 倒れた：しぼみながら薄くなって消える
    public async Awaitable DisappearAsync()
    {
        const float seconds = 0.35f;
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            float t = time / seconds;
            transform.localScale = Vector3.one * (1f - t);
            image.color = new Color(1f, 1f, 1f, 1f - t);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        gameObject.SetActive(false);
    }
}

using TMPro;
using UnityEngine;

// ダメージの数字：大きく出て、放物線を描いて飛び、消える
[RequireComponent(typeof(TextMeshProUGUI))]
public class DamagePopup : MonoBehaviour
{
    [SerializeField] private float lifeSeconds = 0.8f; // 消えるまでの時間
    [SerializeField] private float jumpSpeed = 600f;   // 上へ飛び出す速さ
    [SerializeField] private float gravity = 1800f;    // 下へ引っぱる強さ

    private TextMeshProUGUI text;
    private RectTransform rectTransform;
    private Vector2 velocity;
    private float time;

    public void Setup(int damage)
    {
        text = GetComponent<TextMeshProUGUI>();
        rectTransform = (RectTransform)transform;
        text.text = damage.ToString();
        text.fontSize = Mathf.Min(70f + damage * 3f, 140f); // 大きいダメージほど大きな文字に
        velocity = new Vector2(Random.Range(-150f, 150f), jumpSpeed);
    }

    private void Update()
    {
        time += Time.deltaTime;
        float t = time / lifeSeconds;

        // 放物線：上へ飛び出して、重力で落ちてくる
        velocity.y -= gravity * Time.deltaTime;
        rectTransform.anchoredPosition += velocity * Time.deltaTime;

        // 出た瞬間だけ大きく、後半で透明に
        rectTransform.localScale = Vector3.one * Mathf.Lerp(1.8f, 1f, t / 0.15f);
        text.alpha = Mathf.InverseLerp(1f, 0.6f, t);

        if (time >= lifeSeconds)
        {
            Destroy(gameObject);
        }
    }
}

using UnityEngine;

// 当たったときの演出（ダメージの数字・火花・ヒットストップ・画面の揺れ）をまとめて出す
public class BattleEffects : MonoBehaviour
{
    [SerializeField] private DamagePopup damagePopupPrefab;
    [SerializeField] private RectTransform popupLayer; // 数字を出す親（Canvas の一番手前）
    [SerializeField] private ParticleSystem sparksPrefab;
    [SerializeField] private RectTransform stage;      // 揺らす画面
    [SerializeField] private float hitStopSeconds = 0.06f; // 時間を止める長さ
    [SerializeField] private float shakeSeconds = 0.25f;   // 揺れている時間
    [SerializeField] private float shakePerDamage = 2f;    // ダメージ1あたりの揺れの幅
    [SerializeField] private float maxShake = 30f;         // 揺れの幅の上限

    // 当たった瞬間の演出を、まとめて出す
    public async Awaitable PlayHitAsync(UnitView target, int damage)
    {
        DamagePopup popup = Instantiate(damagePopupPrefab, popupLayer);
        popup.transform.position = target.transform.position;
        popup.Setup(damage);
        Instantiate(sparksPrefab, target.transform.position, Quaternion.identity);

        // 光る・のけぞると、画面の揺れは、待たずに始めておく（同時に動かす）
        Awaitable hit = target.HitAsync();
        Awaitable shake = ShakeAsync(damage);
        await HitStopAsync();
        await hit;
        await shake;
    }

    // 一瞬だけ時間を止める
    private async Awaitable HitStopAsync()
    {
        Time.timeScale = 0f;
        try
        {
            // timeScale が 0 の間も進む unscaledDeltaTime で数える
            float time = 0f;
            while (time < hitStopSeconds)
            {
                await Awaitable.NextFrameAsync(destroyCancellationToken);
                time += Time.unscaledDeltaTime;
            }
        }
        finally
        {
            // 途中で止まっても、必ず時間を戻す
            Time.timeScale = 1f;
        }
    }

    // 戦いの画面（Stage）を揺らす。ダメージが大きいほど強く、だんだん弱く
    private async Awaitable ShakeAsync(int damage)
    {
        float strength = Mathf.Min(damage * shakePerDamage, maxShake);
        Vector2 start = stage.anchoredPosition;
        float timeLeft = shakeSeconds;
        while (timeLeft > 0f)
        {
            float power = strength * (timeLeft / shakeSeconds);
            stage.anchoredPosition = start + Random.insideUnitCircle * power;
            await Awaitable.NextFrameAsync(destroyCancellationToken);
            // ヒットストップ中も揺れるように、unscaledDeltaTime で減らす
            timeLeft -= Time.unscaledDeltaTime;
        }
        stage.anchoredPosition = start;
    }
}

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;            // 敵の見た目
}

    // 前に出て、振って、当てて、戻る。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}の こうげき！");
        await user.View.StepAsync(true);       // 前に出る
        await user.View.PlayAttackPoseAsync(); // 振りかぶって、振る

        int damage = DamageCalculator.Physical(user, target);
        target.TakeDamage(damage);
        await context.Effects.PlayHitAsync(target.View, damage); // 当たった！

        // もとの位置に戻りながら、メッセージを出す
        Awaitable stepBack = user.View.StepAsync(false);
        await context.Message.ShowAsync($"{target.Name}に {damage}の ダメージ！");
        await stepBack;

        if (target.IsDead)
        {
            await target.View.DisappearAsync();
            await context.Message.ShowAsync($"{target.Name}を たおした！");
        }
    }

    [SerializeField] private BattleEffects battleEffects;

        context.Effects = battleEffects;