Tutorial de línea de comandos¶

A algunos desarrolladores les gusta usar la línea de comandos extensivamente. Godot está diseñado para ser amigable con ellos, así que aquí están los pasos para trabajar completamente desde la línea de comandos. Dado que el motor depende de pocas o ninguna librería externa, los tiempos de inicialización son bastante rápidos, lo que lo hace adecuado para este flujo de trabajo.

Nota

En Windows y Linux, puedes ejecutar un binario de Godot en una terminal especificando su ruta relativa o absoluta.

En macOS, el proceso es diferente debido a que Godot está contenido en un paquete .app (que es una carpeta, no un archivo). Para ejecutar un binario de Godot desde un terminal en macOS, debe cd en la carpeta donde se encuentra el paquete de aplicaciones de Godot, luego ejecutar Godot.app / Contents / MacOS / Godot seguido de cualquier línea de comando argumentos. Si ha cambiado el nombre del paquete de aplicaciones de Godot a otro nombre, asegúrese de editar esta línea de comando en consecuencia.

Referencia de la línea de comandos¶

Opciones generales

Comando	Descripción
`-h`, `--help`, `/?`	Muestra la lista de opciones de línea de comandos.
`--version`	Muestra una cadena con la versión.
`-v`, `--verbose`	Usa el modo stdout verboso.
`--quiet`	Modo silencioso, silencia los mensajes de stdout. Los errores seguirán siendo mostrados.

Opciones de ejecución

Comando	Descripción
`-e`, `--editor`	Inicia el editor en lugar de ejecutar la escena (tools debe estar habilitado).
`-p`, `--project-manager`	Inicie el administrador de proyectos, incluso si un proyecto se detecta automáticamente (tools debe estar habilitado).
`-q`, `--quit`	Salir después de la primera iteración.
`-l <locale>`, `--language <locale>`	Usa una configuración de región específica (<locale> es un código de dos letras). Ver :ref:`doc_locales`para más detalles.
`--path <directorio>`	La ruta a un proyecto (<directory> debe contener un archivo 'project.godot').
`-u`, `--upwards`	Buscar en las carpetas superiores el archivo 'project.godot'.
`--main-pack <archivo>`	Ruta a un archivo de paquete (.pck) a cargar.
`--render-thread <modo>`	Modo de renderizado del hilo ('unsafe', 'safe', 'separate'). Ver Thread Model para más detalles.
`--remote-fs <dirección>`	Sistema de archivos remoto (`<host/IP>[:<port>]` dirección).
`--audio-driver <driver>`	Controlador de audio. Usa `--help` primero para mostrar la lista de controladores disponibles.
`--video-driver <driver>`	Controlador de video. Usa `--help` primero para mostrar la lista de controladores disponibles.

Opciones de visualización

Comando	Descripción
`-f`, `--fullscreen`	Solicitar modo de pantalla completa.
`-m`, `--maximized`	Solicitar una ventana maximizada.
`-w`, `--windowed`	Solicitar modo ventana.
`-t`, `--always-on-top`	Solicita una ventana siempre en la cima.
`--resolution <W>x<H>`	Solicitar resolución de ventana.
`--position <X>,<Y>`	Solicitar posición de la ventana.
`--low-dpi`	Forzar el modo de bajo DPI (sólo macOS y Windows).
`--no-window`	Ejecutar con ventana invisible. Útil junto con `--script`.

Opciones de depuración

Nota

Las opciones de depuración sólo están disponibles en el editor y el depurador de plantillas de exportación (estas requieren debug o release_debug, ver :ref:`doc_introduction_to_the_buildsystem_target`para más detalles).

Comando	Descripción
`-d`, `--debug`	Depurar (depurador stdout local).
`-b`, `--breakpoints`	Lista de puntos de interrupción como fuente::pares separados por comas, sin espacios (usar %%20 en su lugar).
`--profiling`	Habilite la creación de perfiles en el depurador de scripts.
`--remote-debug <dirección>`	Depurado remoto (`<host/IP>:<port>` dirección).
`--debug-collisions`	Mostrar la forma de la colisión mientras se ejecuta la escena.
`--debug-navigation`	Mostrar polígonos de navegación mientras se ejecuta la escena.
`--frame-delay <ms>`	Simular una alta carga de CPU (retrasar cada fotograma <ms> milisegundos).
`--time-scale <escala>`	Forzar la escala de tiempo (los valores altos son más rápidos, 1.0 es la velocidad normal).
`--disable-render-loop`	Deshabilite el bucle de renderizado para que el renderizado solo ocurra cuando se llama explícitamente desde el script.
`--disable-crash-handler`	Deshabilite el controlador de fallas cuando sea compatible con el código de la plataforma.
`--fixed-fps <fps>`	Forzar un número fijo de fotogramas por segundo. Esta configuración deshabilita la sincronización en tiempo real.
`--print-fps`	Imprime los fotogramas por segundo en la stdout.

Herramientas independientes

