Tutorial · Sistemi di gioco

Pathfinding degli NPC in Roblox Studio: come far seguire il giocatore a un NPC

Perché un NPC aggiri i muri e raggiunga il giocatore più vicino servono tre cose: un rig che si possa muovere, un percorso da PathfindingService e un ciclo che segua il percorso senza litigare con il motore fisico. In questa guida le costruiamo tutte e tre e alla fine otteniamo un unico script server che basta mettere nel rig dell'NPC.

Aggiornato il 20 novembre 202616 min di letturaScritto da

In breve

Metti uno Script dentro il modello dell'NPC. Crea un percorso con PathfindingService:CreatePath(), calcolalo con path:ComputeAsync(start, goal) dentro un pcall, poi percorri i waypoint uno alla volta con Humanoid:MoveTo(), aspettando MoveToFinished prima del successivo. Perché l'NPC insegua un giocatore, scegli il personaggio più vicino e ricalcola il percorso quando si è spostato di qualche stud, non a ogni frame.

  • Servono un Humanoid e una HumanoidRootPart non ancorata. Chiama SetNetworkOwner(nil) sulla root part così la simula il server: è la soluzione tipica per un NPC che scatta vicino ai giocatori.
  • Salta quando l'Action del waypoint è Jump, e calcola un nuovo percorso quando Path.Blocked scatta per un waypoint davanti all'NPC.
  • Quando il giocatore è in vista diretta, salta il pathfinding e fai MoveTo direttamente verso di lui. Fermati a qualche stud di distanza, o vai a contatto se l'NPC fa danno al tocco.
In questa pagina
  1. Come funziona il pathfinding
  2. 1. Preparare l'NPC
  3. 2. Andare verso un punto
  4. 3. Script di inseguimento
  5. Come funziona l'inseguimento
  6. Eliminare gli scatti
  7. 4. Danno al tocco
  8. Modificatori e link
  9. Common errors
  10. With RoCode
  11. Domande frequenti
  12. Fonti e letture

Come funziona il pathfinding degli NPC

IllustrazioneChaser trova un percorso intorno al muro, salta sulla sporgenza e si ferma a 4 stud da te.

Roblox costruisce una mesh di navigazione (navigation mesh) dalle superfici su cui un personaggio può camminare. PathfindingService cerca su questa mesh un percorso tra due punti e lo restituisce come lista di waypoint: ognuno ha una posizione e un'azione, per esempio camminare o saltare. Poi lo Humanoid dell'NPC cammina da un waypoint al successivo. Il pathfinding pianifica soltanto il percorso: a muoversi lungo di esso deve pensarci il tuo script.

Le API usate in questa guida
APICosa fa
PathfindingService:CreatePath()Crea un oggetto Path riutilizzabile, adatto alle dimensioni del tuo NPC tramite i parametri dell'agente.
Path:ComputeAsync(start, finish)Calcola il percorso. Sospende l'esecuzione (yield) e può fallire, quindi chiamalo dentro un pcall e controlla Path.Status.
Path:GetWaypoints()Restituisce il percorso come array di valori PathWaypoint, ognuno con Position, Action e Label.
Path.BlockedScatta con l'indice del waypoint quando qualcosa blocca il percorso calcolato.
Humanoid:MoveTo(position)Porta l'NPC verso un punto.
Humanoid.MoveToFinishedScatta con true quando l'NPC arriva a circa uno stud dal punto, o con false se non ci è arrivato in 8 secondi.

Esegui tutto questo in uno Script server: il server vede tutta la mappa anche con lo streaming, tutti i giocatori vedono lo stesso NPC, e il danno viene deciso dove il client non può falsificarlo. Script, LocalScript e ModuleScript (in inglese) spiega questa divisione.

Passo 1: un NPC che si può muovere

Qualsiasi modello può seguire un percorso, se ha le tre cose della tabella qui sotto. Ai rig presi dalla Toolbox o da vecchi place a volte manca qualcosa, e di solito si vede così: l'NPC resta fermo e non c'è nessun errore.

