ヴァンサバ風ゲームの作り方#7｜レベルアップで3択の強化を選ばせよう

using UnityEngine;

// 武器に共通する部分。強化はこの型を通してまとめて効かせる
public abstract class Weapon : MonoBehaviour
{
    [SerializeField] private WeaponData sourceData;

    // 遊んでいる間だけのコピー。強化はこちらを書き換える
    public WeaponData Data { get; private set; }

    protected virtual void Awake()
    {
        Data = Instantiate(sourceData);
    }
}

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Pool;

// 一定間隔で、一番近い敵に計量スプーンを投げる
public class SpoonThrower : Weapon
{
    [SerializeField] private LayerMask enemyLayer;

    private SpoonData spoon; // 親が作ったコピーを、スプーン用として見たもの
    private ObjectPool<Spoon> pool;
    private ContactFilter2D filter;
    private readonly List<Collider2D> found = new List<Collider2D>();
    private float timer;

    protected override void Awake()
    {
        base.Awake(); // 先に親にコピーを作ってもらう
        spoon = (SpoonData)Data;

        filter = new ContactFilter2D
        {
            useLayerMask = true,
            layerMask = enemyLayer,
            useTriggers = true,
        };

        pool = new ObjectPool<Spoon>(
            createFunc: () => Instantiate(spoon.bulletPrefab, transform.parent),
            actionOnGet: bullet => bullet.gameObject.SetActive(true),
            actionOnRelease: bullet => bullet.gameObject.SetActive(false),
            actionOnDestroy: bullet => { if (bullet != null) Destroy(bullet.gameObject); },
            defaultCapacity: 20,
            maxSize: 200);
    }

    private void Update()
    {
        timer += Time.deltaTime;
        if (timer < spoon.interval)
        {
            return;
        }
        timer -= spoon.interval;

        Transform nearest = FindNearestEnemy();
        if (nearest == null)
        {
            return;
        }

        Vector2 toEnemy = (Vector2)nearest.position - (Vector2)transform.position;
        if (toEnemy.sqrMagnitude < 0.0001f)
        {
            return;
        }

        // 本数のぶんだけ、少しずつ角度をずらして投げる
        for (int i = 0; i < spoon.bulletCount; i++)
        {
            float angle = (i - (spoon.bulletCount - 1) * 0.5f) * spoon.spreadAngle;
            Vector2 direction = Quaternion.Euler(0f, 0f, angle) * toEnemy.normalized;
            pool.Get().Throw(transform.position, direction, spoon, pool);
        }
    }

    // まわりの敵を集めて、一番近いものを返す
    private Transform FindNearestEnemy()
    {
        Physics2D.OverlapCircle(transform.position, spoon.searchRadius, filter, found);

        Transform nearest = null;
        float nearestDistance = float.MaxValue;
        foreach (Collider2D collider in found)
        {
            float distance = ((Vector2)collider.transform.position - (Vector2)transform.position).sqrMagnitude;
            if (distance < nearestDistance)
            {
                nearestDistance = distance;
                nearest = collider.transform;
            }
        }
        return nearest;
    }
}

using UnityEngine;

// 投げる武器（計量スプーン）だけの性能
[CreateAssetMenu(fileName = "SpoonData", menuName = "SurvivorsLike/Spoon Data")]
public class SpoonData : WeaponData
{
    public Spoon bulletPrefab;       // 飛ばすもの
    public float bulletSpeed = 8f;   // 飛ぶ速さ
    public float searchRadius = 10f; // 狙う範囲
    public int bulletCount = 1;      // 1回に投げる本数
    public float spreadAngle = 15f;  // 本数が増えたときの、1本ごとの角度
}

using System.Collections.Generic;
using UnityEngine;

// プレイヤーの周りでホイッパーを回す（当たり判定は Whipper のほうが持つ）
public class WhipperOrbit : Weapon
{
    [SerializeField] private Whipper headPrefab;

    private WhipperData whipper; // 親が作ったコピーを、ホイッパー用として見たもの
    private readonly List<Transform> heads = new List<Transform>();
    private float angle;
    private float timer;
    private bool isOut;

    protected override void Awake()
    {
        base.Awake();
        whipper = (WhipperData)Data;
    }

