Como Criar IA no Godot 4: Um Guia Passo a Passo (2026)

Pergunte "como criar IA no Godot" e você vai receber duas respostas completamente diferentes dependendo do que você quis dizer, porque a mesma expressão cobre dois trabalhos totalmente distintos.

Um e a IA clássica de jogos: o goblin que te avista, te persegue ao redor de uma coluna e ataca quando chega perto. Isso e lógica de decisão mais movimento, e e o pao com manteiga do desenvolvimento de jogos há décadas.

O outro e a IA com modelo de linguagem: o dono de loja com quem você pode conversar de verdade com suas próprias palavras, que responde mantendo o personagem. Isso e algo novo, envia texto para um modelo pela internet e resolve um problema diferente.

A maioria dos jogos precisa do primeiro tipo para quase tudo e recorre ao segundo apenas para um punhado de personagens faladeiros. Este guia cobre os dois, em ordem, com GDScript pronto para colar no Godot 4. No final, ele mostra como uma engine nativa de IA escreve esse código para você e o testa rodando o jogo, que e exatamente a parte que os tutoriais costumam pular.

Parte 1: IA Clássica de Jogos (o tipo que você mais vai precisar)

Quando um designer diz que um inimigo "tem uma boa IA", ele quase nunca quer dizer que o inimigo roda uma rede neural. Quer dizer que ele toma decisões coerentes: percebe o jogador, escolhe uma ação razoável e muda de ideia quando a situação muda. Em código, isso e uma máquina de estado.

Uma máquina de estado e uma lista de estados (idle, patrol, chase, attack) e as regras para transitar entre eles. E o padrão mais útil em IA de jogos, e o Godot 4 tem tudo que você precisa para construir uma.

Passo 1: Configure a cena do inimigo

Crie uma nova cena com um CharacterBody2D como raiz (use CharacterBody3D para 3D, a lógica e idêntica). Adicione estes filhos:

• Um Sprite2D ou AnimatedSprite2D para poder visualiza-lo
• Um CollisionShape2D para que ele tenha um corpo
• Um Area2D com seu próprio CollisionShape2D, maior que o inimigo, para servir como raio de detecção
• Um NavigationAgent2D para que o inimigo possa contornar paredes

O Area2D de detecção e como o inimigo "enxerga". Quando o jogador entra nele, o inimigo sabe que deve reagir.

Passo 2: Escreva a máquina de estado

Anexe este script a raiz. Ele define quatro estados e alterna entre eles com base na distância até o jogador.

extends CharacterBody2D

enum State { IDLE, PATROL, CHASE, ATTACK }

@export var move_speed: float = 120.0
@export var attack_range: float = 40.0

var state: State = State.IDLE
var player: Node2D = null

@onready var nav: NavigationAgent2D = $NavigationAgent2D

func _physics_process(_delta: float) -> void:
	match state:
		State.IDLE:
			velocity = Vector2.ZERO
			if player != null:
				state = State.CHASE
		State.CHASE:
			_chase()
		State.ATTACK:
			velocity = Vector2.ZERO
			_attack()
	move_and_slide()

func _chase() -> void:
	if player == null:
		state = State.IDLE
		return
	var distance := global_position.distance_to(player.global_position)
	if distance <= attack_range:
		state = State.ATTACK
		return
	nav.target_position = player.global_position
	var next_point := nav.get_next_path_position()
	velocity = global_position.direction_to(next_point) * move_speed

func _attack() -> void:
	# reproduza animacao de ataque, cause dano, depois volte para chase
	if player != null and global_position.distance_to(player.global_position) > attack_range:
		state = State.CHASE

# conecte estes sinais do Area2D de deteccao no editor
func _on_detection_area_body_entered(body: Node2D) -> void:
	if body.is_in_group("player"):
		player = body

func _on_detection_area_body_exited(body: Node2D) -> void:
	if body.is_in_group("player"):
		player = null
		state = State.IDLE

Dois fatores fazem isso funcionar. A instrução match no state mantém cada comportamento isolado, de modo que adicionar um novo estado depois não embaralha os outros. E os sinais body-entered e body-exited do Area2D (conectados na aba Node do editor) alternam o inimigo entre ciente e alheio ao jogador sem precisar verificar a cada frame.

Coloque seu jogador no grupo player (selecione-o, aba Node, Groups, adicione "player") para que a verificação de detecção o encontre.

Passo 3: Adicione pathfinding para que o inimigo contorne paredes

O script acima usa NavigationAgent2D, mas o agente precisa de um mapa de onde fica o chão. Adicione um NavigationRegion2D a sua cena de nível e dê a ele um NavigationPolygon que cubra o terreno transitável, com buracos recortados para as paredes. O Godot roteia o agente por ele automaticamente.

A ideia central: seu script de IA decide o destino (nav.target_position = player.global_position), e o sistema de navegação decide o trajeto. Você nunca precisa escrever a matemática de pathfinding. get_next_path_position() entrega o próximo ponto de passagem, e você se move em direção a ele.

Em 3D, o fluxo e o mesmo com NavigationRegion3D e NavigationAgent3D. Você gera uma malha de navegação sobre a geometria do nível em vez de desenhar um poligono, mas o padrão do script não muda.

Passo 4: Adicione linha de visão (opcional, mas vale a pena)

Só o raio de detecção faz o inimigo enxergar através das paredes. Para corrigir isso, adicione um RayCast2D e verifique se o raio até o jogador bate em alguma coisa antes de iniciar a perseguição.

func can_see_player() -> bool:
	if player == null:
		return false
	$RayCast2D.target_position = to_local(player.global_position)
	$RayCast2D.force_raycast_update()
	if $RayCast2D.is_colliding():
		return $RayCast2D.get_collider() == player
	return true