Cosa serve al modello dell'NPC
RequisitoPerché conta
Uno Humanoid chiamato HumanoidMoveTo, WalkSpeed e i salti appartengono allo Humanoid.
Una HumanoidRootPartLa parte che lo Humanoid controlla. I percorsi partono dalla sua posizione.
Niente di ancoratoUna parte ancorata non può muoversi, e nemmeno le parti collegate a essa. Le parti ancorate appartengono sempre al server, quindi la correzione degli scatti spiegata più sotto non si può applicare.
  1. Apri la scheda Avatar o Home e clicca Character per aprire il Rig Generator. Scegli R15, poi Block Avatar. In Workspace compare un rig. I rig R6 funzionano con gli stessi script.
  2. Rinomina il rig in Chaser e mettilo in uno spazio aperto.
  3. Seleziona la sua HumanoidRootPart e controlla che Anchored nella finestra Properties sia disattivato. Fai lo stesso per ogni altra parte ancorata del modello. Per trovarle in fretta, attiva Anchored parts nel widget Visualization Options nell'angolo in alto a destra della viewport 3D.
Explorer: il modello dell'NPC alla fine di questa guida
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (parti del corpo)
    ChaseAI Script new
    TouchDamage Script new

Per far anche parlare l'NPC, la guida ai dialoghi degli NPC aggiunge un prompt Talk con risposte a scelta e spiega cosa cambia quando l'NPC cammina. Per mostrare il boss con la telecamera prima che inizi l'inseguimento, guarda la guida alle cutscene.

Passo 2: mandare l'NPC verso un punto

Parti dallo script funzionante più piccolo: raggiungere una parte ferma. Mostra ogni fase del pathfinding senza la logica dell'inseguimento.

  1. Inserisci una Part in Workspace, chiamala Goal, attiva Anchored, disattiva CanCollide e mettila sul pavimento in modo che l'NPC debba aggirare un muro.
  2. Nell'Explorer passa il mouse su Chaser, clicca il pulsante + e inserisci uno Script. Chiamalo WalkToGoal e incolla il codice qui sotto.
  3. Premi Play. L'NPC aggira il muro e va verso la parte Goal.
Script in modello Chaser chiamato 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

-- La fisica dell'NPC deve appartenere al server, altrimenti ChangeState (salto) da uno Script non funziona
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 sospende l'esecuzione e può lanciare un errore, per questo è dentro un 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 -- il primo waypoint è il punto in cui l'NPC si trova già
		end
		humanoid:MoveTo(waypoint.Position)
		if waypoint.Action == Enum.PathWaypointAction.Jump then
			humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
		end
		-- Aspettiamo che l'NPC arrivi a questo waypoint, e solo dopo andiamo al successivo
		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 ha CanCollide disattivato, perché un percorso non può finire dentro una parte solida: lo Status del percorso sarebbe NoPath.

La tabella che riceve CreatePath descrive l'NPC (Roblox lo chiama agente), così il percorso evita i passaggi in cui non ci sta. Lo script qui sopra imposta le prime tre chiavi ai valori predefiniti, così si vede dove cambiarle.

Parametri dell'agente per CreatePath
ChiavePredefinitoCosa imposta
AgentRadius2Il raggio dell'NPC in stud. Aumentalo per NPC larghi, così i percorsi restano più lontani dai muri.
AgentHeight5L'altezza dell'NPC. I punti più bassi di così, per esempio sotto una scala, sono considerati bloccati.
AgentCanJumptruePermette percorsi che richiedono un salto. Quei waypoint hanno Action uguale a Jump.
AgentCanClimbfalsePermette di arrampicarsi sulle TrussPart. Quei waypoint hanno l'etichetta Climb.
WaypointSpacing4La distanza in stud tra i waypoint intermedi. math.huge li elimina.
CostsnessunoQuanto costa attraversare materiali e aree etichettate. Vedi modificatori e link.

Nel ciclo contano due dettagli. Il primo waypoint è la posizione dell'NPC stesso, quindi il ciclo lo salta. E dopo ogni MoveTo c'è MoveToFinished:Wait(): un nuovo MoveTo sostituisce la destinazione precedente, quindi un ciclo senza attesa manda l'NPC dritto all'ultimo waypoint, proprio contro il muro che dovrebbe aggirare.

