Tutorial · Sistemas de jogo

Como fazer um NPC seguir e perseguir o jogador no Roblox

Um NPC que contorna paredes para chegar até o jogador mais perto precisa de três coisas: um rig que consegue se mover, uma rota do PathfindingService e um loop que segue essa rota sem brigar com o motor de física. Este guia monta as três e termina com um único script de servidor que você coloca dentro de um rig de NPC.

Atualizado em 14 de novembro de 202617 min de leituraEscrito por

Resumo

Coloque um Script dentro do model do NPC. Crie um caminho com PathfindingService:CreatePath(), calcule com path:ComputeAsync(start, goal) dentro de um pcall e depois ande pelos waypoints um de cada vez com Humanoid:MoveTo(), esperando o MoveToFinished antes do próximo. Para perseguir um jogador, escolha o personagem mais perto e calcule o caminho de novo quando ele tiver andado alguns studs, não a cada frame.

  • O NPC precisa de um Humanoid e de uma HumanoidRootPart não ancorada. Chame SetNetworkOwner(nil) na root part para o servidor simular o NPC: essa é a correção mais comum para um NPC que trava perto dos jogadores.
  • Pule quando a Action de um waypoint for Jump, e calcule um caminho novo quando o Path.Blocked disparar para um waypoint à frente do NPC.
  • Quando o jogador está à vista, pule o pathfinding e use MoveTo direto nele. Pare a alguns studs, ou continue andando se o NPC causa dano ao encostar.
Nesta página
  1. Como funciona
  2. 1. Monte o NPC
  3. 2. Andar até um ponto
  4. 3. Script de perseguição
  5. Como a perseguição funciona
  6. Corrigir travadas
  7. 4. Dano ao encostar
  8. Modifiers e links
  9. Common errors
  10. With RoCode
  11. Perguntas frequentes
  12. Fontes e leitura extra

Como funciona o pathfinding de NPC

IlustraçãoO Chaser acha um jeito de contornar a parede, pula na plataforma e para a 4 studs de você.

O Roblox monta uma navigation mesh com as superfícies onde um personagem consegue andar. O PathfindingService procura nessa malha uma rota entre dois pontos e devolve essa rota como uma lista de waypoints, cada um com uma posição e uma ação, como andar ou pular. Aí o Humanoid do NPC anda de um waypoint para o próximo. O pathfinding só planeja a rota: andar por ela é trabalho do seu script.

As APIs que este guia usa
APIO que faz
PathfindingService:CreatePath()Cria um objeto Path reutilizável, do tamanho do seu NPC, com os parâmetros de agente.
Path:ComputeAsync(start, finish)Calcula a rota. Ele faz yield e pode falhar, então chame dentro de um pcall e confira o Path.Status.
Path:GetWaypoints()Devolve a rota como um array de valores PathWaypoint, cada um com Position, Action e Label.
Path.BlockedDispara com o índice de um waypoint quando alguma coisa bloqueia a rota calculada.
Humanoid:MoveTo(position)Faz o NPC andar até um ponto.
Humanoid.MoveToFinishedDispara com true quando o NPC chega a mais ou menos um stud do ponto, ou com false se ele não chegou depois de 8 segundos.

Rode tudo isso em um Script de servidor: o servidor vê o mapa inteiro mesmo com streaming ligado, todo jogador vê o mesmo NPC, e o dano é decidido onde um cliente não consegue falsificar. O guia Script vs LocalScript vs ModuleScript (em inglês) explica essa divisão.

Passo 1: Monte um NPC que consegue se mover

Qualquer model consegue seguir um caminho se tiver as três coisas abaixo. Rigs da Toolbox ou de places antigos às vezes não têm uma delas, e o sintoma comum é um NPC parado sem nenhum erro.