Condicione a transição IDLE -> CHASE a can_see_player() e o inimigo passa a precisar de uma linha de visão real, o que parece muito mais justo e inteligente para o jogador.

Isso e uma IA de inimigo completa e pronta para lançar: ela detecta, persegue contornando obstáculos, respeita paredes para visão e ataca dentro do alcance. Rotas de patrulha, fuga com pouca vida e táticas em grupo são apenas mais estados e mais transições no mesmo esqueleto.

Parte 2: IA com LLM (NPCs que conversam)

O segundo significado de "IA no Godot" e um NPC com quem você pode conversar livremente. Este e um mecanismo completamente diferente. Em vez de uma máquina de estado, você envia texto para um modelo de linguagem e transforma a resposta em diálogo.

O Godot 4 não tem um modelo embutido, mas tem HTTPRequest, que e tudo que você precisa para chamar um.

Passo 1: Envie uma mensagem para um modelo

Adicione um no HTTPRequest e um script que envia a mensagem do jogador junto com uma breve descrição do personagem para uma API de modelo.

extends Node

@onready var http: HTTPRequest = $HTTPRequest

const ENDPOINT := "https://api.example-model.com/v1/chat"
const API_KEY := "your-key-here" # nao inclua isso em builds publicadas

func ask_npc(player_message: String) -> void:
	var headers := [
		"Content-Type: application/json",
		"Authorization: Bearer " + API_KEY,
	]
	var body := {
		"system": "Voce e Bram, um ferreiro de aldeia cansado. Mantenha o personagem. Responda em ate duas frases.",
		"message": player_message,
	}
	http.request(ENDPOINT, headers, HTTPClient.METHOD_POST, JSON.stringify(body))

func _ready() -> void:
	http.request_completed.connect(_on_response)

func _on_response(_result, _code, _headers, response_body: PackedByteArray) -> void:
	var data = JSON.parse_string(response_body.get_string_from_utf8())
	var reply: String = data.get("reply", "...")
	show_dialogue(reply)

func show_dialogue(text: String) -> void:
	# insira o texto na sua interface de dialogo
	print(text)

Passo 2: Dê memória ao NPC

Um modelo sem memória reinicia cada conversa do zero. Para fazer o ferreiro se lembrar de você, mantenha uma lista das trocas anteriores e inclua um breve resumo em cada requisição. Armazene isso no NPC, acrescente cada turno e, quando ficar longo, peça ao modelo que resuma os turnos antigos em uma ou duas frases para que o prompt não cresça indefinidamente.

Passo 3: Entenda as desvantagens antes de se comprometer

O diálogo com LLM e poderoso, mas não e de graça. Cada mensagem custa dinheiro, leva um momento para retornar pela rede e exige conexão com a internet, o que significa que não funciona offline. Ele também pode sair do personagem ou do tópico se suas instruções forem vagas.

E por isso que o padrão realista e híbrido: IA clássica para comportamento de todos os NPCs, e diálogo com LLM reservado para poucos personagens nos quais a conversa aberta e o ponto central. Se você quiser a versão completa disso, incluindo prompts de personalidade, sistemas de memória e como manter os personagens ancorados no estado do jogo, escrevemos um guia dedicado sobre como criar NPCs com IA, memória e personalidade no Godot 4. O gerador de NPCs com IA e a forma mais rápida de montar um.

O caminho mais rápido: deixe uma engine nativa de IA escrever para você

Tudo acima e o caminho manual, e vale a pena entender porque ensina os padrões. Mas escrever, conectar e depurar uma máquina de estado a mão e lento, e os bugs só aparecem quando você roda o jogo.

E aqui que uma engine nativa de IA muda o trabalho. O Summer Engine e compatível com Godot 4 e integra o assistente de IA diretamente no editor, então ele não apenas sugere código em um painel lateral. Ele lê a árvore de cena, escreve o GDScript, conecta o NavigationAgent e o Area2D de detecção, roda o jogo, lê os erros de execução e os corrige. Você descreve o comportamento em linguagem natural:

Faça o esqueleto patrulhar entre dois pontos, perseguir o jogador quando o avistar e atacar quando estiver perto. Use navegação para que ele contorne as paredes.

Ele produz a mesma máquina de estado que você viu acima, anexada a uma cena de inimigo real, e depois pressiona play para confirmar que o esqueleto realmente persegue em vez de bater na parede. Esse ciclo de escrever, rodar e ler e a diferença entre uma IA que entrega um trecho de código e uma que entrega um comportamento funcionando, porque a maioria dos bugs de IA em jogos são bugs de execução que uma janela de chat nunca vê.

Para ser honesto: o plano gratuito cobre construção, teste e exportação, o que e suficiente para aprender os padrões e lançar um primeiro protótipo com IA. Os planos pagos oferecem mais uso e modelos mais potentes para quem trabalha diariamente. Se você quiser comparar as opções de IA em um fluxo de trabalho com Godot, a página Godot AI apresenta todas elas, e a biblioteca de templates oferece projetos iniciais com inimigos já configurados para que você edite o comportamento em vez de construir do zero.

Por onde começar

Se você esta aprendendo, construa a Parte 1 a mão. Uma máquina de estado e um NavigationAgent vão atender quase todos os inimigos, companheiros e criaturas que você vai precisar, e o padrão escala de um único goblin até um encontro de combate completo.

Recorra a Parte 2 apenas quando a conversa aberta for genuinamente o ponto central de um personagem, e limite-a a poucos NPCs para que custo e latência permaneçam viáveis.

E quando você quiser avançar mais rápido do que digitar cada estado a mão, descreva o comportamento e deixe a engine construir e testar para você. Os padrões deste guia são exatamente o que ela escreve, então entende-los faz de você um diretor melhor, qualquer que seja o caminho que escolher.