Per i salti l'Action del waypoint è Jump, e lo script chiama ChangeState(Enum.HumanoidStateType.Jumping). Il riferimento di Roblox su Humanoid dice che uno script server può cambiare lo stato solo quando il server possiede la fisica del personaggio. È uno dei motivi per cui lo script imposta prima il proprietario.

Nella pagina di Roblox sul pathfinding il personaggio del giocatore si muove con Humanoid:Move() e un controllo dell'arrivo a ogni frame, e questo viene indicato come il modo migliore per guidare uno Humanoid lungo un percorso. MoveTo con MoveToFinished è più breve e più chiaro per un NPC server, quindi la guida usa questo; se più avanti ti serve un controllo più preciso, studia lo script ufficiale.

Passo 3: lo script di inseguimento completo

Questo è lo script che cercano quasi tutti. L'NPC insegue il giocatore più vicino entro 80 stud, aggira i muri, salta dove il percorso lo richiede, trova un nuovo percorso quando qualcosa lo blocca, e torna a casa quando non c'è nessuno vicino.

  1. Elimina WalkToGoal da Chaser, se l'avevi aggiunto.
  2. Passa il mouse su Chaser, clicca +, inserisci uno Script chiamato ChaseAI e incolla il codice qui sotto.
  3. Premi Play, vai dietro un muro, poi scappa oltre la portata. L'NPC aggira il muro per seguirti, e poi torna da dove era partito.
Script in modello Chaser chiamato 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

-- Impostazioni (distanze in stud, tempi in secondi)
local DETECTION_RANGE = 80 -- i giocatori più lontani di così l'NPC non li nota
local STOP_DISTANCE = 4 -- fermarsi a questa distanza dal bersaglio (0 = andare a contatto, per il danno al tocco)
local DIRECT_CHASE_RANGE = 30 -- più vicino di così saltiamo il pathfinding, se non c'è niente in mezzo
local REPATH_DISTANCE = 4 -- di quanto deve spostarsi il bersaglio perché il percorso venga ricalcolato
local MIN_REPATH_INTERVAL = 0.5 -- mai calcolare percorsi più spesso di così
local WAYPOINT_TIMEOUT = 2 -- abbandonare il percorso se un waypoint richiede più di così
local CHASE_SPEED = 14 -- il giocatore di default cammina a 16, quindi può sfuggire a questo NPC
local HOME_RADIUS = 4 -- così vicino a casa conta già come casa
local RAY_HEIGHTS = { 0, -2 } -- raggi di visuale diretta all'altezza della vita e vicino alle ginocchia

local HOME = rootPart.Position -- dove l'NPC torna quando nel raggio non c'è nessuno

humanoid.WalkSpeed = CHASE_SPEED

-- Lasciamo che sia il server a simulare l'NPC. Altrimenti Roblox può dare la sua fisica al dispositivo
-- di un giocatore vicino, e l'NPC scatta quando il proprietario 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, -- attraversare l'acqua solo per evitare una lunga deviazione
		DangerZone = math.huge, -- non entrare mai nelle aree con etichetta DangerZone
	},
})

-- Il percorso che l'NPC sta seguendo in questo momento
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge

-- Blocked può scattare per un waypoint che l'NPC ha già superato. Conta solo un ostacolo davanti.
path.Blocked:Connect(function(blockedIndex: number)
	if blockedIndex >= nextIndex then
		pathBlocked = true
	end
end)

local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- le parti con cui niente collide non bloccano la visuale

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

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

-- La HumanoidRootPart del giocatore vivo più vicino entro DETECTION_RANGE, oppure 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 il bersaglio è più o meno allo stesso livello e in mezzo non c'è niente di solido.
-- Un raggio libero non prova che il terreno sia percorribile, quindi vale solo a breve distanza.
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)
	-- Azzeriamo dopo il calcolo, così un Blocked del vecchio percorso non segna quello nuovo
	pathBlocked = false
	if ok and path.Status == Enum.PathStatus.Success then
		waypoints = path:GetWaypoints()
		nextIndex = 2 -- il waypoint 1 è il punto in cui si trova l'NPC
		pathGoal = goal
	else
		if not ok then
			warn(`{npc.Name}: path request failed: {err}`)
		end
		clearPath() -- per ora nessun percorso; il ciclo principale riproverà presto
	end
