Pet no Godot 4: como criar um companheiro que segue o jogador

Um companheiro que segue o jogador no Godot é daqueles recursos que dão vida instantânea ao jogo: um cachorro, um fantasminha, um drone flutuante. E é também uma armadilha clássica de iniciante, porque a versão ingênua resulta num pet grudado no personagem, tremendo em cima dele a cada frame. Neste tutorial você vai montar um pet 2D completo no Godot 4: follow suave com distância mínima, follow com atraso estilo Zelda, desvio de obstáculos com NavigationAgent2D e uma máquina de estados com teleporte de segurança, que é o padrão usado em jogos comerciais. Todo o código usa GDScript com tipagem estática.

Montando a cena do pet

A estrutura é a mesma de qualquer personagem 2D no Godot 4:

Pet (CharacterBody2D)
├── Sprite2D
└── CollisionShape2D

Crie uma cena nova com um CharacterBody2D como raiz e renomeie para Pet. Adicione um Sprite2D com a textura do bichinho e um CollisionShape2D com um CircleShape2D pequeno. Um detalhe que evita dor de cabeça: se você não quer que o pet empurre o jogador nem trombe nele, coloque o pet numa camada de colisão própria e configure a collision_mask para colidir apenas com o cenário, não com o player.

Salve a cena como pet.tscn e instancie dentro da cena principal do jogo, como irmão do player, não como filho. Se o pet for filho do player, ele herda a transformação do pai e o follow perde o sentido.

Para o script, a referência ao jogador entra via @export, que é a forma mais direta de ligar os dois no editor:

extends CharacterBody2D

@export var player: CharacterBody2D
@export var velocidade_max: float = 160.0
@export var aceleracao: float = 800.0
@export var distancia_minima: float = 48.0

@onready var sprite: Sprite2D = $Sprite2D

Arraste o nó do player para o campo player no inspetor e a base está pronta.

Companheiro que segue o jogador no Godot: follow com distância mínima

A versão ingênua do follow é mover o pet em direção ao jogador todo frame, sem condição nenhuma. O resultado: o pet chega no destino, passa do ponto, corrige, passa de novo, e fica vibrando em cima do personagem. A solução é um limiar de distância. O pet só se move quando está longe demais, e desacelera suavemente quando entra no raio de conforto:

func _physics_process(delta: float) -> void:
    if player == null:
        return

    var distancia: float = global_position.distance_to(player.global_position)

    if distancia > distancia_minima:
        var direcao: Vector2 = global_position.direction_to(player.global_position)
        velocity = velocity.move_toward(direcao * velocidade_max, aceleracao * delta)
    else:
        velocity = velocity.move_toward(Vector2.ZERO, aceleracao * delta)

    move_and_slide()
    _atualizar_flip()


func _atualizar_flip() -> void:
    if absf(velocity.x) > 1.0:
        sprite.flip_h = velocity.x < 0.0

Três pontos importantes aqui. Primeiro, o move_toward na velocity faz o pet acelerar e frear com inércia em vez de mudar de velocidade instantaneamente, o mesmo princípio de suavização que você usa numa câmera 2D que segue o jogador. Se preferir um acabamento mais elástico, dá para trocar por velocity = velocity.lerp(direcao * velocidade_max, 1.0 - exp(-8.0 * delta)), que converge de forma exponencial e independente de framerate. Segundo, quando o pet entra no raio de distancia_minima, a velocidade não é zerada de uma vez: ela decai até Vector2.ZERO, o que elimina a parada seca. Terceiro, o flip do sprite lê a velocity real, não o input, então o bichinho sempre olha para onde está andando. O limiar de 1.0 no absf evita que ele fique virando de lado quando está praticamente parado.

Rode a cena: o pet corre atrás do jogador, freia a uma distância confortável e espera. Já é utilizável. Mas dá para ficar bem melhor.

Follow com atraso: a fila de posições estilo Zelda

O follow direto tem um comportamento meio robótico: o pet corta caminho em linha reta, sempre. Jogos como os Zelda clássicos e vários RPGs usam outro truque para os companheiros: o pet refaz o caminho exato que o jogador percorreu, só que alguns frames atrás. O efeito é o de um rastro, como se o bichinho pisasse nas pegadas do dono.

