CharacterBody2D na Godot 4: O que é, Como Funciona e Quando Usar

Se existe um Node que praticamente todo desenvolvedor de jogos 2D acaba usando na Godot, esse Node é o CharacterBody2D.

Ele aparece em tutoriais de plataforma, RPG, metroidvania, jogos de ação e até em projetos mais simples. Isso faz muita gente pensar que ele serve apenas para mover um personagem. Na prática, ele faz muito mais do que isso.

A documentação explica quais métodos ele possui e como utilizá-los, mas dificilmente responde perguntas como:

Por que esse Node existe?
O que realmente acontece quando usamos move_and_slide()?
Por que precisamos de uma velocity?
Como a Godot sabe quando um personagem está no chão?
Quando vale a pena usar esse Node e quando outro Node é mais indicado?

É exatamente isso que vamos entender neste artigo da série Godot Explicado.

📌 Neste artigo você vai entender o conceito por trás do CharacterBody2D.

O objetivo não é criar um personagem passo a passo, mas compreender como esse Node pensa e por que ele é um dos mais importantes da Godot.

O que é o CharacterBody2D?

Imagine que você desenhou um personagem. Agora imagine que ele precisa andar, parar quando encontra uma parede, cair por causa da gravidade, subir uma rampa e pular uma plataforma.

Quem deveria cuidar de tudo isso?

Você poderia escrever centenas de linhas de código para calcular cada colisão, descobrir se existe chão embaixo do personagem e impedir que ele atravesse paredes.

Ou simplesmente utilizar um Node que já foi criado exatamente para resolver esse problema.

Esse Node é o CharacterBody2D.

Ele representa um corpo controlado por código. Diferente de outros corpos da física da Godot, ele não toma decisões sozinho. Quem decide para onde ele vai é o seu script. O CharacterBody2D apenas transforma essas decisões em um movimento seguro, respeitando colisões e a física do ambiente.

💡 Pense nele como um motorista.

Você diz para onde deseja ir. O CharacterBody2D escolhe a melhor forma de fazer esse movimento sem atravessar paredes ou o chão.

Por que esse Node existe?

Quando alguém começa a estudar desenvolvimento de jogos, costuma imaginar que mover um personagem é algo simples. Basta alterar sua posição, certo?

Na verdade, essa é justamente uma das tarefas mais complicadas de um jogo.

Um personagem precisa lidar com dezenas de situações diferentes ao mesmo tempo.

Não pode atravessar paredes.
Precisa parar quando encontra um obstáculo.
Pode escorregar em rampas.
Deve reconhecer quando está no chão.
Pode bater no teto durante um pulo.
Pode empurrar contra uma parede sem atravessá-la.

Resolver tudo isso manualmente exigiria bastante código e seria muito fácil criar pequenos erros difíceis de encontrar.

O CharacterBody2D existe justamente para concentrar toda essa lógica em um único Node. Assim, você pode dedicar seu tempo à jogabilidade em vez de reinventar um sistema de movimentação do zero.

Quando usar o CharacterBody2D?

Uma regra simples costuma funcionar muito bem.

Sempre que um objeto for controlado diretamente pelo jogador ou por uma inteligência artificial, o CharacterBody2D costuma ser a melhor escolha.

Alguns exemplos são:

Personagens de jogos de plataforma.
Jogadores em RPGs.
NPCs que caminham pelo cenário.
Inimigos que perseguem o jogador.
Chefes (Bosses).
Animais controlados por código.

Todos esses exemplos possuem uma característica em comum.

Eles não se movimentam porque a física decidiu. Eles se movimentam porque o jogo decidiu.

É exatamente esse tipo de comportamento que o CharacterBody2D foi criado para controlar.

🎮 Regra prática

Se o objeto precisa obedecer ao seu código, normalmente o CharacterBody2D é uma excelente escolha.

Quando NÃO usar?

Esse é um ponto que costuma gerar bastante confusão. Nem todo objeto que possui colisão deve ser um CharacterBody2D.

Na própria Godot existem Nodes criados para funções completamente diferentes.

StaticBody2D

Imagine uma parede. Ela possui colisão, mas nunca se move. Nesse caso, um CharacterBody2D seria um desperdício. O ideal é utilizar um StaticBody2D.

RigidBody2D

Agora imagine uma caixa que pode ser empurrada, cair de uma plataforma e quicar no chão. Você não quer controlar esse movimento manualmente. Quer deixar que a física faça esse trabalho. Nesse caso, o Node correto é o RigidBody2D.