end

local function needsNewPath(goal: Vector3): boolean
	if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
		return false -- appena calcolato: seguiamo il percorso attuale
	end
	local currentGoal = pathGoal
	if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
		return true
	end
	return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end

-- Aspetta MoveToFinished, ma si arrende dopo timeout secondi invece degli 8 integrati,
-- così un NPC bloccato riceve presto un nuovo percorso
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() -- bloccato o spinto fuori rotta: calcoliamo un nuovo percorso
	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() -- abbastanza vicino: restiamo accanto al bersaglio
			task.wait(0.2)
			continue
		end
		if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
			clearPath()
			-- Se passiamo anche la parte, l'NPC la segue mentre si muove
			humanoid:MoveTo(targetRoot.Position, targetRoot)
			task.wait(0.15)
			continue
		end
		goal = targetRoot.Position
	else
		if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
			stopMoving() -- nessuno vicino, e l'NPC è già a 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) -- ancora nessun percorso valido, per esempio il bersaglio è irraggiungibile
	end
end

Tutte le impostazioni sono in alto. Per più NPC duplica Chaser: ogni copia esegue il proprio ChaseAI e ricorda la propria casa. Gli script più vecchi filtrano i raggi con FilterDescendantsInstances; il riferimento di Roblox ora consiglia per il lavoro nuovo ExcludeInstances, ed è quello che usa questo script.

Come funziona lo script di inseguimento

Ogni giro del ciclo principale prende una sola decisione e fa una sola piccola azione: stare fermo, fare un passo dritto verso il giocatore o andare al waypoint successivo. Nessuna decisione vale per più di un waypoint, quindi l'NPC reagisce di continuo.

Trovare il giocatore più vicino

findNearestTarget scorre Players:GetPlayers(), salta chi non ha un personaggio, uno Humanoid vivo o una HumanoidRootPart (giocatori che stanno rinascendo o uscendo) e restituisce la root part più vicina entro DETECTION_RANGE. La ricerca avviene a ogni giro, quindi l'NPC passa da solo a un giocatore più vicino, e un giocatore uscito semplicemente non viene più trovato: non c'è nessuno stato per giocatore da ripulire.

Ricalcolare il percorso mentre il giocatore si muove, ma non a ogni frame

Il calcolo del percorso sospende l'esecuzione e consuma tempo del server. needsNewPath chiede un nuovo percorso solo quando non ce n'è uno, quello vecchio è finito o bloccato, o il giocatore si è allontanato più di REPATH_DISTANCE stud dalla fine del percorso attuale, e mai prima di MIN_REPATH_INTERVAL secondi dal precedente. Mentre il percorso viene calcolato l'NPC continua verso il waypoint attuale, e il nuovo percorso viene seguito dal waypoint 2, così l'NPC non si gira verso il punto in cui il percorso è iniziato.

Percorsi bloccati

Le porte si chiudono, le parti cadono. Path.Blocked scatta con l'indice del waypoint bloccato, che può essere dietro l'NPC, quindi lo script reagisce solo con blockedIndex >= nextIndex: imposta un flag e il ciclo calcola un nuovo percorso. Anche un waypoint che l'NPC impiega più di WAYPOINT_TIMEOUT secondi a raggiungere, perché è stato spinto o si è incastrato, avvia un nuovo percorso.

Dritto verso un giocatore visibile

Il pathfinding non serve quando il giocatore è in vista in uno spazio aperto. Entro DIRECT_CHASE_RANGE la funzione canSeeDirectly lancia verso il giocatore due raggi, all'altezza della vita e vicino alle ginocchia per notare i muri bassi, e ignora entrambi i personaggi. Se nessun raggio colpisce qualcosa e il giocatore è più o meno allo stesso livello, l'NPC chiama MoveTo(targetRoot.Position, targetRoot). Il secondo argomento fa muovere la destinazione insieme al giocatore, e ripetere la chiamata ogni 0.15 secondi azzera continuamente il timeout di 8 secondi.

