Gestión de Bloques de Nivel en Videojuegos con Unity

Aprende a generar niveles dinámicos en Unity con un único gestor que añade y elimina bloques según avanzas. Aquí verás cómo estructurar un gestor de nivel sólido en C# con métodos claros, patrón Singleton, y el uso efectivo de listas, arrays y bucles para mantener la escena limpia y estable desde un bloque plano inicial.

¿Qué resuelve el levelmanager en la generación del nivel?

Un bloque cero plano permite que el jugador empiece en una zona estable y conocida, evitando aparecer entre plataformas. A partir de ahí, el gestor debe añadir nuevos bloques al final, destruir los anteriores, generar los bloques iniciales y limpiar todo cuando el personaje muere.

¿Qué métodos públicos debe exponer el levelmanager?

• Añadir un bloque nuevo al final: public void AddLevelBlock.
• Quitar el último o el que corresponda: public void RemoveLevelBlock.
• Eliminar todos los bloques de la escena: public void RemoveAllLevelBlocks.
• Preparar el inicio de la partida: public void GenerateInitialBlocks.

using System.Collections.Generic;
using UnityEngine;

public class LevelManager : MonoBehaviour
{
    public static LevelManager SharedInstance;

    public List<LevelBlock> allTheLevelBlocks = new List<LevelBlock>();
    public List<LevelBlock> currentLevelBlocks = new List<LevelBlock>();
    public Transform levelStartPosition;

    void Awake()
    {
        if (SharedInstance == null)
        {
            SharedInstance = this;
        }
    }

    void Start()
    {
        GenerateInitialBlocks();
    }

    public void AddLevelBlock() { }
    public void RemoveLevelBlock() { }
    public void RemoveAllLevelBlocks() { }

    public void GenerateInitialBlocks()
    {
        for (int i = 0; i < 2; i++)
        {
            AddLevelBlock();
        }
    }
}

¿Cómo preparar la escena en unity para un inicio estable?

El objetivo es arrancar siempre en el mismo punto y con una configuración clara. Además, necesitas ver y localizar el gestor con facilidad usando un gizmo.

¿Cómo configurar el objeto vacío con gizmo y posición cero?

• Crear un objeto vacío llamado LevelManager. Asignar un gizmo para identificarlo. Colocarlo en 0, 0, 0.
• Asignar el script de C# al objeto LevelManager.
• Crear un objeto vacío llamado “Level Start”. Añadir gizmo y colocarlo como referencia del inicio del nivel.
• Usar alturas conocidas: Y en -4 y -13 para alinear con el punto de inicio mencionado. Ajustar Z a 0 para que quede sobre el anterior.

¿Cómo asignar prefabs y referencias en el inspector?

• En LevelManager, arrastrar “Level Start” al campo levelStartPosition.
• Preparar la lista allTheLevelBlocks con el tamaño adecuado según los prefabs creados.
• Arrastrar el bloque 0 (plano) y el bloque 1 a las posiciones 0 y 1 respectivamente.
• Recordatorio crucial: los índices empiezan en 0. Elemento 0 es el primero. Elemento 1 es el segundo.

¿Cómo funcionan listas, arrays y bucles en c# dentro de unity?

Para gestionar bloques dinámicos, necesitas estructuras que crezcan y se modifiquen en tiempo de ejecución. Además, un bucle simple puede invocar varias veces el mismo método sin esfuerzo.

¿Cuál es la diferencia entre arrays y listas?

• Un array tiene tamaño fijo. No puedes añadir posiciones nuevas.
• Una List es dinámica. Puedes añadir y quitar elementos cuando quieras.
• Para bloques que se crean y destruyen en escena, una List es más versátil.

¿Cómo opera el bucle for para generar bloques iniciales?

• Se recomienda generar dos bloques al inicio: el plano inicial y el siguiente para la transición.
• Estructura del bucle: contador que arranca en 0, condición que se cumple mientras sea menor que 2, e incremento al final.

for (int i = 0; i < 2; i++)
{
    AddLevelBlock();
}

• Iteración 1: i = 0, se añade el primer bloque. Se incrementa i.
• Iteración 2: i = 1, se añade el segundo bloque. Se incrementa i.
• Salida: i = 2 ya no cumple i < 2, se detiene el bucle.

¿Por qué usar singleton en el gestor del nivel?

• Debe existir solo un gestor de nivel. Evita conflictos de añadir y destruir a la vez.

• Patrón Singleton: una instancia compartida accesible desde cualquier parte del juego mediante SharedInstance.

• Ventajas prácticas.

  • Control centralizado del flujo del nivel.
  • Menos referencias manuales dispersas.
  • Código más claro y mantenible.

¿Te gustaría añadir más tipos de bloques o reglas para su aparición? Comparte tus ideas y preguntas en los comentarios.