O que o model do NPC precisa
RequisitoPor que importa
Um Humanoid chamado HumanoidMoveTo, WalkSpeed e o pulo são todos do Humanoid.
Uma HumanoidRootPartA part que o Humanoid move. Os caminhos começam da posição dela.
Nada ancoradoUma part ancorada não se move, e as parts presas a ela por juntas também não. O servidor é sempre dono das parts ancoradas, então a correção de travadas abaixo não funciona nelas.
  1. Abra a aba Avatar ou Home e clique em Character para abrir o Rig Generator. Escolha R15 e depois Block Avatar. Um rig aparece no Workspace. Rigs R6 funcionam com os mesmos scripts.
  2. Renomeie o rig para Chaser e coloque ele em um chão aberto.
  3. Selecione a HumanoidRootPart dele e confira na janela Properties se Anchored está desmarcado. Faça o mesmo com qualquer outra part ancorada no model. Para achar elas rápido, ligue Anchored parts no widget Visualization Options, no canto superior direito da viewport 3D.
Explorer: o model do NPC no fim deste guia
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (the body parts)
    ChaseAI Script new
    TouchDamage Script new

Para fazer o NPC falar também, o guia de diálogo de NPC adiciona um prompt Talk com respostas para escolher e diz o que muda quando o NPC anda. Para mostrar um chefe com a câmera antes de ele começar a perseguir, veja o guia de cutscene.

Passo 2: Faça o NPC andar até um ponto

Comece com o menor script que funciona: andar até uma part fixa. Ele mostra cada etapa do pathfinding sem a lógica de perseguição.

  1. Insira uma Part no Workspace, dê o nome Goal, marque Anchored, desmarque CanCollide e coloque ela no chão em um lugar onde o NPC precisa contornar uma parede para chegar.
  2. No Explorer, passe o mouse sobre Chaser, clique no botão + e insira um Script. Dê o nome WalkToGoal e cole o código abaixo.
  3. Aperte Play. O NPC contorna a parede e anda até a part Goal.
Script em o model Chaser chamado 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

-- O servidor precisa ser dono da física do NPC para o ChangeState (pulo) funcionar a partir de um 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 faz yield e pode dar erro, então fica dentro do 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 -- o primeiro waypoint é onde o NPC já está parado
		end
		humanoid:MoveTo(waypoint.Position)
		if waypoint.Action == Enum.PathWaypointAction.Jump then
			humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
		end
		-- Espera chegar neste waypoint antes de ir para o próximo
		local reached = humanoid.MoveToFinished:Wait()
		if not reached then
			warn(`{npc.Name} got stuck on the way to the goal`)
			break
		end
	end
end

A part Goal fica com CanCollide desmarcado porque um caminho não pode terminar dentro de uma part sólida: o Status do caminho seria NoPath.

A tabela passada para o CreatePath descreve o NPC, que a Roblox chama de agente, para a rota evitar espaços por onde ele não passa. O script acima define as três primeiras chaves com os valores padrão para você ver onde mudar.

Parâmetros de agente do CreatePath
ChavePadrãoO que controla
AgentRadius2O raio do NPC em studs. Aumente para NPCs largos, para os caminhos ficarem longe das paredes.
AgentHeight5A altura do NPC. Espaços mais baixos que isso, como embaixo de uma escada, contam como bloqueados.
AgentCanJumptruePermite rotas que precisam de pulo. Esses waypoints têm a Action igual a Jump.
AgentCanClimbfalsePermite escalar TrussParts. Esses waypoints têm o label Climb.
WaypointSpacing4A distância em studs entre os waypoints intermediários. math.huge remove eles.
CostsnenhumO quanto custa atravessar materiais e regiões com label. Veja modifiers e links.

Dois detalhes no loop importam. O primeiro waypoint é a própria posição do NPC, então o loop pula ele. E cada MoveTo vem seguido de MoveToFinished:Wait(): um MoveTo novo substitui o destino anterior, então um loop que não espera manda o NPC direto para o último waypoint, contra a parede que ele deveria contornar.

