Interfaz de Godot aplicada al flujo de trabajo 2D

Paneles y herramientas clave para el flujo 2D

En Godot, el trabajo 2D se apoya en una idea central: construyes escenas compuestas por nodos. La interfaz está organizada para que puedas crear, inspeccionar y reutilizar esas escenas con rapidez. En este capítulo te enfocarás en los paneles que usarás constantemente: Scene dock (árbol de nodos), FileSystem (archivos del proyecto), Inspector (propiedades), el viewport 2D (lienzo), y el sistema de nodos/escenas (composición, instanciación y herencia).

Viewport 2D (lienzo de edición)

El viewport 2D es donde colocas y organizas visualmente los nodos 2D. Aquí verás gizmos de posición/rotación/escala y podrás seleccionar nodos directamente en el lienzo. En un flujo típico: seleccionas un nodo en el Scene dock, lo ajustas en el viewport y luego afinas valores en el Inspector.

• Selección: clic sobre el nodo en el viewport o en el Scene dock.
• Transformación: mueve/rota/escala con las herramientas del editor (según versión, iconos en la barra superior del viewport).
• Orden visual: en 2D, el orden de dibujo suele depender de propiedades como z_index o del tipo de nodo; más adelante lo controlarás con precisión, pero por ahora céntrate en ubicar y estructurar.

Scene dock (árbol de nodos)

El Scene dock muestra la jerarquía de nodos de la escena actual. Es tu “mapa” del contenido: quién es hijo de quién, qué nodos existen y cómo se agrupan. La jerarquía importa porque muchos comportamientos (transformaciones, organización, acceso por código) dependen de la relación padre-hijo.

• Crear nodos: botón + (Add Child Node) o clic derecho sobre un nodo → Add Child Node.
• Renombrar: selecciona el nodo y presiona F2 (o clic lento sobre el nombre). Usa nombres descriptivos: Player, Sprite, Collision.
• Reordenar: arrastra nodos para cambiar su posición en el árbol (cambiar de padre o reordenar hermanos). Esto es clave para mantener escenas limpias.
• Activar/desactivar: puedes ocultar/mostrar o deshabilitar nodos (según tipo y opciones) para depurar.

Inspector (propiedades del nodo)

El Inspector cambia según el nodo seleccionado. Aquí editas propiedades como transformaciones, recursos asignados (texturas, formas de colisión, etc.) y parámetros específicos. Piensa en el Inspector como el lugar donde “configuras” un nodo.

• Propiedades comunes: position, rotation, scale (en nodos 2D), visibilidad, y ajustes del nodo.
• Recursos: muchos campos aceptan recursos (por ejemplo, una forma de colisión). A menudo se crean desde el mismo Inspector con menús desplegables.
• Restaurar valores: útil cuando pruebas cambios y quieres volver al valor por defecto.

FileSystem (archivos del proyecto)

El panel FileSystem te permite navegar por carpetas, escenas (.tscn), scripts (.gd) y recursos. Es el centro para organizar el proyecto y reutilizar contenido.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

• Crear carpetas: clic derecho → New Folder. Recomendación: scenes/, scripts/, assets/.
• Abrir escenas: doble clic en un .tscn.
• Arrastrar para instanciar: puedes arrastrar una escena desde FileSystem al viewport o al Scene dock para crear una instancia.

Sistema de nodos y escenas: composición, instanciación y herencia

Nodos: piezas con responsabilidad

Un nodo es una unidad funcional: puede representar un objeto visible, una colisión, una cámara, un contenedor, etc. En 2D, es común partir de nodos como Node2D, CharacterBody2D, Area2D, Sprite2D, CollisionShape2D.

Escenas: plantillas reutilizables

Una escena es un árbol de nodos guardado como archivo (.tscn). Puedes usar escenas como “prefabs”: por ejemplo, una escena Player.tscn que luego instancias dentro de Level.tscn.

Instanciación: usar una escena dentro de otra

Instanciar es crear una copia viva de una escena dentro de otra escena en ejecución o en el editor. En el editor, lo más directo es arrastrar la escena desde FileSystem al árbol o al viewport. En ejecución, se hace por código (lo verás más adelante), pero el concepto es el mismo: reutilización.

Herencia de escenas: extender una base

La herencia de escenas te permite crear una escena “hija” basada en otra “base”. La escena hija hereda el árbol y configuración de la base, y puedes añadir o sobrescribir partes. Es útil para variaciones: por ejemplo, EnemyBase.tscn y luego EnemyFast.tscn, EnemyTank.tscn.

• Cuándo usar composición: cuando quieres combinar piezas (nodos/escenas) como módulos.
• Cuándo usar herencia: cuando quieres una familia de escenas con estructura común y pequeñas variaciones.