Un raggio libero prova che in mezzo non c'è niente di solido, ma non che ci sia un pavimento. Se sulla mappa tra l'NPC e i giocatori ci sono burroni o dirupi, riduci DIRECT_CHASE_RANGE o mettilo a 0 per usare sempre il pathfinding.

Fermarsi alla distanza giusta

Quando il giocatore è più vicino di STOP_DISTANCE, l'NPC chiama MoveTo sulla propria posizione, e questo lo ferma. 4 stud vanno bene per un NPC che deve stare accanto al giocatore; per un pet o un accompagnatore che tiene le distanze, metti 6 o 8. Per un nemico che colpisce al tocco, metti 0 così va a contatto, come nel passo 4.

Perché l'NPC scatta e come risolverlo

Se l'NPC scatta, si blocca a ogni waypoint o fa passi indietro, di solito la causa è uno dei punti qui sotto. Lo script di inseguimento tiene già conto di ognuno; la tabella serve per sistemare uno script che hai scritto tu.

Scatti nel pathfinding: cause e soluzioni
Cosa vediCausaSoluzione
Fluido quando è solo, a scatti quando c'è un giocatore vicinoNetwork ownership. Roblox dà la fisica delle parti non ancorate al dispositivo di un giocatore vicino, quindi l'NPC può essere simulato sul dispositivo di quel giocatore mentre i comandi li dà il server, e ogni passaggio può sembrare uno scatto.Chiama una volta SetNetworkOwner(nil) sulla HumanoidRootPart dal server. Vale per tutte le parti collegate.
Va dritto all'ultimo waypoint e contro i muriMoveTo viene chiamato per ogni waypoint in un ciclo senza attesa. Ogni chiamata sostituisce la destinazione precedente.Aspetta MoveToFinished prima di passare al waypoint successivo.
Si ferma un attimo a ogni waypoint o taglia gli angoliUn task.wait() fisso tra i waypoint invece di aspettare l'arrivo. Troppo lungo, e l'NPC sta fermo; troppo corto, e salta avanti.Aspetta MoveToFinished con un timeout.
Scatta o fa passi indietro più volte al secondoUn nuovo percorso a ogni frame. Ognuno parte dalla posizione dell'NPC, quindi andare al waypoint 1 lo fa girare indietro.Ricalcola il percorso solo quando il bersaglio si è spostato di qualche stud, non più di due volte al secondo, e parti dal waypoint 2.
Si blocca per qualche secondo, poi riparteMoveToFinished:Wait() su un waypoint irraggiungibile aspetta il timeout di 8 secondi.Usa un tuo timeout più breve e calcola un nuovo percorso quando scade.

Per vedere chi possiede l'NPC, apri Visualization Options durante un playtest e attiva Network owners. Le parti simulate dal tuo client hanno un contorno verde; quelle del server o di un altro client hanno un contorno bianco o grigio.

Passo 4: danno ai giocatori al tocco (facoltativo)

Per un nemico, aggiungi all'NPC un secondo script che danneggia i giocatori quando li tocca. Gira sul server, quindi il client del giocatore non può cambiare il danno o aggirare il cooldown.

  1. In ChaseAI imposta STOP_DISTANCE a 0, così l'NPC va a contatto con i giocatori invece di fermarsi accanto.
  2. Inserisci in Chaser uno Script chiamato TouchDamage e incolla il codice qui sotto.
Script in modello Chaser chiamato 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 sconfitto non fa danno
	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 scatta molte volte al secondo mentre le parti si sovrappongono
	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 rispetta i campi di forza, quindi i giocatori sono al sicuro finché dura il campo di forza dopo lo spawn. Per ignorare i campi di forza, riduci direttamente Humanoid.Health.

Il cooldown è salvato separatamente per ogni giocatore. Touched scatta molte volte al secondo mentre le parti si strofinano, e senza cooldown un solo contatto potrebbe azzerare in un attimo la salute del giocatore. La voce viene eliminata quando il suo giocatore esce, quindi la tabella non cresce per tutta la vita del server.

Per permettere ai giocatori di difendersi, dai loro una spada o una pistola a raycast (in inglese). Entrambe fanno danno sul server a qualsiasi cosa abbia uno Humanoid, quindi colpiranno anche Chaser.

