ターン制RPGの作り方#15｜状態異常と補助のまほう：どく・せきか・ふうじ・ぼうぎょアップ

using UnityEngine;

// 状態1つ分のデータ（どく・せきか・ふうじ・ぼうぎょアップ など）
[CreateAssetMenu(fileName = "NewStatusEffect", menuName = "TurnBasedRpg/Status Effect")]
public class StatusEffectData : ScriptableObject
{
    [SerializeField] private string effectName;         // 画面に出す名前
    [SerializeField] private Sprite icon;               // アイコン
    [SerializeField] private Color color = Color.white; // 名前を飛び出させるときの色
    [SerializeField] private Color tint = Color.white;  // かかっている間の体の色（白なら変えない）
    [SerializeField] private int turns = 3;             // 続くターン（かけたターンも1と数える）
    [SerializeField] private bool canAct = true;        // チェックを外すと、動けなくなる（せきか・ふうじ）
    [SerializeField] private float damageRate = 1f;     // 受けるダメージの倍率（ぼうぎょアップは 0.7）
    [SerializeField] private float poisonRate = 0f;     // ターンのおわりに、最大HPのこの割合のダメージ（どくは 0.25）

    public string EffectName => effectName;
    public Sprite Icon => icon;
    public Color Color => color;
    public Color Tint => tint;
    public int Turns => turns;
    public bool CanAct => canAct;
    public float DamageRate => damageRate;
    public float PoisonRate => poisonRate;
}

// かかっている状態1つ：どの状態か（データ）と、残りのターン
public class ActiveEffect
{
    public StatusEffectData Data { get; }
    public int TurnsLeft { get; set; }

    public ActiveEffect(StatusEffectData data)
    {
        Data = data;
        TurnsLeft = data.Turns;
    }
}

    public List<ActiveEffect> Effects { get; } = new List<ActiveEffect>(); // かかっている状態

    // 動けるか（せきか・ふうじ など、動けない状態が1つでもあれば false）
    public bool CanAct
    {
        get
        {
            foreach (ActiveEffect effect in Effects)
            {
                if (!effect.Data.CanAct)
                {
                    return false;
                }
            }
            return true;
        }
    }

    // 受けるダメージの倍率（ぼうぎょアップ などを、全部かけ合わせたもの）
    public float DamageRate
    {
        get
        {
            float rate = 1f;
            foreach (ActiveEffect effect in Effects)
            {
                rate *= effect.Data.DamageRate;
            }
            return rate;
        }
    }

    // 状態をかける（もうかかっていたら、残りのターンを最初に戻す）
    public void AddEffect(StatusEffectData data)
    {
        foreach (ActiveEffect effect in Effects)
        {
            if (effect.Data == data)
            {
                effect.TurnsLeft = data.Turns;
                return;
            }
        }
        Effects.Add(new ActiveEffect(data));
        ShowEffects();
    }

    // ターンのおわりに、残りのターンを1つ減らす。0になって消えた状態を返す
    public List<ActiveEffect> CountDownEffects()
    {
        List<ActiveEffect> expired = new List<ActiveEffect>();
        foreach (ActiveEffect effect in Effects)
        {
            effect.TurnsLeft--;
            if (effect.TurnsLeft <= 0)
            {
                expired.Add(effect);
            }
        }
        foreach (ActiveEffect effect in expired)
        {
            Effects.Remove(effect);
        }
        ShowEffects();
        return expired;
    }

    // かかっている状態を、見た目（アイコン・体の色）に出す
    public void ShowEffects()
    {
        View.ShowEffects(Effects);
        if (Row != null)
        {
            Row.ShowEffects(Effects);
        }
    }

    // ダメージを受ける（0より下にはしない）。倒れたら、かかっている状態は消える
    public void TakeDamage(int damage)
    {
        Hp = Mathf.Max(0, Hp - damage);
        if (IsDead && Effects.Count > 0)
        {
            Effects.Clear();
            ShowEffects();
        }
    }

        damage *= defender.DamageRate; // ぼうぎょアップ などの倍率
        return Mathf.Max(1, Mathf.RoundToInt(damage));

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

// かかっている状態のアイコンを並べる（同じ GameObject の Horizontal Layout Group が並べてくれる）
public class EffectIcons : MonoBehaviour
{
    [SerializeField] private float iconSize = 44f;