Recorrido guiado: crear, renombrar, reordenar e instanciar

Paso a paso: crear nodos y organizar la jerarquía

Vas a practicar con una escena simple para interiorizar el flujo.

1. Crea una escena nueva: en el editor, crea una escena vacía y elige un nodo raíz 2D (por ejemplo Node2D). Guárdala como Scratch.tscn en una carpeta scenes/.

2. Añade un hijo: selecciona el nodo raíz en Scene dock → Add Child Node → agrega un Node2D (o cualquier nodo 2D). Observa cómo aparece anidado.

3. Renombra: selecciona el nuevo nodo y presiona F2. Nómbralo ChildA.

4. Añade un segundo hijo: crea otro nodo y nómbralo ChildB.

5. Reordena: arrastra ChildB encima o debajo de ChildA. Luego arrastra ChildB para que sea hijo de ChildA. Nota cómo cambia la indentación (jerarquía).

6. Comprueba el Inspector: selecciona cada nodo y mira cómo cambian las propiedades disponibles. Ajusta position para ver el efecto en el viewport.

Paso a paso: instanciar una escena desde FileSystem

1. Guarda la escena: asegúrate de que Scratch.tscn está guardada.

2. Crea otra escena nueva: crea una escena con raíz Node2D y guárdala como Container.tscn.

3. Instancia: en FileSystem, arrastra Scratch.tscn al Scene dock de Container.tscn. Verás una instancia como hijo del nodo raíz.

4. Renombra la instancia: cambia el nombre de la instancia a ScratchInstance para distinguirla de la escena original.

Idea clave: editar la escena original (abrir Scratch.tscn y cambiar nodos) afecta a sus instancias; editar una instancia puede crear cambios locales (overrides) dependiendo del tipo de propiedad.

Ejercicios breves (solo nodos): escena Jugador y escena Nivel

En estos ejercicios no usarás sprites ni scripts todavía. El objetivo es practicar: crear estructura, guardar, abrir y instanciar escenas.

Ejercicio 1: Crear la escena Jugador (solo nodos)

1. Crea una escena nueva con raíz CharacterBody2D (recomendado para un jugador en 2D). Si prefieres mantenerlo más genérico, usa Node2D, pero CharacterBody2D te será útil más adelante.

2. Renombra el nodo raíz a Player.

3. Añade un hijo CollisionShape2D y renómbralo Collision. (No necesitas asignar forma todavía; el objetivo es practicar estructura.)

4. Añade un hijo Marker2D y renómbralo SpawnPoint o Muzzle (aunque no dispares aún). Esto te acostumbra a usar marcadores como referencias.

5. Reordena si lo deseas: por ejemplo, deja Collision primero y SpawnPoint después para mantener consistencia.

6. Guarda la escena como Player.tscn dentro de scenes/.

Comprobación rápida: abre otra escena cualquiera y verifica que Player.tscn aparece en FileSystem y se puede abrir con doble clic.

Ejercicio 2: Crear la escena Nivel e instanciar al Jugador

1. Crea una escena nueva con raíz Node2D y renómbrala Level.

2. Añade nodos de organización (solo estructura):

   • Node2D llamado World
   • Node2D llamado Actors
   • Node2D llamado UI

   Reordena para que queden en ese orden. Esta separación te ayuda a mantener el nivel legible.

3. Instancia el Jugador: arrastra Player.tscn desde FileSystem y suéltalo como hijo de Actors. Renombra la instancia a Player si el editor le asignó un nombre distinto.

4. Mueve la instancia: selecciona el Player instanciado y cambia su position desde el Inspector o arrástralo en el viewport para practicar.

5. Guarda la escena como Level.tscn dentro de scenes/.

6. Practica carga: cierra la escena actual (o abre otra) y vuelve a abrir Level.tscn desde FileSystem. Confirma que la instancia del jugador sigue ahí.

Ejercicio 3 (opcional): herencia de escenas con el Jugador

Vas a crear una variación del jugador sin reconstruir todo.

1. Abre Player.tscn.

2. Crea una escena heredada: usa la opción del editor para crear una escena nueva basada en la actual (según versión: Scene → New Inherited Scene).

3. Guarda como PlayerHeavy.tscn.

4. Añade un nodo extra (por ejemplo otro Marker2D llamado ExtraMarker) o reordena nodos para ver cómo la escena heredada puede extender la base.

5. Instancia PlayerHeavy.tscn en Level.tscn (temporalmente) para comprobar que funciona como una variante.

Con esto habrás practicado el ciclo esencial del curso: crear nodos → organizar jerarquía → guardar escena → instanciar en otra escena → reutilizar.