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'
Actiondel waypoint èJump, e calcola un nuovo percorso quandoPath.Blockedscatta per un waypoint davanti all'NPC. - Quando il giocatore è in vista diretta, salta il pathfinding e fai
MoveTodirettamente verso di lui. Fermati a qualche stud di distanza, o vai a contatto se l'NPC fa danno al tocco.
In questa pagina
Come funziona il pathfinding degli NPC
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.
| API | Cosa 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.Blocked | Scatta con l'indice del waypoint quando qualcosa blocca il percorso calcolato. |
Humanoid:MoveTo(position) | Porta l'NPC verso un punto. |
Humanoid.MoveToFinished | Scatta 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.
| Requisito | Perché conta |
|---|---|
Uno Humanoid chiamato Humanoid | MoveTo, WalkSpeed e i salti appartengono allo Humanoid. |
Una HumanoidRootPart | La parte che lo Humanoid controlla. I percorsi partono dalla sua posizione. |
| Niente di ancorato | Una 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. |
- 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.
- Rinomina il rig in
Chasere mettilo in uno spazio aperto. - 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.
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.
- Inserisci una Part in Workspace, chiamala
Goal, attiva Anchored, disattiva CanCollide e mettila sul pavimento in modo che l'NPC debba aggirare un muro. - Nell'Explorer passa il mouse su Chaser, clicca il pulsante + e inserisci uno Script. Chiamalo
WalkToGoale incolla il codice qui sotto. - Premi Play. L'NPC aggira il muro e va verso la parte Goal.
local PathfindingService = game:GetService("PathfindingService")
local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local rootPart = npc:WaitForChild("HumanoidRootPart") :: BasePart
local goalPart = workspace:WaitForChild("Goal") :: BasePart
-- 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.
| Chiave | Predefinito | Cosa imposta |
|---|---|---|
AgentRadius | 2 | Il raggio dell'NPC in stud. Aumentalo per NPC larghi, così i percorsi restano più lontani dai muri. |
AgentHeight | 5 | L'altezza dell'NPC. I punti più bassi di così, per esempio sotto una scala, sono considerati bloccati. |
AgentCanJump | true | Permette percorsi che richiedono un salto. Quei waypoint hanno Action uguale a Jump. |
AgentCanClimb | false | Permette di arrampicarsi sulle TrussPart. Quei waypoint hanno l'etichetta Climb. |
WaypointSpacing | 4 | La distanza in stud tra i waypoint intermedi. math.huge li elimina. |
Costs | nessuno | Quanto 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.
- Elimina
WalkToGoalda Chaser, se l'avevi aggiunto. - Passa il mouse su Chaser, clicca +, inserisci uno Script chiamato
ChaseAIe incolla il codice qui sotto. - 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.
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.
| Cosa vedi | Causa | Soluzione |
|---|---|---|
| Fluido quando è solo, a scatti quando c'è un giocatore vicino | Network 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 muri | MoveTo 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 angoli | Un 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 secondo | Un 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 riparte | MoveToFinished: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.
- In ChaseAI imposta
STOP_DISTANCEa0, così l'NPC va a contatto con i giocatori invece di fermarsi accanto. - Inserisci in Chaser uno Script chiamato
TouchDamagee incolla il codice qui sotto.
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
- Copri l'area con una parte con Anchored attivo e CanCollide disattivato.
- Inserisci in quella parte un PathfindingModifier e imposta il suo
LabelaDangerZone. - Fatto. Lo script di inseguimento dà già a
DangerZoneun costomath.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.
Passaggi personalizzati: PathfindingLink
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.
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.
- 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
- Roblox Creator Docs: Pathfinding (in inglese). parametri dell'agente, waypoint, percorsi bloccati, modificatori, link e limiti
- Roblox Creator Docs: PathfindingService (in inglese). CreatePath e valori predefiniti
- Roblox Creator Docs: Path (in inglese). ComputeAsync, GetWaypoints, Status e l'evento Blocked
- Roblox Creator Docs: Humanoid (in inglese). MoveTo, il timeout di 8 secondi di MoveToFinished, ChangeState e TakeDamage
- Roblox Creator Docs: Network ownership (in inglese). proprietà automatica, SetNetworkOwner e la modalità Network owners
- Roblox Creator Docs: RaycastParams (in inglese). ExcludeInstances e RespectCanCollide
- Roblox Creator Docs: NPC kit (in inglese). esempi di NPC con i propri script Animate
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.