Generación procedural en Godot 4: guía práctica con GDScript

Source: Dev.to

Introducción

La generación procedural es una de las características que más diferencia un juego indie en Steam de un juego de portfolio. Roguelikes, sandboxes y dungeon crawlers dependen de algún sistema procedural. En Godot 4 hay tres patrones que cubren la mayor parte de los casos de uso, aunque cada uno tiene sutilezas que la mayoría de los tutoriales pasan por alto.

Ruido con FastNoiseLite

Godot 4 incluye FastNoiseLite con varios tipos de ruido (Perlin, Simplex, Value, Cellular). Es el camino más corto para generar terrenos, mapas de calor y distribuciones de recursos.

# fast_noise.gd
@onready var noise := FastNoiseLite.new()

func _ready() -> void:
    noise.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
    noise.seed = randi()
    noise.frequency = 0.05   # Ajusta según la escala de tu mapa

func get_height(x: int, y: int) -> float:
    return noise.get_noise_2d(x, y)

Trampas comunes

• Frecuencia:
  • Muy baja (0.001) → superficie casi plana.
  • Muy alta (0.5) → ruido aleatorio sin estructura.
    Ajusta la frecuencia visualmente para tu escala de mapa.
• Semilla: usar randi() sin guardarla impide reproducir el mismo mundo. Guarda la semilla cuando necesites reproducibilidad (multiplayer, depuración).

Autómatas celulares

Para cuevas, islas y distribuciones orgánicas, los autómatas celulares suelen producir resultados más naturales que el ruido.

Algoritmo clásico

1. Llena una grilla aleatoriamente con piedra (1) y aire (0).
2. Repite N iteraciones: para cada celda, cuenta sus vecinos.
   • Si tiene ≥ 4 vecinos sólidos → la celda se vuelve sólida.
   • En caso contrario → se vuelve aire.
3. Tras 4‑5 iteraciones, los grupos pequeños desaparecen y emergen cuevas naturales.

# cellular_automata.gd
func cellular_step(grid: Array) -> Array:
    var new_grid = grid.duplicate(true)
    for x in grid.size():
        for y in grid[0].size():
            var neighbors = count_neighbors(grid, x, y)
            new_grid[x][y] = 1 if neighbors >= 4 else 0
    return new_grid

Trampa de los bordes

La primera iteración necesita un manejo correcto de los bordes. Si count_neighbors no trata los límites adecuadamente, las cuevas pegadas al borde del mapa se rompen.

División de espacio binaria (BSP)

Para mazmorras estructuradas con habitaciones y pasillos, BSP (Binary Space Partitioning) es el estándar de la industria.

1. Divide recursivamente el mapa en dos sub‑rectángulos.
2. Detén la división cuando los rectángulos alcanzan el tamaño deseado para una habitación.
3. Coloca una habitación en cada hoja.
4. Conecta las habitaciones con pasillos siguiendo la jerarquía del árbol.

Este patrón combina recursión, geometría 2D y un grafo de conectividad, por lo que es el que más falla cuando se genera con asistentes de IA.

Por qué los asistentes de IA generan mundos rotos

Al pedir a ChatGPT, Claude, Cursor u otro modelo que genere un sistema procedural en GDScript, el código suele compilar pero produce mundos visualmente defectuosos. Las causas recurrentes son:

El SonarSource State of Code 2026 reporta que el 60 % de los fallos en código generado por IA son “fallos silenciosos”: el código compila, parece correcto y produce resultados incorrectos. La generación procedural es particularmente vulnerable porque el “resultado correcto” es subjetivo y no suele haber pruebas unitarias que lo capturen.

Reglas prácticas para evitar errores

1. Visualiza siempre
   No te conformes con que el código compile. Genera varios mundos (p. ej. 10) y revisa visualmente los resultados.
2. Guarda la semilla que produce el bug
   Cuando un mundo se vea raro, copia la semilla al portapapeles; sin ella no podrás reproducir el problema.
3. Usa herramientas de ejecución dentro del editor
   Proyectos como Ziva (para Godot) ejecutan el código generado en tiempo real, detectan mundos rotos y facilitan el ciclo de retroalimentación.

Conclusión

Los tres patrones (ruido, autómata celular y BSP) cubren la mayoría de las necesidades procedurales en juegos indie. Cada uno tiene trampas que la IA tiende a pasar por alto, pero la defensa más fuerte es siempre la misma:

Ejecuta el código en Godot, observa el resultado y no confíes en que “el código compila” signifique “el mundo está bien”.

Para tu próximo proyecto procedural en Godot:

1. Empieza con FastNoiseLite y calibra la frecuencia visualmente.
2. Cuando necesites estructura (habitaciones, conectividad), pasa a BSP.
3. Para formas orgánicas, usa autómatas celulares.
4. Guarda siempre la semilla que genera el mundo.