Tutorial · Sistemas de juego

Cómo hacer un NPC que te siga y te persiga en Roblox Studio

Un NPC que rodea paredes para llegar al jugador más cercano necesita tres cosas: un rig que se pueda mover, una ruta de PathfindingService y un bucle que siga esa ruta sin pelearse con el motor de física. Esta guía construye las tres y termina con un solo script del servidor que puedes meter en un rig de NPC.

Actualizado el 14 de noviembre de 202617 min de lecturaEscrito por

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 Action de un waypoint sea Jump, y calcula un camino nuevo cuando Path.Blocked se dispare para un waypoint que el NPC tiene por delante.
  • Cuando el jugador está a la vista, sáltate el pathfinding y haz MoveTo directo hacia él. Para a unos studs, o sigue de largo si el NPC hace daño al tocar.
En esta página
  1. Cómo funciona
  2. 1. Preparar el NPC
  3. 2. Caminar a un punto
  4. 3. Script de persecución
  5. Cómo funciona la persecución
  6. Arreglar los tirones
  7. 4. Daño al tocar
  8. Modificadores y enlaces
  9. Errores comunes
  10. Con RoCode
  11. Preguntas frecuentes
  12. Fuentes y lecturas

Cómo funciona el pathfinding de un NPC

IlustraciónEl Chaser encuentra cómo rodear la pared, salta al saliente y se detiene a 4 studs de ti.

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.

Las APIs que usa esta guía
APIQué 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.BlockedSe 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.MoveToFinishedSe 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.

Lo que necesita el modelo del NPC
RequisitoPor qué importa
Un Humanoid llamado HumanoidMoveTo, WalkSpeed y el salto pertenecen al Humanoid.
Un HumanoidRootPartLa parte que mueve el Humanoid. Los caminos empiezan desde su posición.
Nada ancladoUna 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.
  1. 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.
  2. Cambia el nombre del rig a Chaser y muévelo a un terreno abierto.
  3. 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.
Explorer: el modelo del NPC al final de esta guía
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.

  1. 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.
  2. En el Explorer, pasa el ratón sobre Chaser, haz clic en el botón + e inserta un Script. Llámalo WalkToGoal y pega el código de abajo.
  3. Pulsa Play. El NPC rodea la pared y llega a la parte Goal.
Script en el modelo Chaser llamado WalkToGoal
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.

Parámetros del agente para CreatePath
ClavePor defectoQué controla
AgentRadius2El radio del NPC en studs. Súbelo para NPCs anchos, así los caminos se alejan de las paredes.
AgentHeight5La altura del NPC. Los espacios más bajos que esto, como debajo de una escalera, cuentan como bloqueados.
AgentCanJumptruePermite rutas que necesitan un salto. Esos waypoints tienen Action en Jump.
AgentCanClimbfalsePermite trepar TrussParts. Esos waypoints tienen la etiqueta Climb.
WaypointSpacing4La separación en studs entre los waypoints intermedios. math.huge los quita.
CostsningunoLo 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.

  1. Borra WalkToGoal de Chaser si lo añadiste.
  2. Pasa el ratón sobre Chaser, haz clic en +, inserta un Script llamado ChaseAI y pega el código de abajo.
  3. 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ó.
Script en el modelo Chaser llamado ChaseAI
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ú.

Tirones en el pathfinding: causas y soluciones
Lo que vesCausaSolución
Va fluido cuando está solo y a tirones cuando se acerca un jugadorEl 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 paredesMoveTo 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 esquinasUn 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 segundoUn 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 sigueMoveToFinished: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.

  1. En ChaseAI, pon STOP_DISTANCE en 0 para que el NPC choque con los jugadores en vez de pararse a su lado.
  2. Inserta en Chaser un Script llamado TouchDamage y pega el código de abajo.
Script en el modelo Chaser llamado TouchDamage
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

  1. Cubre la zona con una parte, con Anchored activado y CanCollide desactivado.
  2. Inserta un PathfindingModifier en esa parte y pon su Label en DangerZone.
  3. Eso es todo. El script de persecución ya le da a DangerZone un costo de math.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.

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.

Tú escribes

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.

RoCode hace
  • 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

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.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.