Criando o Jogador: Movimento e Animação 🏃‍♂️✨

Bem-vindos ao terceiro módulo do nosso curso de Fundamentos do Godot! 🎉 Neste módulo, vamos colocar as mãos na massa e começar a construir o nosso primeiro jogo 2D. A jornada começa com o coração do seu game: o jogador.

Nesta aula, você aprenderá a criar o personagem principal, configurar seu movimento responsivo e dar vida a ele através de animações dinâmicas. Usaremos as melhores práticas e recursos recomendados pela documentação oficial do Godot para garantir um código limpo e eficiente.

1. Introdução: Dando Vida ao Nosso Herói 🦸‍♀️

O jogador é a sua ponte com o mundo do jogo. Ele precisa se mover de forma fluida e reagir aos comandos do usuário de maneira intuitiva. Para isso, o Godot nos oferece o nó CharacterBody2D, a escolha ideal para personagens que precisam de controle direto e colisões robustas.

Nesta aula, vamos cobrir:

🏗️ A criação da cena do jogador com os nós essenciais.
💨 A implementação do movimento horizontal e vertical (pulo, gravidade).
🎨 A configuração de animações idle (parado) e run (correndo).
🔄 A integração perfeita entre movimento e animação.

Vamos começar!

2. Configurando a Cena do Jogador 🛠️

Primeiro, precisamos criar uma nova cena para o nosso jogador.

2.1. Escolhendo o Nó Raiz: `CharacterBody2D`

O CharacterBody2D é o nó mais adequado para um personagem que precisa ser controlado pelo jogador e interagir com o ambiente através de colisões. Ele lida com a detecção de colisões e a resolução de forma automática usando o método move_and_slide().

Crie uma Nova Cena: No painel "Scene", clique em "New Scene" e depois em "Other Node".
Selecione CharacterBody2D: Busque por CharacterBody2D e clique em "Create".
Renomeie: Renomeie o nó raiz para Player.
Salve a Cena: Salve a cena em res://Scenes/Player.tscn (ou em uma pasta Player dentro de Scenes).

2.2. Adicionando Componentes Visuais e de Colisão

Um CharacterBody2D precisa de dois nós filhos principais para funcionar corretamente:

Sprite2D: Para exibir a textura do nosso jogador (a imagem).
CollisionShape2D: Para definir a área de colisão do jogador.

Adicione Sprite2D: Selecione o nó Player, clique no + e adicione um Sprite2D como filho.
- Textura: Arraste a textura do seu jogador (ex: player_sheet.png) para a propriedade Texture no Inspetor.
- Animação (se for spritesheet): Se sua textura for uma spritesheet (várias frames em uma imagem), configure Hframes e Vframes para dividir a imagem em células. Por exemplo, se tiver 8 frames horizontais e 1 vertical, defina Hframes = 8 e Vframes = 1.
Adicione CollisionShape2D: Selecione o nó Player, clique no + e adicione um CollisionShape2D como filho.
- Forma: No Inspetor, na propriedade Shape, clique em <empty> e escolha RectangleShape2D ou CapsuleShape2D (geralmente melhor para personagens).
- Ajuste o Tamanho: Redimensione a forma de colisão para que ela envolva seu personagem de forma adequada. Você pode fazer isso diretamente no editor 2D.

2.3. Configurando o `AnimationPlayer`

Para dar vida ao nosso jogador, usaremos o nó AnimationPlayer.

Adicione AnimationPlayer: Selecione o nó Player, clique no + e adicione um AnimationPlayer como filho.
Crie Animações:
- Com o AnimationPlayer selecionado, vá para o painel "Animation" na parte inferior do editor.
- Clique em "Animation" -> "New" e crie uma animação chamada idle.
- Clique em "Animation" -> "New" novamente e crie uma animação chamada run.
- (Opcional) Crie jump ou outras animações conforme necessário.
Configurando a Animação idle:
- Selecione a animação idle.
- Selecione o nó Sprite2D.
- No Inspetor, encontre a propriedade Frame. Clique na chave ao lado dela (🔑) para criar uma nova faixa (track).
- Defina o Frame para a imagem que representa o estado parado.
- Clique na chave novamente para salvar o valor no tempo 0.
- Para animações com várias frames: Adicione mais keyframes em diferentes pontos da linha do tempo, alterando o valor de Frame para cada frame da animação idle.
- Ajuste a duração da animação e o "Loop Mode" (geralmente "Loop" para idle e run).
Configurando a Animação run:
- Repita o processo para a animação run, selecionando as frames correspondentes ao movimento de corrida.

Dica: A documentação oficial do Godot tem um excelente guia sobre AnimationPlayer e Sprite2D para animação: Godot Docs: 2D Sprite Animation

3. Implementando o Movimento e a Lógica do Jogo (GDScript) 💻

Agora é hora de dar funcionalidade ao nosso jogador com um script GDScript.

3.1. Anexando o Script

Selecione o nó Player.
Clique no ícone de "Attach Script" (parece um pergaminho com um + verde) no Inspetor.
Mantenha as configurações padrão (GDScript, Player.gd, CharacterBody2D como modelo) e clique em "Create".

3.2. Código Base para Movimento e Animação

Vamos adicionar o código para controlar o movimento horizontal, a gravidade, o pulo e a lógica de animação.

# Player.gd
extends CharacterBody2D
 
