ヴァンサバ風ゲームの作り方#5｜武器のデータをScriptableObjectでまとめよう

using UnityEngine;

// どの武器にもある性能。これ自体のアセットは作らないので abstract
public abstract class WeaponData : ScriptableObject
{
    public string weaponName = "武器";
    public Sprite icon;          // #7の強化カードで使います
    public int damage = 10;      // 1回あたりのダメージ
    public float interval = 1f;  // 攻撃の間隔（秒）
}

using UnityEngine;

// 投げる武器（計量スプーン）だけの性能
[CreateAssetMenu(fileName = "SpoonData", menuName = "SurvivorsLike/Spoon Data")]
public class SpoonData : WeaponData
{
    public Spoon bulletPrefab;       // 飛ばすもの
    public float bulletSpeed = 8f;   // 飛ぶ速さ
    public float searchRadius = 10f; // 狙う範囲
}

using UnityEngine;

// 回る武器（ホイッパー）だけの性能
[CreateAssetMenu(fileName = "WhipperData", menuName = "SurvivorsLike/Whipper Data")]
public class WhipperData : WeaponData
{
    public float orbitRadius = 1.6f;   // プレイヤーから離れる距離
    public float orbitSeconds = 1.5f;  // 1周にかかる秒数
    public int orbitCount = 1;         // いくつ回すか
    public float activeSeconds = 3f;   // 出ている時間（秒）
    public float restSeconds = 3f;     // 引っこんでいる時間（秒）
}

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

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

    private ObjectPool<Spoon> pool;
    private ContactFilter2D filter;
    private readonly List<Collider2D> found = new List<Collider2D>();
    private float timer;

    private void Awake()
    {
        filter = new ContactFilter2D
        {
            useLayerMask = true,
            layerMask = enemyLayer,
            useTriggers = true,
        };

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

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

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

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

        Spoon spoon = pool.Get();
        spoon.Throw(transform.position, toEnemy.normalized, data, pool);
    }

    // まわりの敵を集めて、一番近いものを返す
    private Transform FindNearestEnemy()
    {
        Physics2D.OverlapCircle(transform.position, data.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;
using UnityEngine.Pool;

// 投げた計量スプーン。まっすぐ飛んで、当たった敵にダメージを与える
[RequireComponent(typeof(Rigidbody2D))]
public class Spoon : MonoBehaviour
{
    [SerializeField] private float life = 3f; // 何秒で消えるか

    private Rigidbody2D body;
    private IObjectPool<Spoon> pool;
    private int damage;
    private float timer;
    private bool used;

    private void Awake()
    {
        body = GetComponent<Rigidbody2D>();
    }

    // 投げるときに、SpoonThrowerから呼んでもらう
    public void Throw(Vector2 position, Vector2 direction, SpoonData data, IObjectPool<Spoon> newPool)
    {
        transform.position = position;
        transform.right = direction;
        body.linearVelocity = direction * data.bulletSpeed;
        damage = data.damage;
        pool = newPool;
        timer = 0f;
        used = false;
    }

    private void Update()
    {
        if (used)
        {
            return;
        }

        timer += Time.deltaTime;
        if (timer >= life)
        {
            used = true;
            pool.Release(this);
        }
    }

    private void OnTriggerEnter2D(Collider2D other)
    {
        if (used)
        {
            return;
        }
        if (!other.TryGetComponent(out Enemy enemy))
        {
            return;
        }

        used = true;
        enemy.TakeDamage(damage);
        pool.Release(this);
    }
}

using System.Collections.Generic;
using UnityEngine;

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

    private readonly List<Transform> heads = new List<Transform>();
    private float angle;
    private float timer;
    private bool isOut; // 今、出ているかどうか

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

    private void Update()
    {
        timer -= Time.deltaTime;
        if (timer <= 0f) // 出ている⇔引っこむ を切り替える
        {
            Switch(!isOut);
        }
        if (!isOut)
        {
            return;
        }

        // 1周にかかる秒数から、1秒あたりに回る角度を出す
        angle += 360f / data.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)) * data.orbitRadius;

            heads[i].position = (Vector2)transform.position + offset;
            heads[i].up = -offset; // 持ち手をプレイヤー側に向ける
        }
    }

    // 出す・引っこめる。次に切り替わるまでの時間もここで決める
    private void Switch(bool next)
    {
        isOut = next;
        timer = next ? data.activeSeconds : data.restSeconds;
        angle = 0f; // 出てくるときは毎回おなじ位置から

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

using System.Collections.Generic;
using UnityEngine;

// 回っているホイッパー。触れている敵にダメージを与える
[RequireComponent(typeof(CircleCollider2D))]
public class Whipper : MonoBehaviour
{
    private WeaponData data;
    private readonly Dictionary<Enemy, float> lastHitTime = new Dictionary<Enemy, float>();

    // 出てくるときに、WhipperOrbit から性能を渡してもらう
    public void Setup(WeaponData newData)
    {
        data = newData;
    }

    // 引っこんで出てくるたびに、覚えていた当たり時刻を消す
    private void OnEnable()
    {
        lastHitTime.Clear();
    }

    private void OnTriggerStay2D(Collider2D other)
    {
        if (data == null)
        {
            return;
        }
        if (!other.TryGetComponent(out Enemy enemy))
        {
            return;
        }

        // 同じ敵に当て続けないよう、前に当ててから interval 秒あける
        if (lastHitTime.TryGetValue(enemy, out float last) && Time.time - last < data.interval)
        {
            return;
        }

        lastHitTime[enemy] = Time.time;
        enemy.TakeDamage(data.damage);
    }
}