Area2D

Existem situações em que você nem precisa bloquear o movimento. Às vezes basta detectar que algo entrou em determinada região. Moedas, áreas de dano, checkpoints e portas automáticas costumam utilizar um Area2D.

✔ Resumindo

CharacterBody2D → Objetos controlados por código.
RigidBody2D → Objetos controlados pela física.
StaticBody2D → Objetos que permanecem parados.
Area2D → Objetos usados apenas para detectar sobreposições.

Por que tantas pessoas confundem esses Nodes?

Todos eles podem possuir colisão. É justamente isso que costuma confundir quem está começando.

A diferença não está na colisão. A diferença está em quem controla o movimento.

Se é o seu código que decide como o objeto deve andar, pular ou parar, normalmente estamos falando de um CharacterBody2D. Se quem toma essas decisões é a simulação física da engine, provavelmente outro Node será mais adequado.

Como o CharacterBody2D "enxerga" o mundo?

Uma dúvida muito comum de quem está começando é imaginar que o CharacterBody2D consegue "ver" o cenário. Na verdade, ele não enxerga paredes, plataformas ou obstáculos como nós enxergamos.

O que ele faz é algo muito mais simples: a cada atualização da física, ele tenta se mover e verifica se encontrou alguma colisão pelo caminho.

Dependendo do que aconteceu durante esse movimento, ele guarda várias informações que podem ser consultadas pelo seu código.

É justamente dessas informações que surgem métodos como is_on_floor(), is_on_wall() e is_on_ceiling().

💡 Pense em uma pessoa andando de olhos vendados.

Ela não sabe onde estão as paredes antes de caminhar. Ela descobre isso quando tenta andar e acaba esbarrando em alguma coisa. O CharacterBody2D funciona de maneira parecida.

O conceito mais importante: velocity

Se existe uma propriedade que você verá em praticamente todo projeto feito na Godot, ela é a velocity.

Traduzindo literalmente, velocity significa velocidade. Mas ela não representa apenas "o quão rápido" um personagem está andando. Ela também indica para qual direção ele pretende se mover.

É por isso que a velocity é um Vector2. Ela precisa armazenar duas informações ao mesmo tempo:

X → movimento para a esquerda ou direita.
Y → movimento para cima ou para baixo.

Imagine que você está segurando um controle de videogame. Quando empurra o analógico para a direita, você está dizendo qual direção deseja seguir. A velocity faz exatamente esse papel dentro do CharacterBody2D.

✔ A velocity representa a intenção de movimento.

Ela não move o personagem sozinha. Ela apenas informa para onde ele gostaria de ir.

O que significa "Floor" (Chão)?

Na documentação da Godot você encontrará diversas referências à palavra Floor.

É fácil imaginar que ela significa simplesmente "o chão". Mas existe um detalhe importante.

Para o CharacterBody2D, chão não é apenas uma plataforma reta. Qualquer superfície considerada caminhável pode ser tratada como um piso.

Por exemplo:

Uma plataforma.
Uma rampa.
Uma ponte inclinada.
Uma colina.

Se a superfície estiver dentro do ângulo configurado como caminhável, o CharacterBody2D entenderá que ela é um chão.

💡 Curiosidade

É por isso que um personagem consegue subir rampas usando o CharacterBody2D sem que você precise programar esse comportamento manualmente.

E o que é uma Wall?

O conceito de Wall é bastante parecido.

Sempre que o personagem tenta se mover e encontra uma superfície lateral, o CharacterBody2D entende que houve contato com uma parede.

Essa informação pode ser utilizada para criar diversas mecânicas muito comuns em jogos.

Wall Jump.
Escalada.
Wall Slide.
Mudança de direção de inimigos.
Personagens que se agarram em paredes.

Perceba que todas essas mecânicas dependem de uma pergunta muito simples:

"O personagem está encostando em uma parede?"

O CharacterBody2D responde essa pergunta para você.

O que é Ceiling?

Da mesma forma que o Node consegue identificar o chão e as paredes, ele também sabe quando o personagem bate em uma superfície acima da cabeça.

Esse tipo de colisão recebe o nome de Ceiling.

Embora pareça um detalhe pequeno, ele é extremamente importante.

Imagine um personagem pulando dentro de uma caverna. Se ele bater a cabeça no teto, normalmente o movimento para cima deve ser interrompido.

