Como hacer IA en Godot 4: Guia paso a paso (2026)

Pregunta "como hacer IA en Godot" y obtendrás dos respuestas completamente diferentes segun lo que hayas querido decir, porque la misma frase abarca dos trabajos sin relacion entre si.

Uno es la IA clasica de videojuegos: el goblin que te detecta, te persigue alrededor de una columna y ataca cuando se acerca. Es logica de decision mas movimiento, y ha sido el pan de cada dia del desarrollo de juegos durante decadas.

El otro es la IA con modelos de lenguaje: el tendero con el que puedes hablar de verdad con tus propias palabras y que responde manteniendose en personaje. Esto es nuevo, envia texto a un modelo a traves de internet y resuelve un problema diferente.

La mayoria de los juegos necesita el primer tipo para casi todo y recurre al segundo solo para un punado de personajes con dialogos. Esta guia cubre ambos, en orden, con GDScript que puedes pegar en Godot 4. Al final muestra como un motor nativo de IA escribe este codigo por ti y lo prueba ejecutando el juego, que es la parte que los tutoriales suelen omitir.

Parte 1: IA clasica de videojuegos (la que mas necesitas)

Cuando un diseñador dice que un enemigo "tiene buena IA", casi nunca quiere decir que ejecuta una red neuronal. Quiere decir que toma decisiones sensatas: nota al jugador, elige una accion razonable y cambia de opinion cuando la situacion cambia. En codigo, eso es una maquina de estados.

Una maquina de estados es una lista de estados (reposo, patrulla, persecucion, ataque) y las reglas para pasar entre ellos. Es el patron mas util en la IA de videojuegos, y Godot 4 tiene todo lo necesario para construirla.

Paso 1: Configura la escena del enemigo

Crea una nueva escena con un CharacterBody2D como raiz (usa CharacterBody3D para 3D, la logica es identica). Agrega estos hijos:

• Un Sprite2D o AnimatedSprite2D para que sea visible
• Un CollisionShape2D para que tenga un cuerpo fisico
• Un Area2D con su propio CollisionShape2D, de tamaño mayor que el enemigo, para actuar como radio de deteccion
• Un NavigationAgent2D para que el enemigo pueda rodear obstaculos

El Area2D de deteccion es como el enemigo "ve". Cuando el jugador entra en el, el enemigo sabe que debe reaccionar.

Paso 2: Escribe la maquina de estados

Asigna este script a la raiz. Define cuatro estados y alterna entre ellos segun la distancia al jugador.

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:
	# reproduce la animacion de ataque, aplica dano y vuelve a perseguir
	if player != null and global_position.distance_to(player.global_position) > attack_range:
		state = State.CHASE

# conecta estas señales desde el Area2D de deteccion en el 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

Dos cosas hacen que esto funcione. La instruccion match sobre state mantiene cada comportamiento aislado, de modo que agregar un nuevo estado mas adelante no enreda los demas. Y las señales body-entered y body-exited del Area2D (conectadas desde la pestaña Node del editor) cambian al enemigo entre alerta e ignorancia sin consultar cada fotograma.

Pon a tu jugador en el grupo player (seleccionalo, pestaña Node, Grupos, agrega "player") para que la verificacion de deteccion lo encuentre.

Paso 3: Agrega busqueda de caminos para que el enemigo rodee los muros

El script anterior usa NavigationAgent2D, pero el agente necesita un mapa de donde esta el suelo. Agrega un NavigationRegion2D a la escena de tu nivel y dale un NavigationPolygon que cubra el terreno transitable, con agujeros recortados para los muros. Godot enruta al agente a traves de el automaticamente.

La idea clave: tu script de IA decide el destino (nav.target_position = player.global_position), y el sistema de navegacion decide la ruta. Nunca escribes matematicas de busqueda de caminos tu mismo. get_next_path_position() te da el siguiente punto de paso y tu te mueves hacia el.

En 3D el flujo es el mismo con NavigationRegion3D y NavigationAgent3D. Bakes un navigation mesh sobre la geometria del nivel en lugar de dibujar un poligono, pero el patron del script no cambia.

Paso 4: Agrega linea de vision (opcional, pero vale la pena)

Un radio de deteccion por si solo significa que el enemigo ve a traves de los muros. Para solucionarlo, agrega un RayCast2D y comprueba si el rayo hacia el jugador choca con algo antes de iniciar la persecucion.

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

Condicionas la transicion IDLE -> CHASE a can_see_player() y el enemigo ahora necesita una linea de vision real, lo que le parece mucho mas justo e inteligente al jugador.

Eso es una IA de enemigo completa y lista para publicar: detecta, persigue sorteando obstaculos, respeta los muros para la vision y ataca en rango. Las rutas de patrulla, la huida con poca vida y las tacticas en grupo no son mas que estados adicionales y mas transiciones sobre el mismo esqueleto.

Parte 2: IA con LLM (NPCs que hablan)

