Capítulo 1: Introducción a Godot y Configuración del Entorno

20 de enero de 2025 Por: Artiko

godotsetupinstalacióninterfazprimera-escenatutorial

Capítulo 1: Introducción a Godot y Configuración del Entorno

Bienvenido al mundo del desarrollo de videojuegos con Godot Engine. En este primer capítulo, instalaremos Godot 4, exploraremos su interfaz, entenderemos su filosofía de diseño y crearemos nuestra primera escena interactiva. Al final de este capítulo, tendrás un sprite moviéndose en pantalla controlado por tu teclado.

¿Qué es Godot Engine?

Godot es un motor de videojuegos completamente gratuito y de código abierto que ha revolucionado el desarrollo indie. Creado originalmente por Juan Linietsky y Ariel Manzur en Argentina, Godot se ha convertido en una alternativa seria a Unity y Unreal Engine.

Historia y Filosofía

Godot nació en 2007 como un motor propietario interno para estudios latinoamericanos. En 2014, fue liberado como software open source bajo la licencia MIT, lo que significa que:

Es 100% gratis: Sin pagos, sin royalties, sin límites de ingresos
Es tuyo para siempre: Puedes modificar el código fuente si lo necesitas
Sin telemetría: No envía datos a ninguna empresa
Desarrollo comunitario: Miles de contribuidores mejoran el engine constantemente

La filosofía de Godot se basa en tres pilares:

Innovación sobre imitación: No copia a otros engines, propone soluciones únicas
Simplicidad sobre complejidad: Fácil de aprender, poderoso de usar
Comunidad sobre corporación: Decisiones tomadas por y para desarrolladores

¿Por Qué Elegir Godot?

Para Principiantes:

Curva de aprendizaje suave
Documentación excelente
Comunidad amigable
No requiere conocimientos previos

Para Profesionales:

Pipeline de desarrollo eficiente
Herramientas integradas completas
Performance optimizada
Exportación multiplataforma real

Para Indies:

Sin costos ocultos
Tamaño ligero
Iteración rápida
Control total del proyecto

Instalación de Godot 4

Descarga

Godot es increíblemente ligero - solo ~100MB comparado con los gigabytes de otros engines.

Visita la página oficial: godotengine.org/download
Elige tu versión:
- Standard: Incluye soporte para GDScript (recomendado)
- .NET: Incluye soporte para C# (requiere .NET SDK)
- Export Templates: Necesarios para exportar tu juego (descargar después)
Selecciona tu sistema operativo:
- Windows (64-bit o 32-bit)
- macOS (Universal o Intel)
- Linux (x86_64 o x86_32)

Instalación por Sistema Operativo

Windows

# Opción 1: Descarga directa
# Descarga el .zip desde godotengine.org
# Extrae en C:\Godot o donde prefieras
# Ejecuta Godot_v4.x.x_win64.exe

# Opción 2: Usando Scoop
scoop install godot

# Opción 3: Usando Chocolatey
choco install godot

macOS

# Opción 1: Descarga directa
# Descarga el .dmg desde godotengine.org
# Arrastra Godot.app a Applications

# Opción 2: Usando Homebrew
brew install --cask godot

# Si macOS bloquea la app:
xattr -dr com.apple.quarantine /Applications/Godot.app

Linux

# Ubuntu/Debian
sudo apt update
sudo apt install godot

# Fedora
sudo dnf install godot

# Arch/Manjaro
sudo pacman -S godot

# Flatpak (universal)
flatpak install flathub org.godotengine.Godot

# AppImage (portable)
wget https://downloads.tuxfamily.org/godotengine/4.x/Godot_v4.x.x_linux.x86_64.zip
unzip Godot_v4.x.x_linux.x86_64.zip
chmod +x Godot_v4.x.x_linux.x86_64
./Godot_v4.x.x_linux.x86_64

Configuración Inicial

Al abrir Godot por primera vez, verás el Project Manager:

