Implementación de un sistema de recolección de monedas en Unity

Una implementación sólida de recolección de monedas en Unity une tres piezas: la moneda, el Game Manager y la interfaz HUD. Aquí verás cómo comunicar objetos recolectables con el contador global y cómo reflejarlo en pantalla a 60 FPS, con código C# claro y buenas prácticas de prefabs y diseño de niveles.

¿Cómo se conectan moneda, game manager y hud?

Para que el flujo sea consistente, cada pieza asume una responsabilidad concreta con un hilo conductor simple: recolectar, contar y mostrar.

• La moneda se recolecta al detectar el evento de colisión con el jugador usando OnTriggerEnter2D. Se oculta con un método tipo hide y marca su estado como recogida.
• Un switch evalúa el tipo del objeto recolectable (CollectableType). Solo en el caso Money se notifica al Game Manager con un método dedicado.
• El Game Manager incrementa el contador global usando el valor del objeto (collectable.value).
• La Game View actualiza el número de monedas en pantalla a 60 FPS, reflejando cambios en tiempo real.

Ejemplo de la variable pública y el método en el Game Manager:

public class GameManager : MonoBehaviour
{
    public static GameManager SharedInstance; // patrón de acceso compartido.

    public int collectedObjects = 0; // empieza en 0.

    public void CollectObject(Collectable collectable)
    {
        collectedObjects += collectable.value; // se incrementa con "+=".
    }
}

Conexión desde la interfaz para pintar el conteo:

// En la GameView (HUD):
coins = GameManager.SharedInstance.collectedObjects;

¿Qué hace collect object y por qué usar +=?

El método CollectObject encapsula la lógica de contar: recibe un recolectable y suma su valor al total. La sintaxis "+=" es clave para escribir código más claro y breve.

• Con "+=": increments en una línea, legible y directa.
• Sin "+=": tendrías que escribir collectedObjects = collectedObjects + collectable.value, más largo y propenso a errores.
• Cada recolectable define su value; por ejemplo, una moneda vale 1.

Llamada desde la moneda usando un switch por tipo:

public void Collect()
{
    switch (collectableType)
    {
        case CollectableType.Money:
            GameManager.SharedInstance.CollectObject(this);
            break;
        case CollectableType.HealthPotion:
            // lógica futura para poción de vida.
            break;
        case CollectableType.ManaPotion:
            // lógica futura para poción de maná.
            break;
    }
}

Claves prácticas que fortalecen tu implementación:

• El evento del jugador dispara la recolección: OnTriggerEnter2D inicia el flujo.
• La moneda se oculta tras recolectarse para feedback inmediato.
• Solo Money comunica al Game Manager; otros tipos tendrán su lógica específica.
• La Game View repinta el contador de monedas a 60 FPS para una experiencia fluida.

¿Cómo depurar, usar prefabs y diseñar niveles con monedas?

Más allá del código, la estabilidad depende de buenos hábitos de edición, pruebas y diseño.

¿Cómo evitar errores por cambios sin guardar?

• Si ves un circulito en la pestaña del script, hay cambios sin guardar.
• Guarda antes de probar para no confundir la lógica con fallos de guardado.
• Si el contador no sube y la moneda se destruye: revisa que el valor (value) de la moneda esté configurado y que el switch llame a CollectObject en Money.

¿Cómo validar el contador con pruebas rápidas?

• Duplica la moneda dos o tres veces para verificar sumas consecutivas.
• Observa que el contador pase de 0 a 1, 2, 3 tras cada colisión.
• Usa atajos para velocidad: Ctrl + D en Windows o Cmd + D en Mac (D de duplicar).

¿Cómo aplicar cambios en prefabs y organizar la escena?

• Después de ajustar posición, rotación, tipo y valor del recolectable, aplica los cambios al prefab desde el menú correspondiente.
• Mantén el prefab padre en posición 0,0,0 por defecto. Facilita su colocación en niveles.
• Al trabajar con un level block, aplica sus cambios al prefab padre y resetea la instancia visual usada para editar.

¿Cómo guiar al jugador con diseño de monedas?

• Crea rutas de monedas que indiquen dirección y ritmo de movimiento.
• Alterna alturas para sugerir saltos y caídas seguras.
• Puedes jugar con “monedas trampa” para provocar decisiones arriesgadas. Úsalas con mesura para no frustrar.

Habilidades y conceptos reforzados en este flujo:

• Comunicación entre componentes: moneda → Game Manager → HUD.
• Eventos de física 2D: OnTriggerEnter2D para iniciar la recolección.
• Contadores y acumuladores: uso de "+=" para sumar valores.
• Lectura de estados con switch por tipo de recolectable.
• Render en interfaz: actualización a 60 FPS en la Game View.
• Gestión de prefabs: aplicar cambios y mantener origen en 0,0,0.
• Productividad en editor: duplicación rápida con Ctrl/Cmd + D.
• Game design básico: rutas de monedas y señales visuales.

¿Te animas a mostrar tu propuesta? Comparte un screenshot de tu diseño de niveles y cuántas monedas logras recolectar sin morir. Si te atreves con monedas trampa, cuéntanos dónde las pusiste y qué buscabas provocar en el jugador.