Unity/디자인 패턴

[Unity] 디자인 패턴 - 팩토리(Factory) 패턴 이해하기

MayQ 2025. 6. 3. 22:05

Unity에서 객체 생성을 위한 팩토리(Factory) 패턴

게임 개발을 하다 보면 여러 종류의 객체를 효율적으로 생성하고 관리하는 것이 큰 도전이 됩니다. 특히 Unity에서는 아이템, 캐릭터, 적, 환경 오브젝트 등 다양한 객체를 다루게 되는데, 이들을 직접 생성하고 관리하다 보면 코드가 복잡해지고 유지보수하기 어려워집니다. 예를 들어, 게임 내 아이템이 수십 개가 넘는다면, 각 아이템의 생성 로직을 일일이 작성하는 것은 매우 비효율적입니다. 이렇게 객체 생성이 복잡해질수록 코드의 가독성이 떨어지고, 새로운 기능을 추가하거나 변경할 때마다 버그가 발생할 가능성이 높아집니다.

이러한 문제를 해결하기 위한 효율적인 방법이 바로 디자인 패턴 중 하나인 팩토리 패턴(Factory Pattern)입니다. 팩토리 패턴은 객체 생성 로직을 중앙 집중화하고, 클라이언트 코드와 객체 생성 방식을 분리하여 코드의 유지보수성과 확장성을 향상시킵니다. 특히 Unity에서는 팩토리 패턴을 활용하여 게임의 다양한 요소들을 더욱 깔끔하고 유연하게 관리할 수 있습니다.

이번 글에서는 팩토리 패턴이 무엇인지, 그리고 Unity에서 이 패턴을 어떻게 적용할 수 있는지 자세히 알아보겠습니다. 팩토리 패턴을 통해 복잡한 객체 생성 문제를 간단하게 해결하고, 게임 개발의 생산성을 높이는 방법을 살펴보도록 하겠습니다. 팩토리 패턴을 이해하고 이를 실전 개발에 적용하면, 더욱 견고하고 유지보수하기 쉬운 게임 구조를 설계할 수 있을 것입니다.

팩토리 패턴이란?

정의

팩토리 패턴은 객체 생성 로직을 분리하여, 객체 생성과 관련된 코드를 중앙 집중화하는 디자인 패턴입니다. 이 패턴의 핵심 목적은 클라이언트 코드와 객체 생성 방식을 분리함으로써 유지보수와 확장성을 높이는 데 있습니다. 팩토리 패턴을 사용하면 객체를 생성하는 방식에 변화가 생겨도 클라이언트 코드를 수정할 필요 없이 팩토리 클래스만 변경하면 됩니다. 이를 통해 코드를 더욱 유연하고 견고하게 만들 수 있습니다.

필요성

게임 개발에서 객체 생성은 매우 흔한 작업이며, 다양한 아이템, 캐릭터, 적 등 여러 종류의 객체를 생성해야 합니다. 이때, 객체를 직접 생성하면 코드가 복잡해지고 유지보수에 어려움이 따를 수 있습니다. 예를 들어, 다양한 종류의 아이템을 생성하기 위해 여러 스위치-케이스 구조를 사용하면, 아이템이 추가될 때마다 코드를 수정해야 하므로 코드의 가독성과 유지보수성이 저하됩니다.

이러한 문제를 해결하기 위해 팩토리 패턴이 필요합니다. 팩토리 패턴은 객체 생성 로직을 별도의 클래스(팩토리)에 위임하여, 클라이언트 코드에서 객체 생성의 복잡성을 숨깁니다. 이를 통해 클라이언트 코드는 단순히 팩토리에서 제공하는 인터페이스를 통해 객체를 얻기만 하면 되며, 객체 생성 방식에 대한 상세한 지식이 필요하지 않습니다.

주요 개념

