CRIANDO UM
PLAYER BÁSICO

A base profissional para personagens no Godot 4!

O QUE É UM NODE?

A menor engrenagem do seu jogo

CONCEITO BASE

O Tijolo de Lego

No Godot, tudo é construído usando Nodes. Eles são blocos individuais que fazem apenas uma coisa específica, mas fazem com perfeição.

Existem centenas de Nodes prontos para tudo:

Camera

Camera2D

Filma o cenário

Audio

AudioPlayer

Toca sons e músicas

Light

PointLight2D

Ilumina o jogo

O CONCEITO DE SCENE

Agrupando peças para formar um Ator

Um Player não é feito de um Node só! Ele é complexo: precisa bater nas paredes, ter um desenho na tela e rodar vários scripts de lógica.

🎬 A Scene (Cena)

Quando conectamos vários Nodes diferentes juntos para formar um objeto completo (como nosso Player, uma Moeda ou um Inimigo), chamamos esse agrupamento de Scene.

A Receita da Scene do Player

Corpo Físico (Pai)
Colisão
Visual
Lógica

A BASE: CHARACTERBODY2D

O Node Pai que sustenta o nosso Player

Para iniciar nossa Scene do Player, precisamos escolher o Node raiz (O Pai). Ele ditará qual é a característica primária deste objeto.

CharacterBody2D

CharacterBody2D

Este Node foi feito especificamente para objetos móveis controlados por nós! Ele já vem com uma variável mágica de física chamada velocity e sabe deslizar em paredes.

Scene
Player

O AVISO DE FÍSICA

O corpo precisa de um formato!

Ao criar o CharacterBody2D, o Godot exibe um sinal de Warning (Aviso) amarelo na árvore.

Por que o erro aparece?

O CharacterBody entende física, mas ele não tem formato! Ele não sabe se o personagem é grande, pequeno, quadrado ou redondo.

Scene
Player

A CAIXA DE COLISÃO

A silhueta física do personagem

CollisionShape2D

Ao adicionar este Node como filho e escolher seu Shape (como RectangleShape2D) no Inspector, o erro some. Ele resolve a física em 2 níveis:

1 Impede que CharacterBodies entrem uns nos outros (sobreposição).
2 Gera limites perfeitos para esbarrar no mundo (chão, paredes).
Scene
Player
CollisionShape2D
Inspector
CollisionShape2D
Shape
[RectangleShape2D] ▼

O VISUAL DO JOGO

Adicionando gráficos e movimento de arte ao Ator

Nosso Player tem corpo e esbarra nas paredes, mas é invisível! Precisamos adicionar Nodes focados no aspecto visual.

Sprite2D

Sprite2D

É a imagem na tela! Ele segura o arquivo PNG (Spritesheet) que contém os desenhos cortados do personagem.

AnimationPlayer

AnimationPlayer

É o Diretor de Cinema. Nós criamos trilhas para animar as propriedades do Sprite2D ao longo do tempo.

FATIANDO A IMAGEM

Ensinando o Sprite2D a ler arquivos de animação

Um jogo não usa apenas 1 arquivo de imagem. O artista cria arquivos separados como idle.png e run_side.png.

Texture É aqui que arrastamos o arquivo da animação (PNG).
Hframes Fatias Horizontais: Corta o arquivo em colunas (ex: 4 quadros).
Frame Define qual o pedaço numérico da fatia estamos vendo agora (0, 1, 2...).
Inspector - Sprite2D
Texture run_side.png
Animation
Hframes 4
Vframes 1
Frame 0

O TRUQUE DO ESPELHO

Economizando desenhos usando Flip H

Geralmente, o artista desenha o boneco correndo apenas para a Direita (run_side.png). Ele não precisa desenhar um arquivo novo para a esquerda!

Flip H (Inversão Horizontal)

O Sprite2D tem uma propriedade chamada Flip H no grupo Offset. Ao marcar esta caixa, o Godot espelha a imagem instantaneamente!

Flip H: OFF

Flip H: ON

O PAINEL DE ANIMAÇÃO

O Diretor que controla as propriedades

Agora sabemos que uma animação não é apenas "mudar o frame". Nós criamos as trilhas de animação gravando chaves múltiplas no AnimationPlayer!

1. A Chave da Imagem Na trilha run_side, gravamos o Texture e o Hframes = 4.
2. A Chave da Direção Gravamos o Flip H: Desligado na direita, Ligado na esquerda.
3. A Chave do Tempo Aí sim gravamos a troca do Frame (0, 1, 2) e ativamos o 🔁 LOOP!
Animation
Animation: running_left ▼ 🕒 0.600 🔁 LOOPED
Sprite2D: texture
Sprite2D: flip_h
Sprite2D: frame

SISTEMA DE COMPONENTES

Dividindo a lógica usando Nodes Básicos

❌ O Código Monstro

A estrutura física, visual e as animações estão prontas. Colocar todo o código de andar e animar apenas no Player.gd gera um arquivo gigante e difícil de dar manutenção!

✅ A Solução: Componentes (Nodes)

Nós usamos Nodes Vazios e anexamos scripts específicos neles. Isolando a lógica, podemos reutilizar essas peças num Inimigo no futuro!

InputComponent Lógica de ouvir o teclado.
MovementComponent Lógica de andar na física.
VisualComponent Lógica de tocar a animação certa.

