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

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

Uno es la IA clásica de videojuegos: el goblin que te detecta, te persigue alrededor de una columna y ataca cuando se acerca. Es lógica de decisión más movimiento, y ha sido el pan de cada día del desarrollo de juegos durante décadas.

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 manteniéndose en personaje. Esto es nuevo, envía texto a un modelo a través de internet y resuelve un problema diferente.

La mayoría de los juegos necesita el primer tipo para casi todo y recurre al segundo solo para un puñado de personajes con diálogos. Esta guía cubre ambos, en orden, con GDScript que puedes pegar en Godot 4. Al final muestra como un motor nativo de IA escribe este código por ti y lo prueba ejecutando el juego, que es la parte que los tutoriales suelen omitir.

Parte 1: IA clásica de videojuegos (la que más 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 acción razonable y cambia de opinión cuando la situación cambia. En código, eso es una máquina de estados.

Una máquina de estados es una lista de estados (reposo, patrulla, persecución, ataque) y las reglas para pasar entre ellos. Es el patrón más útil 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 raíz (usa CharacterBody3D para 3D, la lógica es idéntica). Agrega estos hijos:

• Un Sprite2D o AnimatedSprite2D para que sea visible
• Un CollisionShape2D para que tenga un cuerpo físico
• Un Area2D con su propio CollisionShape2D, de tamaño mayor que el enemigo, para actuar como radio de detección
• Un NavigationAgent2D para que el enemigo pueda rodear obstáculos

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

Paso 2: Escribe la máquina de estados

Asigna este script a la raíz. Define cuatro estados y alterna entre ellos según 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 instrucción match sobre state mantiene cada comportamiento aislado, de modo que agregar un nuevo estado más adelante no enreda los demás. 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 verificación de detección lo encuentre.

Paso 3: Agrega búsqueda 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 través de el automáticamente.

La idea clave: tu script de IA decide el destino (nav.target_position = player.global_position), y el sistema de navegación decide la ruta. Nunca escribes matemáticas de búsqueda 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 geometría del nivel en lugar de dibujar un poligono, pero el patrón del script no cambia.

Paso 4: Agrega línea de visión (opcional, pero vale la pena)

Un radio de detección por si solo significa que el enemigo ve a través de los muros. Para solucionarlo, agrega un RayCast2D y comprueba si el rayo hacia el jugador choca con algo antes de iniciar la persecución.

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 transición IDLE -> CHASE a can_see_player() y el enemigo ahora necesita una línea de visión real, lo que le parece mucho más justo e inteligente al jugador.

Eso es una IA de enemigo completa y lista para publicar: detecta, persigue sorteando obstáculos, respeta los muros para la visión y ataca en rango. Las rutas de patrulla, la huida con poca vida y las tácticas en grupo no son más que estados adicionales y más 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 máquina de estados, envías texto a un modelo de lenguaje y conviertes la respuesta en diálogo.

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

Paso 1: Envía un mensaje a un modelo

Agrega un nodo HTTPRequest y un script que envíe el mensaje del jugador más una descripción 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 conversación. Para que el herrero te recuerde, mantiene una lista continua de intercambios pasados e incluye un resumen breve en cada petición. 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 límite.

Paso 3: Conoce las desventajas antes de comprometerte

El diálogo con LLM es potente, pero no es gratuito. Cada mensaje cuesta dinero, tarda un momento en llegar a través de la red y necesita conexión a internet, lo que significa que no puede funcionar sin conexión. También puede desviarse del tema o salirse del personaje si las instrucciones son imprecisas.

Por eso el patrón realista es híbrido: IA clásica para el comportamiento de todos los NPCs, y diálogo con LLM reservado para unos pocos personajes donde la conversación abierta es el punto central. Si quieres la versión completa, incluyendo prompts de personalidad, sistemas de memoria y como mantener a los personajes anclados en el estado del juego, escribimos una guía dedicada sobre como crear NPCs con IA con memoria y personalidad en Godot 4. El generador de NPCs con IA es la forma más rápida de comenzar con uno.

El camino más rápido: 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 máquina de estados a mano es lento, y los errores solo aparecen cuando ejecutas el juego.

Aquí 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 código en un panel lateral. Lee el árbol de escenas, escribe el GDScript, conecta el NavigationAgent y el Area2D de detección, ejecuta el juego, lee los errores en tiempo de ejecución 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 navegación para que rodee los muros.

Produce la misma máquina 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 código y una que entrega comportamiento funcional, porque la mayoría de los errores de IA en un juego son errores en tiempo de ejecución que una ventana de chat nunca ve.

La versión honesta: el nivel gratuito cubre la construcción, las pruebas y la exportación, que es suficiente para aprender los patrones y publicar un primer prototipo con IA. Los planes de pago agregan más uso y modelos más potentes para el trabajo diario. Si quieres comparar las opciones para IA en un flujo de trabajo con Godot, la página 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 máquina de estados y un NavigationAgent te llevaran a través de casi todos los enemigos, compañeros y criaturas que necesitarás, y el patrón escala desde un solo goblin hasta un encuentro de combate completo.

Recurre a la Parte 2 solo cuando la conversación 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 más rápido 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 guía son exactamente lo que escribe, así que entenderlos te hace mejor a la hora de dirigirlo, cualquiera que sea la ruta que elijas.