Configurar el idioma (opcional):
- Editor Settings → Interface → Editor → Language → Español
Configurar el tema:
- Editor Settings → Interface → Theme
- Elige entre Default, Alien, Arc, Light, Solarized
Configurar el editor de código:
- Editor Settings → Text Editor
- Font Size: 14-16 recomendado
- Enable Code Folding: ✓
- Highlight Current Line: ✓

Tu Primer Proyecto

Creando un Nuevo Proyecto

En el Project Manager, click en “New Project”
Completa los campos:
- Project Name: “Mi Primer Juego”
- Project Path: Elige o crea una carpeta
- Renderer: Forward+ (mejor calidad) o Mobile (mejor compatibilidad)
- Version Control: Git (si usas Git)
Click en “Create & Edit”

Entendiendo la Interfaz

Al abrir tu proyecto, verás la interfaz principal de Godot dividida en varias áreas:

┌─────────────────────────────────────────────────────────┐
│  Barra de Menú (File, Scene, Project, Debug, Editor...) │
├─────────────┬────────────────────────┬──────────────────┤
│             │                        │                  │
│  FileSystem │      Viewport          │    Inspector     │
│   (Archivos)│    (Vista Principal)   │   (Propiedades)  │
│             │                        │                  │
│             │                        ├──────────────────┤
│             │                        │                  │
│   Scene     │                        │  Node            │
│  (Escena)   │                        │ (Crear Nodos)    │
│             │                        │                  │
├─────────────┴────────────────────────┴──────────────────┤
│          Output / Debugger / Audio / Animation          │
└─────────────────────────────────────────────────────────┘

Paneles Principales

1. FileSystem (Sistema de Archivos)

Muestra todos los archivos de tu proyecto
Organizado en carpetas
Drag & drop para importar assets
Doble click para abrir/editar

2. Scene (Escena)

Árbol jerárquico de nodos
Representa la estructura de tu escena
Click derecho para añadir/eliminar nodos
Drag & drop para reorganizar

3. Inspector

Propiedades del nodo seleccionado
Modificación en tiempo real
Añadir componentes y scripts
Configurar señales

4. Viewport (Vista Principal)

Vista 2D/3D de tu escena
Herramientas de transformación
Preview en tiempo real
Modo de edición vs ejecución

5. Bottom Panel

Output: Mensajes y errores
Debugger: Depuración en tiempo real
Audio: Buses de audio
Animation: Editor de animaciones

Barra de Herramientas Principal

[▶ Play] [⏸ Pause] [⏹ Stop] [▶| Play Scene] [🎬 Play Custom] [🔧 Project Settings]

[Select] [Move] [Rotate] [Scale] [📐 Ruler] [🔒 Lock] [👥 Groups]

Conceptos Fundamentales de Godot

Antes de crear nuestra primera escena, es crucial entender los conceptos base de Godot:

1. Nodos (Nodes)

En Godot, TODO es un nodo. Un nodo es la unidad básica de construcción:

Node2D: Base para objetos 2D
Sprite2D: Muestra imágenes
CollisionShape2D: Define colisiones
Control: Base para UI
Node3D: Base para objetos 3D

Los nodos tienen:

Nombre: Identificador único
Propiedades: Valores configurables
Señales: Eventos que emiten
Métodos: Funciones que ejecutan

2. Escenas (Scenes)

Una escena es una colección de nodos organizados en árbol:

Player (KinematicBody2D)
├── Sprite (Sprite2D)
├── Collision (CollisionShape2D)
└── Sound (AudioStreamPlayer)

Las escenas son reutilizables y componibles:

Puedes instanciar escenas dentro de otras escenas
Cada escena puede ser un prefab/template
Cambios en la escena original se propagan

3. Scripts

Los scripts dan comportamiento a los nodos:

GDScript: Lenguaje nativo (Python-like)
C#: Para desarrolladores .NET
C++: Para máximo rendimiento
Visual Script: Programación visual (deprecated)