Comando	Descripción
`-s <script>`, `--script <script>`	Ejecutar un script.
`--check-only`	Analizar solo los errores y salir (usar con `` --script``).
`--export <target>`	Exporta el proyecto usando el objetivo de exportación indicado. Exporta sólo el paquete principal si termina con .pck o .zip (tiene que tener habilitado tools).
`--export-debug <target>`	Como `--export`, pero use la plantilla de depuración (tools debe estar habilitada).
`--doctool <ruta>`	Volcar la referencia de la API del motor a la <ruta> en formato XML, fusionando si se encuentran archivos existentes (tools debe estar habilitado).
`--no-docbase`	Anular el volcado de tipos base (utilizados con `--doctool`, tools debe estar habilitado).
`--build-solutions`	Cree las soluciones de secuencias de comandos (por ejemplo, para proyectos de C#, tools debe estar habilitado).
`--gdnative-generate-json-api`	Genere un volcado en JSON de la API de Godot para enlaces de GDNative (tools debe estar habilitado).
`--test <test>`	Ejecute una prueba unitaria. Usar``--help`` primero para mostrar la lista de pruebas. (tools debe estar habilitado).
`--export-pack <preestablecido> <ruta>`	Como el parametro `--export`, solo exporta el paquete del juego con el ajuste preestablecido ya dado. La extensión <path> determina si estará en formato PCK o ZIP. (tools deben estar habilitadas para funcionar correctamente).

Ruta¶

Se recomienda que el binario de godot se encuentre en la variable de entorno PATH, para que pueda ejecutarse fácilmente desde cualquier lugar escribiendo godot. Puedes hacerlo en Linux colocando el binario de Godot en /usr/local/bin y asegurándote de que se llame godot.

Configuración de la ruta del proyecto¶

Dependiendo de dónde se encuentre el binario de Godot y cuál sea su directorio de trabajo actual, es posible que necesites establecer la ruta a tu proyecto para que cualquiera de los siguientes comandos funcione correctamente.

Esto se puede hacer indicando la ruta al archivo project.godot de tu proyecto como primer argumento, de esta forma:

godot path_to_your_project/project.godot [other] [commands] [and] [args]

O usando el argumento --path:

godot --path path_to_your_project [other] [commands] [and] [args]

Por ejemplo, el comando completo para exportar tu juego (como se explica a continuación) podría verse así:

godot --path path_to_your_project --export my_export_preset_name game.exe

Creación de un proyecto¶

Para crear un proyecto desde la línea de comandos, navega hasta el lugar deseado y crea un archivo project.godot vacío.

mkdir newgame
cd newgame
touch project.godot

El proyecto ahora puede abrirse con Godot.

Ejecutar el editor¶

El editor se abre ejecutando Godot con el parámetro -e. Esto debe hacerse desde el directorio del proyecto, o desde un subdirectorio, de lo contrario el comando se ignora y aparece el gestor de proyectos.

godot -e

Si una escena ha sido creada y guardada, puede ser editada más tarde ejecutando el mismo código con esa escena como argumento.

godot -e scene.tscn

Borrar una escena¶

Godot es amigo de tu sistema de archivos, y no creará archivos de metadatos adicionales, simplemente usa rm para borrar un archivo. Asegúrate de que nada hace referencia a esa escena, de lo contrario se producirá un error al abrirla.

rm scene.tscn

Ejecutar el juego¶

Para ejecutar el juego, simplemente ejecuta Godot dentro del directorio o subdirectorio del proyecto.

godot

Cuando sea necesario probar una escena específica, pásala por línea de comandos.

godot scene.tscn

Depuración¶

Capturar errores en línea de comandos puede ser una tarea difícil porque simplemente pasan uno tras otro. Para esto, se proporciona un depurador de línea de comandos añadiendo -d. Funciona tanto para ejecutar el juego como para una escena simple.

godot -d

godot -d scene.tscn

Exportar¶

También se puede exportar el proyecto desde la línea de comandos. Esto es especialmente útil para configuraciones de integración continua. La versión de Godot que es headless (server build, no video) es ideal para esto.

godot --export "Linux/X11" /var/builds/project
godot --export Android /var/builds/project.apk

El nombre del preset debe coincidir con el nombre de un preset de exportación definido en el archivo `` export_presets.cfg `` del proyecto. Si el nombre predeterminado contiene espacios o caracteres especiales (como "Escritorio de Windows"), debe estar entre comillas.

Para exportar una versión de depuración del juego, utiliza la opción --export-debug en lugar de --export. Sus parámetros y uso son los mismos.

Para exportar sólo un archivo PCK, utilice la opción --export-pack seguida del nombre y la ruta de salida preestablecidos, con la extensión del archivo, en lugar de --export. La extensión de la ruta de salida determina el formato del paquete, ya sea PCK o ZIP.

Advertencia

Al especificar una ruta relativa como ruta para --export,` --export-debug` o --export-pack, la ruta será relativa al directorio que contiene el archivo` project.godot`, ** no ** relativo al directorio de trabajo actual.

Ejecutar un script¶

Es posible ejecutar un script .gd desde línea de comandos. Esta función es especialmente útil en proyectos de gran envergadura, para la conversión por lotes de recursos o la importación/exportación personalizada.

El script debe heredar de SceneTree o MainLoop.

He aquí un ejemplo simple del funcionamiento de sayhello.gd :

#!/usr/bin/env -S godot -s
extends SceneTree

func _init():
    print("Hello!")
    quit()

Y cómo ejecutarlo:

# Prints "Hello!" to standard output.
godot -s sayhello.gd

Si project.godot no existe en la ruta, se asume que la ruta actual es el directorio de trabajo a utilizar (a menos que se especifique --path).

La primera línea de sayhello.gd se conoce comúnmente como shebang. Si el binario Godot está en tu PATH como godot, te permite ejecutar el script de la siguiente manera en distribuciones Linux modernas, así como en macOS:

# Mark script as executable.
chmod +x sayhello.gd
# Prints "Hello!" to standard output.
./sayhello.gd

Si lo anterior no funciona en su versión actual de Linux o MacOS, siempre puede hacer que el shebang ejecute Godot directamente desde donde se encuentra, de la siguiente manera:

#!/usr/bin/godot -s