É exatamente esse tipo de situação que o CharacterBody2D consegue detectar.

Entendendo o conceito de Collision

Toda vez que o CharacterBody2D tenta se mover, ele verifica se existe algum obstáculo no caminho. Quando isso acontece, dizemos que ocorreu uma Collision, ou seja, uma colisão.

Mas colisão não significa apenas "bater em alguma coisa". Ela também fornece informações importantes sobre o que aconteceu durante aquele movimento.

Por exemplo, a engine consegue descobrir:

Em qual direção aconteceu o impacto.
Quantas colisões ocorreram naquele movimento.
Qual objeto foi atingido.
Qual foi a superfície tocada.

Essas informações são utilizadas em efeitos de partículas, sons, inimigos inteligentes, plataformas móveis e diversas outras mecânicas.

🎯 O CharacterBody2D não apenas detecta colisões.

Ele também guarda informações sobre elas para que seu código possa tomar decisões mais inteligentes.

Como tudo isso trabalha junto?

Agora fica mais fácil entender a lógica do CharacterBody2D.

Primeiro, seu código informa qual é a velocity desejada. Depois, o CharacterBody2D tenta realizar esse movimento. Durante esse processo, ele verifica se encontrou chão, paredes, teto ou qualquer outro obstáculo. Por fim, ele armazena todas essas informações para que possam ser consultadas no próximo quadro da física.

É justamente por isso que tantos métodos desse Node começam com nomes como is_on_ ou get_. Eles simplesmente permitem acessar aquilo que o CharacterBody2D descobriu durante o último movimento.

📌 Resumindo o funcionamento

Você informa como deseja mover o personagem.
O CharacterBody2D tenta executar esse movimento.
Ele verifica todas as colisões encontradas.
Classifica essas colisões como chão, parede ou teto.
Guarda essas informações para serem usadas pelo seu código.

Agora que você já entende como o CharacterBody2D interpreta o mundo ao seu redor, vamos conhecer seus principais métodos e propriedades. Em vez de listar cada função como na documentação, vamos agrupá-las por objetivo, mostrando quando cada grupo faz sentido e como eles trabalham juntos na prática.

Os métodos do CharacterBody2D fazem muito mais sentido quando agrupados

Ao abrir a documentação do CharacterBody2D, você encontrará uma longa lista de métodos. À primeira vista ela pode até assustar.

Mas existe um detalhe interessante. A maioria desses métodos resolve problemas parecidos. Em vez de decorar dezenas de nomes, é muito mais fácil entender qual informação você precisa naquele momento. Depois basta saber qual método fornece essa resposta.

Vamos organizar esses métodos da mesma forma que você provavelmente irá utilizá-los durante o desenvolvimento de um jogo.

🚶 Métodos relacionados ao movimento

Antes de qualquer colisão acontecer, existe uma pergunta muito importante.

"Como o personagem deve se mover?"

É justamente esse grupo de métodos que responde essa necessidade.

move_and_slide()

Se existe um método que representa o CharacterBody2D, ele é o move_and_slide().

Muita gente acredita que essa função simplesmente move o personagem. Na prática, ela faz muito mais.

Move o personagem utilizando a velocity.
Detecta colisões durante o caminho.
Impede que o personagem atravesse obstáculos.
Desliza naturalmente sobre paredes e rampas.
Atualiza todas as informações usadas pelos outros métodos.

Ou seja, praticamente tudo o que acontece no CharacterBody2D começa aqui.

💡 Pense no move_and_slide() como o momento em que o personagem realmente tenta caminhar.

Até esse instante existe apenas uma intenção de movimento. É durante essa chamada que a Godot verifica o mundo ao redor e calcula o resultado final.

get_real_velocity()

Existe uma diferença entre a velocidade que você pediu e a velocidade que realmente aconteceu.

Imagine que você mandou o personagem correr para a direita. No caminho havia uma parede.

A velocidade desejada continua sendo para a direita. Mas a velocidade real foi menor porque houve uma colisão.

É exatamente isso que o método get_real_velocity() informa.

Quando isso é útil?

Animações de corrida.
Efeitos de poeira.
Câmeras dinâmicas.
Calcular velocidade real do personagem.

get_last_motion()

Depois que o personagem termina seu movimento, a Godot guarda qual foi o deslocamento realizado naquele quadro da física.

Na maioria dos projetos você dificilmente precisará utilizar esse método.

Mas ele pode ser útil quando algum sistema precisa saber exatamente quanto o personagem se moveu durante o último frame.