Para os pulos, a Action do waypoint é Jump e o script chama ChangeState(Enum.HumanoidStateType.Jumping). A referência do Humanoid da Roblox diz que um script de servidor só consegue mudar um estado quando o servidor é dono da física do personagem, e esse é um dos motivos de o script definir o network owner primeiro.

A página de pathfinding da Roblox move o próprio personagem do jogador com Humanoid:Move() e uma checagem de chegada a cada frame, e diz que esse é o melhor jeito de mover um Humanoid por um caminho. MoveTo com MoveToFinished é mais curto e mais fácil de entender para um NPC no servidor, então este guia usa ele; estude o script oficial se você precisar de mais controle depois.

Passo 3: O script completo de perseguição

Este é o script que a maioria das pessoas procura. O NPC persegue o jogador mais perto a até 80 studs, contorna paredes, pula onde a rota precisa, acha uma rota nova quando alguma coisa bloqueia e volta para casa quando não tem ninguém por perto.

  1. Apague o WalkToGoal do Chaser se você adicionou ele.
  2. Passe o mouse sobre Chaser, clique em +, insira um Script chamado ChaseAI e cole o código abaixo.
  3. Aperte Play, ande para trás de uma parede e depois corra para fora do alcance. O NPC segue você pela parede e depois volta para onde começou.
Script em o model Chaser chamado 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

-- Configurações (distâncias em studs, tempos em segundos)
local DETECTION_RANGE = 80 -- jogadores mais longe que isso são ignorados
local STOP_DISTANCE = 4 -- para a essa distância do alvo (0 = anda até encostar, para dano ao tocar)
local DIRECT_CHASE_RANGE = 30 -- dentro dessa distância, pula o pathfinding quando nada está no caminho
local REPATH_DISTANCE = 4 -- quanto o alvo precisa andar antes de o caminho ser calculado de novo
local MIN_REPATH_INTERVAL = 0.5 -- nunca calcula caminhos com mais frequência que isso
local WAYPOINT_TIMEOUT = 2 -- desiste de um caminho se um waypoint demora mais que isso
local CHASE_SPEED = 14 -- um jogador anda a 16 por padrão, então consegue fugir deste NPC
local HOME_RADIUS = 4 -- estar a essa distância de casa conta como estar em casa
local RAY_HEIGHTS = { 0, -2 } -- raios de linha de visão na altura da cintura e perto dos joelhos

local HOME = rootPart.Position -- para onde o NPC volta quando não tem ninguém no alcance

humanoid.WalkSpeed = CHASE_SPEED

-- Deixa o servidor simular o NPC. Senão o Roblox pode passar a física dele para o
-- dispositivo de um jogador perto, e o NPC trava quando isso muda.
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, -- entra na água só para evitar uma volta muito longa
		DangerZone = math.huge, -- nunca entra em regiões com o label DangerZone
	},
})

-- O caminho que o NPC está seguindo agora
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge

-- O Blocked pode disparar para um waypoint que o NPC já passou. Só um bloqueio à frente importa.
path.Blocked:Connect(function(blockedIndex: number)
	if blockedIndex >= nextIndex then
		pathBlocked = true
	end
end)

local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- parts com que nada colide não bloqueiam a visão

local function clearPath()
	waypoints = {}
	nextIndex = 0
	pathGoal = nil
end

local function stopMoving()
	clearPath()
	humanoid:MoveTo(rootPart.Position)
end

-- A HumanoidRootPart do jogador vivo mais perto dentro do DETECTION_RANGE, ou 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 quando o alvo está mais ou menos no mesmo nível e nada sólido está no meio.
-- Um raio livre não prova que dá para andar no chão, então isso só é usado de perto.
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)
	-- Zera depois de calcular, para um evento Blocked da rota antiga não marcar a nova
	pathBlocked = false
	if ok and path.Status == Enum.PathStatus.Success then
		waypoints = path:GetWaypoints()
		nextIndex = 2 -- o waypoint 1 é onde o NPC está parado
		pathGoal = goal
	else
		if not ok then
			warn(`{npc.Name}: path request failed: {err}`)
		end
		clearPath() -- sem rota agora; o loop principal tenta de novo logo
	end