팩토리 패턴의 핵심 요소는 인터페이스와 구현의 분리와 추상화에 의존하는 것입니다. 팩토리 패턴에서는 인터페이스를 통해 객체를 생성하고, 이 인터페이스를 구현하는 팩토리 클래스가 구체적인 객체 생성 로직을 담당합니다. 이렇게 하면 클라이언트는 인터페이스에만 의존하게 되며, 객체 생성 방식의 변경이나 확장이 필요할 때도 클라이언트 코드를 수정할 필요가 없습니다.

  • 인터페이스와 구현 분리: 팩토리 패턴은 객체 생성 로직을 팩토리 인터페이스로 분리하고, 구체적인 팩토리 클래스를 통해 객체를 생성합니다. 이를 통해 클라이언트는 인터페이스에만 의존하며, 구체적인 구현에 대한 세부 사항을 알 필요가 없습니다.
  • 추상화에 의존: 클라이언트는 구체적인 클래스가 아닌 인터페이스에 의존함으로써, 객체 생성 방식이 바뀌더라도 클라이언트 코드를 변경하지 않아도 됩니다. 이는 코드의 유연성과 확장성을 높이는 중요한 원칙입니다.

팩토리 패턴을 사용하면 다양한 객체를 생성하는 로직을 깔끔하게 분리하고, 코드의 재사용성과 확장성을 향상시킬 수 있습니다. 게임 개발에서 특히 유용하며, 새로운 아이템이나 캐릭터를 추가할 때마다 생성 로직을 간단히 팩토리 클래스에 추가하여 유연한 구조를 유지할 수 있습니다.

Unity에서 팩토리 패턴의 필요성

게임 개발의 복잡성

Unity로 게임을 개발할 때, 특히 FPS 게임이나 RPG 게임과 같이 다양한 객체를 다루는 게임에서는 아이템, 캐릭터, 무기, 적 등 수많은 객체를 생성하고 관리해야 합니다. 예를 들어, FPS 게임에서 무기만 해도 권총, 소총, 저격총 등 여러 종류가 존재하며, 각 무기는 다양한 특성과 동작 방식을 가질 수 있습니다. 이뿐만 아니라, 방어구, 소모품, 파워업 아이템 등도 각각의 특성과 기능을 가지고 있어야 합니다. 이러한 객체들을 하나하나 직접 생성하고 관리하려면 코드가 매우 복잡해지고, 새로운 객체가 추가될 때마다 생성 로직을 수정해야 하는 번거로움이 생깁니다.

객체 생성의 문제점

일반적으로 이러한 다양한 객체를 생성하는 방법으로 스위치-케이스 구조나 직접 객체 생성 방식을 사용하는 경우가 많습니다. 아래는 스위치-케이스 구조를 이용해 아이템을 생성하는 간단한 예시입니다.

switch (itemType)
{
    case ItemType.HealthPotion:
        return new HealthPotion();
    case ItemType.ManaPotion:
        return new ManaPotion();
    case ItemType.Shield:
        return new Shield();
    // 더 많은 아이템이 추가될수록 케이스가 늘어납니다.
    default:
        return null;
}

위와 같은 방식은 초기에는 간단해 보이지만, 아이템의 종류가 많아지거나 아이템의 생성 방식이 복잡해질수록 문제가 발생합니다. 새로운 아이템이 추가될 때마다 코드를 수정해야 하고, 스위치-케이스 구조가 길어질수록 코드의 가독성이 떨어집니다. 또한, 생성 로직이 여러 곳에 분산되어 있을 경우, 생성 로직을 변경해야 할 때 모든 부분을 찾아 수정해야 하므로 유지보수에 어려움이 생깁니다. 이는 객체 생성 로직이 게임 전체에 분산되어 있는 경우, 코드를 수정하는 과정에서 버그가 발생할 가능성이 높아진다는 것을 의미합니다.

팩토리 패턴의 이점

팩토리 패턴을 사용하면 이러한 문제를 효과적으로 해결할 수 있습니다. 팩토리 패턴은 객체 생성 로직을 하나의 팩토리 클래스에 중앙 집중화하여 관리하고, 클라이언트 코드는 팩토리 인터페이스를 통해 객체를 생성하게 합니다. 이로 인해 객체 생성 방식이 변경되거나 새로운 객체가 추가될 때에도 클라이언트 코드를 수정할 필요가 없습니다.

팩토리 패턴의 구조와 구현 방법

구조

