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

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

Um e a IA classica de jogos: o goblin que te avista, te persegue ao redor de uma coluna e ataca quando chega perto. Isso e logica de decisao mais movimento, e e o pao com manteiga do desenvolvimento de jogos ha decadas.

O outro e a IA com modelo de linguagem: o dono de loja com quem voce pode conversar de verdade com suas proprias 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 codigo para voce e o testa rodando o jogo, que e exatamente a parte que os tutoriais costumam pular.

Parte 1: IA Classica de Jogos (o tipo que voce 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 decisoes coerentes: percebe o jogador, escolhe uma acao razoavel e muda de ideia quando a situacao muda. Em codigo, isso e uma maquina de estado.

Uma maquina de estado e uma lista de estados (idle, patrol, chase, attack) e as regras para transitar entre eles. E o padrao mais util em IA de jogos, e o Godot 4 tem tudo que voce 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 logica e identica). Adicione estes filhos:

• Um Sprite2D ou AnimatedSprite2D para poder visualiza-lo
• Um CollisionShape2D para que ele tenha um corpo
• Um Area2D com seu proprio CollisionShape2D, maior que o inimigo, para servir como raio de deteccao
• Um NavigationAgent2D para que o inimigo possa contornar paredes

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

Passo 2: Escreva a maquina de estado

Anexe este script a raiz. Ele define quatro estados e alterna entre eles com base na distancia ate 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 instrucao match no state mantem cada comportamento isolado, de modo que adicionar um novo estado depois nao 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 verificacao de deteccao 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 chao. Adicione um NavigationRegion2D a sua cena de nivel e dê a ele um NavigationPolygon que cubra o terreno transitavel, 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 navegacao decide o trajeto. Voce nunca precisa escrever a matematica de pathfinding. get_next_path_position() entrega o proximo ponto de passagem, e voce se move em direcao a ele.

Em 3D, o fluxo e o mesmo com NavigationRegion3D e NavigationAgent3D. Voce gera uma malha de navegacao sobre a geometria do nivel em vez de desenhar um poligono, mas o padrao do script nao muda.

Passo 4: Adicione linha de visao (opcional, mas vale a pena)

So o raio de deteccao faz o inimigo enxergar atraves das paredes. Para corrigir isso, adicione um RayCast2D e verifique se o raio ate o jogador bate em alguma coisa antes de iniciar a perseguicao.

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 transicao IDLE -> CHASE a can_see_player() e o inimigo passa a precisar de uma linha de visao real, o que parece muito mais justo e inteligente para o jogador.

Isso e uma IA de inimigo completa e pronta para lancar: ela detecta, persegue contornando obstaculos, respeita paredes para visao e ataca dentro do alcance. Rotas de patrulha, fuga com pouca vida e taticas em grupo sao apenas mais estados e mais transicoes no mesmo esqueleto.

Parte 2: IA com LLM (NPCs que conversam)

O segundo significado de "IA no Godot" e um NPC com quem voce pode conversar livremente. Este e um mecanismo completamente diferente. Em vez de uma maquina de estado, voce envia texto para um modelo de linguagem e transforma a resposta em dialogo.

O Godot 4 nao tem um modelo embutido, mas tem HTTPRequest, que e tudo que voce 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 descricao 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ê memoria ao NPC

Um modelo sem memoria reinicia cada conversa do zero. Para fazer o ferreiro se lembrar de voce, mantenha uma lista das trocas anteriores e inclua um breve resumo em cada requisicao. Armazene isso no NPC, acrescente cada turno e, quando ficar longo, peca ao modelo que resuma os turnos antigos em uma ou duas frases para que o prompt nao cresça indefinidamente.

Passo 3: Entenda as desvantagens antes de se comprometer

O dialogo com LLM e poderoso, mas nao e de graca. Cada mensagem custa dinheiro, leva um momento para retornar pela rede e exige conexao com a internet, o que significa que nao funciona offline. Ele tambem pode sair do personagem ou do topico se suas instrucoes forem vagas.

E por isso que o padrao realista e hibrido: IA classica para comportamento de todos os NPCs, e dialogo com LLM reservado para poucos personagens nos quais a conversa aberta e o ponto central. Se voce quiser a versao completa disso, incluindo prompts de personalidade, sistemas de memoria e como manter os personagens ancorados no estado do jogo, escrevemos um guia dedicado sobre como criar NPCs com IA, memoria e personalidade no Godot 4. O gerador de NPCs com IA e a forma mais rapida de montar um.

O caminho mais rapido: deixe uma engine nativa de IA escrever para voce

Tudo acima e o caminho manual, e vale a pena entender porque ensina os padroes. Mas escrever, conectar e depurar uma maquina de estado a mao e lento, e os bugs so aparecem quando voce roda o jogo.

E aqui que uma engine nativa de IA muda o trabalho. O Summer Engine e compativel com Godot 4 e integra o assistente de IA diretamente no editor, entao ele nao apenas sugere codigo em um painel lateral. Ele le a arvore de cena, escreve o GDScript, conecta o NavigationAgent e o Area2D de deteccao, roda o jogo, le os erros de execucao e os corrige. Voce descreve o comportamento em linguagem natural:

Faca o esqueleto patrulhar entre dois pontos, perseguir o jogador quando o avistar e atacar quando estiver perto. Use navegacao para que ele contorne as paredes.

Ele produz a mesma maquina de estado que voce 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 diferenca entre uma IA que entrega um trecho de codigo e uma que entrega um comportamento funcionando, porque a maioria dos bugs de IA em jogos sao bugs de execucao que uma janela de chat nunca ve.

Para ser honesto: o plano gratuito cobre construcao, teste e exportacao, o que e suficiente para aprender os padroes e lancar um primeiro prototipo com IA. Os planos pagos oferecem mais uso e modelos mais potentes para quem trabalha diariamente. Se voce quiser comparar as opcoes de IA em um fluxo de trabalho com Godot, a pagina Godot AI apresenta todas elas, e a biblioteca de templates oferece projetos iniciais com inimigos ja configurados para que voce edite o comportamento em vez de construir do zero.

Por onde comecar

Se voce esta aprendendo, construa a Parte 1 a mao. Uma maquina de estado e um NavigationAgent vao atender quase todos os inimigos, companheiros e criaturas que voce vai precisar, e o padrao escala de um unico goblin ate 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 latencia permanecam viaveis.

E quando voce quiser avancar mais rapido do que digitar cada estado a mao, descreva o comportamento e deixe a engine construir e testar para voce. Os padroes deste guia sao exatamente o que ela escreve, entao entende-los faz de voce um diretor melhor, qualquer que seja o caminho que escolher.