Cómo funciona el sistema de experiencia y nivel en Unity

Gana claridad para construir un sistema de experiencia y subida de nivel en Unity con C#. Aquí verás cómo definir los stats del personaje, crear una curva de dificultad combinando crecimiento lineal y exponencial, y otorgar experiencia al derrotar enemigos con tags y prefabs bien configurados.

¿Cómo configurar los stats para un juego de rol en Unity?

Para que cualquier entidad de la escena (protagonista, enemigo, NPC o boss) comparta la misma lógica, se propone un script versátil: Character Stats. La idea es centralizar el nivel actual, la experiencia acumulada y los requisitos de XP por nivel en un solo componente reutilizable.

¿Qué variables definen nivel y experiencia?

• Un entero para el nivel: currentLevel.
• Un entero para la experiencia acumulada: currentXP.
• Un arreglo con los requisitos por nivel: experienceToLevelUp.

Ejemplo en C# (script asignado al Player):

using UnityEngine;

public class CharacterStats : MonoBehaviour
{
    public int currentLevel;       // Nivel actual.
    public int currentXP;          // Experiencia acumulada.
    public int[] experienceToLevelUp; // Requisitos de XP por nivel.

    void Update()
    {
        if (currentLevel >= experienceToLevelUp.Length) return;
        if (currentXP >= experienceToLevelUp[currentLevel])
        {
            currentLevel++; // Subir de nivel cuando alcanza el umbral.
        }
    }

    public void AddExperience(int xp)
    {
        currentXP += xp; // Sumar XP ganada.
    }
}

¿Cómo definir la curva de dificultad lineal y exponencial?

Para evitar que el jugador se aburra con un progreso siempre igual, se alterna crecimiento lineal y exponencial en los requisitos de XP. Idea planteada: empezar con algo suave y alternar tramos lineales y picos más exigentes.

• Primeros niveles suaves: 10, 20.
• Pico intermedio: 50.
• Tramo lineal: 100, 200.
• Nuevo pico: 500.
• Tramo lineal largo: 1000, 2000, 5000.

Esto forma parte del game design y se sugiere validar con pruebas tipo test A-B.

¿Qué lógica de level up y experiencia implementa el sistema?

El control vive en Update: se verifica si puede subir de nivel y si la experiencia actual alcanza el umbral del nivel actual. Además, un método público simplifica sumar XP al personaje desde otros sistemas.

¿Cómo comprobar el tope de niveles y subir de nivel?

• Si el nivel actual es mayor o igual a la longitud del arreglo, no sube más.
• Si la XP acumulada alcanza el requisito del nivel actual, incrementa currentLevel en 1.
• El chequeo continuo en Update asegura que el cambio ocurra en cuanto se cumpla la condición.

Pseudoflujo: - Comprobar límite de niveles. - Comparar currentXP con experienceToLevelUp[currentLevel]. - Si cumple, subir de nivel.

¿Cómo añadir experiencia desde otros componentes?

Mediante un método público, por ejemplo AddExperience(int xp), cualquier sistema (combate, misiones, recolectables) puede otorgar puntos. Basta con localizar el componente CharacterStats y llamar al método con la cantidad ganada.

¿Cómo dar experiencia al derrotar enemigos en Unity?

La entrega de XP se integra en el componente que gestiona la vida, aquí llamado HealthManager. Al detectarse la muerte, si el objeto destruido tiene el tag Enemy, se localiza al Player y se invoca AddExperience con la cantidad definida en el enemigo.

¿Cómo identificar enemigos por tag y otorgar XP?

• Declarar en el gestor de vida del enemigo: public int experienceWhenDefeated;.
• Antes de destruir el GameObject, comprobar el tag.
• Si es Enemy, buscar al Player, obtener su CharacterStats y sumar la XP.

Ejemplo en C# dentro de HealthManager (en el bloque donde se cumple la condición de muerte):

if (CompareTag("Enemy"))
{
    GameObject player = GameObject.Find("Player");
    if (player != null)
    {
        var stats = player.GetComponent<CharacterStats>();
        if (stats != null)
        {
            stats.AddExperience(experienceWhenDefeated);
        }
    }
}
// Destroy(gameObject); // Destruir después de otorgar XP.

Puntos clave: - Solo los objetos con tag Enemy otorgan experiencia. - La búsqueda del Player se hace con GameObject.Find y GetComponent. - La suma se realiza justo antes de destruir el enemigo.

¿Qué configuración mínima en los enemigos funciona de prueba?

• Asignar experienceWhenDefeated = 10 en cada enemigo.
• Si trabajas con prefabs, recuerda propagar cambios con apply all para no quedarte con un solo enemigo actualizado.
• Verifica en el Inspector del Player cómo cambian currentXP y currentLevel al derrotar enemigos.

¿Qué mostrar en pantalla con el HUD?

Como mejora, se sugiere añadir al head up display un texto para nivel y otro para experiencia.

• Crear dos elementos de texto en el HUD.
• Vincularlos a los valores currentLevel y currentXP.
• Actualizarlos en tiempo real para dar feedback claro al jugador.

¿Tienes dudas sobre la mejor curva de XP para tu juego o cómo estructurar los niveles? Comparte tu enfoque y comenta tus resultados con diferentes combinaciones lineales y exponenciales.