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. |
--versão |
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 local específico (<código de localidade> sendo um código de duas letras). Veja Localizações 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
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.
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.
Executando um script¶
It is possible to run a simple .gd
script from the command line.
This feature is especially useful in large projects, e.g. for batch
conversion of assets or custom import/export.
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