Godot do Zero: Preparando o ambiente e entendendo a interface 2D

Instalação e primeiro acesso ao Godot

O que você precisa entender

O Godot é um editor que já inclui as ferramentas para criar, testar e depurar seu jogo. Você trabalha com projetos (uma pasta no seu computador) e dentro deles cria cenas (arquivos .tscn) compostas por nós (nodes). Neste capítulo, o objetivo é deixar o ambiente pronto para começar um jogo 2D com organização e configurações mínimas.

Passo a passo: baixar, instalar e abrir

• Baixe o Godot (versão estável recomendada para o curso) e extraia/instale conforme seu sistema.
• Abra o executável do Godot. Você verá o Project Manager (gerenciador de projetos).
• Se for a primeira vez, confirme permissões de acesso a pastas (quando solicitado pelo sistema).

Criando um projeto 2D e estrutura inicial de pastas

Conceito: projeto = pasta raiz do jogo

Um projeto no Godot é uma pasta que contém o arquivo project.godot e todos os recursos do jogo (cenas, scripts, imagens, áudio). Manter uma estrutura de diretórios consistente evita bagunça e facilita encontrar arquivos no painel FileSystem.

Passo a passo: criar o projeto

• No Project Manager, clique em New Project.
• Defina Project Name e escolha um Project Path (uma pasta dedicada).
• Em Renderer, mantenha o padrão recomendado (para 2D, o padrão costuma funcionar bem).
• Clique em Create & Edit para abrir o editor.

Passo a passo: criar pastas iniciais

No painel FileSystem (geralmente à esquerda), crie uma organização mínima. Clique com o botão direito na raiz do projeto e use New Folder:

• scenes/ (cenas .tscn)
• scripts/ (GDScript)
• art/ (sprites, tilesets, fontes)
• audio/ (músicas e efeitos)
• ui/ (cenas e recursos de interface)

Dica prática: evite espaços e acentos em nomes de pastas/arquivos para reduzir problemas de caminho e compatibilidade.

Entendendo a interface 2D (foco prático)

Viewport 2D (área central)

É onde você posiciona nós 2D visualmente (por exemplo, Sprite2D, CharacterBody2D, TileMap). Você pode selecionar, mover, rotacionar e escalar objetos. Use zoom e pan para navegar pelo espaço.

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

• Selecionar: clique no objeto na viewport.
• Mover: arraste com a ferramenta de mover (ou arraste o gizmo quando disponível).
• Zoom: roda do mouse (ou atalhos do editor, dependendo do layout).
• Pan: geralmente com botão do meio do mouse (ou Space + arrastar, dependendo das preferências).

Scene (árvore de cena)

Mostra a hierarquia de nós da cena atual. Pense nela como a “estrutura” do que existe na cena: um nó raiz e seus filhos. Você cria e organiza nós aqui.

• Adicionar nó: botão + (Add Child Node) na árvore.
• Renomear: clique lento no nome ou use o menu de contexto.
• Reorganizar: arraste nós para mudar a ordem/parentesco.

Inspector (propriedades do nó selecionado)

Quando você seleciona um nó, o Inspector mostra propriedades editáveis: posição, escala, recursos, colisões, scripts anexados etc. É aqui que você configura o comportamento visual e parâmetros do nó sem escrever código.

Uso prático: sempre que algo “não aparece” ou “não funciona”, confira no Inspector se o recurso correto está atribuído (por exemplo, textura, shape de colisão, material) e se o nó está habilitado/visível.

Node dock (aba “Node”)

Normalmente ao lado do Inspector, a aba Node concentra ações específicas do nó: sinais (signals), grupos e outras opções. Na prática, você usará muito para conectar sinais de UI e eventos (cliques, entradas, colisões).

• Signals: lista eventos que o nó emite (ex.: pressed em botões).
• Groups: permite marcar nós com tags para encontrá-los e agir em lote via código.

FileSystem (arquivos do projeto)

