ターン制RPGの作り方#16｜どうぐとインベントリ：ハーブティー・まほうのクッキー・めざましどけい

using UnityEngine;

// どうぐを使われた人のポーズ
public enum ItemPose
{
    None,  // ポーズなし
    Drink, // 飲む（drink_01〜03）
    Eat,   // 食べる（eat_01・02）
}

// どうぐ1つ分のデータ。コマンドと同じように、相手を選んで使う
[CreateAssetMenu(fileName = "NewItem", menuName = "TurnBasedRpg/Item")]
public class ItemData : BattleCommand
{
    [SerializeField] private int hpAmount;                // 回復する HP
    [SerializeField] private int mpAmount;                // 回復する MP
    [SerializeField] private StatusEffectData cureEffect; // 治す状態（どくけしキャンディは どく）
    [SerializeField] private bool revives;                // チェックすると、倒れた仲間を起こす（めざましどけい）
    [SerializeField] private ItemPose pose;               // 使われた人のポーズ
    [SerializeField] private ParticleSystem effectPrefab; // 使われた人のところに出す

    public override async Awaitable<BattleAction> SelectAsync(BattleUnit user, BattleContext context)
    {
        // めざましどけい は倒れている仲間から、ほかは立っている仲間から選ぶ
        return await SelectPartyMemberAsync(context, revives);
    }

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        BattleUnit target = action.Target.Unit;
        if (!revives && target.IsDead)
        {
            target = user; // 選んだ人が先に倒れていたら、自分に使う
        }

        // 同じターンに、ほかの仲間が最後の1つを使っていたら、もう無い
        if (!context.Inventory.Remove(this))
        {
            await context.Message.ShowAsync($"{user.Name}は {CommandName}を さがしたが、もう なかった！");
            return;
        }
        await context.Message.ShowAsync($"{user.Name}は {CommandName}を つかった！");

        if (revives)
        {
            if (!target.IsDead)
            {
                await context.Message.ShowAsync("しかし なにも おこらなかった。");
                return;
            }
            target.Revive();
            PlayEffect(target.View);
            await context.Effects.PlayHealAsync(target.View, target.Hp);
            await context.Message.ShowAsync($"{target.Name}は めを さました！");
            return;
        }

        // 使われた人が、飲む・食べる
        if (pose == ItemPose.Drink)
        {
            await target.View.PlayDrinkAsync();
        }
        else if (pose == ItemPose.Eat)
        {
            await target.View.PlayEatAsync();
        }
        PlayEffect(target.View);