get_position_delta()

Esse método também está relacionado ao deslocamento.

A diferença é que ele informa quanto a posição mudou entre uma atualização da física e outra.

Embora pareça semelhante ao anterior, costuma ser utilizado em situações mais específicas, principalmente em sistemas que acompanham o movimento do personagem.

🧱 Métodos relacionados ao chão

Um personagem precisa saber quando está apoiado em alguma superfície.

Sem essa informação seria impossível impedir pulos infinitos ou reconhecer quando ele acabou de aterrissar.

É justamente para isso que existe este grupo de métodos.

is_on_floor()

Talvez seja o segundo método mais conhecido do CharacterBody2D.

Sua função é bastante simples. Responder apenas uma pergunta.

"O personagem está apoiado em um chão?"

Se a resposta for sim, esse método retorna true. Caso contrário, retorna false.

Exemplos de uso

Permitir que o personagem pule.
Trocar animação de corrida.
Iniciar animação de aterrissagem.
Tocar som ao encostar no chão.

apply_floor_snap()

Imagine que seu personagem acabou de descer uma pequena escada ou passou por uma rampa com uma leve irregularidade.

Às vezes ele pode perder o contato com o chão por apenas um instante. Visualmente isso pode causar pequenos "saltos" ou dar a impressão de que o personagem está flutuando.

É justamente esse tipo de situação que o apply_floor_snap() ajuda a resolver.

Ele tenta manter o personagem "grudado" ao chão quando isso faz sentido, evitando pequenas separações causadas pelo movimento.

Você normalmente não vai precisar chamá-lo em todos os projetos. Mas ele pode ser muito útil em jogos de plataforma ou movimentações sobre terrenos inclinados.

💡 Pense nele como alguém caminhando por uma ladeira.

Em vez de dar pequenos pulos a cada desnível do terreno, o personagem continua acompanhando a superfície de forma mais natural.

get_floor_normal()

Nem todo chão é completamente reto.

Rampas possuem uma inclinação diferente de uma plataforma plana.

O método get_floor_normal() permite descobrir a direção dessa superfície.

Embora isso pareça avançado, essa informação é muito utilizada para criar movimentações mais naturais em terrenos inclinados.

get_floor_angle()

Enquanto o método anterior informa a direção da superfície, este retorna o ângulo do chão.

Isso pode ser útil para limitar quais rampas um personagem consegue subir ou alterar a velocidade conforme a inclinação do terreno.

🧠 O mais importante não é decorar os métodos

Quem está começando costuma tentar memorizar todos os nomes da documentação.

Na prática, isso não é necessário.

O mais importante é entender qual problema você está tentando resolver. Depois disso, encontrar o método correto se torna muito mais simples.

📌 O que aprendemos nesta parte

Como o CharacterBody2D realiza o movimento.
A diferença entre velocidade desejada e velocidade real.
Como a Godot identifica quando o personagem está no chão.
Por que existe o apply_floor_snap().
Como obter informações sobre rampas e superfícies.

🧱 Métodos relacionados às paredes

Em muitos jogos, saber que o personagem encostou em uma parede é tão importante quanto saber que ele está no chão.

Essa informação permite criar desde comportamentos simples até mecânicas mais avançadas, como escaladas, wall jump e inimigos que mudam de direção quando encontram um obstáculo.

is_on_wall()

O método is_on_wall() responde uma pergunta muito simples:

"O personagem está encostando em uma parede?"

Se a resposta for sim, o método retorna true. Caso contrário, retorna false.

Embora pareça simples, essa informação é utilizada em diversos tipos de jogos.

Exemplos de uso

Permitir Wall Jump.
Criar Wall Slide.
Fazer inimigos mudarem de direção ao bater em uma parede.
Impedir que o personagem continue acelerando contra um obstáculo.

get_wall_normal()

Saber que existe uma parede nem sempre é suficiente.

Às vezes também precisamos descobrir de qual lado ela está.

É exatamente essa informação que o método get_wall_normal() fornece.

Com ela é possível identificar se o personagem colidiu com uma parede à esquerda, à direita ou até mesmo com superfícies inclinadas.

Essa informação costuma ser utilizada em sistemas de movimentação mais avançados, efeitos visuais e cálculos de ricochete.

🏠 Métodos relacionados ao teto

Quando pensamos em colisão, normalmente lembramos do chão e das paredes. Mas o teto também faz parte da movimentação.

