La respuesta corta
Pon un Script dentro del modelo del NPC. Crea un camino con PathfindingService:CreatePath(), calcúlalo con path:ComputeAsync(start, goal) dentro de pcall y luego recorre los waypoints uno por uno con Humanoid:MoveTo(), esperando a MoveToFinished antes del siguiente. Para perseguir a un jugador, elige el personaje más cercano y vuelve a calcular el camino cuando se haya movido unos studs, no en cada frame.
- El NPC necesita un Humanoid y un HumanoidRootPart sin anclar. Llama a
SetNetworkOwner(nil)en la root part para que el servidor lo simule: es la solución habitual para un NPC que da tirones cerca de los jugadores. - Salta cuando la
Actionde un waypoint seaJump, y calcula un camino nuevo cuandoPath.Blockedse dispare para un waypoint que el NPC tiene por delante. - Cuando el jugador está a la vista, sáltate el pathfinding y haz
MoveTodirecto hacia él. Para a unos studs, o sigue de largo si el NPC hace daño al tocar.
En esta página
Cómo funciona el pathfinding de un NPC
Roblox construye una malla de navegación (navigation mesh) con las superficies por las que podría caminar un personaje. PathfindingService busca en esa malla una ruta entre dos puntos y la devuelve como una lista de waypoints, cada uno con una posición y una acción como caminar o saltar. Después, el Humanoid del NPC camina de un waypoint al siguiente. El pathfinding solo planea la ruta: moverse por ella es trabajo de tu script.
| API | Qué hace |
|---|---|
PathfindingService:CreatePath() | Crea un objeto Path reutilizable, con el tamaño de tu NPC según los parámetros del agente. |
Path:ComputeAsync(start, finish) | Calcula la ruta. Espera (hace yield) y puede fallar, así que llámalo dentro de pcall y revisa Path.Status. |
Path:GetWaypoints() | Devuelve la ruta como un array de valores PathWaypoint, cada uno con Position, Action y Label. |
Path.Blocked | Se dispara con el índice de un waypoint cuando algo bloquea la ruta calculada. |
Humanoid:MoveTo(position) | Hace que el NPC camine hacia un punto. |
Humanoid.MoveToFinished | Se dispara con true cuando el NPC llega a más o menos un stud del punto, o con false si no ha llegado después de 8 segundos. |
Ejecuta todo esto en un Script del servidor: el servidor ve todo el mapa aunque el streaming esté activado, todos los jugadores ven el mismo NPC y el daño se decide donde un cliente no lo puede falsear. Script vs LocalScript vs ModuleScript (en inglés) explica la diferencia.
Paso 1: Prepara un NPC que se pueda mover
Cualquier modelo puede seguir un camino si tiene las tres cosas de abajo. A los rigs de la Toolbox o de places viejos a veces les falta una, y el síntoma habitual es un NPC que se queda quieto sin ningún error.
| Requisito | Por qué importa |
|---|---|
Un Humanoid llamado Humanoid | MoveTo, WalkSpeed y el salto pertenecen al Humanoid. |
Un HumanoidRootPart | La parte que mueve el Humanoid. Los caminos empiezan desde su posición. |
| Nada anclado | Una parte anclada no se puede mover, y tampoco las partes unidas a ella. El servidor siempre es dueño de las partes ancladas, así que la solución de los tirones de más abajo no se les puede aplicar. |
- Abre la pestaña Avatar o Home y haz clic en Character para abrir el Rig Generator. Elige R15 y luego Block Avatar. Aparece un rig en Workspace. Los rigs R6 funcionan con los mismos scripts.
- Cambia el nombre del rig a
Chasery muévelo a un terreno abierto. - Selecciona su HumanoidRootPart y comprueba que Anchored está desactivado en la ventana Properties. Haz lo mismo con cualquier otra parte anclada del modelo. Para encontrarlas rápido, activa Anchored parts en el widget Visualization Options, arriba a la derecha del viewport 3D.
Workspace
Chaser Model
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (the body parts)
ChaseAI Script new
TouchDamage Script new
Para que el NPC también hable, la guía de diálogo de NPC añade un prompt Talk con respuestas para elegir, y explica qué cambia cuando el NPC camina. Para mostrar un jefe con la cámara antes de que empiece a perseguir, consulta la guía de cinemáticas.
Paso 2: Haz que el NPC camine hasta un punto
Empieza con el script más pequeño que funciona: caminar hasta una parte fija. Muestra cada etapa del pathfinding sin la lógica de persecución.
- Inserta una Part en Workspace, llámala
Goal, activa Anchored, desactiva CanCollide y ponla en el suelo en un sitio donde el NPC tenga que rodear una pared para llegar. - En el Explorer, pasa el ratón sobre Chaser, haz clic en el botón + e inserta un Script. Llámalo
WalkToGoaly pega el código de abajo. - Pulsa Play. El NPC rodea la pared y llega a la parte Goal.
local PathfindingService = game:GetService("PathfindingService")
local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local rootPart = npc:WaitForChild("HumanoidRootPart") :: BasePart
local goalPart = workspace:WaitForChild("Goal") :: BasePart
-- El servidor tiene que ser dueño de la física del NPC para que ChangeState (saltar) funcione desde un Script
local canSetOwner, ownerProblem = rootPart:CanSetNetworkOwnership()
if not canSetOwner then
warn(`{npc.Name} cannot move: {ownerProblem}. Untick Anchored on every part of the rig.`)
return
end
rootPart:SetNetworkOwner(nil)
local path = PathfindingService:CreatePath({
AgentRadius = 2,
AgentHeight = 5,
AgentCanJump = true,
})
-- ComputeAsync espera y puede lanzar un error, así que va dentro de pcall
local ok, err = pcall(function()
path:ComputeAsync(rootPart.Position, goalPart.Position)
end)
if not ok then
warn(`Path request failed: {err}`)
elseif path.Status ~= Enum.PathStatus.Success then
warn(`No path to the goal: {path.Status.Name}`)
else
for index, waypoint in path:GetWaypoints() do
if index == 1 then
continue -- el primer waypoint es donde el NPC ya está parado
end
humanoid:MoveTo(waypoint.Position)
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
-- Espera a llegar a este waypoint antes de pasar al siguiente
local reached = humanoid.MoveToFinished:Wait()
if not reached then
warn(`{npc.Name} got stuck on the way to the goal`)
break
end
end
end
La parte Goal tiene CanCollide desactivado porque un camino no puede terminar dentro de una parte sólida: el Status del camino sería NoPath.
La tabla que se pasa a CreatePath describe al NPC, que Roblox llama el agente, para que la ruta evite huecos por los que no cabe. El script de arriba pone las tres primeras claves en sus valores por defecto para que veas dónde cambiarlas.
| Clave | Por defecto | Qué controla |
|---|---|---|
AgentRadius | 2 | El radio del NPC en studs. Súbelo para NPCs anchos, así los caminos se alejan de las paredes. |
AgentHeight | 5 | La altura del NPC. Los espacios más bajos que esto, como debajo de una escalera, cuentan como bloqueados. |
AgentCanJump | true | Permite rutas que necesitan un salto. Esos waypoints tienen Action en Jump. |
AgentCanClimb | false | Permite trepar TrussParts. Esos waypoints tienen la etiqueta Climb. |
WaypointSpacing | 4 | La separación en studs entre los waypoints intermedios. math.huge los quita. |
Costs | ninguno | Lo caro que es cruzar materiales y regiones con etiqueta. Mira modificadores y enlaces. |
Hay dos detalles del bucle que importan. El primer waypoint es la propia posición del NPC, así que el bucle se lo salta. Y cada MoveTo va seguido de MoveToFinished:Wait(): un MoveTo nuevo reemplaza al objetivo anterior, así que un bucle que no espera manda al NPC directo al último waypoint, contra la pared que debería rodear.
Para los saltos, la Action del waypoint es Jump y el script llama a ChangeState(Enum.HumanoidStateType.Jumping). La referencia de Humanoid de Roblox dice que un script del servidor solo puede cambiar un estado cuando el servidor es dueño de la física del personaje, y por eso, entre otras cosas, el script pone primero el dueño de red.
La página de pathfinding de Roblox mueve el personaje del propio jugador con Humanoid:Move() y una comprobación de llegada en cada frame, y dice que es la mejor forma de mover un Humanoid por un camino. MoveTo con MoveToFinished es más corto y más fácil de seguir para un NPC del servidor, así que esta guía usa eso; estudia el script oficial si más adelante necesitas un control más fino.
Paso 3: El script de persecución completo
Este es el script que busca casi todo el mundo. El NPC persigue al jugador más cercano a menos de 80 studs, rodea paredes, salta donde la ruta lo necesita, encuentra una ruta nueva cuando algo la bloquea y vuelve a casa cuando no hay nadie cerca.
- Borra
WalkToGoalde Chaser si lo añadiste. - Pasa el ratón sobre Chaser, haz clic en +, inserta un Script llamado
ChaseAIy pega el código de abajo. - Pulsa Play, ponte detrás de una pared y luego aléjate corriendo fuera de su alcance. El NPC te sigue rodeando la pared y después vuelve a donde empezó.
local Players = game:GetService("Players")
local PathfindingService = game:GetService("PathfindingService")
local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local rootPart = npc:WaitForChild("HumanoidRootPart") :: BasePart
-- Ajustes (distancias en studs, tiempos en segundos)
local DETECTION_RANGE = 80 -- se ignora a los jugadores que estén más lejos que esto
local STOP_DISTANCE = 4 -- para a esta distancia del objetivo (0 = chocar con él, para daño al tocar)
local DIRECT_CHASE_RANGE = 30 -- dentro de esta distancia, sin pathfinding si no hay nada en medio
local REPATH_DISTANCE = 4 -- cuánto tiene que moverse el objetivo para volver a calcular el camino
local MIN_REPATH_INTERVAL = 0.5 -- nunca calcular caminos más seguido que esto
local WAYPOINT_TIMEOUT = 2 -- abandonar un camino si un waypoint tarda más que esto
local CHASE_SPEED = 14 -- un jugador camina a 16 por defecto, así que puede dejar atrás a este NPC
local HOME_RADIUS = 4 -- estar así de cerca de casa cuenta como estar en casa
local RAY_HEIGHTS = { 0, -2 } -- rayos de línea de visión a la altura de la cintura y cerca de las rodillas
local HOME = rootPart.Position -- adonde vuelve el NPC cuando no hay nadie a su alcance
humanoid.WalkSpeed = CHASE_SPEED
-- Deja que el servidor simule al NPC. Si no, Roblox puede pasar su física al
-- dispositivo de un jugador cercano, y el NPC da tirones cada vez que eso cambia.
local canSetOwner, ownerProblem = rootPart:CanSetNetworkOwnership()
if not canSetOwner then
warn(`{npc.Name} cannot move: {ownerProblem}. Untick Anchored on every part of the rig.`)
return
end
rootPart:SetNetworkOwner(nil)
local path = PathfindingService:CreatePath({
AgentRadius = 2,
AgentHeight = 5,
AgentCanJump = true,
Costs = {
Water = 20, -- cruzar el agua solo para evitar un rodeo largo
DangerZone = math.huge, -- nunca entrar en regiones con la etiqueta DangerZone
},
})
-- El camino que el NPC está siguiendo ahora mismo
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge
-- Blocked se puede disparar para un waypoint que el NPC ya pasó. Solo importa un bloqueo por delante.
path.Blocked:Connect(function(blockedIndex: number)
if blockedIndex >= nextIndex then
pathBlocked = true
end
end)
local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- las partes con las que nada puede chocar no tapan la vista
local function clearPath()
waypoints = {}
nextIndex = 0
pathGoal = nil
end
local function stopMoving()
clearPath()
humanoid:MoveTo(rootPart.Position)
end
-- El HumanoidRootPart del jugador vivo más cercano dentro de DETECTION_RANGE, o nil
local function findNearestTarget(): BasePart?
local nearestRoot: BasePart? = nil
local nearestDistance = DETECTION_RANGE
for _, player in Players:GetPlayers() do
local character = player.Character
local targetHumanoid = character and character:FindFirstChildOfClass("Humanoid")
local targetRoot = character and character:FindFirstChild("HumanoidRootPart")
if targetHumanoid and targetHumanoid.Health > 0 and targetRoot and targetRoot:IsA("BasePart") then
local distance = (targetRoot.Position - rootPart.Position).Magnitude
if distance < nearestDistance then
nearestDistance = distance
nearestRoot = targetRoot
end
end
end
return nearestRoot
end
-- True cuando el objetivo está más o menos al mismo nivel y no hay nada sólido en medio.
-- Un rayo libre no prueba que se pueda caminar por el suelo, así que esto solo se usa de cerca.
local function canSeeDirectly(targetRoot: BasePart): boolean
local offset = targetRoot.Position - rootPart.Position
if math.abs(offset.Y) > 3 then
return false
end
local character = targetRoot.Parent
rayParams.ExcludeInstances = if character then { npc, character } else { npc }
for _, height in RAY_HEIGHTS do
local origin = rootPart.Position + Vector3.new(0, height, 0)
if workspace:Raycast(origin, offset, rayParams) then
return false
end
end
return true
end
local function computePath(goal: Vector3)
lastComputeTime = os.clock()
local ok, err = pcall(function()
path:ComputeAsync(rootPart.Position, goal)
end)
-- Se reinicia después de calcular, para que un evento Blocked de la ruta vieja no marque la nueva
pathBlocked = false
if ok and path.Status == Enum.PathStatus.Success then
waypoints = path:GetWaypoints()
nextIndex = 2 -- el waypoint 1 es donde está parado el NPC
pathGoal = goal
else
if not ok then
warn(`{npc.Name}: path request failed: {err}`)
end
clearPath() -- ahora no hay ruta; el bucle principal lo vuelve a intentar en un momento
end
end
local function needsNewPath(goal: Vector3): boolean
if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
return false -- se calculó hace un momento: sigue caminando por el camino actual
end
local currentGoal = pathGoal
if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
return true
end
return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end
-- Espera a MoveToFinished, pero se rinde después de timeout segundos en vez de los
-- 8 que trae por defecto, así un NPC atascado recibe un camino nuevo rápido
local function waitForMoveToFinished(timeout: number): boolean
local finished = false
local reachedGoal = false
local connection = humanoid.MoveToFinished:Connect(function(reached: boolean)
finished = true
reachedGoal = reached
end)
local deadline = os.clock() + timeout
while not finished and os.clock() < deadline do
task.wait()
end
connection:Disconnect()
return reachedGoal
end
local function walkToNextWaypoint()
local waypoint = waypoints[nextIndex]
humanoid:MoveTo(waypoint.Position)
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
if waitForMoveToFinished(WAYPOINT_TIMEOUT) then
nextIndex += 1
else
clearPath() -- atascado o desviado a empujones: calcula un camino nuevo
end
end
while humanoid.Health > 0 do
local targetRoot = findNearestTarget()
local goal: Vector3
if targetRoot then
local distance = (targetRoot.Position - rootPart.Position).Magnitude
if distance <= STOP_DISTANCE then
stopMoving() -- lo bastante cerca: quédate junto al objetivo
task.wait(0.2)
continue
end
if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
clearPath()
-- Pasar también la parte hace que el NPC la siga mientras se mueve
humanoid:MoveTo(targetRoot.Position, targetRoot)
task.wait(0.15)
continue
end
goal = targetRoot.Position
else
if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
stopMoving() -- no hay nadie cerca y ya está en casa
task.wait(0.5)
continue
end
goal = HOME
end
if needsNewPath(goal) then
computePath(goal)
end
if nextIndex >= 2 and nextIndex <= #waypoints then
walkToNextWaypoint()
else
task.wait(0.1) -- todavía no hay un camino que sirva, por ejemplo el objetivo está fuera de alcance
end
end
Todos los ajustes están arriba. Para tener más NPCs, duplica Chaser: cada copia ejecuta su propio ChaseAI y recuerda su propia casa. Los scripts viejos filtran los rayos con FilterDescendantsInstances; la referencia de Roblox ahora recomienda ExcludeInstances para código nuevo, que es lo que usa este script.
Cómo funciona el script de persecución
Cada vuelta del bucle principal toma una decisión y luego hace una sola cosa pequeña: quedarse quieto, ir directo hacia el jugador o caminar al siguiente waypoint. Nada dura más que un waypoint, así que el NPC sigue reaccionando.
Encontrar al jugador más cercano
findNearestTarget recorre Players:GetPlayers(), se salta a quien no tenga personaje, un Humanoid vivo o un HumanoidRootPart (jugadores que están reapareciendo o saliendo) y devuelve la root part más cercana dentro de DETECTION_RANGE. La búsqueda se hace en cada vuelta, así que el NPC cambia solo a un jugador más cercano, y a un jugador que se va simplemente no lo vuelve a encontrar: no hay estado por jugador que limpiar.
Recalcular cuando el jugador se mueve, sin hacerlo en cada frame
Calcular un camino espera (hace yield) y gasta tiempo del servidor. needsNewPath pide uno solo cuando no hay camino, el anterior terminó o está bloqueado, o el jugador se movió más de REPATH_DISTANCE studs desde donde termina el camino actual, y nunca antes de MIN_REPATH_INTERVAL segundos desde el último. Mientras calcula, el NPC sigue caminando hacia su waypoint actual, y el camino nuevo se sigue desde el waypoint 2, así que el NPC no se da la vuelta hacia el punto donde empezó el camino.
Caminos bloqueados
Las puertas se cierran y las partes se caen. Path.Blocked se dispara con el índice del waypoint bloqueado, que puede estar detrás del NPC, así que el script solo reacciona cuando blockedIndex >= nextIndex: pone una bandera y el bucle calcula una ruta nueva. Un waypoint que tarda más de WAYPOINT_TIMEOUT segundos en alcanzarse, porque empujaron al NPC o se enganchó, también provoca una ruta nueva.
Ir directo hacia un jugador visible
El pathfinding sobra cuando el jugador está a la vista en terreno abierto. Dentro de DIRECT_CHASE_RANGE, canSeeDirectly lanza dos rayos hacia el jugador, a la altura de la cintura y cerca de las rodillas para detectar muros bajos, ignorando a los dos personajes. Si ninguno choca con nada y el jugador está más o menos al mismo nivel, el NPC llama a MoveTo(targetRoot.Position, targetRoot). El segundo argumento hace que el objetivo se mueva con el jugador, y repetir la llamada cada 0.15 segundos reinicia una y otra vez el límite de 8 segundos.
Un rayo libre prueba que no hay nada sólido en medio, no que haya suelo por donde caminar. Si tu mapa tiene huecos o caídas entre el NPC y los jugadores, baja DIRECT_CHASE_RANGE, o ponlo en 0 para usar siempre pathfinding.
Parar a la distancia correcta
Cuando el jugador está dentro de STOP_DISTANCE, el NPC llama a MoveTo con su propia posición, y eso lo detiene. 4 studs va bien para un NPC que debe quedarse al lado del jugador; súbelo a 6 u 8 para una mascota o un acompañante que deja algo de espacio. Para un enemigo que hace daño al tocar, ponlo en 0 para que choque con el jugador, como en el paso 4.
Por qué los NPCs dan tirones y cómo arreglarlo
Un NPC que se mueve a saltos, se para en cada waypoint o se sacude hacia atrás suele tener una de las causas de abajo. El script de persecución ya resuelve cada una; la tabla sirve para arreglar un script que escribiste tú.
| Lo que ves | Causa | Solución |
|---|---|---|
| Va fluido cuando está solo y a tirones cuando se acerca un jugador | El dueño de red (network ownership). Roblox da la física de las partes sin anclar al dispositivo de un jugador cercano, así que el NPC puede acabar simulado en el dispositivo de ese jugador mientras el servidor da las órdenes, y cada traspaso puede notarse como un tirón. | Llama una vez a SetNetworkOwner(nil) en el HumanoidRootPart, desde el servidor. Se aplica a todas las partes conectadas a él. |
| Camina directo al último waypoint y contra las paredes | MoveTo llamado para cada waypoint en un bucle sin esperar. Cada llamada reemplaza al objetivo anterior. | Espera a MoveToFinished antes de pasar al siguiente waypoint. |
| Se para un momento en cada waypoint, o corta las esquinas | Un task.wait() fijo entre waypoints en vez de esperar a que llegue. Si es muy largo, el NPC se queda quieto; si es muy corto, se adelanta. | Espera a MoveToFinished, con un límite de tiempo. |
| Se sacude o da pasos hacia atrás varias veces por segundo | Un camino nuevo en cada frame. Cada uno empieza en la propia posición del NPC, así que caminar al waypoint 1 lo hace girar hacia atrás. | Recalcula solo cuando el objetivo se ha movido unos studs, como mucho dos veces por segundo, y empieza desde el waypoint 2. |
| Se congela varios segundos y luego sigue | MoveToFinished:Wait() en un waypoint al que no puede llegar espera los 8 segundos del límite. | Usa tu propio límite más corto y calcula un camino nuevo cuando se acabe. |
Para ver quién es dueño del NPC, abre Visualization Options durante una prueba de juego y activa Network owners. Las partes que simula tu cliente tienen un contorno verde; las que son del servidor o de otro cliente tienen un contorno blanco o gris.
Paso 4: Hacer daño a los jugadores al tocarlos (opcional)
Para un enemigo, añade al NPC un segundo script que haga daño a los jugadores que toca. Se ejecuta en el servidor, así que el cliente de un jugador no puede cambiar la cantidad ni saltarse la espera.
- En ChaseAI, pon
STOP_DISTANCEen0para que el NPC choque con los jugadores en vez de pararse a su lado. - Inserta en Chaser un Script llamado
TouchDamagey pega el código de abajo.
local Players = game:GetService("Players")
local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local DAMAGE = 10
local COOLDOWN_SECONDS = 1
local lastHit: { [Player]: number } = {}
local function onTouched(hit: BasePart)
if humanoid.Health <= 0 then
return -- un NPC derrotado no hace daño
end
local character = hit:FindFirstAncestorOfClass("Model")
local player = character and Players:GetPlayerFromCharacter(character)
local targetHumanoid = character and character:FindFirstChildOfClass("Humanoid")
if not player or not targetHumanoid or targetHumanoid.Health <= 0 then
return
end
local now = os.clock()
local last = lastHit[player]
if last and now - last < COOLDOWN_SECONDS then
return -- Touched se dispara muchas veces por segundo mientras las partes se tocan
end
lastHit[player] = now
targetHumanoid:TakeDamage(DAMAGE)
end
for _, descendant in npc:GetDescendants() do
if descendant:IsA("BasePart") then
descendant.Touched:Connect(onTouched)
end
end
Players.PlayerRemoving:Connect(function(player: Player)
lastHit[player] = nil
end)
TakeDamage respeta los force fields, así que los jugadores están a salvo mientras dura el force field de aparición. Para ignorar los force fields, baja Humanoid.Health directamente.
La espera (cooldown) se guarda por jugador. Touched se dispara muchas veces por segundo mientras las partes se rozan, y sin la espera un solo choque podría vaciar la vida de un jugador en un momento. Cada entrada se borra cuando su jugador se va, así que la tabla no crece durante toda la vida del servidor.
Para que los jugadores puedan defenderse, dales la espada o la pistola con raycast (en inglés). Las dos hacen su daño en el servidor a cualquier cosa con un Humanoid, así que también le dan al Chaser.
Modificadores y enlaces de pathfinding
Por defecto, un camino es la ruta más corta, evitando saltos cuando puede. Tres herramientas cambian eso. Los costos y los modificadores funcionan con el script de persecución tal como está, porque ya pasa una tabla Costs a CreatePath; los enlaces necesitan unas líneas tuyas.
Costos de materiales
Las claves de Costs pueden ser nombres de materiales como Water, Mud o CrackedLava, tanto para el terreno como para las partes. Cada material cuesta 1 por defecto. Un número más alto hace que el NPC evite ese material a menos que el rodeo sea peor, y math.huge lo vuelve imposible de cruzar. El script de persecución pone Water = 20.
Regiones que evitar: PathfindingModifier
- Cubre la zona con una parte, con Anchored activado y CanCollide desactivado.
- Inserta un PathfindingModifier en esa parte y pon su
LabelenDangerZone. - Eso es todo. El script de persecución ya le da a
DangerZoneun costo demath.huge, así que el NPC rodea la zona. Activa Pathfinding modifiers en Visualization Options para ver la etiqueta en la malla de navegación.
Un modificador con PassThrough activado hace lo contrario: la ruta atraviesa un obstáculo sólido, como una puerta cerrada, como si no estuviera. El NPC sigue sin poder atravesar la puerta, pero va hacia ella, como si hubiera oído al jugador al otro lado.
Cruces propios: PathfindingLink
Un PathfindingLink une dos puntos entre los que el NPC normalmente no podría moverse, como las orillas de un río que cruza en barco. Pon un Attachment en cada extremo, asigna el Attachment0 y el Attachment1 del enlace, dale un Label como UseBoat y añade UseBoat a Costs con un costo más bajo que Water. Así el camino incluye un waypoint con esa etiqueta: revisa waypoint.Label en walkToNextWaypoint y ejecuta tu propia acción, como sentar al NPC en el barco, en vez de MoveTo. Los enlaces funcionan en los dos sentidos a menos que desactives IsBidirectional.
Errores comunes y soluciones
Mira primero la ventana Output. Ábrela desde el menú Window o la pestaña Script. Los scripts de esta página escriben una advertencia cuando falla una petición de camino o el rig no se puede mover.
El NPC no se mueve nada
Si Output dice que el NPC no se puede mover, una parte del rig está anclada: desactiva Anchored en el HumanoidRootPart y en las demás partes. Si no, comprueba que el código es un Script y no un LocalScript, que está dentro del modelo en Workspace y que el Humanoid no ha muerto.
Output dice "Infinite yield possible" en WaitForChild
El script está esperando un objeto que no existe: un Humanoid o HumanoidRootPart con otro nombre, o ninguna parte llamada Goal para el script del paso 2. Cambia el nombre del objeto o el texto en el script. La guía de errores de scripts explica esta advertencia.
El camino falla, o el NPC ignora a un jugador al que podría llegar
Path.Status es NoPath después de ComputeAsync cuando el inicio o el final están dentro de una parte sólida, cuando la única ruta necesita un salto y AgentCanJump es false, o cuando AgentHeight o AgentRadius son demasiado grandes para un hueco del camino. Roblox también documenta límites fijos: como mucho 3,000 studs en línea recta del inicio al final, y un presupuesto de búsqueda de 20,000 nodos que se puede agotar en mundos abiertos enormes o en laberintos. Activa Navigation mesh para revisar la ruta.
El NPC se desliza sin mover las piernas
Eso es un problema de animación, no de pathfinding. Los personajes de los jugadores reciben un script Animate automáticamente, pero un NPC necesita su propio script para reproducir las animaciones de caminar. Cada NPC del NPC kit de Roblox incluye un Script llamado Animate que puedes estudiar. Para cargar y reproducir una animación en un NPC desde un Script del servidor, mira reproducir una animación en un NPC.
El NPC se atasca en las esquinas o salta sin pasar un obstáculo
Sube AgentRadius para que las rutas se alejen más de las paredes, sobre todo con NPCs anchos. Si salta pero nunca logra pasar, el obstáculo es más alto de lo que puede saltar el Humanoid: sube el JumpHeight o el JumpPower del Humanoid, o cambia el nivel.
El daño al tocar pega demasiado seguido, o nunca
Demasiado seguido: falta la espera, o se guarda por parte en vez de por jugador. Nunca: STOP_DISTANCE es mayor que 0, así que el NPC casi siempre se para antes de tocar a nadie, o el jugador todavía tiene el force field de aparición.
Constrúyelo con RoCode
Si prefieres describir el NPC en vez de montarlo a mano, RoCode puede escribir estos scripts en el place que tienes abierto. Es un agente de IA independiente para Roblox Studio: escribes en un chat web y su plugin de Studio crea y edita los scripts en tu Explorer.
Haz que el modelo Chaser de Workspace persiga con pathfinding al jugador más cercano a menos de 80 studs, que vuelva a casa cuando no haya nadie cerca y que haga 10 de daño al tocar, con una espera de 1 segundo.
- Puede revisar el modelo primero, con Get Properties, para leer valores clave como Anchored en sus partes y WalkSpeed en su Humanoid. Escribe / en el chat para adjuntar la ruta exacta del modelo
- Escribe los scripts de persecución y de daño dentro del modelo con Create Script, y puede desactivar Anchored con Set Property si el rig lo necesita
- Revisa que los dos scripts compilan con Check Script dentro de Studio. Eso detecta errores de compilación y patrones como wait() en vez de task.wait(), no fallos de lógica como una ruta que nunca llega al jugador
- Envía sus cambios por lotes, y cada lote es un punto de deshacer en el historial de Studio
Con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba para comprobar que el juego funciona, pero no saca capturas mientras el juego corre, así que pulsa Play y mira el NPC tú mismo. Si se porta mal, dile a RoCode lo que viste: Check Output puede leer las líneas de Server y Client de tu última prueba. Los NPCs son un sistema entre muchos; mira cómo construir un juego completo de Roblox con IA, primero un núcleo jugable y luego rondas (en inglés). Cómo se conecta RoCode a Studio.
Preguntas frecuentes
¿El pathfinding de un NPC va en el servidor o en el cliente?
En el servidor, en un Script. El ejemplo de pathfinding de Roblox se ejecuta en un LocalScript, pero mueve el personaje del propio jugador. Un NPC lo comparten todos, y el daño que hace lo tiene que decidir el servidor. Mira Script vs LocalScript vs ModuleScript (en inglés).
¿Cuántos NPCs que persiguen aguanta un servidor?
La documentación de Roblox no da un número fijo; depende de tu mapa y de cada cuánto se calculan los caminos. Calcular el camino es la parte cara, por eso el script de persecución lo limita a dos veces por segundo por NPC y se lo salta cuando el jugador está a la vista. Con muchos NPCs, la guía de Roblox sobre dónde poner los scripts sugiere ponerles un tag y manejarlos con CollectionService desde un solo ModuleScript, en vez de un script en cada modelo.
¿Cómo hago que el NPC reaparezca cuando muere?
Guarda una copia del NPC en ServerStorage y maneja la reaparición desde un script en ServerScriptService, porque un script dentro del NPC se destruye con él. Cuando se dispare el evento Died del Humanoid, espera unos segundos, destruye el modelo viejo y pon en Workspace un Clone() de la copia. El script ChaseAI dentro del clon arranca solo, porque los scripts del servidor se ejecutan en cuanto están en Workspace.
¿Puedo hacer que los NPCs persigan solo durante una ronda?
Sí. Haz que tu script de rondas clone los NPCs en Workspace cuando empiece una ronda y los destruya cuando termine. La guía del sistema de rondas construye el intermedio y el bucle de rondas donde conectarías esto.
Fuentes y lecturas
- Roblox Creator Docs: Pathfinding (en inglés). parámetros del agente, waypoints, caminos bloqueados, modificadores, enlaces y límites
- Roblox Creator Docs: PathfindingService (en inglés). CreatePath y sus valores por defecto
- Roblox Creator Docs: Path (en inglés). ComputeAsync, GetWaypoints, Status y el evento Blocked
- Roblox Creator Docs: Humanoid (en inglés). MoveTo, el límite de 8 segundos de MoveToFinished, ChangeState y TakeDamage
- Roblox Creator Docs: Network ownership (en inglés). el dueño automático, SetNetworkOwner y la vista Network owners
- Roblox Creator Docs: RaycastParams (en inglés). ExcludeInstances y RespectCanCollide
- Roblox Creator Docs: NPC kit (en inglés). NPCs de ejemplo con sus propios scripts Animate
Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 14 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.