Implementando un Sistema de Detección de Colisiones 2D en Unity: Guía Completa 💥

La detección de colisiones es uno de los pilares fundamentales en el desarrollo de videojuegos, especialmente en 2D. Es lo que permite a tus personajes interactuar con el entorno, recoger objetos, chocar contra enemigos o atravesar puertas. Sin un sistema de colisiones bien implementado, tus juegos serían meras animaciones sin vida.

En este tutorial, profundizaremos en cómo Unity gestiona las colisiones en 2D, explorando las herramientas y conceptos clave que necesitas para crear interacciones dinámicas y responsivas en tus proyectos.

🚀 ¿Qué es la Detección de Colisiones 2D?

En su esencia, la detección de colisiones es el proceso de determinar si dos o más objetos gráficos en tu escena se están superponiendo espacialmente. En Unity 2D, esto se logra principalmente a través de componentes llamados Colliders 2D y Rigidbodies 2D.

• Colliders 2D: Son formas invisibles que definen los límites físicos de un objeto. No se renderizan en el juego, pero son cruciales para que Unity sepa dónde choca un objeto.
• Rigidbody 2D: Es un componente que permite que un GameObject esté sujeto a la física simulada por Unity, como la gravedad, la fuerza y la colisión. Un objeto necesita un Rigidbody 2D para que sus colisiones sean detectadas (al menos uno de los objetos que colisionan debe tenerlo).

🛠️ Tipos de Colliders 2D en Unity

Unity ofrece varios tipos de colliders 2D, cada uno adecuado para diferentes formas y necesidades. Elegir el collider correcto es crucial para la precisión y el rendimiento.

Box Collider 2D 🟦

El Box Collider 2D es el más común y se utiliza para objetos rectangulares o cuadrados. Es muy eficiente y fácil de configurar.

• Uso ideal: Plataformas, paredes, cajas, personajes con formas cuadradas.
• Propiedades clave: Size (tamaño), Offset (desplazamiento).

Circle Collider 2D 🔴

El Circle Collider 2D se usa para objetos circulares. Es eficiente para formas redondas.

• Uso ideal: Monedas, ruedas, pelotas, cabezas de personajes redondas.
• Propiedades clave: Radius (radio), Offset (desplazamiento).

Polygon Collider 2D 🔺

El Polygon Collider 2D es más versátil, ya que puede adaptarse a cualquier forma personalizada dibujando una serie de puntos que forman un polígono. Es más costoso en rendimiento que los anteriores, pero ofrece mayor precisión.

• Uso ideal: Terrenos complejos, objetos con formas irregulares, personajes con contornos únicos.
• Propiedades clave: Points (puntos del polígono, se editan manualmente o automáticamente).

Edge Collider 2D 📏

El Edge Collider 2D es ideal para dibujar líneas o bordes. A diferencia del Polygon Collider, no forma un área cerrada, lo que lo hace perfecto para suelos, paredes de una sola cara o líneas de colisión.

• Uso ideal: Suelos, rampas, límites de nivel, cables.
• Propiedades clave: Points (puntos que forman la línea).

Capsule Collider 2D 💊

El Capsule Collider 2D es una forma de cápsula (rectangular con extremos redondeados). Es muy útil para personajes, ya que se adapta bien a la mayoría de las figuras humanoides y evita que se atasquen en las esquinas.

• Uso ideal: Personajes, proyectiles alargados.
• Propiedades clave: Size, Direction (vertical u horizontal), Offset.

💫 Colisiones vs. Triggers: ¿Cuál es la Diferencia?

Comprender la distinción entre colisiones y triggers es fundamental. Ambos detectan la superposición, pero su comportamiento es diferente:

Colisiones (Is Trigger: Off) 💥

Cuando dos colliders no están marcados como Is Trigger (está desactivado), Unity los trata como objetos sólidos que se empujan o reaccionan físicamente entre sí. La física del motor se encarga de resolver la interacción.