팩토리 패턴의 구조는 객체 생성의 책임을 팩토리 클래스로 위임하여, 클라이언트가 직접 객체를 생성하지 않고 팩토리를 통해 객체를 얻도록 설계됩니다. 이 패턴은 주로 인터페이스, 추상 클래스, 구체 클래스 간의 관계로 구성됩니다. 기본 구조는 다음과 같습니다:

  1. Product 인터페이스: 생성될 객체의 공통 인터페이스를 정의합니다.
  2. ConcreteProduct 클래스: Product 인터페이스를 구현하는 구체적인 클래스입니다.
  3. Creator (Factory) 인터페이스: 객체를 생성하는 팩토리 메서드를 정의합니다.
  4. ConcreteCreator (Concrete Factory) 클래스: Creator 인터페이스를 구현하며, Product 객체를 생성하는 구체적인 팩토리 클래스입니다.

이 구조를 다이어그램으로 나타내면 다음과 같은 형태를 가집니다:

Client -> Creator Interface -> ConcreteCreator
                          \-> Product Interface -> ConcreteProduct

팩토리 패턴의 핵심은 클라이언트가 객체를 생성하는 방법을 알 필요 없이 Creator 인터페이스에 정의된 메서드를 호출하여 Product를 생성하는 것입니다.

코드 예시

Unity에서 팩토리 패턴을 사용해 공을 생성하는 예제를 통해 이 구조를 구현해보겠습니다. 공을 생성하는 여러 종류의 객체를 관리하기 위해 팩토리 패턴을 적용해 보겠습니다.

  1. Product 인터페이스: 공의 공통 인터페이스를 정의합니다.
  2. ConcreteProduct 클래스: 다양한 종류의 공을 구현합니다.
  3. Factory 인터페이스: 공을 생성하는 메서드를 정의합니다.
  4. ConcreteFactory 클래스: 구체적인 공을 생성하는 클래스를 구현합니다.
// 1. Product 인터페이스
public interface IBall
{
    void Bounce();
}

// 2. ConcreteProduct 클래스
public class Football : IBall
{
    public void Bounce()
    {
        Debug.Log("축구공이 튀어오릅니다!");
    }
}

public class Basketball : IBall
{
    public void Bounce()
    {
        Debug.Log("농구공이 튀어오릅니다!");
    }
}

// 3. Factory 인터페이스
public interface IBallFactory
{
    IBall CreateBall();
}

// 4. ConcreteFactory 클래스
public class FootballFactory : IBallFactory
{
    public IBall CreateBall()
    {
        return new Football();
    }
}

public class BasketballFactory : IBallFactory
{
    public IBall CreateBall()
    {
        return new Basketball();
    }
}

// 클라이언트 코드
public class BallManager : MonoBehaviour
{
    private IBallFactory ballFactory;

    public void SetFactory(IBallFactory factory)
    {
        ballFactory = factory;
    }

    public void CreateAndBounceBall()
    {
        IBall ball = ballFactory.CreateBall();
        ball.Bounce();
    }
}

코드 해설

  • IBall 인터페이스
    • 공의 기본 행동인 Bounce() 메서드를 정의합니다. 모든 공은 IBall 인터페이스를 구현해야 하므로, 공이 어떻게 튀어오를지에 대한 동작을 지정할 수 있습니다.
  • Football 및 Basketball 클래스
    • IBall 인터페이스를 구현하는 구체적인 공 클래스입니다. 각 클래스는 Bounce() 메서드를 고유하게 구현합니다. Football은 축구공의 튀는 동작을, Basketball은 농구공의 튀는 동작을 담당합니다.
  • IBallFactory 인터페이스
    • 공을 생성하는 팩토리 메서드인 CreateBall()을 정의합니다. 팩토리 패턴을 통해 생성할 수 있는 공의 종류에 상관없이 공을 생성하는 로직을 캡슐화합니다.
  • FootballFactory 및 BasketballFactory 클래스
    • IBallFactory 인터페이스를 구현하는 구체적인 팩토리 클래스입니다. CreateBall() 메서드를 통해 각각 축구공과 농구공을 생성합니다.
  • BallManager 클래스 (클라이언트 코드)
    • 공을 생성하고 튀어오르는 동작을 관리하는 클라이언트 클래스입니다. SetFactory() 메서드를 통해 사용할 팩토리를 설정하고, CreateAndBounceBall() 메서드를 통해 팩토리에서 공을 생성한 후 그 동작을 실행합니다.