    // 前のアイコンを消して、今の状態のアイコンを作り直す
    public void Show(List<ActiveEffect> effects)
    {
        foreach (Transform child in transform)
        {
            Destroy(child.gameObject);
        }
        foreach (ActiveEffect effect in effects)
        {
            GameObject icon = new GameObject(effect.Data.EffectName, typeof(RectTransform), typeof(Image));
            icon.transform.SetParent(transform, false);
            ((RectTransform)icon.transform).sizeDelta = new Vector2(iconSize, iconSize);
            Image image = icon.GetComponent<Image>();
            image.sprite = effect.Data.Icon;
            image.raycastTarget = false;
        }
    }
}

    [SerializeField] private EffectIcons effectIcons; // 状態のアイコン（敵のプレハブだけ。仲間はステータスの行に出す）

    private bool isDimmed;          // 暗くしているか
    private Color tint = Color.white; // 状態による体の色（せきかは灰色）

    // 暗くする（false で、状態の色に戻す。戦闘不能の人は暗いまま）
    public void SetDimmed(bool dimmed)
    {
        isDimmed = dimmed;
        image.color = (isDimmed || isDown) ? dimColor : tint;
    }

    // かかっている状態を見た目に出す：アイコンと、体の色（白以外の色の状態があれば、その色）
    public void ShowEffects(List<ActiveEffect> effects)
    {
        if (effectIcons != null)
        {
            effectIcons.Show(effects);
        }
        tint = Color.white;
        foreach (ActiveEffect effect in effects)
        {
            if (effect.Data.Tint != Color.white)
            {
                tint = effect.Data.Tint;
            }
        }
        SetDimmed(isDimmed);
    }

    [SerializeField] private EffectIcons effectIcons;

    public void ShowEffects(List<ActiveEffect> effects)
    {
        effectIcons.Show(effects);
    }

using System.Collections.Generic;
using UnityEngine;

// 状態をかけるまほう（どく・せきか・ふうじ・ぼうぎょアップ など）
[CreateAssetMenu(fileName = "NewStatusSpell", menuName = "TurnBasedRpg/Skills/Status Spell")]
public class StatusSpellCommand : SkillCommand
{
    [SerializeField] private StatusEffectData effect; // かける状態
    [SerializeField] private bool forAllies;          // チェックすると、味方にかける（まもりの風 など）
    [SerializeField, Range(0, 100)] private int chance = 100; // かかる確率（%）

    public override async Awaitable<BattleAction> SelectAsync(BattleUnit user, BattleContext context)
    {
        if (forAllies)
        {
            return TargetsAll ? await SelectAllAlliesAsync(context) : await SelectAllyAsync(context);
        }
        return TargetsAll ? await SelectAllEnemiesAsync(context) : await SelectEnemyAsync(context);
    }

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        // かける相手：全体なら立っている全員、1人ならねらった相手（倒れていたら、敵は別の敵・味方は自分）
        List<BattleUnit> targets = new List<BattleUnit>();
        if (TargetsAll)
        {
            UnitView[] side = forAllies ? context.Party : context.Enemies;
            foreach (UnitView view in side)
            {
                if (!view.Unit.IsDead)
                {
                    targets.Add(view.Unit);
                }
            }
        }
        else if (forAllies && action.Target.Unit.IsDead)
        {
            targets.Add(user);
        }
        else
        {
            targets.Add(FindTarget(user, action, context));
        }

        SpendMp(user);
        await context.Message.ShowAsync($"{user.Name}は {CommandName}を となえた！");
        if (forAllies)
        {
            await user.View.PlayCastAsync(); // 味方には、力をためる
        }
        else
        {
            await user.View.PlayOrbAsync();  // 敵には、杖をふる
        }

        // 全員いっしょに、かかったかを決めて、名前を飛び出させる
        bool[] isApplied = new bool[targets.Count];
        for (int i = 0; i < targets.Count; i++)
        {
            BattleUnit target = targets[i];
            isApplied[i] = GameRandom.Range(0f, 100f) < chance;
            if (isApplied[i])
            {
                target.AddEffect(effect);
                PlayEffect(target.View);
                context.Effects.ShowText(target.View, effect.EffectName, effect.Color);
            }
            else
            {
                context.Effects.ShowText(target.View, "ミス", Color.gray);
            }
        }
        await Awaitable.WaitForSecondsAsync(0.6f);
        user.View.ResumeIdle();