@export var speed: float = 150.0 # Velocidade de movimento horizontal
@export var jump_velocity: float = -400.0 # Força do pulo
@export var gravity: float = 980.0 # Gravidade (pixels/segundo^2)
 
@onready var sprite_2d: Sprite2D = $Sprite2D
@onready var animation_player: AnimationPlayer = $AnimationPlayer
 
func _physics_process(delta: float) -> void:
	# 1. Aplicar Gravidade
	if not is_on_floor():
		velocity.y += gravity * delta
 
	# 2. Lidar com Pulo
	if Input.is_action_just_pressed("jump") and is_on_floor():
		velocity.y = jump_velocity
 
	# 3. Lidar com Movimento Horizontal
	var input_direction: Vector2 = Input.get_vector("move_left", "move_right", "ui_up", "ui_down")
	# Usamos ui_up/down no get_vector, mas só nos importamos com o x para movimento horizontal.
	# Godot 4: Input.get_vector(left, right, up, down)
	
	if input_direction.x != 0:
		velocity.x = input_direction.x * speed
	else:
		velocity.x = move_toward(velocity.x, 0, speed * delta * 2) # Desaceleração suave
 
	# 4. Mover o Personagem
	move_and_slide()
 
	# 5. Lógica de Animação
	update_animation()
 
func update_animation() -> void:
	if not is_on_floor():
		# Exemplo: Animação de pulo (se você tiver uma)
		# animation_player.play("jump")
		pass # Por enquanto, não fazemos nada no ar
	elif velocity.x != 0:
		animation_player.play("run")
		# Virar o sprite na direção do movimento
		sprite_2d.flip_h = velocity.x < 0
	else:
		animation_player.play("idle")

3.3. Entendendo o Código 🧠

@export var: Permite que você ajuste essas variáveis (velocidade, gravidade, etc.) diretamente no Inspetor do Godot, sem precisar editar o código. Muito útil para balanceamento de jogo!
@onready var: Garante que os nós Sprite2D e AnimationPlayer sejam referenciados apenas quando o nó Player estiver pronto na árvore de cena, evitando erros.
_physics_process(delta: float): Esta função é chamada a cada frame da física (geralmente 60 vezes por segundo), ideal para lógica de movimento e colisões. delta é o tempo decorrido desde o último frame, essencial para movimentos consistentes em diferentes taxas de quadros.
is_on_floor(): Uma função embutida do CharacterBody2D que retorna true se o personagem estiver colidindo com o chão.
Input.is_action_just_pressed("jump"): Verifica se a ação "jump" (padrão Spacebar no Godot) foi pressionada neste frame.
Input.get_vector("move_left", "move_right", "ui_up", "ui_down"): Uma maneira conveniente de obter a direção de entrada como um Vector2. move_left e move_right são ações de entrada que você pode configurar (veja abaixo).
velocity: Uma propriedade do CharacterBody2D que representa a velocidade atual do corpo.
move_and_slide(): A função mais importante para CharacterBody2D. Ela move o corpo usando sua velocity e lida com colisões, deslizando ao longo das superfícies.
update_animation(): Uma função auxiliar que criamos para gerenciar qual animação deve ser reproduzida com base no estado do jogador (parado, correndo, pulando).
sprite_2d.flip_h = velocity.x < 0: Vira horizontalmente o sprite se o jogador estiver se movendo para a esquerda, garantindo que ele sempre olhe na direção do movimento.

3.4. Configurando as Ações de Entrada 🎮

Para que Input.get_vector() funcione, precisamos garantir que as ações "move_left" e "move_right" estejam configuradas no Godot.

Vá em Project -> Project Settings...
Selecione a aba Input Map.
No campo "Action", digite move_left e clique em "Add".
- Clique no + ao lado de move_left e adicione uma "Physical Key" (ex: seta para a esquerda ou A).
Repita para move_right (ex: seta para a direita ou D).
A ação jump já deve existir por padrão (associada ao Spacebar).

4. Exercícios e Desafios (Projeto) 🚀

É hora de colocar em prática o que aprendemos! Siga os passos abaixo para construir seu jogador.

Tarefas Essenciais:

Desafios Extras (Opcional):

Animação de Pulo: Crie uma animação jump no AnimationPlayer e adicione lógica ao update_animation() para reproduzi-la quando o jogador não estiver no chão.
Ataque Simples: Adicione uma nova ação de entrada "attack" e uma animação "attack". Implemente a lógica para reproduzir a animação de ataque quando a tecla for pressionada.
Câmera Seguidora: Adicione um nó Camera2D como filho do Player e configure-o para seguir o jogador suavemente (drag_horizontal_enabled, drag_vertical_enabled, smoothing_enabled).

5. Resumo e Próximos Passos 🚀

Parabéns! Você acaba de criar a base para o seu personagem principal. Nesta aula, você aprendeu a:

Estruturar a cena do seu jogador usando CharacterBody2D.
Dar vida ao seu personagem com Sprite2D e AnimationPlayer.
Programar o movimento, pulo e gravidade usando GDScript e move_and_slide().
Integrar perfeitamente o movimento com as animações.

O jogador é agora uma entidade viva no seu jogo! No próximo módulo, vamos focar em construir o mundo ao redor do nosso jogador, adicionando plataformas, cenários e talvez até alguns inimigos simples.

Fique atento e continue praticando! A cada passo, seu jogo ganha mais forma e vida. 🎮✨

Fundamentos do Godot: Desenvolvimento de games para iniciantes

Criando o Jogador: Movimento e Animação