클라이언트 코드 사용 예시

Unity 에디터에서 BallManager 스크립트를 사용하는 방법을 간단히 설명하면:

  1. BallManager를 Unity 씬의 게임 오브젝트에 추가합니다.
  2. 원하는 시점에 SetFactory() 메서드를 통해 공을 생성할 팩토리를 설정합니다. 예를 들어, 축구공을 생성하고 싶다면 FootballFactory를 설정합니다.
  3. CreateAndBounceBall() 메서드를 호출하여 해당 공을 생성하고 튀어오르게 합니다.
void Start()
{
    BallManager ballManager = FindObjectOfType<BallManager>();

    // 축구공을 생성
    ballManager.SetFactory(new FootballFactory());
    ballManager.CreateAndBounceBall(); // "축구공이 튀어오릅니다!" 출력

    // 농구공을 생성
    ballManager.SetFactory(new BasketballFactory());
    ballManager.CreateAndBounceBall(); // "농구공이 튀어오릅니다!" 출력
}

이렇게 팩토리 패턴을 통해 공을 생성하는 로직을 분리하면, 새로운 종류의 공을 추가할 때도 클라이언트 코드(BallManager)를 수정하지 않고, 새로운 ConcreteProduct 클래스와 ConcreteFactory 클래스만 추가하면 됩니다. 이를 통해 코드의 유지보수성과 확장성을 높일 수 있습니다.

팩토리 패턴의 장점과 확장성

장점

팩토리 패턴을 사용하면 코드의 구조와 유연성을 향상시키는 다양한 이점을 얻을 수 있습니다. 이를 통해 게임 개발에서 복잡한 객체 생성 문제를 간단하고 효율적으로 해결할 수 있습니다.

  1. 유지보수 용이성:
    • 팩토리 패턴을 사용하면 객체 생성 로직을 팩토리 클래스에 캡슐화할 수 있습니다. 클라이언트 코드에서는 팩토리를 통해 객체를 생성하기 때문에, 객체 생성 방식이 변경되더라도 클라이언트 코드를 수정할 필요가 없습니다. 이는 코드의 유지보수를 훨씬 더 쉽게 만들어 줍니다. 새로운 객체 유형을 추가하거나 기존 객체의 생성 로직을 변경할 때도 팩토리 클래스만 수정하면 됩니다.
  2. 확장성:
    • 팩토리 패턴은 객체 생성 방식을 추상화하기 때문에, 새로운 객체를 추가하거나 기존 객체를 확장할 때 매우 유연합니다. 새로운 클래스와 팩토리 클래스만 추가하면 기존 시스템에 쉽게 통합할 수 있습니다. 이로써 기존 코드를 변경하지 않고도 기능을 확장할 수 있습니다. 이는 개방-폐쇄 원칙(Open-Closed Principle)을 준수하는 좋은 예입니다. 즉, 코드는 확장에 열려 있고, 수정에는 닫혀 있습니다.
  3. 개방-폐쇄 원칙 준수:
    • 팩토리 패턴은 코드를 확장 가능하게 설계하면서도 기존 코드를 안정적으로 유지할 수 있도록 합니다. 새로운 객체를 생성할 필요가 있을 때, 팩토리 패턴을 사용하면 기존의 팩토리 인터페이스를 구현하는 새로운 팩토리 클래스를 만들어서 새로운 객체를 생성할 수 있습니다. 이를 통해 기존 코드에 영향을 주지 않고도 새로운 기능을 추가할 수 있습니다.

확장성: 키-밸류 딕셔너리 활용

게임 개발에서는 다양한 객체를 다루다 보면 생성 로직이 복잡해지는 경우가 많습니다. 예를 들어, 아이템을 생성할 때 아이템의 종류가 수십 개 이상이 될 수 있습니다. 이런 경우 팩토리 패턴을 더욱 확장하여 키-밸류 딕셔너리를 활용해 객체를 효율적으로 관리할 수 있습니다.

예를 들어, 아이템을 생성하는 팩토리를 키-밸류 딕셔너리에 저장하여 필요한 아이템을 키로 찾아서 생성하는 구조를 만들 수 있습니다. 다음은 키-밸류 딕셔너리를 사용하여 다양한 아이템을 관리하는 팩토리의 예시입니다.