É o explorador interno do Godot. Ele reflete as pastas do projeto e permite criar, mover, renomear e abrir recursos. Use-o como fonte principal para arrastar recursos para a cena (sprites, áudio, cenas).

Boa prática: mova arquivos sempre pelo FileSystem (e não pelo explorador do sistema operacional) para reduzir risco de referências quebradas.

Painel de scripts (Script editor)

Quando você cria/abre um script, o editor de script aparece (geralmente em uma aba no topo: 2D / 3D / Script). Aqui você escreve GDScript, navega por funções, busca texto e vê erros.

• Erros e avisos: aparecem no rodapé/saída e também podem ser sublinhados no código.
• Auto-complete: ajuda a descobrir propriedades e métodos dos nós.

Debugger (depuração em execução)

Quando você roda o jogo, o Debugger ajuda a inspecionar o que está acontecendo: erros, prints, performance e variáveis (dependendo do modo). Ele é essencial para entender por que algo não está se comportando como esperado.

• Output/Console: logs, print(), erros.
• Errors: lista de erros com links para a origem.
• Monitors: métricas (FPS, uso de memória etc.).

Primeira cena 2D para testar o projeto

Passo a passo: criar e salvar uma cena vazia

• Crie uma nova cena (Scene > New Scene).
• Escolha um nó raiz 2D (comumente Node2D para uma cena genérica 2D).
• Salve em scenes/ com um nome claro, por exemplo: main.tscn.
• Defina como cena principal do projeto: Project > Project Settings > Application > Run > Main Scene e selecione main.tscn.

Por que isso importa: sem uma Main Scene, o botão de executar pode pedir para escolher uma cena toda vez, ou o projeto pode não iniciar como esperado.

Atalhos e controles essenciais (rodar, pausar, recarregar, colisões)

Executar e controlar a execução

Você vai alternar o tempo todo entre editar e testar. Foque nestas ações:

• Executar o projeto: botão de “Play” (triângulo) no canto superior direito.
• Executar a cena atual: botão “Play Scene” (útil para testar uma cena isolada).
• Pausar: botão de pausa no painel de execução (aparece quando o jogo está rodando).
• Parar: botão de stop para encerrar a execução.
• Recarregar/Restart: botão de reiniciar (quando disponível) para rodar novamente sem fechar manualmente.

Exibir colisões (debug visual)

Para jogos 2D, ver colisões é uma das formas mais rápidas de identificar problemas (colisor faltando, tamanho errado, deslocamento). Durante a execução, ative a visualização de colisões no menu de debug do editor (opções como Visible Collision Shapes / Visible Navigation podem variar conforme a versão).

Uso prático: se um personagem atravessa uma parede, primeiro confirme se as CollisionShape2D estão aparecendo e alinhadas aos sprites.

Configurações mínimas do projeto (resolução, janela e input)

Resolução base e modo de janela

Defina uma resolução base para o jogo desde o início para evitar UI e câmera “quebrando” depois.

Passo a passo: configurar resolução e janela

• Abra Project > Project Settings.
• Vá em Display > Window.
• Defina uma resolução base (ex.: 1280x720 ou 1920x1080, conforme seu objetivo).
• Configure o modo de janela: Windowed (janela) ou Fullscreen (tela cheia) conforme o escopo do projeto.
• Se disponível na sua versão, ajuste opções de stretch (como manter proporção) para evitar distorção em diferentes telas.

Input Map (ações de controle)

Em vez de checar teclas diretamente no código, o Godot incentiva criar ações (por exemplo, move_left, jump). Isso facilita trocar teclas e suportar controle.

Passo a passo: criar ações básicas

• Abra Project > Project Settings e vá em Input Map.
• Crie ações (exemplos comuns): move_left, move_right, move_up, move_down, jump, attack, pause.
• Para cada ação, clique em Add Event e atribua teclas (ex.: A/D ou setas para movimento, Space para pulo, Esc para pause).

Exemplo de leitura de ação (apenas para referência rápida):

func _process(delta):
    if Input.is_action_pressed("move_left"):
        # mover para a esquerda
        pass

Checklist de configuração ao final do capítulo