    private void Start()
    {
        for (int i = 0; i < whipper.orbitCount; i++)
        {
            Whipper head = Instantiate(headPrefab, transform.parent);
            head.Setup(whipper);
            heads.Add(head.transform);
        }
        Switch(true);
    }

    private void Update()
    {
        timer -= Time.deltaTime;
        if (timer <= 0f)
        {
            Switch(!isOut);
        }
        if (!isOut)
        {
            return;
        }

        angle += 360f / whipper.orbitSeconds * Time.deltaTime;

        for (int i = 0; i < heads.Count; i++)
        {
            float headAngle = angle + 360f / heads.Count * i;
            float radian = headAngle * Mathf.Deg2Rad;
            Vector2 offset = new Vector2(Mathf.Cos(radian), Mathf.Sin(radian)) * whipper.orbitRadius;

            heads[i].position = (Vector2)transform.position + offset;
            heads[i].up = -offset;
        }
    }

    private void Switch(bool next)
    {
        isOut = next;
        timer = next ? whipper.activeSeconds : whipper.restSeconds;
        angle = 0f;

        foreach (Transform head in heads)
        {
            head.gameObject.SetActive(next);
        }
    }
}

    // 強化で呼ばれる。移動速度を上げる
    public void AddSpeed(float amount)
    {
        moveSpeed += amount;
    }

using UnityEngine;

// 範囲攻撃の武器（ストレーナー）だけの性能
[CreateAssetMenu(fileName = "StrainerData", menuName = "SurvivorsLike/Strainer Data")]
public class StrainerData : WeaponData
{
    public float radius = 2.5f;      // 粉がかかる範囲
    public float effectSeconds = 0.35f; // 粉が見えている時間
}

using System.Collections.Generic;
using UnityEngine;

// 一定間隔で、足元の丸い範囲にいる敵ぜんぶにダメージを与える
public class StrainerArea : Weapon
{
    [SerializeField] private LayerMask enemyLayer;
    [SerializeField] private SpriteRenderer effect; // 粉が広がる見た目

    private StrainerData strainer;
    private ContactFilter2D filter;
    private readonly List<Collider2D> found = new List<Collider2D>();
    private float timer;
    private float effectTimer;

    protected override void Awake()
    {
        base.Awake();
        strainer = (StrainerData)Data;

        filter = new ContactFilter2D
        {
            useLayerMask = true,
            layerMask = enemyLayer,
            useTriggers = true,
        };
        effect.transform.localScale = Vector3.one * strainer.radius * 2f;
        effect.gameObject.SetActive(false);
    }

    private void Update()
    {
        if (effect.gameObject.activeSelf)
        {
            effectTimer -= Time.deltaTime;
            if (effectTimer <= 0f)
            {
                effect.gameObject.SetActive(false);
            }
        }

        timer += Time.deltaTime;
        if (timer < strainer.interval)
        {
            return;
        }
        timer -= strainer.interval;

        Physics2D.OverlapCircle(transform.position, strainer.radius, filter, found);
        foreach (Collider2D collider in found)
        {
            if (collider.TryGetComponent(out Enemy enemy))
            {
                enemy.TakeDamage(strainer.damage);
            }
        }

        effect.gameObject.SetActive(true);
        effectTimer = strainer.effectSeconds;
    }
}

using UnityEngine;

// 強化1つ分。どう効くかは、種類ごとの子クラスが決める
public abstract class UpgradeData : ScriptableObject
{
    public string upgradeName = "強化";
    [TextArea] public string description = "説明";
    public Sprite icon;

    // カードを押したときに呼ばれる
    public abstract void Apply(GameObject player);

    // 今もらえる強化かどうか（もう持っているものを出さないため）
    public virtual bool CanTake(GameObject player) => true;
}

using UnityEngine;

// 砂糖コーティング：持っている武器ぜんぶの攻撃力を上げる
[CreateAssetMenu(fileName = "PowerUpgrade", menuName = "SurvivorsLike/Upgrade/Power")]
public class PowerUpgrade : UpgradeData
{
    public int addDamage = 5;

    public override void Apply(GameObject player)
    {
        foreach (Weapon weapon in player.GetComponents<Weapon>())
        {
            weapon.Data.damage += addDamage;
        }
    }
}

using UnityEngine;