4. Señales (Signals)

Sistema de eventos de Godot:

Comunicación entre nodos
Desacoplamiento de código
Patrón observador built-in

Creando Tu Primera Escena Interactiva

Vamos a crear un personaje simple que se mueve con las teclas de dirección.

Paso 1: Crear la Estructura de la Escena

Click derecho en el panel Scene → Add Child Node
Busca y selecciona CharacterBody2D (para un personaje que se mueve)
Renómbralo a “Player” (F2 o doble click)

Tu escena ahora:

🎮 Player (CharacterBody2D)

Paso 2: Añadir un Sprite

Con Player seleccionado, Add Child Node
Busca y selecciona Sprite2D
En el Inspector, en Texture, click en [empty] → Load
Selecciona icon.svg (icono por defecto de Godot)

Tu escena ahora:

🎮 Player (CharacterBody2D)
  └── 🖼️ Sprite2D

Paso 3: Añadir Colisión

Selecciona Player, Add Child Node
Busca y selecciona CollisionShape2D
En el Inspector, en Shape, click en [empty] → New RectangleShape2D
Ajusta el tamaño para cubrir el sprite (arrastra los puntos en el viewport)

Tu escena ahora:

🎮 Player (CharacterBody2D)
  ├── 🖼️ Sprite2D
  └── 📦 CollisionShape2D

Paso 4: Añadir el Script de Movimiento

Selecciona el nodo Player
Click en el botón de Script (📄) en la barra superior
Mantén las opciones por defecto y click Create

Godot creará este script base:

extends CharacterBody2D


const SPEED = 300.0
const JUMP_VELOCITY = -400.0


func _physics_process(delta):
    # Add the gravity.
    if not is_on_floor():
        velocity += get_gravity() * delta

    # Handle jump.
    if Input.is_action_just_pressed("ui_accept") and is_on_floor():
        velocity.y = JUMP_VELOCITY

    # Get the input direction and handle the movement/deceleration.
    var direction := Input.get_axis("ui_left", "ui_right")
    if direction:
        velocity.x = direction * SPEED
    else:
        velocity.x = move_toward(velocity.x, 0, SPEED)

    move_and_slide()

Paso 5: Modificar para Movimiento 8-Direcciones

Reemplaza el contenido del script con:

extends CharacterBody2D

# Velocidad de movimiento en píxeles por segundo
const SPEED = 300.0

func _ready():
    # Se ejecuta cuando el nodo entra en la escena
    print("¡Player listo para la acción!")

func _physics_process(delta):
    # Se ejecuta 60 veces por segundo (por defecto)
    
    # Vector de dirección basado en input
    var direction = Vector2.ZERO
    
    # Detectar input del jugador
    if Input.is_action_pressed("ui_right"):
        direction.x += 1
    if Input.is_action_pressed("ui_left"):
        direction.x -= 1
    if Input.is_action_pressed("ui_down"):
        direction.y += 1
    if Input.is_action_pressed("ui_up"):
        direction.y -= 1
    
    # Normalizar el vector para movimiento diagonal consistente
    if direction.length() > 0:
        direction = direction.normalized()
    
    # Aplicar movimiento
    velocity = direction * SPEED
    
    # Mover el personaje
    move_and_slide()
    
    # Debug: mostrar posición
    if direction != Vector2.ZERO:
        print("Posición: ", global_position)

Paso 6: Guardar y Probar

Ctrl+S para guardar la escena
- Nómbrala “player.tscn”
Click en el botón Play Scene (▶|) o F6
Si es tu primera vez, Godot pedirá seleccionar la escena principal
- Selecciona “player.tscn”
¡Prueba el movimiento con las flechas del teclado!

Mejorando la Escena

Añadir un Fondo

Add Child Node al root
Selecciona ColorRect
En Inspector:
- Size: 1152 x 648 (tamaño de ventana por defecto)
- Color: Elige un color de fondo
- En Node2D → Z Index: -1 (para que esté detrás)

