Recolectables con enum y switch en Unity

Conviértete en quien define un objetivo claro para el jugador en Unity 2D. Aquí verás cómo añadir monedas y pociones como recolectables, configurar un collider como trigger, y programar en C# un script genérico con enum y switch para gestionar efectos y visibilidad, sin destruir objetos innecesariamente.

¿Cómo añadir recolectables y objetivo de juego en Unity 2D con C#?

Al sumar monedas como asset en la escena, el jugador obtiene un propósito más allá de moverse. La moneda ya existe como prefab animado y se coloca en el escenario. Si no se ve, el problema suele ser de profundidad z: dos objetos en z igual tienden a renderizarse de forma impredecible. Solución: mover el fondo más atrás en z (por ejemplo, si el fondo está en z=10 respecto a la cámara en z=-10, enviarlo a z=11) para evitar artefactos y ver la moneda.

¿Cómo configurar un collider como trigger para una moneda?

• Añadir un CircleCollider2D al objeto moneda.
• Activar el check Is Trigger en el inspector.
• Detectar la entrada del jugador con OnTriggerEnter2D usando la etiqueta "Player".
• Probar el flujo destruyendo el objeto con Destroy(gameObject) y luego refinar.

Ejemplo rápido de prueba:

void OnTriggerEnter2D(Collider2D other)
{
    if (other.CompareTag("Player"))
    {
        Destroy(gameObject); // prueba inicial para validar la colisión
    }
}

¿Cómo diseñar un script genérico de recolectables con enum y switch?

En lugar de un script por tipo (moneda o poción), se crea un único Collectable extensible. Un enumerado define el tipo de recolectable y un switch aplica la lógica correspondiente. Así, el Game Manager podrá contar dinero y el jugador podrá curarse con pociones.

¿Qué estructura tiene el enum CollectableType?

• Valores: Money, HealthPotion, ManaPotion.
• Permite ampliar con nuevos tipos sin reescribir lógica base.

public enum CollectableType
{
    HealthPotion,
    ManaPotion,
    Money
}

public class Collectable : MonoBehaviour
{
    public CollectableType type = CollectableType.Money;
    // ... resto del código
}

¿Cómo gestionar estado, valor y componentes del recolectable?

• Referencias a componentes: SpriteRenderer y CircleCollider2D.
• Estado: hasBeenCollected para saber si ya fue recogido.
• Valor: value = 1 por defecto (sirve como moneda o puntos de curación/maná).

public class Collectable : MonoBehaviour
{
    public CollectableType type = CollectableType.Money;
    private SpriteRenderer sprite;
    private CircleCollider2D itemCollider;
    private bool hasBeenCollected = false;
    public int value = 1;

    void Awake()
    {
        sprite = GetComponent<SpriteRenderer>();
        itemCollider = GetComponent<CircleCollider2D>();
    }
}

¿Cómo implementar show, hide y collect en C#?

En lugar de destruir el GameObject, se muestra/oculta para reutilizarlo al reinstanciar el nivel. Tres métodos concentran la lógica: show, hide y collect.

public class Collectable : MonoBehaviour
{
    // ... campos previos

    void Show()
    {
        sprite.enabled = true;
        itemCollider.enabled = true;
        hasBeenCollected = false;
    }

    void Hide()
    {
        sprite.enabled = false;
        itemCollider.enabled = false;
    }

    void Collect()
    {
        Hide();
        hasBeenCollected = true;

        switch (type)
        {
            case CollectableType.Money:
                // TODO: lógica para sumar al contador global.
                break;
            case CollectableType.HealthPotion:
                // TODO: lógica para curar vida al jugador.
                break;
            case CollectableType.ManaPotion:
                // TODO: lógica para recuperar maná.
                break;
        }
    }

    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.CompareTag("Player"))
        {
            Collect();
        }
    }
}

Puntos clave:

• OnTriggerEnter2D solo reacciona al tag "Player" para ignorar otros choques.
• switch + enum acotan casos y facilitan extensiones con nuevos tipos.
• Show/Hide evitan fragmentar el nivel al no destruir objetos.

¿Qué buenas prácticas y habilidades se refuerzan?

Dominar estos pasos mejora tu base de programación en C# para Unity y tu diseño de gameplay.

• Gestión visual y de colisión: SpriteRenderer, CircleCollider2D, Is Trigger.
• Control de profundidad: mover el fondo en eje z para un renderizado coherente.
• Detección de jugador: tags y CompareTag("Player").
• Estado del objeto: hasBeenCollected para evitar recolectas duplicadas.
• Valor flexible: value reutilizable para dinero, vida y maná.
• Arquitectura reusable: un único script Collectable para varios tipos.
• Flujo de interacción: Show/Hide/Collect como núcleo del recolectable.
• Uso de prefabs y assets para iterar rápido en la escena.
• Prueba incremental: primero Destroy(gameObject) para validar, luego refactor a Collect().
• Sintaxis esencial: enum, switch, case, break, métodos del ciclo de vida como Awake.

¿Quieres compartir cómo extenderías el enum con nuevos ítems o cómo conectarías el contador global? Comenta tus ideas y dudas.