public class ItemFactory
{
    private Dictionary<string, IItemFactory> factoryMap;

    public ItemFactory()
    {
        // 팩토리 맵을 초기화하고 등록
        factoryMap = new Dictionary<string, IItemFactory>
        {
            { "HealthPotion", new HealthPotionFactory() },
            { "ManaPotion", new ManaPotionFactory() },
            { "Shield", new ShieldFactory() }
        };
    }

    public IItem CreateItem(string itemType)
    {
        if (factoryMap.ContainsKey(itemType))
        {
            return factoryMap[itemType].CreateItem();
        }
        else
        {
            throw new ArgumentException($"Item type {itemType} not found.");
        }
    }
}

위 예시에서, ItemFactory는 다양한 아이템 팩토리를 키-밸류 딕셔너리에 등록하고, CreateItem() 메서드를 통해 요청된 아이템을 동적으로 생성합니다. 이를 통해 아이템의 생성 로직을 간결하고 확장 가능하게 관리할 수 있습니다. 새로운 아이템이 추가되면, 해당 팩토리를 딕셔너리에 등록하기만 하면 됩니다.

객체 풀링과의 병행

게임에서는 수많은 객체를 생성하고 파괴하는 작업이 빈번하게 일어납니다. 예를 들어, 총알, 적, 파편 등과 같이 일시적으로 사용되었다가 제거되는 객체를 매번 생성하고 파괴하는 것은 성능에 영향을 줄 수 있습니다. 이러한 상황에서 팩토리 패턴과 객체 풀링(Object Pooling)을 결합하여 대량의 객체를 효율적으로 관리할 수 있습니다.

객체 풀링은 객체를 미리 생성해 두고 재사용하는 기법입니다. 팩토리 패턴과 결합하면 객체의 생성과 재사용을 통합적으로 관리할 수 있습니다. 아래는 팩토리 패턴과 객체 풀링을 함께 사용하는 간단한 예시입니다.

public class Bullet
{
    public void Shoot()
    {
        Debug.Log("총알 발사!");
    }
}

public class BulletPool
{
    private Queue<Bullet> bulletPool = new Queue<Bullet>();

    public Bullet GetBullet()
    {
        if (bulletPool.Count > 0)
        {
            return bulletPool.Dequeue();
        }
        else
        {
            return new Bullet(); // 풀에 객체가 없으면 새로 생성
        }
    }

    public void ReturnBullet(Bullet bullet)
    {
        bulletPool.Enqueue(bullet); // 사용이 끝난 객체를 다시 풀에 반환
    }
}

public class BulletFactory
{
    private BulletPool bulletPool;

    public BulletFactory(BulletPool pool)
    {
        bulletPool = pool;
    }

    public Bullet CreateBullet()
    {
        return bulletPool.GetBullet();
    }
}

이 예시에서는 BulletPool이 총알 객체를 관리하고, BulletFactory는 이 풀을 통해 총알을 생성합니다. 총알이 필요할 때마다 팩토리에서 풀을 통해 총알을 얻고, 사용이 끝나면 풀에 다시 반환합니다. 이를 통해 객체의 재사용을 최적화하고, 불필요한 객체 생성 및 파괴로 인한 성능 저하를 방지할 수 있습니다.

팩토리 패턴의 변형: 팩토리 메서드 vs 추상 팩토리 패턴

팩토리 패턴은 객체 생성 로직을 관리하기 위한 여러 변형이 있습니다. 대표적인 변형으로는 팩토리 메서드 패턴과 추상 팩토리 패턴이 있습니다. 이 두 패턴은 모두 객체 생성과 관련된 공통의 목표를 가지지만, 사용하는 방식과 적용 범위에서 차이가 있습니다.

팩토리 메서드 패턴

팩토리 메서드 패턴은 객체 생성을 위한 인터페이스를 정의하고, 실제 객체를 생성하는 작업을 서브클래스에서 처리하는 패턴입니다. 팩토리 메서드 패턴에서는 팩토리 메서드가 객체를 생성하도록 하고, 이를 통해 클라이언트 코드와 객체 생성 로직 간의 결합을 줄입니다.