end

local function needsNewPath(goal: Vector3): boolean
	if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
		return false -- calculou agora há pouco: continua andando no caminho atual
	end
	local currentGoal = pathGoal
	if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
		return true
	end
	return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end

-- Espera o MoveToFinished, mas desiste depois de timeout segundos em vez dos
-- 8 padrão, para um NPC preso ganhar um caminho novo 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() -- preso ou empurrado para fora da rota: calcula um caminho novo
	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() -- perto o bastante: fica do lado do alvo
			task.wait(0.2)
			continue
		end
		if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
			clearPath()
			-- Passar a part também faz o NPC seguir ela enquanto ela se move
			humanoid:MoveTo(targetRoot.Position, targetRoot)
			task.wait(0.15)
			continue
		end
		goal = targetRoot.Position
	else
		if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
			stopMoving() -- ninguém por perto e já está em 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) -- ainda sem caminho que sirva, por exemplo o alvo está fora de alcance
	end
end

Todas as configurações ficam no topo. Para ter mais NPCs, duplique o Chaser: cada cópia roda o próprio ChaseAI e lembra a própria casa. Scripts antigos filtram raios com FilterDescendantsInstances; a referência da Roblox agora recomenda ExcludeInstances para código novo, e é o que este script usa.

Como o script de perseguição funciona

Cada volta do loop principal toma uma decisão e depois faz uma coisa pequena: ficar parado, dar um passo direto até o jogador ou andar até o próximo waypoint. Nada fica decidido por mais de um waypoint, então o NPC continua reagindo.

Achar o jogador mais perto

O findNearestTarget passa por Players:GetPlayers(), pula quem não tem personagem, Humanoid vivo ou HumanoidRootPart (jogadores renascendo ou saindo) e devolve a root part mais perto dentro do DETECTION_RANGE. A busca roda em toda volta, então o NPC troca sozinho para um jogador mais perto, e um jogador que sai simplesmente não é achado de novo: não tem estado por jogador para limpar.

Recalcular quando o jogador anda, sem fazer isso a cada frame

Calcular um caminho faz yield e gasta tempo do servidor. O needsNewPath pede um só quando não tem caminho, o antigo acabou ou foi bloqueado, ou o jogador andou mais de REPATH_DISTANCE studs de onde o caminho atual termina, e nunca dentro de MIN_REPATH_INTERVAL segundos do último. Enquanto calcula, o NPC continua andando até o waypoint atual, e o caminho novo é seguido a partir do waypoint 2, então o NPC não volta para o lugar onde o caminho começou.

Caminhos bloqueados

Portas fecham e parts caem. O Path.Blocked dispara com o índice do waypoint bloqueado, que pode estar atrás do NPC, então o script só reage quando blockedIndex >= nextIndex: ele marca uma flag e o loop calcula uma rota nova. Um waypoint que demora mais de WAYPOINT_TIMEOUT segundos para ser alcançado, porque o NPC foi empurrado ou enroscou, também gera uma rota nova.

Ir direto até um jogador visível

O pathfinding é desperdício quando o jogador está à vista em um chão aberto. Dentro do DIRECT_CHASE_RANGE, o canSeeDirectly lança dois raios até o jogador, na altura da cintura e perto dos joelhos para pegar paredes baixas, ignorando os dois personagens. Se nenhum acerta nada e o jogador está mais ou menos no mesmo nível, o NPC chama MoveTo(targetRoot.Position, targetRoot). O segundo argumento faz o destino se mover junto com o jogador, e repetir a chamada a cada 0,15 segundo fica zerando o limite de 8 segundos.