MAPA DE BOTÕES
(INPUT MAP)

Ensinando o teclado antes de programar

Antes do código do Input existir, ensinamos ao Godot o que vamos apertar: Project > Project Settings > Input Map.

Ações Virtuais

Em vez de programar "Se apertar D", programamos "Ação ui_right". O Input Map vincula a tecla física D a essa ação ui_right!

Project Settings
General
Input Map
ui_up
W (Physical) +

ENTENDENDO O VECTOR2

A bússola matemática do Godot

Ouviremos nossos botões usando o Vector2, que armazena duas informações de Eixo (X e Y):

X é Horizontal (+ Direita, - Esquerda).
Y é Vertical (+ Baixo, - Cima).
A direção combinada aponta para onde o personagem vai.
+ X
+ Y
- Y
- X

CRIANDO O
INPUT COMPONENT

Adicionando um Node Básico e seu script

O Node Básico

Usamos este Node (que é invisível e não tem física) apenas para guardar a lógica. Renomeamos para InputComponent e adicionamos um Script. Ele será o ouvido do jogo!

W
A
S
D
InputComponent.gd
●●●
extends Node

func get_direction() -> Vector2:
    var direction = Input.get_vector(
        "ui_left",   # Esquerda (A)
        "ui_right",  # Direita (D)
        "ui_up",     # Cima (W)
        "ui_down"    # Baixo (S)
    )
    return direction

CRIANDO O
MOVEMENT COMPONENT

Adicionando as pernas da nossa arquitetura

Criamos outro Node básico e o nomeamos MovementComponent. A especialidade dele é pegar uma direção vetorial e andar usando a física.

Usamos @export var body para criarmos uma gaveta no Inspector. Assim, o próprio Player (CharacterBody2D) é arrastado pra lá, e o Node sabe QUEM ele vai empurrar.

MovementComponent.gd
●●●
extends Node

@export var body: CharacterBody2D
@export var speed: int = 200

func move(direction: Vector2):
    if body:
        # Direção * Velocidade
        body.velocity = direction * speed
        body.move_and_slide()
Inspector
MovementComponent.gd
Body Assign...
Speed 200

A FÍSICA NO CÓDIGO

Dissecando o Movement Component

Acabamos de usar dois conceitos absurdamente mágicos do CharacterBody2D que precisamos entender a fundo:

body.velocity

Nós não precisamos declarar essa variável! A velocity já existe em todo CharacterBody. Ela guarda a inércia, informando matematicamente ao motor do jogo a direção e a força que o boneco está indo.

body.move_and_slide()

Sem essa linha, o boneco não anda! É o "Execute" da física. Ela pega a velocity e empurra o corpo. Se o corpo bater na quina de uma parede, essa função desliza ele lindamente, evitando que o player "trave" nas quinas!

velocity

JUNTANDO TUDO
NO PAI (PLAYER)

Testando o movimento antes da arte

A Orquestração

Já temos Input e Movement. O Pai (Player.gd) agora atua como um maestro para ligar os ouvidos nas pernas, e garantir que a física funcione pura e perfeitamente!

@onready → Puxa o nó de Input e de Movimento quando a cena carrega.
Player.gd
●●●
extends CharacterBody2D

@onready var input_comp = $InputComponent
@onready var movement_comp = $MovementComponent

func _physics_process(delta: float) -> void:
    
    # 1. Pega direção das teclas com os Ouvidos
    var direction = input_comp.get_direction()
    
    # 2. As Pernas lidam com a física
    movement_comp.move(direction)

CRIANDO O
VISUAL COMPONENT

Adicionando vida ao personagem que já se move!

Nosso bloco já se move perfeitamente. Agora, criamos o VisualComponent para tocar as animações por cima dessa movimentação física.

Autônomo → Ele tem 3 gavetas no Inspector para conectarmos as dependências. O Player nem precisa saber que a animação existe!
VisualComponent.gd
●●●
extends Node
class_name VisualComponent

@export var animation : AnimationPlayer
@export var body : CharacterBody2D
@export var input_component : Node

var last_direction : Vector2 = Vector2.DOWN

func _process(delta: float):
    if(body and animation and input_component.get_direction() != Vector2.ZERO):
        last_direction = body.velocity
        play("running")
    else:
        play("idle")
        
func play(type : String):
    var anim = type + "_"
    if(abs(last_direction.x) >= abs(last_direction.y)):
        if(last_direction.x > 0): anim += "right"
        else: anim += "left"
    else:
        if(last_direction.y > 0): anim += "down"
        else: anim += "up"
        
    animation.play(anim)
Inspector
VisualComponent.gd
Animation Assign...
Body Assign...
Input Assign...

A ÁRVORE COMPLETA

A interface final com todas as peças montadas!

A Obra de Arte Final

Nós construímos o corpo e física. Adicionamos a arte. E agora, acoplamos nossos 3 Componentes Modulares de lógica puros. Esta é uma arquitetura profissional!

Olhe para o Inspector: Você só precisa arrastar os Nodes corretos para dentro das gavetas do `@export`. Nenhum componente amarra o outro por código sujo!

Scene
Player
CollisionShape2D
Sprite2D
AnimationPlayer
InputComponent
MovementComponent
VisualComponent