        string message = "しかし なにも おこらなかった。";
        if (hpAmount > 0)
        {
            int amount = target.Heal(hpAmount);
            await context.Effects.PlayHealAsync(target.View, amount);
            message = $"{target.Name}の HPが {amount} かいふくした！";
        }
        if (mpAmount > 0)
        {
            int amount = target.RestoreMp(mpAmount);
            await context.Effects.PlayMpHealAsync(target.View, amount);
            message = $"{target.Name}の MPが {amount} かいふくした！";
        }
        if (cureEffect != null && target.RemoveEffect(cureEffect))
        {
            context.Effects.ShowText(target.View, "なおった！", Color.white);
            await Awaitable.WaitForSecondsAsync(0.5f);
            message = $"{target.Name}の {cureEffect.EffectName}が なおった！";
        }
        target.View.ResumeIdle();
        await context.Message.ShowAsync(message);
    }

    // 使われた人のところに、パーティクルを出す
    private void PlayEffect(UnitView target)
    {
        if (effectPrefab != null)
        {
            Instantiate(effectPrefab, target.transform.position, Quaternion.identity);
        }
    }
}

    // 仲間を1人選ぶ。isDown が true なら倒れている仲間から、false なら立っている仲間から
    // 選べる人がいなければ、メッセージを出して null を返す
    protected async Awaitable<BattleAction> SelectPartyMemberAsync(BattleContext context, bool isDown)
    {
        List<UnitView> candidates = new List<UnitView>();
        foreach (UnitView view in context.Party)
        {
            if (view.Unit.IsDead == isDown)
            {
                candidates.Add(view);
            }
        }
        if (candidates.Count == 0)
        {
            await context.Message.ShowAsync("つかえる なかまが いない！");
            return null;
        }

        context.MessageText.text = "だれに つかう？";
        UnitView target = await context.TargetSelector.SelectTargetAsync(candidates.ToArray(), context.Enemies);
        if (target == null)
        {
            return null;
        }
        return new BattleAction(this, target);
    }

    // MP を回復する（最大MPより上にはしない）。実際に増えた量を返す
    public int RestoreMp(int amount)
    {
        int before = Mp;
        Mp = Mathf.Min(Stats.maxMp, Mp + amount);
        return Mp - before;
    }

    // 状態を治す。かかっていたら true
    public bool RemoveEffect(StatusEffectData data)
    {
        foreach (ActiveEffect effect in Effects)
        {
            if (effect.Data == data)
            {
                Effects.Remove(effect);
                ShowEffects();
                return true; // 消したらすぐ抜けるので、foreach の途中で Remove してもエラーにならない
            }
        }
        return false;
    }

    // 倒れた人を起こす：HP を最大の半分にして、見た目を待機に戻す
    public void Revive()
    {
        Hp = Mathf.Max(1, Stats.maxHp / 2);
        View.Revive();
    }

    [SerializeField] private Sprite[] drinkFrames; // 飲む（drink_01・02・03）
    [SerializeField] private Sprite[] eatFrames;   // 食べる（eat_01・02）

    public Sprite[] DrinkFrames => drinkFrames;
    public Sprite[] EatFrames => eatFrames;

    private Sprite[] drinkFrames; // 飲む（仲間だけ）
    private Sprite[] eatFrames;   // 食べる（仲間だけ）

        drinkFrames = data.DrinkFrames;
        eatFrames = data.EatFrames;

    // 起き上がる：戦闘不能の絵をやめて、待機の弾みに戻す
    public void Revive()
    {
        isDown = false;
        idleBounce.enabled = true;
        SetDimmed(isDimmed);
    }

    // どうぐ：正面を向いて、飲む
    public async Awaitable PlayDrinkAsync()
    {
        await PlayFramesAsync(drinkFrames);
    }

    // どうぐ：正面を向いて、食べる
    public async Awaitable PlayEatAsync()
    {
        await PlayFramesAsync(eatFrames);
    }

    [SerializeField] private Color mpColor = new Color(0.45f, 0.75f, 1f);      // MP の回復の数字の色（水色）

    // MP を回復した：ステータスのゲージを増やして、水色の数字を出す
    public async Awaitable PlayMpHealAsync(UnitView target, int amount)
    {
        BattleUnit unit = target.Unit;
        if (unit.Row != null)
        {
            unit.Row.SetMp(unit.Mp, unit.Stats.maxMp);
        }
        ShowText(target, $"+{amount}", mpColor);
        await Awaitable.WaitForSecondsAsync(0.5f, destroyCancellationToken);
    }

// どうぐ1種類と、その個数（Inspector で最初の持ち物を書くのにも使う）
[System.Serializable]
public class ItemStack
{
    public ItemData item;
    public int count;
}

using System.Collections.Generic;

// 持ち物：どうぐと個数のリスト。同じどうぐは1つにまとめて、個数で数える
public class Inventory
{
    private readonly List<ItemStack> stacks = new List<ItemStack>();

    // 持っているどうぐの種類の数
    public int Count => stacks.Count;

    // どうぐを count 個ふやす（もう持っていたら、個数を足す）
    public void Add(ItemData item, int count)
    {
        foreach (ItemStack stack in stacks)
        {
            if (stack.item == item)
            {
                stack.count += count;
                return;
            }
        }
        ItemStack newStack = new ItemStack();
        newStack.item = item;
        newStack.count = count;
        stacks.Add(newStack);
    }

    // どうぐを1つへらす（0になったら、リストから消す）。持っていなければ false
    public bool Remove(ItemData item)
    {
        for (int i = 0; i < stacks.Count; i++)
        {
            ItemStack stack = stacks[i];
            if (stack.item == item)
            {
                stack.count--;
                if (stack.count <= 0)
                {
                    stacks.RemoveAt(i);
                }
                return true;
            }
        }
        return false;
    }