Um raio livre prova que nada sólido está no meio, não que existe chão para andar. Se o seu mapa tem buracos ou quedas entre o NPC e os jogadores, diminua o DIRECT_CHASE_RANGE, ou coloque 0 para usar sempre o pathfinding.

Parar na distância certa

Quando o jogador está dentro do STOP_DISTANCE, o NPC chama MoveTo na própria posição, o que faz ele parar. 4 studs serve para um NPC que deve ficar do lado do jogador; aumente para 6 ou 8 para um pet ou acompanhante que mantém um espaço. Para um inimigo que machuca ao encostar, coloque 0 para ele andar até o jogador, como no Passo 4.

Por que NPCs travam, e como corrigir

Um NPC que dá trancos, para em todo waypoint ou treme para trás normalmente tem uma das causas abaixo. O script de perseguição já cuida de cada uma; a tabela é para corrigir um script que você escreveu.

NPC travando no pathfinding: causas e correções
O que você vêCausaCorreção
Liso quando está sozinho, dá trancos quando um jogador chega pertoNetwork ownership. O Roblox passa a física de parts não ancoradas para o dispositivo de um jogador perto, então o NPC pode acabar simulado no dispositivo desse jogador enquanto o servidor dá as ordens, e cada troca pode aparecer como um tranco.Chame SetNetworkOwner(nil) na HumanoidRootPart uma vez, no servidor. Vale para todas as parts conectadas a ela.
Anda direto até o último waypoint e bate nas paredesMoveTo chamado para todo waypoint em um loop sem espera. Cada chamada substitui o destino anterior.Espere o MoveToFinished antes de ir para o próximo waypoint.
Para um pouco em cada waypoint, ou corta caminho nas quinasUm task.wait() fixo entre os waypoints em vez de esperar a chegada. Longo demais e o NPC fica parado; curto demais e ele pula para a frente.Espere o MoveToFinished, com um limite de tempo.
Treme ou dá passos para trás várias vezes por segundoUm caminho novo a cada frame. Cada um começa na própria posição do NPC, então andar até o waypoint 1 faz ele voltar.Recalcule só quando o alvo andou alguns studs, no máximo duas vezes por segundo, e comece do waypoint 2.
Congela por vários segundos e depois continuaMoveToFinished:Wait() em um waypoint que ele não alcança espera o limite de 8 segundos.Use um limite seu, mais curto, e calcule um caminho novo quando ele acabar.

Para ver quem é dono do NPC, abra Visualization Options durante um teste e ligue Network owners. As parts que o seu cliente simula ganham um contorno verde; as parts do servidor ou de outro cliente ficam com contorno branco ou cinza.

Passo 4: Dano ao encostar no jogador (opcional)

Para um inimigo, adicione um segundo script ao NPC que causa dano nos jogadores em que ele encosta. Ele roda no servidor, então o cliente de um jogador não consegue mudar o valor nem pular o cooldown.

  1. No ChaseAI, mude o STOP_DISTANCE para 0, para o NPC andar até os jogadores em vez de parar do lado deles.
  2. Insira um Script chamado TouchDamage no Chaser e cole o código abaixo.
Script em o model Chaser chamado 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 -- um NPC derrotado não causa dano
	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 -- o Touched dispara muitas vezes por segundo enquanto as parts se sobrepõem
	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)

O TakeDamage respeita force fields, então os jogadores ficam protegidos enquanto dura o force field do spawn. Para ignorar force fields, diminua o Humanoid.Health direto.

O cooldown é guardado por jogador. O Touched dispara muitas vezes por segundo enquanto as parts se esfregam, e sem o cooldown uma esbarrada poderia zerar a vida de um jogador em um instante. Cada entrada é removida quando o jogador dela sai, então a tabela não cresce durante a vida do servidor.

Para os jogadores poderem revidar, dê a eles a espada ou a arma com raycast (em inglês). As duas causam dano no servidor em qualquer coisa com Humanoid, então acertam o Chaser também.

Modifiers e links de pathfinding

