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).