• Propósito: Interacciones físicas donde los objetos chocan y no pueden ocupar el mismo espacio.
• Eventos: OnCollisionEnter2D, OnCollisionStay2D, OnCollisionExit2D.

Triggers (Is Trigger: On) 👻

Cuando al menos uno de los colliders involucrados tiene la propiedad Is Trigger activada, los objetos pueden atravesarse mutuamente sin ninguna reacción física. El motor de física no resuelve la interacción.

• Propósito: Detectar la entrada, permanencia o salida de un objeto en un área, sin impedir su movimiento. Ideal para recoger ítems, activar eventos o áreas de daño.
• Eventos: OnTriggerEnter2D, OnTriggerStay2D, OnTriggerExit2D.

Tabla Comparativa

📝 Implementación de Colisiones y Triggers con C#

Para reaccionar a las colisiones y triggers, necesitas scripts de C# adjuntos a los GameObjects con colliders. Aquí están los métodos que Unity invoca automáticamente:

Eventos de Colisión

Estos métodos se llaman cuando se produce una interacción física (ambos Is Trigger: Off).

using UnityEngine;

public class CollisionHandler : MonoBehaviour
{
    // Se llama una vez cuando dos colliders empiezan a tocarse físicamente
    private void OnCollisionEnter2D(Collision2D collision)
    {
        Debug.Log("¡Colisión detectada con: " + collision.gameObject.name + "!");

        // Acceder al Rigidbody del otro objeto
        Rigidbody2D otherRigidbody = collision.rigidbody;

        // Acceder al collider del otro objeto
        Collider2D otherCollider = collision.collider;

        // Acceder al punto de contacto de la colisión
        Vector2 contactPoint = collision.GetContact(0).point;

        // Ejemplo: Destruir el otro objeto si tiene la etiqueta "Enemy"
        if (collision.gameObject.CompareTag("Enemy"))
        {
            Destroy(collision.gameObject);
        }
    }

    // Se llama cada fotograma mientras dos colliders se están tocando físicamente
    private void OnCollisionStay2D(Collision2D collision)
    {
        // Debug.Log("Colisionando con: " + collision.gameObject.name);
    }

    // Se llama una vez cuando dos colliders dejan de tocarse físicamente
    private void OnCollisionExit2D(Collision2D collision)
    {
        Debug.Log("Colisión terminada con: " + collision.gameObject.name);
    }
}

Eventos de Trigger

Estos métodos se llaman cuando un collider con Is Trigger: On entra/sale/permanece en contacto con otro collider.

using UnityEngine;

public class TriggerHandler : MonoBehaviour
{
    // Se llama una vez cuando un collider entra en el área del trigger
    private void OnTriggerEnter2D(Collider2D other)
    {
        Debug.Log("¡Trigger detectado! Objeto que entró: " + other.gameObject.name);

        // Ejemplo: Recoger una moneda
        if (other.CompareTag("Coin"))
        {
            Debug.Log("Moneda recogida!");
            Destroy(other.gameObject);
            // Añadir puntos al jugador, reproducir sonido, etc.
        }
    }

    // Se llama cada fotograma mientras un collider está dentro del área del trigger
    private void OnTriggerStay2D(Collider2D other)
    {
        // Debug.Log("Objeto " + other.gameObject.name + " está dentro del trigger.");
    }

    // Se llama una vez cuando un collider sale del área del trigger
    private void OnTriggerExit2D(Collider2D other)
    {
        Debug.Log("Objeto " + other.gameObject.name + " salió del trigger.");
    }
}

🛡️ Capas de Colisión y Matrices de Interacción

En juegos complejos, no querrás que todos los objetos colisionen con todos los demás. Unity te permite controlar qué capas de objetos interactúan entre sí, lo que es esencial para el rendimiento y la lógica del juego.

Creando Capas (Layers)

