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.

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

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

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

--profiling

Habilite 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

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.

Ferramentas independentes

Comando

Descrição

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

Executar um script.

--check-only

Apenas procure erros e saia (use com `` --script``).

--export <destino>

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

Como o --export, mas usa o template de debug (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> <path>

Like --export, but only export the game pack for the given preset. The <path> extension determines whether it will be in PCK or ZIP format. (tools must be enabled).

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

The preset name must match the name of an export preset defined in the project's export_presets.cfg file. If the preset name contains spaces or special characters (such as "Windows Desktop"), it must be surrounded with quotes.

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.

To export only a PCK file, use the --export-pack option followed by the preset name and output path, with the file extension, instead of --export. The output path extension determines the package's format, either PCK or ZIP.

Aviso

When specifying a relative path as the path for --export, --export-debug or --export-pack, the path will be relative to the directory containing the project.godot file, not relative to the current working directory.

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.

The script must inherit from SceneTree or MainLoop.

Here is a simple sayhello.gd example of how it works:

#!/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

If no project.godot exists at the path, current path is assumed to be the current working directory (unless --path is specified).

The first line of sayhello.gd above is commonly referred to as a shebang. If the Godot binary is in your PATH as godot, it allows you to run the script as follows in modern Linux distributions, as well as macOS:

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

If the above doesn't work in your current version of Linux or macOS, you can always have the shebang run Godot straight from where it is located as follows:

#!/usr/bin/godot -s