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
No Windows e Linux, você pode rodar um binário do Godot em um terminal especificando o seu caminho absoluto ou relativo.
No macOS, o processo é diferente porque a Godot está contida em um pacote .app
(que é uma pasta, não um arquivo). Para rodar um executável da Godot de um terminal no macOS, você deve executar um cd
para a pasta onde o pacote do aplicativo Godot está localizado, em seguida, execute Godot.app / Contents / MacOS / Godot
seguido por quaisquer argumentos de linha de comando. Se você renomeou o pacote do aplicativo da Godot
para outro nome, certifique-se de editar a linha de comando de acordo.
Referência para linha de comando¶
Opções gerais
Comando |
Descrição |
|
Exiba a lista de opções para linha de comando. |
|
Exibe a string da versão. |
|
Usar modo de saída verbose. |
|
Modo silencioso, silencia mensagens stdout. Os erros ainda são exibidos. |
Opções de execução
Comando |
Descrição |
|
Inicia o editor ao invés de rodar a cena (tools deve estar ativado). |
|
Inicia o gerenciador de projetos, mesmo que um projeto seja detectado automaticamente (tools deve estar ativado). |
|
Sair depois da primeira iteração. |
|
Use um locale específico (<código de localidade> sendo um código de duas letras). Veja Locales para mais detalhes. |
|
Caminho para um projeto (<directory> deve conter um arquivo 'project.godot'). |
|
Escanear pastas acima por arquivo 'project.godot'. |
|
Caminho para um arquivo de pacote (.pck) a ser carregado. |
|
Modo de thread de renderização ('unsafe', 'safe', 'separate'). Veja Modelo de Thread para mais detalhes. |
|
Sistema de Arquivos Remoto (endereço |
|
Driver de áudio. Use |
|
Driver de vídeo. Use |
Opções de exibição
Comando |
Descrição |
|
Solicitar o modo Tela Cheia. |
|
Solicitar uma janela maximizada. |
|
Solicitar o Modo Janela. |
|
Solicitar uma Janela Sempre Visível. |
|
Solicitar a Resolução de Janela. |
|
Solicitar a Posição da Janela. |
|
Forçar Modo de baixo DPI (Apenas para macOS e Windows). |
|
Execute com janela invisível. Útil junto com |
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 Alvo para obter mais detalhes).
Comando |
Descrição |
|
Depurar (Depuração stdout local). |
|
Lista de pontos de interrupção com pares de fonte::linha separados por vírgulas, sem espaços (use %%20 no lugar). |
|
Habilita a criação de perfil no depurador de scripts. |
|
Depuração Remota (endereço |
|
Mostrar formas de colisão ao executar a cena. |
|
Mostrar polígonos de navegação ao executar a cena. |
|
Simular alta carga de CPU (atrase cada quadro em <ms> milissegundos). |
|
Forçar escala de tempo (valores mais altos são mais rápidos, 1,0 é velocidade normal). |
|
Desabilitar o loop de renderização de modo que a renderização só ocorra quando for explicitamente chamado pelo script. |
|
Desabilitar o manipulador de falhas quando suportado pelo código da plataforma. |
|
Força um número fixo de quadros por segundo. Essa configuração desativa a sincronização em tempo real. |
|
Imprime os quadros por segundo para o stdout. |
Ferramentas independentes
Comando |
Descrição |
|
Executar um script. |
|
Apenas analisa erros e sai (use com |
|
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). |
|
Como o |
|
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). |
|
Não permitir o despejamento de tipos base (usado com |
|
Construa as soluções de script (por exemplo, para projetos em C#, tools deve estar ativado). |
|
Gerar despejo JSON da API do Godot para as ligações do GDNative (tools deve estar habilitado). |
|
Execute um teste unitário. Utilize ``-help'' primeiro para exibir a lista de testes. (tools deve estar habilitado). |
|
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