Por padrão, um caminho é a rota mais curta, evitando pulos quando dá. Três ferramentas mudam isso. Costs e modifiers funcionam com o script de perseguição do jeito que ele está, porque ele já passa uma tabela Costs para o CreatePath; links precisam de algumas linhas suas.

Custos de material

As chaves do Costs podem ser nomes de materiais como Water, Mud ou CrackedLava, tanto para terrain quanto para parts. Todo material custa 1 por padrão. Um número maior faz o NPC evitar aquele material, a não ser que a volta seja pior, e math.huge deixa ele intransponível. O script de perseguição usa Water = 20.

Regiões para evitar: PathfindingModifier

  1. Cubra a área com uma part, com Anchored marcado e CanCollide desmarcado.
  2. Insira um PathfindingModifier nessa part e defina o Label dele como DangerZone.
  3. Só isso. O script de perseguição já dá a DangerZone um custo de math.huge, então o NPC contorna a área. Ligue Pathfinding modifiers em Visualization Options para ver o label na navigation mesh.

Um modifier com PassThrough ligado faz o contrário: a rota atravessa um obstáculo sólido, como uma porta fechada, como se ele não existisse. O NPC continua sem conseguir passar pela porta, mas vai até ela, como se tivesse ouvido o jogador do outro lado.

Um PathfindingLink liga dois pontos entre os quais o NPC normalmente não consegue ir, como as margens de um rio que ele atravessa de barco. Coloque um Attachment em cada ponta, defina o Attachment0 e o Attachment1 do link, dê a ele um Label como UseBoat e adicione UseBoat ao Costs com um custo menor que o de Water. Aí o caminho inclui um waypoint com esse label: confira o waypoint.Label no walkToNextWaypoint e rode a sua própria ação, como sentar o NPC no barco, em vez do MoveTo. Links funcionam nos dois sentidos, a não ser que você desligue o IsBidirectional.

Erros comuns e como resolver

Olhe a janela Output primeiro. Abra ela pelo menu Window ou pela aba Script. Os scripts desta página mostram um aviso quando um pedido de caminho falha ou quando o rig não consegue se mover.

O NPC não se move de jeito nenhum

Se o Output diz que o NPC não consegue se mover, alguma part do rig está ancorada: desmarque Anchored na HumanoidRootPart e nas outras parts. Se não, confira se o código é um Script, não um LocalScript, se ele está dentro do model no Workspace e se o Humanoid não morreu.

O Output mostra "Infinite yield possible" no WaitForChild

O script está esperando um objeto que não existe: um Humanoid ou HumanoidRootPart com outro nome, ou nenhuma part chamada Goal para o script do Passo 2. Renomeie o objeto ou o texto no script. O guia de erros de script explica esse aviso.

O caminho falha, ou o NPC ignora um jogador que ele conseguiria alcançar

O Path.Status fica NoPath depois do ComputeAsync quando o início ou o fim está dentro de uma part sólida, quando a única rota precisa de um pulo e o AgentCanJump é false, ou quando o AgentHeight ou o AgentRadius é grande demais para um espaço no caminho. A Roblox também documenta limites fixos: no máximo 3.000 studs em linha reta do início ao fim, e um orçamento de busca de 20.000 nós que mundos abertos enormes ou labirintos podem esgotar. Ligue a Navigation mesh para conferir a rota.

O NPC desliza sem mexer as pernas

Isso é um problema de animação, não de pathfinding. Personagens de jogadores ganham um script Animate automaticamente, mas um NPC precisa do próprio script para tocar as animações de andar. Cada NPC do NPC kit da Roblox inclui um Script chamado Animate que você pode estudar. Para carregar e tocar uma animação em um NPC a partir de um Script de servidor, veja tocar uma animação em um NPC.

O NPC fica preso nas quinas ou pula sem passar por cima do obstáculo