A implementação é uma fila de posições. A cada frame de física, você guarda a posição global do jogador num Array[Vector2]. Quando a fila passa de N elementos, a posição mais antiga sai da frente e vira o alvo do pet:

extends CharacterBody2D

@export var player: CharacterBody2D
@export var velocidade_max: float = 200.0
@export var frames_de_atraso: int = 25

@onready var sprite: Sprite2D = $Sprite2D

var historico: Array[Vector2] = []


func _physics_process(_delta: float) -> void:
    if player == null:
        return

    historico.push_back(player.global_position)

    if historico.size() > frames_de_atraso:
        var alvo: Vector2 = historico.pop_front()
        if global_position.distance_to(alvo) > 4.0:
            var direcao: Vector2 = global_position.direction_to(alvo)
            velocity = direcao * velocidade_max
            move_and_slide()
            if absf(velocity.x) > 1.0:
                sprite.flip_h = velocity.x < 0.0

Com frames_de_atraso = 25 e a física padrão de 60 ticks por segundo, o pet segue a posição de aproximadamente 0,4 segundo atrás. Aumente o valor para um companheiro mais preguiçoso, diminua para um mais colado. Repare que quando o jogador para, a fila para de andar naturalmente: as posições novas empilhadas são todas iguais, o alvo converge para o mesmo ponto e o pet estaciona sozinho, sem precisar de limiar de distância elaborado. O check de 4.0 pixels só evita micro tremida no destino final.

Esse padrão escala de graça: quer três pets em fila indiana? Cada um segue a fila com um atraso maior que o do anterior, tipo 25, 50 e 75 frames, todos lendo o mesmo histórico.

Uma ressalva: esse método ignora colisão com o cenário no trajeto, porque o pet anda por cima do caminho que o jogador validou. Em mapas abertos isso é perfeito. Em mapas com paredes e o pet nascendo longe do jogador, você precisa do próximo passo.

Desvio de obstáculos com NavigationAgent2D

Se o cenário tem paredes, o follow em linha reta deixa o pet preso na primeira quina. A resposta do Godot 4 para isso é a dupla NavigationRegion2D no mapa e NavigationAgent2D no pet. O funcionamento em detalhe, incluindo como assar o polígono de navegação, está no tutorial de pathfinding com NavigationAgent2D no Godot. Aqui vai a aplicação direta ao pet.

Adicione um nó NavigationAgent2D como filho do Pet e configure no inspetor path_desired_distance e target_desired_distance em torno de 8.0. O script fica assim:

extends CharacterBody2D

@export var player: CharacterBody2D
@export var velocidade_max: float = 160.0
@export var distancia_minima: float = 48.0

@onready var nav_agent: NavigationAgent2D = $NavigationAgent2D
@onready var sprite: Sprite2D = $Sprite2D


func _physics_process(_delta: float) -> void:
    if player == null:
        return

    var distancia: float = global_position.distance_to(player.global_position)
    if distancia <= distancia_minima:
        velocity = Vector2.ZERO
        return

    nav_agent.target_position = player.global_position

    if nav_agent.is_navigation_finished():
        velocity = Vector2.ZERO
    else:
        var proximo: Vector2 = nav_agent.get_next_path_position()
        var direcao: Vector2 = global_position.direction_to(proximo)
        velocity = direcao * velocidade_max
        move_and_slide()
        if absf(velocity.x) > 1.0:
            sprite.flip_h = velocity.x < 0.0

A lógica central: você atualiza target_position com a posição do jogador e, em vez de mirar nele diretamente, mira no ponto intermediário que get_next_path_position() devolve. O agente recalcula a rota conforme o alvo se move, e o pet contorna paredes sozinho. A distância mínima continua lá, cumprindo o mesmo papel de antes.

Dica de performance: setar target_position todo frame força recálculo de caminho todo frame. Para um pet, dá para atualizar o alvo a cada 0,2 segundo com um Timer e ninguém percebe a diferença.

Estados do pet: IDLE, FOLLOW e TELEPORT

Agora a estrutura que jogos reais usam de verdade. Um pet comercial não tem só "seguir": ele descansa quando o jogador está perto, segue quando afasta e, crucialmente, teleporta para perto do dono quando fica longe demais. O teleporte parece gambiarra, mas é o padrão da indústria: World of Warcraft, Torchlight e praticamente todo jogo com pet fazem isso, porque nenhum pathfinding cobre 100% dos casos de pet preso atrás de porta ou caído de plataforma.

