Tutorial de linha de comando

Some developers like using the command line extensively. Godot is designed to be friendly to them, so here are the steps for working entirely from the command line. Given the engine relies on almost no external libraries, initialization times are pretty fast, making it suitable for this workflow.

Command line reference

General options

Comando Descrição
-h, --help, /? Display the list of command line options.
--versão Exibe a string da versão.
-v, --verbose Use verbose stdout mode.
--quiet Modo silencioso, silencia mensagens stdout. Os erros ainda são exibidos.

Run options

Comando Descrição
-e, --editor Inicia o editor ao invés de rodar a cena (tools deve estar ativado).
-p, --project-manager Inicia o gerenciador de projetos, mesmo que um projeto seja detectado automaticamente (tools deve estar ativado).
-q, --quit Sair depois da primeira iteração.
-l <locale>, --language <locale> Use a specific locale (<locale> being a two-letter code). See Localizações for more details.
--path <directory> Caminho para um projeto (<directory> deve conter um arquivo ‘project.godot’).
-u, --upwards Escanear pastas acima por arquivo ‘project.godot’
--main-pack <file> Caminho para um arquivo de pacote (.pck) a ser carregado.
--render-thread <mode> Render thread mode (‘unsafe’, ‘safe’, ‘separate’). See Thread Model for more details.
--remote-fs <address> Sistema de Arquivos Remoto (endereço <host/IP>[:<port>]).
--audio-driver <driver> Driver de áudio. Use `` –help`` primeiro para exibir a lista de drivers disponíveis.
--video-driver <driver> Driver de vídeo. Use `` –help`` primeiro para exibir a lista de drivers disponíveis.

Display options

Comando Descrição
-f, --fullscreen Solicitar o modo Tela Cheia.
-m, --maximized Solicitar uma janela maximizada.
-w, --windowed Solicitar o Modo Janela.
-t, --always-on-top Solicitar uma Janela Sempre Visível.
--resolution <W>x<H> Solicitar a Resolução de Janela.
--position <X>,<Y> Solicitar a Posição da Janela.
--low-dpi Forçar Modo de baixo DPI (Apenas para macOS e Windows).
--no-window Desativar a Criação de Janela (Apenas para Windows). Útil em conjunto com --script.

Opções de Depuração

Nota

As opções de depuração estão disponíveis apenas no editor e nos modelos de exportação de depuração (eles exigem destinos de compilação `` debug`` ou `` release_debug``, consulte: ref: doc_introduction_to_the_buildsystem_target para obter mais detalhes).

Comando Descrição
-d, --debug Depurar (Depuração stdout local).
-b, --breakpoints Breakpoint list as source::line comma-separated pairs, no spaces (use %%20 instead).
--profiling Habilite a criação de perfil no depurador de scripts.
--remote-debug <address> Depuração Remota (endereço <host/IP>:<port> ).
--debug-collisions Mostrar formas de colisão ao executar a cena.
--debug-navigation Mostrar polígonos de navegação ao executar a cena.
--frame-delay <ms> Simular alta carga de CPU (atrase cada quadro em <ms> milissegundos).
--time-scale <scale> Forçar escala de tempo (valores mais altos são mais rápidos, 1,0 é velocidade normal).
--disable-render-loop Desabilitar o loop de renderização de modo que a renderização só ocorra quando for explicitamente chamado pelo script.
--disable-crash-handler Desabilite o manipulador de falhas quando suportado pelo código da plataforma.
--fixed-fps <fps> Force um número fixo de quadros por segundo. Essa configuração desativa a sincronização em tempo real.
--print-fps Imprima os quadros por segundo para o stdout.

Standalone tools

Comando Descrição
-s <script>, --script <script> Executar um script.
--check-only Only parse for errors and quit (use with --script).
--export <target> Exporte o projeto usando o destino de exportação especificado. Exporte apenas o pacote principal se o caminho terminar com .pck ou .zip (: ref: tools <doc_introduction_to_the_buildsystem_tools> deve estar ativado).
--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).

Caminho

It is recommended that your Godot binary be in your PATH environment variable, so it can be executed easily from any place by typing godot. You can do so on Linux by placing the Godot binary in /usr/local/bin and making sure it is called godot.

Definindo o caminho do projeto

Dependendo de onde seu binário Godot está localizado e qual é seu diretório de trabalho atual, talvez seja necessário definir o caminho para o seu projeto para que qualquer um dos comandos a seguir funcione corretamente.

Isto pode ser feito dando o caminho para o arquivo `` project.godot`` do seu projeto como o primeiro argumento, assim:

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

Ou usando o argumento `` –path``:

[email protected]:~$ godot --path path_to_your_project [other] [commands] [and] [args]

Por exemplo, o comando completo para exportar seu jogo (conforme explicado abaixo) pode ser assim:

[email protected]:~$ godot --path path_to_your_project --export my_export_preset_name game.exe

Criando um projeto

Criar um projeto a partir da linha de comando pode ser feito navegando no shell até o local desejado e criando um arquivo project.godot.

[email protected]:~$ mkdir newgame
[email protected]:~$ cd newgame
[email protected]:~/newgame$ touch project.godot

O projeto agora pode ser aberto com Godot.

Executando o editor

Running the editor is done by executing Godot with the -e flag. This must be done from within the project directory or a subdirectory, otherwise the command is ignored and the project manager appears.

[email protected]:~/newgame$ godot -e

Se uma cena foi criada e salva, ela pode ser editada posteriormente, executando o mesmo código com aquela cena como argumento.

[email protected]:~/newgame$ godot -e scene.tscn

Apagando uma cena

Godot é o amigo do seu sistema de arquivos e não criará arquivos extras de metadados. Use `` rm`` para apagar um arquivo de cena. Certifique-se de que nada faça referência a essa cena, senão um erro será lançado na abertura.

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

Executando o jogo

Para rodar o jogo, simplesmente execute Godot dentro do diretório ou subdiretório do projeto.

[email protected]:~/newgame$ godot

Quando uma cena específica precisa ser testada, passe essa cena para a linha de comando.

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

Depuração

Catching errors in the command line can be a difficult task because they just fly by. For this, a command line debugger is provided by adding -d. It works for running either the game or a simple scene.

[email protected]:~/newgame$ godot -d
[email protected]:~/newgame$ godot -d scene.tscn

Exportando

Exportar o projeto da linha de comando também é suportado. Isso é especialmente útil para configurações de integração contínua. A versão da Godot que é sem cabeça (construção de servidor, sem vídeo) é ideal para isso.

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

Os nomes de plataforma reconhecidos pela opção `` –export`` são os mesmos exibidos no assistente de exportação do editor. Para obter uma lista de plataformas suportadas a partir da linha de comandos, tente exportar para uma plataforma não reconhecida e a listagem completa das plataformas suportadas pela sua configuração será mostrada.

Para exportar uma versão de depuração do jogo, use a opção `` –export-debug`` em vez de `` –export``. Seus parâmetros e uso são os mesmos.

Executando um script

É possível executar um script .gd simples a partir da linha de comando. Esse recurso é especialmente útil em projetos grandes, para conversão em lote de ativos ou importação / exportação personalizada.

O script deve herdar do SceneTree ou do MainLoop.

Aqui está um exemplo simples de como funciona:

#sayhello.gd
extends SceneTree

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

E como executá-lo:

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

Se nenhum project.godot existir no caminho, o caminho atual é assumido como o diretório de trabalho atual (a menos que `` -path`` seja especificado).