    // 一覧に並べるどうぐ
    public ItemData[] Items()
    {
        ItemData[] items = new ItemData[stacks.Count];
        for (int i = 0; i < stacks.Count; i++)
        {
            items[i] = stacks[i].item;
        }
        return items;
    }
}

    [SerializeField] private ItemStack[] startItems; // 最初の持ち物（#17 からは、ロビーから持ち越す）

    public Inventory Inventory { get; } = new Inventory(); // 持ち物

        foreach (ItemStack stack in startItems)
        {
            Inventory.Add(stack.item, stack.count);
        }

    public CommandMenu ItemMenu;          // どうぐの一覧
    public Inventory Inventory;           // 持ち物

    [SerializeField] private CommandMenu itemMenu;  // どうぐの一覧（ItemWindow）

        context.ItemMenu = itemMenu;
        context.Inventory = lineup.Inventory;

    [SerializeField] private ScrollRect scrollRect; // 一覧をスクロールするとき（まほう・どうぐ）。コマンドのウインドは空のまま

        else
        {
            if (scrollRect != null && current != lastSelected)
            {
                ScrollTo((RectTransform)current.transform); // 選ぶボタンが変わったら、見えるところまでスクロール
            }
            lastSelected = current;
        }

        // スクロールする一覧は Content の子に、そうでなければ自分の子にボタンを作る
        Transform parent = transform;
        if (scrollRect != null)
        {
            parent = scrollRect.content;
            scrollRect.content.anchoredPosition = Vector2.zero; // 一覧の一番上から見せる
        }

    // item のボタンが、見える枠（Viewport）からはみ出していたら、入るところまで一覧を動かす
    private void ScrollTo(RectTransform item)
    {
        RectTransform viewport = scrollRect.viewport;
        Vector3[] corners = new Vector3[4]; // 0：左下、1：左上、2：右上、3：右下
        item.GetWorldCorners(corners);
        float bottom = viewport.InverseTransformPoint(corners[0]).y; // ボタンの下（Viewport から見た高さ）
        float top = viewport.InverseTransformPoint(corners[1]).y;    // ボタンの上
        Rect view = viewport.rect;
        if (top > view.yMax)
        {
            scrollRect.content.anchoredPosition -= new Vector2(0f, top - view.yMax); // 上にはみ出した：一覧を下げる
        }
        else if (bottom < view.yMin)
        {
            scrollRect.content.anchoredPosition += new Vector2(0f, view.yMin - bottom); // 下にはみ出した：一覧を上げる
        }
    }

    // ボタンの右はしに出す個数（「× 3」「×12」のように、2けたの幅にそろえる）
    public string[] Counts()
    {
        string[] counts = new string[stacks.Count];
        for (int i = 0; i < stacks.Count; i++)
        {
            counts[i] = $"×<mspace=0.6em>{stacks[i].count,2}</mspace>";
        }
        return counts;
    }

    // user のコマンドでボタンを作り、どれかが押されるまで待つ（キャンセルなら null）
    // values を渡すと、ボタンの右はしにそれを出す（どうぐの個数、まほうの MP）
    public async Awaitable<BattleCommand> WaitForCommandAsync(BattleCommand[] commands, BattleUnit user, string[] values = null)
    {
        // 前の人の決定（Enter など）が、まだこのフレームに残っていることがあるので、1フレーム待ってから始める
        await Awaitable.NextFrameAsync(destroyCancellationToken);
        CreateButtons(commands, user, values);

    // コマンドの数だけボタンを作る（前のボタンは消す）。user が使えないコマンドは灰色にする
    private void CreateButtons(BattleCommand[] commands, BattleUnit user, string[] values)
    {
        foreach (Button oldButton in buttons)
        {
            // Destroy はフレームの最後に消えるので、先に隠して、並びから外しておく
            oldButton.gameObject.SetActive(false);
            Destroy(oldButton.gameObject);
        }
        buttons.Clear();

        // スクロールする一覧は Content の子に、そうでなければ自分の子にボタンを作る
        Transform parent = transform;
        if (scrollRect != null)
        {
            parent = scrollRect.content;
            scrollRect.content.anchoredPosition = Vector2.zero; // 一覧の一番上から見せる
        }

        for (int i = 0; i < commands.Length; i++)
        {
            BattleCommand command = commands[i];
            Button button = Instantiate(buttonPrefab, parent);
            button.GetComponentInChildren<TMP_Text>().text = command.MenuLabel;
            if (values != null)
            {
                // 一覧のボタン（ListButton）は、右はしの ValueText に出す
                button.transform.Find("ValueText").GetComponent<TMP_Text>().text = values[i];
            }
            button.interactable = command.CanUse(user);
            button.onClick.AddListener(() => Choose(command));
            buttons.Add(button);
        }
    }

    // 一覧の右はしに出す MP（「MP 3」「MP12」のように、2けたの幅にそろえる）
    public string MpText => $"MP<mspace=0.6em>{mpCost,2}</mspace>";

            string[] mpTexts = new string[user.Skills.Count];
            for (int i = 0; i < user.Skills.Count; i++)
            {
                mpTexts[i] = user.Skills[i].MpText;
            }
            BattleCommand skill = await context.SkillMenu.WaitForCommandAsync(user.Skills.ToArray(), user, mpTexts);

using UnityEngine;

// どうぐ：持ち物の一覧を開いて、選んだどうぐの相手を選ぶ
[CreateAssetMenu(fileName = "Item", menuName = "TurnBasedRpg/Commands/Item")]
public class ItemCommand : BattleCommand
{
    public override async Awaitable<BattleAction> SelectAsync(BattleUnit user, BattleContext context)
    {
        while (true)
        {
            if (context.Inventory.Count == 0)
            {
                await context.Message.ShowAsync("どうぐを なにも もっていない！");
                return null; // コマンドを選び直す
            }

            context.MessageText.text = $"どの {CommandName}を つかう？";
            context.ItemMenu.gameObject.SetActive(true);
            BattleCommand item = await context.ItemMenu.WaitForCommandAsync(context.Inventory.Items(), user, context.Inventory.Counts());
            context.ItemMenu.gameObject.SetActive(false);

            if (item == null)
            {
                return null; // 一覧でキャンセル：コマンドを選び直す
            }

            BattleAction action = await item.SelectAsync(user, context);
            if (action != null)
            {
                return action; // どうぐと相手が決まった
            }
            // 相手を選ぶところでキャンセルしたら、もう一度どうぐの一覧を開く
        }
    }
}

using UnityEngine;

// 倒れた仲間を起こすまほう（めざめの歌）
[CreateAssetMenu(fileName = "NewReviveSpell", menuName = "TurnBasedRpg/Skills/Revive Spell")]
public class ReviveSpellCommand : SkillCommand
{
    public override async Awaitable<BattleAction> SelectAsync(BattleUnit user, BattleContext context)
    {
        return await SelectPartyMemberAsync(context, true); // 倒れている仲間から選ぶ
    }

    public override async Awaitable ExecuteAsync(BattleUnit user, BattleAction action, BattleContext context)
    {
        BattleUnit target = action.Target.Unit;
        SpendMp(user);
        await context.Message.ShowAsync($"{user.Name}は {CommandName}を うたった！");
        await user.View.PlayCastAsync();

        if (!target.IsDead)
        {
            // 同じターンに、ほかの仲間が先に起こしていた
            user.View.ResumeIdle();
            await context.Message.ShowAsync("しかし なにも おこらなかった。");
            return;
        }
        target.Revive();
        PlayEffect(target.View);
        await context.Effects.PlayHealAsync(target.View, target.Hp);
        user.View.ResumeIdle();
        await context.Message.ShowAsync($"{target.Name}は めを さました！");
    }
}

    [SerializeField] private StatusEffectData addEffect;      // 当たったときに、ときどきかける状態（本の虫の かみつく は どく）
    [SerializeField, Range(0, 100)] private int effectChance; // かける確率（%）

        if (target.IsDead)
        {
            await ShowFallAsync(target, context);
        }
        else if (addEffect != null && GameRandom.Range(0f, 100f) < effectChance)
        {
            target.AddEffect(addEffect);
            context.Effects.ShowText(target.View, addEffect.EffectName, addEffect.Color);
            await context.Message.ShowAsync($"{target.Name}は {addEffect.EffectName}に なった！");
        }