8.2 Implementando el patrón Factory

Ejemplo 1: Crear enemigos con una EnemyFactory

Vamos a crear un sistema donde puedas generar enemigos del tipo:

• Goblin: rápido pero débil
• Orco: fuerte pero lento
• JefeFinal: mucha vida y daño

Paso 1: Clase base Enemigo.cs

public abstract class Enemigo
{
    public abstract void Atacar();
}

Clase abstracta que define el contrato común de todos los enemigos.

Paso 2: Crear las Clases concretas

Goblin.cs

using UnityEngine;

public class Goblin : Enemigo
{
    public override void Atacar()
    {
        Debug.Log("Goblin ataca rápidamente con 5 de daño");
    }
}

Orco.cs

using UnityEngine;

public class Orco : Enemigo
{
    public override void Atacar()
    {
        Debug.Log("Orco golpea con fuerza: 15 de daño");
    }
}

JefeFinal.cs

using UnityEngine;

public class JefeFinal : Enemigo
{
    public override void Atacar()
    {
        Debug.Log("¡El Jefe Final lanza un ataque devastador de 50 de daño!");
    }
}

Paso 3: Crear la clase Factory

EnemyFactory.cs

public enum TipoEnemigo
{
    Goblin,
    Orco,
    JefeFinal
}

public class EnemyFactory
{
    public static Enemigo CrearEnemigo(TipoEnemigo tipo)
    {
        switch (tipo)
        {
            case TipoEnemigo.Goblin:
                return new Goblin();
            case TipoEnemigo.Orco:
                return new Orco();
            case TipoEnemigo.JefeFinal:
                return new JefeFinal();
            default:
                throw new System.ArgumentException("Tipo de enemigo desconocido");
        }
    }
}

Este método recibe un tipo y devuelve una instancia del enemigo correspondiente.

Paso 4: Uso en un GameManager o controlador

using UnityEngine;

public class GameManager : MonoBehaviour
{
    void Start()
    {
        Enemigo goblin = EnemyFactory.CrearEnemigo(TipoEnemigo.Goblin);
        Enemigo orco = EnemyFactory.CrearEnemigo(TipoEnemigo.Orco);
        Enemigo jefe = EnemyFactory.CrearEnemigo(TipoEnemigo.JefeFinal);

        goblin.Atacar();
        orco.Atacar();
        jefe.Atacar();
    }
}

Una vez creados todos los script antes mencionados; si añadimos nuestro GameManager a un escena de Unity y le damos play, tendríamos lo siguiente en la consola:

Goblin ataca rápidamente con 5 de daño
Orco golpea con fuerza: 15 de daño
¡El Jefe Final lanza un ataque devastador de 50 de daño!

El ejemplo anterior manda llamar a los scripts de los enemigos para mostrar una notificación en la consola, pero si quisiéramos un ejemplo aún más enfocado en la realidad (que nos sirva para desarrollar videojuegos), tendíamos que hacer lo siguiente:

Ejemplo 2: Patrón Factory adaptado con GameObject

Si quieres instanciar enemigos como prefabs reales en la escena:

public class EnemyFactory : MonoBehaviour
{
    public GameObject goblinPrefab;
    public GameObject orcoPrefab;
    public GameObject jefePrefab;

    public GameObject CrearEnemigo(TipoEnemigo tipo)
    {
        switch (tipo)
        {
            case TipoEnemigo.Goblin:
                return Instantiate(goblinPrefab);
            case TipoEnemigo.Orco:
                return Instantiate(orcoPrefab);
            case TipoEnemigo.JefeFinal:
                return Instantiate(jefePrefab);
            default:
                throw new System.ArgumentException("Tipo de enemigo desconocido");
        }
    }
}

Esto en conjunto con el GameManager te permite usar el patrón Factory con prefabs en una escena real de Unity.

8.3 Conclusión

El patrón Factory es una herramienta poderosa en Unity y C# que te permite manejar creación dinámica, variedad y escalabilidad. Ya sea que estés generando enemigos, armas, niveles o habilidades, este patrón te da una forma limpia y mantenible de hacerlo.

Ventajas:

• Desacopla la creación de objetos de su uso
• Permite agregar fácilmente nuevos tipos sin modificar el resto del código
• Facilita la gestión de lógicas condicionales complejas
• Ideal para sistemas de generación dinámica (spawners, loot, etc.)

¿Cuándo no usarlo?

• Si solo vas a crear una o dos instancias manualmente
• Si no hay lógica condicional o variabilidad
• Si puedes usar ScriptableObject para parametrización simple

Variaciones en Unity

Además del patrón clásico, puedes adaptarlo a:

• Crear prefabs de enemigos con Instantiate()
• Usar ScriptableObjects como configuraciones
• Integrar con sistemas como Object Pooling para rendimiento

Ejercicios.

Para reforzar lo aprendido, es necesario practicarlo, por ello intenta realizar los siguientes ejercicios:

1. Siguiendo los ejemplos de este tutorial, crea tu propio ScriptableObject para desarrollar un código sencillo que use su información para realizar operaciones aritméticas.

Este Tutorial de Unity termina aquí. Acompáñanos en el siguiente tutorial donde veremos “Máquinas de Estado”.

Siguiente Tutorial de Unity: “2.”