주요 특징:

  • 객체 생성의 책임을 서브클래스에게 위임합니다.
  • 서브클래스에서 팩토리 메서드를 오버라이드하여 필요한 객체를 생성할 수 있습니다.
  • 상속을 사용하여 객체 생성 로직을 커스터마이징합니다.

예시: Unity에서 팩토리 메서드 패턴을 사용하면, 다양한 적 캐릭터를 생성할 때 각 적의 종류에 따라 생성 로직을 서브클래스에서 정의할 수 있습니다.

public abstract class EnemyFactory
{
    public abstract IEnemy CreateEnemy();
}

public class ZombieFactory : EnemyFactory
{
    public override IEnemy CreateEnemy()
    {
        return new Zombie();
    }
}

public class AlienFactory : EnemyFactory
{
    public override IEnemy CreateEnemy()
    {
        return new Alien();
    }
}

위 코드에서 EnemyFactory는 추상 팩토리 클래스로, CreateEnemy 메서드를 통해 적을 생성합니다. ZombieFactory와 AlienFactory는 이 팩토리 메서드를 오버라이드하여 각각 Zombie와 Alien 객체를 생성합니다.

추상 팩토리 패턴

추상 팩토리 패턴은 관련된 객체를 그룹화하여 생성하는 인터페이스를 제공하는 패턴입니다. 이 패턴은 구체적인 팩토리 메서드와는 다르게, 서로 연관된 객체를 생성하는 일련의 팩토리들을 제공합니다. 즉, 복잡한 객체를 구성하거나 여러 종류의 객체를 생성하는 데 사용됩니다.

주요 특징:

  • 관련된 객체를 그룹으로 생성하는 인터페이스를 제공합니다.
  • 구체적인 팩토리를 생성하고, 이를 통해 관련된 객체를 생성합니다.
  • 서로 연관된 객체를 함께 생성해야 할 때 사용됩니다.

예시: Unity에서 추상 팩토리 패턴을 사용하여 게임의 테마(예: 판타지, 공상과학)에 따라 다양한 객체(예: 무기, 방어구)를 생성할 수 있습니다.

// 추상 팩토리 인터페이스
public interface IGameThemeFactory
{
    IWeapon CreateWeapon();
    IArmor CreateArmor();
}

// 판타지 테마 팩토리
public class FantasyThemeFactory : IGameThemeFactory
{
    public IWeapon CreateWeapon()
    {
        return new Sword();
    }

    public IArmor CreateArmor()
    {
        return new Shield();
    }
}

// 공상과학 테마 팩토리
public class SciFiThemeFactory : IGameThemeFactory
{
    public IWeapon CreateWeapon()
    {
        return new LaserGun();
    }

    public IArmor CreateArmor()
    {
        return new EnergyShield();
    }
}

위 코드에서 IGameThemeFactory는 무기와 방어구를 생성하는 추상 팩토리 인터페이스입니다. FantasyThemeFactory와 SciFiThemeFactory는 이 인터페이스를 구현하여 판타지 테마와 공상과학 테마에 맞는 무기와 방어구를 생성합니다.

비교

  • 팩토리 메서드 패턴은 단일 객체를 생성하기 위한 인터페이스를 제공합니다. 구체적인 생성 로직은 서브클래스에서 정의하며, 객체 생성의 세부 사항을 서브클래스에 위임합니다. 이는 하나의 객체를 생성하거나, 객체 생성 로직이 비교적 간단할 때 유용합니다.
  • 추상 팩토리 패턴은 관련된 객체를 그룹화하여 일관된 방식으로 생성할 때 사용됩니다. 여러 종류의 객체를 함께 생성해야 하거나, 다양한 제품군을 생성할 때 적합합니다.

두 패턴은 객체 생성과 관련된 문제를 해결하지만, 그 경계는 때로는 모호할 수 있습니다. 예를 들어, 추상 팩토리 패턴을 사용하다가 객체 생성의 복잡도가 낮아지면 팩토리 메서드 패턴으로 전환할 수 있습니다. 반대로, 팩토리 메서드 패턴으로 시작했는데 생성해야 할 객체가 늘어나고 복잡해지면 추상 팩토리 패턴으로 확장할 수 있습니다.