        // そのあとで、1人ずつメッセージ
        for (int i = 0; i < targets.Count; i++)
        {
            if (isApplied[i])
            {
                await context.Message.ShowAsync($"{targets[i].Name}は {effect.EffectName}に なった！");
            }
            else
            {
                await context.Message.ShowAsync($"{targets[i].Name}には きかなかった！");
            }
        }
    }
}

            if (!action.User.CanAct)
            {
                // せきか・ふうじ などで動けない
                await messageWindow.ShowAsync($"{action.User.Name}は うごけない！");
                continue;
            }

        // 勝ち負けが決まっていなければ、ターンのおわり
        if (!context.IsEscaped && LivingEnemyViews().Length > 0 && !IsPartyDown())
        {
            await EndTurnAsync();
        }

    // どく などで、何人かが同時にダメージを受ける：色の付いた数字を出して、のけぞる（ヒットストップと揺れは無し）
    public async Awaitable PlayStatusDamageAsync(UnitView[] targets, int[] damages, Color[] colors)
    {
        List<Awaitable> hits = new List<Awaitable>();
        for (int i = 0; i < targets.Length; i++)
        {
            UnitView target = targets[i];
            BattleUnit unit = target.Unit;
            if (unit.Row != null)
            {
                unit.Row.SetHp(unit.Hp, unit.Stats.maxHp);
            }
            ShowText(target, damages[i].ToString(), colors[i]);
            hits.Add(target.HitAsync());
        }
        foreach (Awaitable hit in hits)
        {
            await hit;
        }
    }

    // ターンのおわり：どくのダメージを受けて、状態の残りターンを1つ減らす
    private async Awaitable EndTurnAsync()
    {
        List<BattleUnit> living = new List<BattleUnit>();
        foreach (BattleUnit unit in lineup.PartyUnits)
        {
            if (!unit.IsDead)
            {
                living.Add(unit);
            }
        }
        foreach (BattleUnit unit in lineup.EnemyUnits)
        {
            if (!unit.IsDead)
            {
                living.Add(unit);
            }
        }

        // どく：全員いっしょにダメージを受けてから、1人ずつメッセージ
        List<BattleUnit> poisoned = new List<BattleUnit>();
        List<int> damages = new List<int>();
        List<Color> colors = new List<Color>();
        List<string> names = new List<string>();
        foreach (BattleUnit unit in living)
        {
            foreach (ActiveEffect effect in unit.Effects)
            {
                if (effect.Data.PoisonRate > 0f)
                {
                    poisoned.Add(unit);
                    damages.Add(Mathf.Max(1, Mathf.RoundToInt(unit.Stats.maxHp * effect.Data.PoisonRate)));
                    colors.Add(effect.Data.Color);
                    names.Add(effect.Data.EffectName);
                    break;
                }
            }
        }
        if (poisoned.Count > 0)
        {
            UnitView[] views = new UnitView[poisoned.Count];
            for (int i = 0; i < poisoned.Count; i++)
            {
                BattleUnit unit = poisoned[i];
                unit.TakeDamage(damages[i]);
                views[i] = unit.View;
            }
            await battleEffects.PlayStatusDamageAsync(views, damages.ToArray(), colors.ToArray());
            await FallTogetherAsync(poisoned);
            for (int i = 0; i < poisoned.Count; i++)
            {
                await messageWindow.ShowAsync($"{poisoned[i].Name}は {names[i]}で {damages[i]}の ダメージ！");
            }
            foreach (BattleUnit unit in poisoned)
            {
                if (unit.IsDead)
                {
                    await messageWindow.ShowAsync(unit.IsEnemy ? $"{unit.Name}を たおした！" : $"{unit.Name}は たおれてしまった！");
                }
            }
        }

        // 残りのターンを減らして、消えた状態を知らせる
        foreach (BattleUnit unit in living)
        {
            if (unit.IsDead)
            {
                continue;
            }
            foreach (ActiveEffect effect in unit.CountDownEffects())
            {
                await messageWindow.ShowAsync($"{unit.Name}の {effect.Data.EffectName}が とけた！");
            }
        }
    }

    // 倒れた人を、全員いっしょに消す（敵はしぼんで消え、仲間は戦闘不能の絵に）
    private async Awaitable FallTogetherAsync(List<BattleUnit> units)
    {
        List<Awaitable> falls = new List<Awaitable>();
        foreach (BattleUnit unit in units)
        {
            if (!unit.IsDead)
            {
                continue;
            }
            if (unit.IsEnemy)
            {
                falls.Add(unit.View.DisappearAsync());
            }
            else
            {
                unit.View.ShowDown();
            }
        }
        foreach (Awaitable fall in falls)
        {
            await fall;
        }
    }