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.

Command line reference

General options

Command Descripción
-h, --help, /? Display the list of command line options.
--version Display the version string.
-v, --verbose Use verbose stdout mode.
--quiet Quiet mode, silences stdout messages. Errors are still displayed.

Run options

Command Descripción
-e, --editor Start the editor instead of running the scene (tools must be enabled).
-p, --project-manager Start the project manager, even if a project is auto-detected (tools must be enabled).
-q, --quit Quit after the first iteration.
-l <locale>, --language <locale> Use a specific locale (<locale> being a two-letter code). See Localización for more details.
--path <directory> Path to a project (<directory> must contain a “project.godot” file).
-u, --upwards Scan folders upwards for “project.godot” file.
--main-pack <file> Path to a pack (.pck) file to load.
--render-thread <mode> Render thread mode (“unsafe”, “safe”, “separate”). See Thread Model for more details.
--remote-fs <address> Remote filesystem (<host/IP>[:<port>] address).
--audio-driver <driver> Audio driver. Use --help first to display the list of available drivers.
--video-driver <driver> Video driver. Use --help first to display the list of available drivers.

Display options

Command Descripción
-f, --fullscreen Request fullscreen mode.
-m, --maximized Request a maximized window.
-w, --windowed Request windowed mode.
-t, --always-on-top Request an always-on-top window.
--resolution <W>x<H> Request window resolution.
--position <X>,<Y> Request window position.
--low-dpi Force low-DPI mode (macOS and Windows only).
--no-window Disable window creation (Windows only). Useful together with --script.

Debug options

Nota

Debug options are only available in the editor and debug export templates (they require debug or release_debug build targets, see Objetivo for more details).

Command Descripción
-d, --debug Debug (local stdout debugger).
-b, --breakpoints Breakpoint list as source::line comma-separated pairs, no spaces (use %%20 instead).
--profiling Enable profiling in the script debugger.
--remote-debug <address> Remote debug (<host/IP>:<port> address).
--debug-collisions Show collision shapes when running the scene.
--debug-navigation Show navigation polygons when running the scene.
--frame-delay <ms> Simulate high CPU load (delay each frame by <ms> milliseconds).
--time-scale <scale> Force time scale (higher values are faster, 1.0 is normal speed).
--disable-render-loop Disable render loop so rendering only occurs when called explicitly from script.
--disable-crash-handler Disable crash handler when supported by the platform code.
--fixed-fps <fps> Force a fixed number of frames per second. This setting disables real-time synchronization.
--print-fps Print the frames per second to the stdout.

Standalone tools

Command Descripción
-s <script>, --script <script> Run a script.
--check-only Only parse for errors and quit (use with --script).
--export <target> Export the project using the given export target. Export only main pack if path ends with .pck or .zip (tools must be enabled).
--export-debug <target> Like --export, but use debug template (tools must be enabled).
--doctool <path> Dump the engine API reference to the given <path> in XML format, merging if existing files are found (tools must be enabled).
--no-docbase Disallow dumping the base types (used with --doctool, tools must be enabled).
--build-solutions Build the scripting solutions (e.g. for C# projects, tools must be enabled).
--gdnative-generate-json-api Generate JSON dump of the Godot API for GDNative bindings (tools must be enabled).
--test <test> Run a unit test. Use --help first to display the list of tests. (tools must be enabled).

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:

[email protected]:~$ godot path_to_your_project/project.godot [other] [commands] [and] [args]

O usando el argumento --path:

[email protected]:~$ 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í:

[email protected]:~$ 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.

[email protected]:~$ mkdir newgame
[email protected]:~$ cd newgame
[email protected]:~/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.

[email protected]:~/newgame$ 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.

[email protected]:~/newgame$ 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.

[email protected]:~/newgame$ rm scene.tscn

Ejecutar el juego

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

[email protected]:~/newgame$ godot

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

[email protected]:~/newgame$ 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.

[email protected]:~/newgame$ godot -d
[email protected]:~/newgame$ 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.

[email protected]:~/newgame$ godot --export "Linux/X11" /var/builds/project
[email protected]:~/newgame$ godot --export Android /var/builds/project.apk

Los nombres de plataforma reconocidos por el parámetro --export son los mismos que se muestran en el asistente de exportación del editor. Para obtener una lista de plataformas compatibles desde la línea de comandos, intenta exportar a una plataforma no reconocida y se mostrará la lista completa de plataformas compatibles con tu configuración.

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.

Ejecutar un script

Es posible ejecutar un script.gd simple 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 de su funcionamiento:

#sayhello.gd
extends SceneTree

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

Y cómo ejecutarlo:

[email protected]:~/newgame$ godot -s sayhello.gd
Hello!

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