1. Abrir el menú Layers: En el Inspector de cualquier GameObject, en la parte superior, verás un desplegable llamado Layer. Haz clic en él y selecciona Add Layer....
2. Definir nuevas capas: En el panel Tags & Layers, puedes crear hasta 31 capas personalizadas (las primeras 8 están reservadas por Unity).
   • Por ejemplo, podrías tener capas como Player, Enemy, Ground, Collectible, Projectile.
3. Asignar capas a GameObjects: Selecciona tus GameObjects y asígnales la capa correspondiente a través del desplegable Layer en el Inspector.

Configurando la Matriz de Colisiones

Una vez que tienes tus capas definidas, puedes controlar qué capas colisionan entre sí.

1. Abrir Configuración de Física 2D: Ve a Edit > Project Settings... > Physics 2D.
2. Matriz de Capas: En la sección Layer Collision Matrix, verás una tabla. Cada casilla representa la interacción entre dos capas.
   • Si la casilla está marcada, los objetos de esas dos capas colisionarán/detectarán triggers entre sí.
   • Si la casilla está desmarcada, los objetos de esas capas se ignorarán mutuamente.

⚙️ Propiedades Avanzadas y Optimización

Materiales de Física 2D (Physics Material 2D)

Los Physics Material 2D te permiten controlar la fricción y el rebote de los colliders. Puedes crearlos en tu carpeta de proyecto (Assets > Create > Physics Material 2D).

• Friction (Fricción): Determina cuánto se ralentiza un objeto al deslizarse sobre otro (0 = sin fricción, 1 = máxima fricción).
• Bounciness (Rebote): Determina cuánto rebota un objeto al colisionar (0 = sin rebote, 1 = rebote total).

Para aplicar un material de física, arrástralo desde tu carpeta de proyecto al campo Material del componente Collider 2D en el Inspector.

Modo de Detección de Colisiones (Collision Detection Mode)

En el componente Rigidbody 2D, encontrarás la propiedad Collision Detection. Esto es crucial para evitar el túnel (tunnelling) en objetos rápidos.

• Discrete (Discreto): (Por defecto) Detecta colisiones solo en los intervalos de tiempo de física. Suficiente para la mayoría de los casos.
• Continuous (Continuo): Realiza un barrido más exhaustivo entre los frames de física. Más preciso, pero más costoso en rendimiento. Útil para proyectiles rápidos o personajes que pueden atravesar objetos pequeños a alta velocidad.
• Continuous Dynamic (Dinámico Continuo): Similar a Continuous, pero también verifica las colisiones con otros Rigidbody 2D configurados como Continuous. El más costoso.

Interpolación (Interpolate)

También en Rigidbody 2D, la propiedad Interpolate puede ayudar a suavizar el movimiento de los objetos en la pantalla, especialmente si la tasa de fotogramas del juego es variable o baja.

• None (Ninguno): Sin interpolación. El movimiento puede parecer entrecortado si el framerate es bajo.
• Interpolate (Interpolar): Suaviza el movimiento basándose en la posición del fotograma anterior.
• Extrapolate (Extrapolar): Suaviza el movimiento basándose en la posición del fotograma siguiente (más propenso a errores si el framerate varía mucho).

🎯 Ejemplo Práctico: Recogiendo Monedas y Daño por Espinas

Vamos a consolidar nuestros conocimientos con un pequeño ejemplo.

Escena:

1. Player: Un cuadrado (Sprite Renderer), Box Collider 2D (no trigger), Rigidbody 2D. Script PlayerController (con TriggerHandler o CollisionHandler si quieres ambos).
2. Coin: Un círculo (Sprite Renderer), Circle Collider 2D (marcado como Is Trigger), Rigidbody 2D (con Is Kinematic activado para que no caiga por gravedad, si no queremos que sea afectado por la física). Etiqueta (Tag) Coin.
3. Spikes: Un triángulo (Sprite Renderer), Polygon Collider 2D (marcado como Is Trigger), Rigidbody 2D (con Is Kinematic activado). Etiqueta Hazard.
4. Ground: Un rectángulo (Sprite Renderer), Box Collider 2D (no trigger). Sin Rigidbody 2D (es estático).