Modificatori e link del pathfinding

Di default il percorso è il tragitto più breve, senza salti quando possibile. Puoi cambiarlo in tre modi. Costi e modificatori funzionano con lo script di inseguimento così com'è, perché passa già una tabella Costs a CreatePath; per i link servono alcune righe tue.

Costo dei materiali

Le chiavi di Costs possono essere nomi di materiali, per esempio Water, Mud o CrackedLava, sia per il terrain sia per le parti. Di default ogni materiale costa 1. Un numero più alto fa evitare all'NPC quel materiale se la deviazione non è peggiore, e math.huge lo rende impraticabile. Lo script di inseguimento imposta Water = 20.

Aree da evitare: PathfindingModifier

  1. Copri l'area con una parte con Anchored attivo e CanCollide disattivato.
  2. Inserisci in quella parte un PathfindingModifier e imposta il suo Label a DangerZone.
  3. Fatto. Lo script di inseguimento dà già a DangerZone un costo math.huge, quindi l'NPC evita quell'area. Attiva Pathfinding modifiers in Visualization Options per vedere l'etichetta sulla mesh di navigazione.

Un modificatore con PassThrough attivo fa il contrario: il percorso passa attraverso un ostacolo solido, per esempio una porta chiusa, come se non ci fosse. L'NPC comunque non può attraversare la porta, ma ci va incontro come se avesse sentito il giocatore dall'altra parte.

Un PathfindingLink collega due punti tra cui l'NPC normalmente non può passare, per esempio le rive di un fiume che attraversa in barca. Metti un Attachment a ogni estremità, imposta Attachment0 e Attachment1 del link, dagli un Label, per esempio UseBoat, e aggiungi UseBoat a Costs con un costo più basso di Water. A quel punto nel percorso comparirà un waypoint con quell'etichetta: controlla waypoint.Label in walkToNextWaypoint e avvia la tua azione, per esempio far salire l'NPC in barca, al posto di MoveTo. I link funzionano in entrambe le direzioni, a meno che tu non disattivi IsBidirectional.

Errori comuni e soluzioni

Controlla prima la finestra Output. Si apre dal menu Window o dalla scheda Script. Gli script di questa pagina stampano un avviso quando una richiesta di percorso fallisce o il rig non può muoversi.

L'NPC non si muove per niente

Se l'Output dice che l'NPC non può muoversi (cannot move), una parte del rig è ancorata: togli Anchored dalla HumanoidRootPart e dalle altre parti. Altrimenti controlla che il codice sia in uno Script e non in un LocalScript, che stia dentro il modello in Workspace e che lo Humanoid non sia morto.

L'Output scrive "Infinite yield possible" su WaitForChild

Lo script aspetta un oggetto che non c'è: uno Humanoid o una HumanoidRootPart con un altro nome, o una parte Goal mancante per lo script del passo 2. Rinomina l'oggetto o la stringa nello script. La guida agli errori degli script spiega questo avviso.

Il percorso non si crea, o l'NPC ignora un giocatore che potrebbe raggiungere

Path.Status dopo ComputeAsync vale NoPath quando l'inizio o la fine sono dentro una parte solida, quando l'unico percorso richiede un salto e AgentCanJump è false, o quando AgentHeight o AgentRadius è troppo grande per un passaggio lungo il tragitto. La documentazione di Roblox indica anche limiti fissi: non più di 3.000 stud in linea retta dall'inizio alla fine e un budget di ricerca di 20.000 nodi, che può non bastare per enormi mondi aperti o labirinti. Attiva Navigation mesh per controllare il percorso.

L'NPC scivola e non muove le gambe

È un problema di animazione, non di pathfinding. I personaggi dei giocatori ricevono lo script Animate automaticamente, mentre un NPC ha bisogno di un suo script per riprodurre le animazioni di camminata. Ogni NPC del NPC kit di Roblox ha uno Script chiamato Animate che puoi studiare. Per caricare e riprodurre un'animazione su un NPC da uno Script server, guarda la sezione animazione sugli NPC.

L'NPC si incastra negli angoli o salta ma non supera l'ostacolo