El segundo significado de "IA en Godot" es un NPC con el que puedes conversar libremente. Este es un mecanismo completamente diferente. En lugar de una maquina de estados, envias texto a un modelo de lenguaje y conviertes la respuesta en dialogo.

Godot 4 no tiene ningun modelo incorporado, pero tiene HTTPRequest, que es todo lo que necesitas para llamar a uno.

Paso 1: Envia un mensaje a un modelo

Agrega un nodo HTTPRequest y un script que envie el mensaje del jugador mas una descripcion breve del personaje a una API de un modelo.

extends Node

@onready var http: HTTPRequest = $HTTPRequest

const ENDPOINT := "https://api.example-model.com/v1/chat"
const API_KEY := "tu-clave-aqui" # no incluyas esto en las builds publicadas

func ask_npc(player_message: String) -> void:
	var headers := [
		"Content-Type: application/json",
		"Authorization: Bearer " + API_KEY,
	]
	var body := {
		"system": "Eres Bram, un herrero del pueblo que esta cansado. Mantente en personaje. Las respuestas deben tener menos de dos 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:
	# inserta el texto en tu interfaz de dialogo
	print(text)

Paso 2: Dale memoria al NPC

Un modelo sin memoria reinicia cada conversacion. Para que el herrero te recuerde, mantiene una lista continua de intercambios pasados e incluye un resumen breve en cada peticion. Guardala en el NPC, agrega cada turno y cuando sea demasiado larga, pide al modelo que resuma los turnos antiguos en una o dos frases para que el prompt no crezca sin limite.

Paso 3: Conoce las desventajas antes de comprometerte

El dialogo con LLM es potente, pero no es gratuito. Cada mensaje cuesta dinero, tarda un momento en llegar a traves de la red y necesita conexion a internet, lo que significa que no puede funcionar sin conexion. Tambien puede desviarse del tema o salirse del personaje si las instrucciones son imprecisas.

Por eso el patron realista es hibrido: IA clasica para el comportamiento de todos los NPCs, y dialogo con LLM reservado para unos pocos personajes donde la conversacion abierta es el punto central. Si quieres la version completa, incluyendo prompts de personalidad, sistemas de memoria y como mantener a los personajes anclados en el estado del juego, escribimos una guia dedicada sobre como crear NPCs con IA con memoria y personalidad en Godot 4. El generador de NPCs con IA es la forma mas rapida de comenzar con uno.

El camino mas rapido: deja que un motor nativo de IA lo escriba

Todo lo anterior es la ruta manual, y vale la pena entenderla porque enseña los patrones. Pero escribir, conectar y depurar una maquina de estados a mano es lento, y los errores solo aparecen cuando ejecutas el juego.

Aqui es donde un motor nativo de IA cambia el trabajo. Summer Engine es compatible con Godot 4 e integra el asistente de IA directamente en el editor, por lo que no solo sugiere codigo en un panel lateral. Lee el arbol de escenas, escribe el GDScript, conecta el NavigationAgent y el Area2D de deteccion, ejecuta el juego, lee los errores en tiempo de ejecucion y los corrige. Describes el comportamiento en lenguaje natural:

Haz que el esqueleto patruelle entre dos puntos, persiga al jugador cuando lo vea y ataque cuando este cerca. Usa navegacion para que rodee los muros.

Produce la misma maquina de estados que viste arriba, adjunta a una escena de enemigo real, luego presiona play para confirmar que el esqueleto realmente persigue en lugar de caminar contra un muro. Ese ciclo de escribir, ejecutar y leer es la diferencia entre una IA que te entrega un fragmento de codigo y una que entrega comportamiento funcional, porque la mayoria de los errores de IA en un juego son errores en tiempo de ejecucion que una ventana de chat nunca ve.

La version honesta: el nivel gratuito cubre la construccion, las pruebas y la exportacion, que es suficiente para aprender los patrones y publicar un primer prototipo con IA. Los planes de pago agregan mas uso y modelos mas potentes para el trabajo diario. Si quieres comparar las opciones para IA en un flujo de trabajo con Godot, la pagina de Godot AI las detalla, y la biblioteca de plantillas te da proyectos iniciales con enemigos ya configurados para que puedas editar el comportamiento en lugar de construirlo desde cero.

Por donde empezar

Si estas aprendiendo, construye la Parte 1 a mano. Una maquina de estados y un NavigationAgent te llevaran a traves de casi todos los enemigos, compañeros y criaturas que necesitaras, y el patron escala desde un solo goblin hasta un encuentro de combate completo.

Recurre a la Parte 2 solo cuando la conversacion abierta sea genuinamente el punto central de un personaje, y limitala a pocos NPCs para que el costo y la latencia sean manejables.

Y cuando quieras moverte mas rapido que escribiendo cada estado a mano, describe el comportamiento y deja que el motor lo construya y lo pruebe por ti. Los patrones de esta guia son exactamente lo que escribe, asi que entenderlos te hace mejor a la hora de dirigirlo, cualquiera que sea la ruta que elijas.