Imagine um personagem pulando dentro de uma caverna. Se ele bater a cabeça em uma plataforma, o movimento para cima precisa ser interrompido imediatamente.

É exatamente esse tipo de situação que o CharacterBody2D consegue detectar.

is_on_ceiling()

Esse método informa se o personagem está encostando em uma superfície acima dele.

Embora não seja utilizado com tanta frequência quanto is_on_floor(), ele pode ser muito útil em diversas situações.

Alguns exemplos

Cancelar um pulo quando o personagem bate a cabeça.
Evitar que animações continuem subindo após a colisão.
Criar obstáculos que reagem quando são atingidos por baixo.

💥 Métodos relacionados às colisões

Até agora vimos métodos que respondem perguntas simples, como saber se existe chão ou parede.

Mas algumas vezes precisamos de informações mais detalhadas sobre a colisão que acabou de acontecer.

É justamente para isso que existe este grupo de métodos.

get_slide_collision_count()

Durante um único movimento, o personagem pode colidir com mais de um objeto.

Imagine um corredor estreito. Enquanto anda, o personagem pode tocar uma parede, depois outra e finalmente parar no chão.

O método get_slide_collision_count() informa quantas colisões ocorreram durante o último movimento.

get_slide_collision()

Depois de descobrir quantas colisões aconteceram, podemos acessar cada uma delas individualmente.

O método get_slide_collision() retorna informações detalhadas sobre uma colisão específica.

Esses dados incluem, por exemplo:

Qual objeto foi atingido.
Em que ponto ocorreu o impacto.
Qual era a direção da superfície.

Esse tipo de informação é muito utilizado para criar sistemas mais avançados, como partículas, efeitos sonoros, impactos personalizados e comportamentos diferentes dependendo do objeto atingido.

💡 Você provavelmente não utilizará esse método em projetos simples.

Mas ele se torna extremamente útil quando o jogo precisa reagir de maneira diferente para cada tipo de colisão.

📌 Pequenos exemplos para entender os conceitos

Os exemplos abaixo não servem para construir um personagem completo. O objetivo é apenas mostrar como esses métodos costumam aparecer no código.

Permitir um pulo apenas quando existe chão


if is_on_floor():
    velocity.y = JUMP_FORCE

Nesse caso, o personagem só poderá pular quando realmente estiver apoiado em uma superfície considerada como chão.

Detectar contato com uma parede


if is_on_wall():
    print("Encostei em uma parede.")

Esse tipo de verificação pode ser utilizado para iniciar uma animação de Wall Slide ou mudar o comportamento de um inimigo.

Cancelar um movimento ao bater no teto


if is_on_ceiling():
    velocity.y = 0

Assim que o personagem toca o teto, a velocidade vertical é interrompida, impedindo que ele continue subindo.

Descobrir se houve alguma colisão durante o movimento


if get_slide_collision_count() > 0:
    print("O personagem colidiu com algum objeto.")

Esse exemplo mostra apenas o conceito. Em projetos reais, normalmente você analisará cada colisão individualmente para decidir como o jogo deve reagir.

📖 O que todos esses exemplos têm em comum?

Perceba que nenhum deles move o personagem. Eles apenas fazem perguntas sobre o que aconteceu durante o último movimento. Essa é uma das ideias mais importantes para entender o CharacterBody2D. Primeiro ele tenta se mover. Depois você consulta as informações que ele coletou durante esse movimento.

⚠️ Erros comuns de quem está começando

O CharacterBody2D facilita bastante a movimentação de personagens, mas existem alguns erros que aparecem com muita frequência entre quem está começando a usar a Godot.

A boa notícia é que quase todos eles acontecem por causa de um pequeno mal-entendido sobre como esse Node funciona.

❌ "Meu personagem não anda."

Na maioria das vezes, o problema não está no CharacterBody2D.

Lembre-se de que ele não decide para onde deve ir. Quem faz isso é o seu código.

Se a propriedade velocity nunca recebe um valor ou se o método move_and_slide() não é chamado, o personagem continuará parado.

✔ O CharacterBody2D executa o movimento.

Mas é o seu script que diz qual movimento deve ser realizado.

❌ "Meu personagem atravessa o chão."

Esse costuma ser um dos primeiros problemas encontrados por iniciantes.

Na maioria dos casos, a causa é uma destas situações:

O CharacterBody2D não possui um CollisionShape2D.
O CollisionShape2D existe, mas nenhuma forma foi configurada.
O chão também não possui uma colisão configurada.