Añadir Límites al Movimiento

Modifica el script del Player:

extends CharacterBody2D

const SPEED = 300.0
# Límites de pantalla
const SCREEN_WIDTH = 1152
const SCREEN_HEIGHT = 648
const MARGIN = 64  # Margen desde el borde

func _ready():
    print("¡Player listo para la acción!")

func _physics_process(delta):
    var direction = Vector2.ZERO
    
    if Input.is_action_pressed("ui_right"):
        direction.x += 1
    if Input.is_action_pressed("ui_left"):
        direction.x -= 1
    if Input.is_action_pressed("ui_down"):
        direction.y += 1
    if Input.is_action_pressed("ui_up"):
        direction.y -= 1
    
    if direction.length() > 0:
        direction = direction.normalized()
    
    velocity = direction * SPEED
    move_and_slide()
    
    # Limitar posición dentro de la pantalla
    global_position.x = clamp(global_position.x, MARGIN, SCREEN_WIDTH - MARGIN)
    global_position.y = clamp(global_position.y, MARGIN, SCREEN_HEIGHT - MARGIN)

Añadir Rotación al Movimiento

extends CharacterBody2D

const SPEED = 300.0
const ROTATION_SPEED = 10.0  # Velocidad de rotación

func _physics_process(delta):
    var direction = Vector2.ZERO
    
    if Input.is_action_pressed("ui_right"):
        direction.x += 1
    if Input.is_action_pressed("ui_left"):
        direction.x -= 1
    if Input.is_action_pressed("ui_down"):
        direction.y += 1
    if Input.is_action_pressed("ui_up"):
        direction.y -= 1
    
    if direction.length() > 0:
        direction = direction.normalized()
        # Rotar suavemente hacia la dirección de movimiento
        rotation = lerp_angle(rotation, direction.angle(), ROTATION_SPEED * delta)
    
    velocity = direction * SPEED
    move_and_slide()

Configuración del Proyecto

Project Settings

Accede a Project → Project Settings:

General

Application/Config
- Name: “Mi Primer Juego”
- Description: “Aprendiendo Godot”
- Icon: Selecciona un icono .png

Display

Window
- Size: 1152 x 648 (o tu preferencia)
- Resizable: ✓
- Borderless: ✗
- Always on Top: ✗

Input Map

Aquí defines los controles de tu juego. Los controles por defecto (ui_*) ya están configurados, pero puedes añadir los tuyos:

Añadir nueva acción: “move_left”
Asignar teclas: A, ←
Repetir para: move_right (D, →), move_up (W, ↑), move_down (S, ↓)

Luego actualiza tu script:

# Cambiar de:
if Input.is_action_pressed("ui_right"):
# A:
if Input.is_action_pressed("move_right"):

Estructura de Archivos del Proyecto

Godot organiza automáticamente tu proyecto:

mi_primer_juego/
├── .godot/           # Cache y archivos temporales (ignorar)
├── .import/          # Assets importados (ignorar)
├── project.godot     # Archivo de configuración principal
├── player.tscn       # Tu escena del jugador
├── player.gd         # Script del jugador
├── icon.svg          # Icono por defecto
├── scenes/           # (crear) Para organizar escenas
├── scripts/          # (crear) Para scripts compartidos
├── assets/           # (crear) Para imágenes, sonidos, etc.
│   ├── sprites/
│   ├── audio/
│   └── fonts/
└── export/           # (crear) Para builds exportados

Mejores Prácticas de Organización

Usa carpetas descriptivas
- entities/ para jugador, enemigos, NPCs
- ui/ para interfaces
- levels/ para niveles/mapas
- components/ para escenas reutilizables
Nomenclatura consistente
- snake_case para archivos: player_controller.gd
- PascalCase para clases: class_name PlayerController
- camelCase para variables: var playerSpeed = 300
Un script por escena
- Mantén scripts junto a sus escenas
- Usa class_name para scripts compartidos