Aumente o AgentRadius para as rotas ficarem mais longe das paredes, principalmente para NPCs largos. Se ele pula mas nunca passa, o obstáculo é mais alto do que o Humanoid consegue pular: aumente o JumpHeight ou o JumpPower do Humanoid, ou mude o mapa.

O dano ao encostar acerta vezes demais, ou nunca

Vezes demais: falta o cooldown, ou ele está guardado por part em vez de por jogador. Nunca: o STOP_DISTANCE está acima de 0, então o NPC normalmente para antes de encostar em alguém, ou o jogador ainda está com o force field do spawn.

Crie com o RoCode

Se você prefere descrever o NPC em vez de montar tudo à mão, o RoCode pode escrever esses scripts no place que você tem aberto. Ele é um agente de IA independente para Roblox Studio: você digita em um chat na web, e o plugin dele para o Studio cria e edita os scripts no seu Explorer.

Você digita

Faça o model Chaser no Workspace perseguir o jogador mais perto a até 80 studs com pathfinding, voltar para casa quando não tiver ninguém por perto e causar 10 de dano ao encostar, com cooldown de 1 segundo.

O RoCode faz
  • Pode olhar o model primeiro, usando Get Properties para ler valores importantes como Anchored nas parts e WalkSpeed no Humanoid. Digite / no chat para anexar o caminho exato do model
  • Escreve os scripts de perseguição e de dano dentro do model com Create Script, e pode desmarcar Anchored com Set Property se o rig precisar
  • Checa a compilação dos dois scripts com Check Script dentro do Studio. Isso pega erros de compilação e padrões como wait() em vez de task.wait(), não bugs de lógica como uma rota que nunca chega ao jogador
  • Envia as mudanças em lotes, e cada lote é um ponto de desfazer no histórico do Studio

Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.11 ou mais recente ele pode controlar um personagem de teste para conferir se o jogo funciona, mas ele não tira screenshots enquanto o jogo roda, então aperte Play e olhe o NPC você mesmo. Se ele se comportar errado, conte ao RoCode o que você viu: o Check Output consegue ler as linhas de Server e Client do seu último teste. NPCs são um sistema entre muitos; veja como montar um jogo completo de Roblox com IA, primeiro um núcleo jogável e depois rodadas. Como o RoCode se conecta ao Studio.

Perguntas frequentes

O pathfinding do NPC deve rodar no servidor ou no cliente?

No servidor, em um Script. O exemplo de pathfinding da própria Roblox roda em um LocalScript, mas ele move o próprio personagem do jogador. Um NPC é compartilhado por todos, e o dano que ele causa precisa ser decidido pelo servidor. Veja Script vs LocalScript vs ModuleScript (em inglês).

Quantos NPCs perseguindo um servidor aguenta?

A documentação da Roblox não dá um número fixo; depende do seu mapa e de quantas vezes os caminhos são calculados. Calcular o caminho é a parte cara, e é por isso que o script de perseguição limita isso a duas vezes por segundo por NPC e pula o cálculo quando o jogador está à vista. Com muitos NPCs, a orientação da Roblox sobre onde colocar scripts sugere marcar eles com tags e cuidar de todos com o CollectionService a partir de um único ModuleScript, em vez de um script em cada model.

Como fazer o NPC renascer depois de morrer?

Guarde uma cópia do NPC no ServerStorage e cuide do renascimento em um script no ServerScriptService, já que um script dentro do NPC é destruído junto com ele. Quando o evento Died do Humanoid disparar, espere alguns segundos, destrua o model antigo e coloque um Clone() da cópia no Workspace. O script ChaseAI dentro do clone começa sozinho, porque scripts de servidor rodam assim que estão no Workspace.

Dá para os NPCs perseguirem os jogadores só durante uma rodada?

Sim. Faça o seu script de rodadas clonar os NPCs no Workspace quando uma rodada começa e destruir eles quando ela acaba. O guia de sistema de rounds monta o loop de intervalo e rodada onde você ligaria isso.

Fontes e leitura extra

Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.