🎮 Unity 타워 디펜스 개발기 - 오브젝트 풀링 - 발사체 성능 최적화 🛁

2D 하이브리드 타워 디펜스 게임의 핵심 시스템 개발 과정
(지금까지의 작업물을 AI가 작성해준 개발일지)

문제 발견

타워를 여러 개 건설하고 적이 몰려오면 눈에 띄는 렉이 발생했다.
원인은 명확했다. BasicTower가 공격할 때마다 발사체를 Instantiate()로 생성하고, 명중하면 Destroy()로 파괴하는 구조였기 때문이다.

// 기존 코드 - 매 공격마다 생성/파괴 반복
public override void Attack()
{
    GameObject projectileObj = Instantiate(projectilePrefab, spawnPos, Quaternion.identity);
    ...
}

void HitTarget()
{
    enemy.TakeDamage(damage);
    Destroy(gameObject); // 매번 파괴
}

타워 10개가 초당 1발씩 쏘면, 매 초마다 10번의 Instantiate + 10번의 Destroy가 발생한다.
이 과정에서 메모리 할당 → GC(가비지 컬렉션) 발동 → 프레임 드랍이 일어난다.

해결: 오브젝트 풀링

오브젝트 풀링의 핵심은 간단하다.

파괴하지 말고 숨기고, 생성하지 말고 꺼내 쓴다.

게임 시작 시 발사체를 미리 만들어놓고, 필요할 때 활성화해서 쓰고, 다 쓰면 비활성화해서 풀에 돌려놓는다.

기존 방식:
Attack → Instantiate() → 이동 → 명중 → Destroy() → GC 부하

풀링 방식:
게임 시작 → 미리 20개 생성 (비활성화)
    ↓
Attack → Pool.Get() (활성화) → 이동 → 명중 → Pool.Return() (비활성화)
    ↓
다음 Attack → 같은 오브젝트 재사용

구현

1. ProjectilePool.cs - 풀 매니저

public class ProjectilePool : MonoBehaviour
{
    public static ProjectilePool Instance;

    [Header("Pool Settings")]
    public GameObject projectilePrefab;
    public int initialPoolSize = 20;

    private Queue<GameObject> pool = new Queue<GameObject>();

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            InitializePool();
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void InitializePool()
    {
        for (int i = 0; i < initialPoolSize; i++)
        {
            CreateNewProjectile();
        }
    }

    void CreateNewProjectile()
    {
        GameObject obj = Instantiate(projectilePrefab, transform);
        obj.SetActive(false);
        pool.Enqueue(obj);
    }

    public GameObject Get(Vector3 position, Quaternion rotation)
    {
        if (pool.Count == 0)
        {
            CreateNewProjectile();
        }

        GameObject obj = pool.Dequeue();

        if (obj == null)
        {
            CreateNewProjectile();
            obj = pool.Dequeue();
        }

        obj.transform.SetParent(null);
        obj.transform.position = position;
        obj.transform.rotation = rotation;
        obj.SetActive(true);

        return obj;
    }

    public void Return(GameObject obj)
    {
        if (obj == null) return;

        obj.SetActive(false);
        obj.transform.SetParent(transform);
        pool.Enqueue(obj);
    }
}

Queue를 사용한 이유는 FIFO(선입선출) 구조라서 가장 오래 쉰 오브젝트부터 재사용하기 때문이다. List로도 가능하지만 Queue가 의미적으로 더 맞다.

풀이 비었을 때는 CreateNewProjectile()로 자동 확장된다. 처음에 20개로 부족하면 알아서 늘어나니까 풀 크기를 정밀하게 계산할 필요가 없다.

2. Projectile.cs - 풀 반환으로 변경

public class Projectile : MonoBehaviour
{
    private Transform target;
    private float damage;
    private float speed;
    private bool isInitialized = false;
    private float lifetime = 7f;
    private float aliveTimer;
    private Vector3 lastDirection;

    public void Initialize(Transform target, float damage, float speed)
    {
        this.target = target;
        this.damage = damage;
        this.speed = speed;
        this.isInitialized = true;
        this.aliveTimer = 0f;
        this.lastDirection = Vector3.right;
    }

    void Update()
    {
        if (!isInitialized) return;

        // 7초 초과 시 자동 회수
        aliveTimer += Time.deltaTime;
        if (aliveTimer >= lifetime)
        {
            ReturnToPool();
            return;
        }

        // 타겟이 있으면 추적, 없으면 마지막 방향으로 직진
        Vector3 direction;
        if (target != null)
        {
            direction = (target.position - transform.position).normalized;
            lastDirection = direction;
        }
        else
        {
            direction = lastDirection;
        }

        transform.position += direction * speed * Time.deltaTime;

        float angle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
        transform.rotation = Quaternion.Euler(0, 0, angle);

        if (target == null) return;
        float distanceToTarget = Vector3.Distance(transform.position, target.position);
        if (distanceToTarget < 0.2f)
        {
            HitTarget();
        }
    }

    void HitTarget()
    {
        Enemy enemy = target.GetComponent<Enemy>();
        if (enemy != null)
        {
            enemy.TakeDamage(damage);
        }

        ReturnToPool();
    }

    void ReturnToPool()
    {
        isInitialized = false;
        target = null;

        if (ProjectilePool.Instance != null)
        {
            ProjectilePool.Instance.Return(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

변경 포인트 두 가지:

Destroy → ReturnToPool: Destroy(gameObject) 대신 ProjectilePool.Instance.Return()을 호출한다. 상태(isInitialized, target)를 초기화하고 비활성화만 하면 끝.

타겟 소실 처리 개선: 기존에는 타겟이 사라지면 발사체가 바로 없어졌다. 이건 시각적으로 어색하다. 적이 죽었는데 날아가던 탄알이 갑자기 사라지니까. 이제는 lastDirection을 저장해서 마지막 방향으로 계속 직진하다가 7초 후 자동 회수된다.

타겟 살아있음 → 추적 이동
타겟 사라짐   → 마지막 방향으로 직진
7초 경과      → 자동 풀 반환

3. BasicTower.cs - 풀에서 가져오기

public override void Attack()
{
    if (currentTarget == null) return;
    if (projectilePrefab == null) return;

    Vector3 spawnPos = firePoint != null ? firePoint.position : transform.position;
    GameObject projectileObj = null;

    if (ProjectilePool.Instance != null)
    {
        projectileObj = ProjectilePool.Instance.Get(spawnPos, Quaternion.identity);
    }
    else
    {
        // 풀이 없으면 기존 방식 (폴백)
        projectileObj = Instantiate(projectilePrefab, spawnPos, Quaternion.identity);
    }

    Projectile projectile = projectileObj.GetComponent<Projectile>();
    if (projectile != null)
    {
        projectile.Initialize(currentTarget, damage, projectileSpeed);
    }

    OnAttackExecuted();
}

ProjectilePool.Instance가 없으면 기존 Instantiate 방식으로 폴백한다. 풀을 안 만들어도 게임이 돌아간다.

정리

항목	기존	풀링 적용 후
생성	매 공격마다 Instantiate()	게임 시작 시 1회
제거	매 명중마다 Destroy()	SetActive(false)
GC 발생	매 프레임	거의 없음
타겟 소실	즉시 파괴 (어색함)	직진 후 7초 뒤 회수

오브젝트 풀링은 Unity에서 반복 생성/파괴되는 오브젝트(발사체, 이펙트, 적 등)에 거의 필수적으로 적용하는 패턴이다. 구현 자체는 Queue 하나로 간단한데, 성능 차이는 크다.