개발 상황에 따라 이 두 패턴을 유연하게 적용하는 것이 중요합니다. 게임의 구조나 요구사항에 따라 적절한 패턴을 선택하거나, 두 패턴을 조합하여 더 효율적인 객체 생성 로직을 설계할 수 있습니다.

실전 팁 및 주의 사항

매니저 클래스와의 결합

팩토리 패턴은 게임 개발에서 다양한 객체를 생성하고 관리하는 매니저 클래스와 결합하여 활용되는 경우가 많습니다. 예를 들어, 아이템 매니저, 적 스폰 매니저, 효과 매니저 등 다양한 매니저 클래스는 게임의 흐름에 따라 여러 객체를 생성하고 관리하는 역할을 담당합니다. 이때 팩토리 패턴을 매니저 클래스와 결합하면 코드의 복잡성을 줄이고 객체 생성 로직을 중앙화할 수 있습니다.

싱글톤 패턴과의 결합

팩토리 패턴을 매니저 클래스에서 사용할 때, 매니저 클래스를 싱글톤 패턴과 결합하는 경우가 많습니다. 매니저 클래스는 게임 내에서 하나의 인스턴스만 존재해야 하는 경우가 일반적이므로, 싱글톤 패턴을 통해 전역에서 접근 가능한 매니저 클래스를 구현할 수 있습니다. 이로써 게임의 다양한 곳에서 팩토리 패턴을 통해 객체를 생성하고 관리할 수 있습니다.

장점:

  • 전역 접근성: 싱글톤으로 구현된 매니저 클래스는 게임 내 어디에서든지 동일한 인스턴스에 접근할 수 있습니다. 이를 통해 팩토리 패턴을 통해 생성된 객체를 일관되게 관리할 수 있습니다.
  • 중앙화된 관리: 객체 생성과 관리 로직이 매니저 클래스에 중앙화되어 유지보수가 용이합니다.

주의 사항:

  • 의존성 관리: 싱글톤 매니저 클래스가 너무 많은 의존성을 가지게 되면, 코드의 결합도가 높아질 수 있습니다. 이로 인해 테스트가 어려워지고, 클래스 간의 의존 관계가 복잡해질 수 있습니다. 따라서, 매니저 클래스는 필요한 최소한의 기능만을 가지도록 설계하는 것이 좋습니다.

예시:

public class EnemyManager : MonoBehaviour
{
    private static EnemyManager _instance;
    public static EnemyManager Instance => _instance;