// バターましまし：移動速度を上げる
[CreateAssetMenu(fileName = "SpeedUpgrade", menuName = "SurvivorsLike/Upgrade/Speed")]
public class SpeedUpgrade : UpgradeData
{
    public float addSpeed = 1f;

    public override void Apply(GameObject player)
    {
        player.GetComponent<PlayerMove>().AddSpeed(addSpeed);
    }
}

using UnityEngine;

// 計量スプーンを1本増やす
[CreateAssetMenu(fileName = "SpoonUpgrade", menuName = "SurvivorsLike/Upgrade/Spoon")]
public class SpoonUpgrade : UpgradeData
{
    public override void Apply(GameObject player)
    {
        SpoonData spoon = (SpoonData)player.GetComponent<SpoonThrower>().Data;
        spoon.bulletCount++;
    }
}

using UnityEngine;

// ストレーナーを手に入れる（止めてあるStrainerAreaを動かす）
[CreateAssetMenu(fileName = "StrainerUpgrade", menuName = "SurvivorsLike/Upgrade/Strainer")]
public class StrainerUpgrade : UpgradeData
{
    public override void Apply(GameObject player)
    {
        player.GetComponent<StrainerArea>().enabled = true;
    }

    // すでに動いているなら、もう出さない
    public override bool CanTake(GameObject player) => !player.GetComponent<StrainerArea>().enabled;
}

using System;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

// カード1枚。中身を書き換えて、押されたら知らせる
public class UpgradeCard : MonoBehaviour
{
    [SerializeField] private Image icon;
    [SerializeField] private TextMeshProUGUI nameText;
    [SerializeField] private TextMeshProUGUI descriptionText;
    [SerializeField] private Button button;

    private UpgradeData data;
    private Action<UpgradeData> onChosen;

    public void Show(UpgradeData newData, Action<UpgradeData> newOnChosen)
    {
        data = newData;
        onChosen = newOnChosen;

        icon.sprite = data.icon;
        nameText.text = data.upgradeName;
        descriptionText.text = data.description;

        button.onClick.RemoveAllListeners();
        button.onClick.AddListener(() => onChosen(data));

        gameObject.SetActive(true);
    }
}

using System.Collections.Generic;
using UnityEngine;

// レベルアップでゲームを止めて、3枚のカードから1つ選ばせる
public class UpgradeView : MonoBehaviour
{
    [SerializeField] private PlayerLevel playerLevel;
    [SerializeField] private GameObject panel;
    [SerializeField] private UpgradeCard[] cards;
    [SerializeField] private UpgradeData[] allUpgrades;

    private readonly List<UpgradeData> candidates = new List<UpgradeData>();
    private int waiting; // まだ選んでいないレベルアップの回数

    private void OnEnable()
    {
        playerLevel.LevelUp += OnLevelUp;
    }

    private void OnDisable()
    {
        playerLevel.LevelUp -= OnLevelUp;
    }

    private void OnLevelUp()
    {
        waiting++;
        if (!panel.activeSelf)
        {
            ShowNext();
        }
    }

    private void ShowNext()
    {
        // 今もらえるものだけを集めて、前から3つ使う（順番はシャッフルする）
        candidates.Clear();
        foreach (UpgradeData upgrade in allUpgrades)
        {
            if (upgrade.CanTake(playerLevel.gameObject))
            {
                candidates.Add(upgrade);
            }
        }
        for (int i = candidates.Count - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);
            (candidates[i], candidates[j]) = (candidates[j], candidates[i]);
        }

        for (int i = 0; i < cards.Length; i++)
        {
            if (i < candidates.Count)
            {
                cards[i].Show(candidates[i], Choose);
            }
            else // 出せるものが3つ未満のとき
            {
                cards[i].gameObject.SetActive(false);
            }
        }

        panel.SetActive(true);
        Time.timeScale = 0f; // ゲームを止める
    }

    private void Choose(UpgradeData upgrade)
    {
        upgrade.Apply(playerLevel.gameObject);
        waiting--;

        if (waiting > 0)
        {
            ShowNext(); // 一度に2レベル上がったときは、続けてもう1回選ぶ
            return;
        }

        panel.SetActive(false);
        Time.timeScale = 1f; // 再開する
    }
}