Uma máquina de estados com enum organiza tudo:

extends CharacterBody2D

enum Estado { IDLE, FOLLOW, TELEPORT }

@export var player: CharacterBody2D
@export var velocidade_max: float = 160.0
@export var aceleracao: float = 800.0
@export var distancia_minima: float = 48.0
@export var distancia_teleporte: float = 480.0

@onready var sprite: Sprite2D = $Sprite2D

var estado: Estado = Estado.IDLE


func _physics_process(delta: float) -> void:
    if player == null:
        return

    var distancia: float = global_position.distance_to(player.global_position)
    _atualizar_estado(distancia)

    match estado:
        Estado.IDLE:
            velocity = velocity.move_toward(Vector2.ZERO, aceleracao * delta)
        Estado.FOLLOW:
            var direcao: Vector2 = global_position.direction_to(player.global_position)
            velocity = velocity.move_toward(direcao * velocidade_max, aceleracao * delta)
        Estado.TELEPORT:
            _teleportar_para_perto()
            return

    move_and_slide()
    if absf(velocity.x) > 1.0:
        sprite.flip_h = velocity.x < 0.0


func _atualizar_estado(distancia: float) -> void:
    if distancia > distancia_teleporte:
        estado = Estado.TELEPORT
    elif distancia > distancia_minima:
        estado = Estado.FOLLOW
    else:
        estado = Estado.IDLE


func _teleportar_para_perto() -> void:
    var deslocamento: Vector2 = Vector2(randf_range(-32.0, 32.0), randf_range(-32.0, 32.0))
    global_position = player.global_position + deslocamento
    velocity = Vector2.ZERO
    estado = Estado.IDLE

O _atualizar_estado centraliza as transições em um lugar só, e o match executa o comportamento do estado atual. O teleporte solta o pet num ponto aleatório num raio de 32 pixels ao redor do jogador, para não aparecer sempre exatamente em cima dele. Dois refinamentos que valem a pena em produção: só teleportar quando o pet está fora da tela, checando com um nó VisibleOnScreenNotifier2D, e tocar um efeitinho de fumaça ou partícula no destino para disfarçar o pulo.

Essa estrutura de enum é o esqueleto para qualquer evolução. Companheiro de combate? Adicione Estado.ATTACK e uma Area2D de detecção de inimigos. Pet que dorme? Estado.SLEEP depois de X segundos parado.

Bônus: pet que interage com o mundo

Um toque rápido que transforma o pet de enfeite em mecânica: fazer ele coletar itens próximos. Adicione uma Area2D chamada AlcanceColeta como filha do pet, com um CircleShape2D maior que a colisão do corpo, e conecte o sinal area_entered:

func _on_alcance_coleta_area_entered(area: Area2D) -> void:
    if area.is_in_group("coletaveis"):
        area.queue_free()
        # aqui voce soma a moeda/item no inventario do jogador

Basta colocar as moedas e itens do jogo no grupo coletaveis e o pet vira um aspirador ambulante, um quality of life que jogadores adoram. Outra variação comum: em vez de coletar, o pet corre até segredos próximos e late, apontando paredes falsas ou baús escondidos. A mesma Area2D, detectando um grupo segredos, trocando o alvo do follow temporariamente.

Resumo e próximos passos

Você montou quatro camadas de um companheiro 2D: follow com distância mínima para o movimento básico sem tremida, fila de posições para o rastro estilo Zelda, NavigationAgent2D para mapas com paredes e uma máquina de estados com teleporte de segurança, que é o que separa protótipo de jogo publicável. Misture as camadas conforme o seu jogo pede: num mapa aberto, a fila de posições sozinha resolve; num dungeon crawler, navegação mais teleporte é o combo certo.

Se você está começando na engine e quer entender o panorama antes de se aprofundar, veja o guia sobre vale a pena aprender Godot. E se quiser levar o pet para o próximo nível, o caminho natural é dar utilidade de combate a ele: detecção de inimigos, um estado de ataque e cooldowns. A base de estados que você acabou de escrever já aguenta tudo isso.