    private void Awake()
    {
        if (_instance == null)
        {
            _instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private IEnemyFactory enemyFactory;

    public void SetFactory(IEnemyFactory factory)
    {
        enemyFactory = factory;
    }

    public void SpawnEnemy()
    {
        IEnemy enemy = enemyFactory.CreateEnemy();
        // 스폰된 적 관리 로직 추가
    }
}

위 코드에서 EnemyManager는 싱글톤으로 구현되어 있으며, IEnemyFactory를 통해 적을 생성합니다. 이를 통해 게임 내 어디에서든 EnemyManager.Instance를 통해 적을 생성하고 관리할 수 있습니다.

성능 고려 사항

게임에서는 대량의 객체를 생성하고 파괴하는 일이 빈번하게 발생합니다. 이때 객체를 매번 새로 생성하고 파괴하면, 메모리 할당과 해제에 따른 성능 문제가 발생할 수 있습니다. 특히 게임의 프레임 속도에 민감한 부분에서는 이러한 동작이 프레임 드랍을 유발할 수 있습니다.

객체 풀링과의 결합

팩토리 패턴을 사용할 때 객체 풀링(Object Pooling) 기법을 결합하면, 성능을 최적화할 수 있습니다. 객체 풀링은 객체를 미리 생성해 두고 재사용하는 기법으로, 필요할 때마다 새로운 객체를 생성하지 않고 미리 생성된 객체를 풀에서 가져와 사용합니다. 이를 통해 메모리 할당과 해제에 따른 성능 문제를 최소화할 수 있습니다.

예시:

public class BulletPool
{
    private Queue<Bullet> bulletPool = new Queue<Bullet>();

    public Bullet GetBullet()
    {
        if (bulletPool.Count > 0)
        {
            return bulletPool.Dequeue();
        }
        else
        {
            // 풀에 객체가 없으면 새로 생성
            return new Bullet();
        }
    }

    public void ReturnBullet(Bullet bullet)
    {
        bulletPool.Enqueue(bullet);
    }
}

public class BulletFactory
{
    private BulletPool bulletPool;

    public BulletFactory(BulletPool pool)
    {
        bulletPool = pool;
    }

    public Bullet CreateBullet()
    {
        return bulletPool.GetBullet();
    }
}

위 예시에서는 BulletFactory가 BulletPool을 사용하여 총알을 생성합니다. BulletFactory는 CreateBullet() 메서드를 통해 총알을 풀에서 가져오고, 사용이 끝난 총알은 ReturnBullet()을 통해 다시 풀로 반환됩니다. 이렇게 하면 대량의 총알 객체를 효율적으로 관리할 수 있으며, 성능 문제를 최소화할 수 있습니다.

실전 적용 사례

팩토리 패턴은 다양한 게임 개발 상황에서 성공적으로 사용되고 있습니다. 다음은 실제 게임 개발에서 팩토리 패턴을 적용한 사례와 그 과정에서 마주칠 수 있는 문제점 및 해결 방법입니다.

적 스폰 시스템:

  • 문제점: 오픈 월드 게임에서 다양한 종류의 적을 생성하고 관리해야 할 때, 각 적마다 생성 로직이 복잡해질 수 있습니다. 적을 직접 생성하고 관리하면 코드가 복잡해지고, 새로운 적 유형이 추가될 때마다 코드를 수정해야 하는 문제가 발생합니다.
  • 팩토리 패턴 적용: 팩토리 패턴을 사용하여 적 생성 로직을 캡슐화하고, EnemyFactory를 통해 적을 생성하는 구조를 설계합니다. 이를 통해 다양한 종류의 적을 일관된 방식으로 생성하고 관리할 수 있게 되었습니다.
  • 해결 방법: 적 유형이 추가될 때마다 새로운 팩토리 클래스를 추가하여 기존 코드를 수정하지 않고도 확장할 수 있도록 했습니다. 이를 통해 게임의 유지보수성과 확장성을 향상시켰습니다.

아이템 생성 시스템:

해결 방법: 아이템의 생성과 관리 로직을 분리하여 코드의 복잡성을 줄이고, 새로운 아이템 추가 시에도 최소한의 코드 수정만으로 기능을 확장할 수 있게 되었습니다.

문제점: RPG 게임에서 수많은 아이템을 생성하고 관리해야 하는데, 아이템마다 생성 방식이 다를 수 있습니다. 이를 직접 관리하면 아이템 생성 로직이 복잡해지고, 코드의 가독성이 떨어집니다.

팩토리 패턴 적용: 아이템 생성 로직을 팩토리 패턴을 통해 중앙 집중화하고, ItemFactory를 통해 아이템을 생성하는 구조를 만들었습니다. 이를 통해 아이템의 생성 로직을 쉽게 관리하고, 아이템 추가 시에도 간단하게 확장할 수 있도록 설계했습니다.

결론

팩토리 패턴은 객체 생성 로직을 분리하고 중앙 집중화하여 코드의 유지보수성과 확장성을 향상시키는 디자인 패턴입니다. Unity에서 팩토리 패턴을 사용하면 다양한 게임 오브젝트(아이템, 적, 무기 등)의 생성 로직을 간단하고 유연하게 관리할 수 있습니다. 이 패턴은 특히 게임 개발에서 객체 생성에 따른 복잡성을 줄이고, 코드의 재사용성을 높이는 데 큰 도움을 줍니다. 싱글톤 패턴 및 객체 풀링과 함께 사용하면 더욱 효율적으로 게임 개발의 여러 문제를 해결할 수 있습니다.

팩토리 패턴은 게임 개발에 있어 필수적인 디자인 패턴 중 하나로, 게임 내에서 다양한 객체를 효율적으로 관리하고 유지보수하기 쉽게 만들어줍니다. 여러분이 개발 중인 게임에서 객체 생성이 복잡해지고 관리가 어려워지는 상황이 있다면 팩토리 패턴을 적극적으로 활용해 보시길 권장합니다. 이 패턴을 통해 코드를 더 깔끔하게 유지하고, 확장 가능한 게임 구조를 설계할 수 있습니다.