Tutorial de linha de comando

Alguns desenvolvedores gostam de usar a linha de comando extensivamente. Godot é projetado para funcionar com elas, então aqui estão os passos para trabalhar inteiramente a partir da linha de comando. Como a engine depende de quase nenhuma biblioteca externa, os tempos de inicialização são muito rápidos, o que o torna adequado para esse fluxo de trabalho.

Nota

On Windows and Linux, you can run a Godot binary in a terminal by specifying its relative or absolute path.

On macOS, the process is different due to Godot being contained within an .app bundle (which is a folder, not a file). To run a Godot binary from a terminal on macOS, you have to cd to the folder where the Godot application bundle is located, then run Godot.app/Contents/MacOS/Godot followed by any command line arguments. If you've renamed the application bundle from Godot to another name, make sure to edit this command line accordingly.

Referência para linha de comando

Opções gerais

Comando

Descrição

-h, --help, /?

Exiba a lista de opções para linha de comando.

--version

Exibe a string da versão.

-v, --verbose

Usar modo de saída verbose.

--quiet

Modo silencioso, silencia mensagens stdout. Os erros ainda são exibidos.

Opções de execução

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 <código de localidade>, --language <código de localidade>

Use um locale específico (<código de localidade> sendo um código de duas letras). Veja Locales para mais detalhes.

--path <diretório>

Caminho para um projeto (<directory> deve conter um arquivo 'project.godot').

-u, --upwards

Escanear pastas acima por arquivo 'project.godot'.

--main-pack <arquivo>

Caminho para um arquivo de pacote (.pck) a ser carregado.

--render-thread <modo>

Modo de thread de renderização ('unsafe', 'safe', 'separate'). Veja Modelo de Thread para mais detalhes.

--remote-fs <endereço>

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.

Opções de exibição

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 <largura>x<altura>

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

Run with invisible window. Useful together with --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 Destino para obter mais detalhes).

Comando

Descrição

-d, --debug

Depurar (Depuração stdout local).

-b, --breakpoints

Lista de pontos de interrupção com pares de fonte::linha separados por vírgulas, sem espaços (use %%20 no lugar).

--profiling

Habilita a criação de perfil no depurador de scripts.

--remote-debug <endereço>

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 <escala>

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

Desabilitar o manipulador de falhas quando suportado pelo código da plataforma.

--fixed-fps <fps>

Força um número fixo de quadros por segundo. Essa configuração desativa a sincronização em tempo real.

--print-fps

Imprime os quadros por segundo para o stdout.

Ferramentas independentes

Comando

Descrição

-s <script>, --script <script>

Executar um script.

--check-only

Apenas analisa erros e sai (use com --script).

--export <destino>

Exporta o projeto usando o destino de exportação especificado. Exporta apenas o pacote principal se o caminho terminar com .pck ou .zip (tools deve estar ativado).

--export-debug <destino>

Como o --export, mas usa o modelo de depuração (tools deve estar habilitado).

--doctool <caminho>

Despeje a referência da API da engine para o <caminho> dado em formato XML, fundindo se arquivos existentes forem encontrados (tools deve estar habilitado).

--no-docbase

Não permitir o despejamento de tipos base (usado com --doctool, tools deve estar habilitado).

--build-solutions

Construa as soluções de script (por exemplo, para projetos em C#, tools deve estar ativado).

--gdnative-generate-json-api

Gerar despejo JSON da API do Godot para as ligações do GDNative (tools deve estar habilitado).

--test <teste>

Execute um teste unitário. Utilize ``-help'' primeiro para exibir a lista de testes. (tools deve estar habilitado).

--export-pack <preset> <caminho>

Como `` --export``, mas apenas exporta o pacote de jogo para o preset fornecido. A extensão <caminho> determina se será no formato PCK ou ZIP. (tools deve estar habilitado).

Caminho

É recomendado que o seu binário no Godot esteja na sua variável de ambiente PATH, de modo que possa ser executado facilmente de qualquer lugar digitando godot. Você pode fazer isso no Linux colocando o binário do Godot em /usr/local/bin e certificando-se de que ele se chama 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:

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

Ou usando o argumento --path:

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:

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.

mkdir newgame
cd newgame
touch project.godot

O projeto agora pode ser aberto com Godot.

Executando o editor

Rodar o editor é feito executando Godot com o sinalizador -e. Isso deve ser feito a partir do diretório do projeto ou de um subdiretório, caso contrário, o comando será ignorado e o gerenciador de projetos será exibido.

godot -e

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

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.

rm scene.tscn

Executando o jogo

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

godot

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

godot scene.tscn

Depuração

Capturar erros na linha de comando pode ser uma tarefa difícil porque eles simplesmente passam voando. Para isso, um depurador de linha de comando é fornecido adicionando -d. Funciona tanto para rodar o jogo quanto para uma cena simples.

godot -d
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 do Godot que é sem cabeça (construção de servidor, sem vídeo) é ideal para isso.

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

O nome do preset deve corresponder ao nome de um preset de exportação definido no arquivo export_presets.cfg do projeto. Se o nome da predefinição contiver espaços ou caracteres especiais (como "Windows Desktop"), ele deve ser colocado entre aspas.

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.

Para exportar apenas um arquivo PCK, use a opção --export-pack seguida pelo nome da predefinição e pelo caminho de saída, com a extensão do arquivo, ao invés de --export. A extensão do caminho de saída determina o formato do pacote, PCK ou ZIP.

Aviso

Ao especificar um caminho relativo como o caminho para --export, --export-debug ou --export-pack, o caminho será relativo ao diretório que contém o arquivo project.godot, não relativo ao diretório de trabalho atual.

Executando um script

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

O script deve herdar de SceneTree ou MainLoop.

Aqui está um exemplo simples sayhello.gd de como funciona:

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

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

E como executá-lo:

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

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

A primeira linha de sayhello.gd acima é comumente referida como shebang. Se o binário Godot estiver em seu PATH como godot, ele permite que você execute o script da seguinte forma em distribuições Linux modernas, bem como no macOS:

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

Se o acima não funcionar em sua versão atual do Linux ou macOS, você sempre pode fazer com que o shebang execute Godot diretamente de onde está localizado da seguinte maneira:

#!/usr/bin/godot -s