Exportar Templates

Para poder exportar tu juego a diferentes plataformas:

Editor → Manage Export Templates
Download (descarga ~500MB)
Una vez instalados, ve a Project → Export
Add → Selecciona plataforma
Configura opciones y Export Project

Plataformas Disponibles

Windows: .exe ejecutable
Linux: .x86_64 ejecutable
macOS: .app bundle
HTML5: Para navegadores web
Android: .apk (requiere Android SDK)
iOS: Proyecto Xcode (requiere Mac)

Recursos de Aprendizaje

Documentación Oficial

Godot Docs: Referencia completa
GDScript Reference: Todas las clases
Tutorials: Guías paso a paso

Atajos de Teclado Esenciales

Atajo	Acción
F1	Buscar en documentación
F2	Renombrar nodo
F5	Play proyecto
F6	Play escena actual
F7	Pausar ejecución
F8	Stop
Ctrl+S	Guardar
Ctrl+Shift+S	Guardar como
Ctrl+A	Añadir nodo
Ctrl+D	Duplicar
Ctrl+Z	Deshacer
Ctrl+Shift+Z	Rehacer
Ctrl+Space	Autocompletado

Ejercicios Prácticos

Ejercicio 1: Movimiento con Mouse

Modifica el script para que el jugador siga al mouse:

func _physics_process(delta):
    var mouse_pos = get_global_mouse_position()
    var direction = (mouse_pos - global_position).normalized()
    
    velocity = direction * SPEED
    move_and_slide()
    
    # Opcional: rotar hacia el mouse
    look_at(mouse_pos)

Ejercicio 2: Múltiples Sprites

Duplica el Player (Ctrl+D)
Cambia el color del sprite (Modulate en Inspector)
Crea diferentes controles para cada jugador

Ejercicio 3: Añadir Obstáculos

Crea un nuevo nodo StaticBody2D
Añade Sprite2D y CollisionShape2D
Posiciona varios en la escena
Prueba que el jugador no puede atravesarlos

Ejercicio 4: Sistema de Partículas

Añade un nodo CPUParticles2D como hijo del Player
Configura:
- Emitting: true
- Amount: 50
- Lifetime: 0.5
- Direction: Abajo (0, 1)
- Initial Velocity: 100
- Color: Gradiente de tu elección

Solución de Problemas Comunes

”No se mueve mi personaje”

Verifica que el script esté attached al nodo correcto
Comprueba que no haya errores en Output
Asegúrate de usar _physics_process no _process

”El personaje atraviesa objetos”

Verifica que ambos tengan CollisionShape2D
El jugador debe ser CharacterBody2D o RigidBody2D
Los obstáculos deben ser StaticBody2D

”El proyecto no ejecuta”

Define una escena principal en Project Settings
Verifica que no haya errores de sintaxis
Revisa la consola Output

”Los controles no responden”

Verifica Input Map en Project Settings
Comprueba los nombres de las acciones
Asegúrate de usar el método correcto (is_action_pressed vs is_action_just_pressed)

Resumen del Capítulo

En este capítulo hemos:

✅ Instalado y configurado Godot 4
✅ Explorado la interfaz y herramientas principales
✅ Entendido los conceptos de Nodos, Escenas y Scripts
✅ Creado un personaje controlable
✅ Añadido movimiento con teclado
✅ Configurado el proyecto
✅ Aprendido la estructura de archivos

Próximo Capítulo

En el siguiente capítulo aprenderemos GDScript desde cero:

Variables y tipos de datos
Estructuras de control
Funciones y clases
Señales y eventos
Programación orientada a objetos en Godot

→ Capítulo 2: GDScript - El Lenguaje de Godot

Reto Final: Crea una escena con 3 objetos diferentes moviéndose con patrones distintos (circular, zigzag, aleatorio). ¡Comparte tu creación en la comunidad Godot!