É importante lembrar que o CharacterBody2D não detecta imagens. Ele detecta formas de colisão.

❌ "O personagem não consegue pular."

Antes de procurar um erro no código, vale fazer uma pergunta simples.

O CharacterBody2D realmente considera que o personagem está no chão?

Grande parte dos sistemas de pulo depende de métodos como is_on_floor(). Se o personagem nunca estiver em contato com uma superfície válida, ele jamais será considerado pronto para pular.

❌ "Meu personagem fica tremendo nas rampas."

Movimentos sobre terrenos inclinados costumam exigir alguns ajustes dependendo da mecânica do jogo.

Em determinadas situações, recursos como apply_floor_snap() ajudam a manter o personagem acompanhando melhor a superfície, evitando pequenas separações que causam a sensação de "pulos" durante a caminhada.

💬 Dúvidas frequentes

O CharacterBody2D possui gravidade automaticamente?

Não.

Ele possui ferramentas para trabalhar com gravidade, mas quem decide como essa força será aplicada é o seu código. Isso permite criar jogos completamente diferentes usando o mesmo Node.

Ele serve apenas para jogos de plataforma?

Também não.

Embora seja muito conhecido por esse tipo de jogo, o CharacterBody2D pode ser utilizado em RPGs, jogos de aventura, shooters com visão superior, jogos de sobrevivência e muitos outros estilos.

O importante não é o gênero do jogo. O importante é que o movimento seja controlado pelo seu código.

Preciso decorar todos os métodos?

Não.

Na prática, poucos desenvolvedores decoram toda a documentação da Godot.

O mais importante é compreender o conceito por trás do Node. Quando você entende como ele funciona, encontrar o método certo se torna muito mais natural.

💡 Aprenda os conceitos primeiro.

Os nomes dos métodos podem ser consultados na documentação sempre que necessário. O entendimento de como o CharacterBody2D funciona é o que realmente fará diferença durante o desenvolvimento.

📌 O que você deve lembrar sobre o CharacterBody2D?

Depois de conhecer esse Node, existe uma ideia que vale a pena guardar.

O CharacterBody2D não é um sistema completo de movimentação. Ele também não é uma inteligência artificial. Muito menos um personagem pronto.

Ele é uma ferramenta criada para transformar as decisões do seu código em movimentos que respeitam as colisões do mundo do jogo.

Sempre que seu script informa uma direção e uma velocidade, o CharacterBody2D tenta executar esse movimento da forma mais segura possível. Durante esse processo, ele analisa o ambiente, identifica colisões e guarda informações que podem ser utilizadas pelo restante do jogo.

É justamente essa combinação que faz dele um dos Nodes mais utilizados da Godot.

🎯 Conclusão

À primeira vista, o CharacterBody2D pode parecer apenas um Node para mover personagens. Mas agora você sabe que ele faz muito mais do que isso.

Ele funciona como uma ponte entre o seu código e o sistema de física da Godot, permitindo criar movimentações confiáveis sem precisar calcular manualmente cada colisão.

Entender esse funcionamento é muito mais importante do que decorar métodos ou copiar trechos de código. Quando os conceitos ficam claros, escrever scripts se torna uma consequência natural.

🚀 Continue aprendendo

O CharacterBody2D raramente trabalha sozinho. Nos próximos artigos da série Godot Explicado, vamos conhecer outros Nodes que normalmente aparecem ao lado dele e entender por que cada um desempenha um papel importante na criação de um personagem.

📚 Próximos artigos da série

📖 CollisionShape2D Explicado
📖 Sprite2D Explicado
📖 Area2D Explicado
📖 RigidBody2D Explicado
📖 StaticBody2D Explicado
📖 Input Explicado
📖 Input Map Explicado
📖 Vector2 Explicado
📖 move_and_slide() Explicado
📖 Física 2D na Godot Explicada

💬 Sua opinião ajuda a melhorar esta série

O objetivo da série Godot Explicado é traduzir a documentação oficial para uma linguagem mais simples, mostrando não apenas o que cada Node faz, mas principalmente por que ele existe e quando faz sentido utilizá-lo.

Se alguma explicação ficou confusa, encontrou alguma informação que pode ser melhorada ou conhece uma maneira ainda mais fácil de entender o CharacterBody2D, deixe um comentário. Sua contribuição pode ajudar outros desenvolvedores que estão começando na Godot.