Matriz de Colisiones:

• Player y Ground: Activado.
• Player y Coin: Activado.
• Player y Hazard: Activado.

Scripts:

PlayerController.cs (Este script se adjuntará al GameObject del Player)

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float moveSpeed = 5f;
    private Rigidbody2D rb;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        if (rb == null)
        {
            Debug.LogError("Rigidbody2D no encontrado en el Player. ¡Es necesario para las colisiones!");
        }
    }

    void FixedUpdate()
    {
        // Movimiento básico del jugador
        float moveInput = Input.GetAxis("Horizontal");
        rb.velocity = new Vector2(moveInput * moveSpeed, rb.velocity.y);
    }

    // Este método se llama cuando el player entra en un TRIGGER
    private void OnTriggerEnter2D(Collider2D other)
    {
        if (other.CompareTag("Coin"))
        {
            Debug.Log("¡Moneda recogida!");
            Destroy(other.gameObject); // Destruye la moneda
            // Aquí podrías añadir puntos, reproducir sonido, etc.
        }
        else if (other.CompareTag("Hazard"))
        {
            Debug.Log("¡Player tocó espinas! Daño recibido.");
            // Aquí podrías reducir la vida del jugador, reiniciar nivel, etc.
        }
    }

    // Este método se llama cuando el player colisiona físicamente con algo
    private void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            Debug.Log("Player tocó el suelo.");
            // Aquí podrías resetear un contador de saltos, etc.
        }
    }
}

📈 Optimizando el Rendimiento de Colisiones

La detección de colisiones puede ser una de las operaciones más costosas en un motor de juego, especialmente con muchos objetos en movimiento. Aquí hay algunas estrategias para mantener el rendimiento alto:

1. Reduce el número de Colliders: Usa menos colliders y formas más simples cuando sea posible. Un Box Collider 2D es más barato que un Polygon Collider 2D.
2. Usa Colliders más simples para objetos distantes: Si un objeto está lejos del jugador o solo sirve como fondo, un collider simple o ningún collider puede ser suficiente.
3. Aprovecha la Matriz de Colisiones: Desactiva las interacciones entre capas que no necesiten colisionar. Esto reduce significativamente el número de cálculos de colisión.
4. Desactiva Colliders innecesarios: Si un objeto no necesita detectar colisiones durante un tiempo, desactiva su componente Collider 2D (collider.enabled = false;).
5. Evita OnCollisionStay2D y OnTriggerStay2D excesivos: Estos métodos se llaman cada fotograma. Si la lógica dentro de ellos es pesada o se ejecuta en muchos objetos, puede impactar el rendimiento. Considera alternativas si es posible.
6. Usa Is Kinematic para objetos estáticos que se mueven: Si tienes plataformas móviles o puertas que se mueven pero no deben reaccionar a la física de colisión, activa Is Kinematic en su Rigidbody 2D. Esto permite que aún disparen eventos de colisión/trigger, pero su movimiento es controlado por script y no por el motor de física, lo que es más eficiente para objetos 'controlados'.

✨ Conclusión

La implementación de un sistema de detección de colisiones 2D en Unity es un aspecto crucial para crear juegos interactivos y atractivos. Hemos cubierto los fundamentos, desde los diferentes tipos de colliders y la diferencia entre colisiones y triggers, hasta cómo gestionar las interacciones con scripts de C# y optimizar el rendimiento mediante capas y propiedades avanzadas.

Con esta guía, tienes las herramientas necesarias para construir sistemas de colisión robustos y eficientes para tus propios juegos 2D. ¡Experimenta, prueba y crea interacciones únicas para tus jugadores!