Aumenta AgentRadius, così i percorsi restano più lontani dai muri, soprattutto per NPC larghi. Se salta ma non riesce a passare, l'ostacolo è più alto di quanto lo Humanoid possa saltare: aumenta JumpHeight o JumpPower dello Humanoid o modifica il livello.

Il danno al tocco scatta troppo spesso o mai

Troppo spesso: non c'è un cooldown, o è salvato per ogni parte invece che per ogni giocatore. Mai: STOP_DISTANCE è maggiore di 0, quindi l'NPC di solito si ferma prima di toccare qualcuno, oppure il giocatore ha ancora il campo di forza dello spawn.

Costruiscilo con RoCode

Se per te è più facile descrivere l'NPC che costruirlo a mano, RoCode può scrivere questi script nel place che hai aperto. È un agente IA indipendente per Roblox Studio: scrivi nella chat web, e il suo plugin per Studio crea e modifica gli script nel tuo Explorer.

Tu scrivi

Fai in modo che il modello Chaser in Workspace insegua con il pathfinding il giocatore più vicino entro 80 stud, torni a casa quando non c'è nessuno vicino e faccia 10 di danno al tocco con un cooldown di 1 secondo.

RoCode fa
  • Può prima esaminare il modello con Get Properties e leggere i valori chiave, per esempio Anchored sulle sue parti e WalkSpeed dello Humanoid. Scrivi / nella chat per allegare il percorso esatto del modello
  • Scrive gli script di inseguimento e di danno dentro il modello con Create Script, e può togliere Anchored con Set Property se il rig ne ha bisogno
  • Controlla che entrambi gli script compilino con Check Script direttamente in Studio. Questo trova gli errori di compilazione e cose come wait() al posto di task.wait(), ma non i bug di logica come un percorso che non arriva mai al giocatore
  • Invia le modifiche a gruppi, e ogni gruppo è un punto di annullamento nella cronologia di Studio

Con il plugin 3.9 o più recente RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o più recente può controllare un personaggio di prova per verificare che il gioco funzioni, ma durante il gioco non fa screenshot, quindi premi Play e guarda tu l'NPC. Se si comporta in modo diverso, racconta a RoCode cosa hai visto: Check Output può leggere le righe Server e Client del tuo ultimo playtest. Un NPC è un sistema tra tanti; guarda come costruire un intero gioco Roblox con l'IA: prima il nucleo giocabile, poi i round. Come RoCode si collega a Studio.

Domande frequenti

Dove va eseguito il pathfinding degli NPC: sul server o sul client?

Sul server, in uno Script. L'esempio di pathfinding di Roblox gira in un LocalScript, ma lì si muove il personaggio del giocatore stesso. Un NPC è condiviso da tutti, e il danno che fa deve deciderlo il server. Vedi Script, LocalScript e ModuleScript (in inglese).

Quanti NPC che inseguono regge un server?

La documentazione di Roblox non dà un numero preciso; dipende dalla mappa e da quanto spesso si calcolano i percorsi. La cosa più costosa è il calcolo del percorso, quindi lo script di inseguimento lo limita a due volte al secondo per NPC e lo salta quando il giocatore è in vista. Per molti NPC, le indicazioni di Roblox su dove tenere gli script consigliano di etichettarli con tag e gestirli tramite CollectionService da un solo ModuleScript, invece di mettere uno script in ogni modello.

Come faccio a far rinascere un NPC dopo la morte?

Tieni una copia dell'NPC in ServerStorage e gestisci la rinascita da uno script in ServerScriptService, perché uno script dentro l'NPC viene distrutto insieme a lui. Quando scatta l'evento Died dello Humanoid, aspetta qualche secondo, distruggi il vecchio modello e metti in Workspace un Clone() della copia. Lo script ChaseAI dentro il clone partirà da solo, perché gli script server girano appena si trovano in Workspace.

Si può fare in modo che gli NPC inseguano i giocatori solo durante un round?

Sì. Fai clonare gli NPC in Workspace dal tuo script dei round quando il round inizia, e falli distruggere quando finisce. La guida al sistema di round costruisce il ciclo di intermissione e round a cui collegarlo.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.