Pe scurt
Pune un Script în modelul NPC-ului. Creează un traseu prin PathfindingService:CreatePath(), calculează-l prin path:ComputeAsync(start, goal) într-un pcall, apoi parcurge waypoint-urile pe rând prin Humanoid:MoveTo(), așteptând MoveToFinished înainte de următorul. Ca NPC-ul să urmărească un jucător, alege cel mai apropiat personaj și recalculează traseul când s-a mișcat câțiva studs, nu la fiecare cadru.
- Ai nevoie de un Humanoid și de un HumanoidRootPart neancorat. Apelează
SetNetworkOwner(nil)pe root part, ca să-l simuleze serverul: e reparația obișnuită pentru un NPC care sacadează lângă jucători. - Sari când
Action-ul waypoint-ului eJumpși calculează un traseu nou cândPath.Blockedse declanșează pentru un waypoint din fața NPC-ului. - Când jucătorul se vede direct, sari peste pathfinding și fă
MoveTodirect spre el. Oprește-te la câțiva studs sau mergi până lângă el, dacă NPC-ul dă daune la atingere.
Pe această pagină
Cum funcționează pathfinding-ul unui NPC
Roblox construiește o plasă de navigare (navigation mesh) din suprafețele pe care poate merge un personaj. PathfindingService caută pe această plasă un traseu între două puncte și îl returnează ca o listă de waypoint-uri: fiecare are o poziție și o acțiune, de exemplu mers sau săritură. Apoi Humanoid-ul NPC-ului merge de la un waypoint la următorul. Pathfinding-ul doar planifică traseul: să-l parcurgă trebuie scriptul tău.
| API | Ce face |
|---|---|
PathfindingService:CreatePath() | Creează un obiect Path refolosibil, pe măsura NPC-ului tău, prin parametrii agentului. |
Path:ComputeAsync(start, finish) | Calculează traseul. Cedează execuția (yield) și poate eșua, așa că apelează-l într-un pcall și verifică Path.Status. |
Path:GetWaypoints() | Returnează traseul ca o listă de valori PathWaypoint, fiecare cu Position, Action și Label. |
Path.Blocked | Se declanșează cu indexul waypoint-ului când ceva blochează traseul calculat. |
Humanoid:MoveTo(position) | Duce NPC-ul spre un punct. |
Humanoid.MoveToFinished | Se declanșează cu true când NPC-ul ajunge la aproximativ un stud de punct sau cu false dacă nu a ajuns în 8 secunde. |
Rulează toate astea într-un Script de server: serverul vede toată harta chiar și cu streaming, toți jucătorii văd același NPC, iar daunele se decid acolo unde clientul nu le poate falsifica. Script, LocalScript și ModuleScript explică această împărțire.
Pasul 1: un NPC care se poate mișca
Pe un traseu poate merge orice model, dacă are cele trei lucruri din tabelul de mai jos. Rigurilor din Toolbox sau din place-uri vechi le lipsește uneori ceva, iar de obicei arată așa: NPC-ul stă pe loc și nu apare nicio eroare.
| Cerință | De ce contează |
|---|---|
Un Humanoid numit Humanoid | MoveTo, WalkSpeed și săriturile țin de Humanoid. |
HumanoidRootPart | Part-ul controlat de Humanoid. Traseele pornesc de la poziția lui. |
| Nimic ancorat | Un part ancorat nu se poate mișca, la fel și part-urile legate de el. Part-urile ancorate sunt mereu deținute de server, așa că reparația pentru sacadare de mai jos nu li se poate aplica. |
- Deschide fila Avatar sau Home și apasă Character ca să deschizi Rig Generator. Alege R15, apoi Block Avatar. În Workspace apare un rig. Rigurile R6 merg cu aceleași scripturi.
- Redenumește rigul în
Chaserși pune-l într-un loc deschis. - Selectează-i HumanoidRootPart-ul și verifică dacă Anchored e dezactivat în fereastra Properties. Fă la fel pentru orice alt part ancorat din model. Ca să le găsești repede, activează Anchored parts în widgetul Visualization Options din colțul din dreapta sus al viewport-ului 3D.
Workspace
Chaser Model
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (părți ale corpului)
ChaseAI Script new
TouchDamage Script new
Ca NPC-ul să și vorbească, ghidul despre dialogul cu NPC adaugă un prompt Talk cu variante de răspuns și explică ce se schimbă când NPC-ul merge. Ca să arăți un boss cu camera înainte să înceapă urmărirea, vezi ghidul despre cutscene-uri.
Pasul 2: trimitem NPC-ul spre un punct
Începe cu cel mai mic script funcțional: mersul spre un part nemișcat. Arată fiecare etapă a pathfinding-ului fără logica de urmărire.
- Inserează un Part în Workspace, numește-l
Goal, activează Anchored, dezactivează CanCollide și pune-l pe podea astfel încât NPC-ul să trebuiască să ocolească un perete. - În Explorer treci cu mouse-ul peste Chaser, apasă butonul + și inserează un Script. Numește-l
WalkToGoalși lipește codul de mai jos. - Apasă Play. NPC-ul ocolește peretele și merge spre part-ul 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
-- Fizica NPC-ului trebuie deținută de server, altfel ChangeState (săritura) dintr-un Script nu merge
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 cedează execuția și poate arunca o eroare, așa că e în 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 -- primul waypoint e locul unde NPC-ul stă deja
end
humanoid:MoveTo(waypoint.Position)
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
-- Așteptăm ca NPC-ul să ajungă la acest waypoint și abia apoi mergem la următorul
local reached = humanoid.MoveToFinished:Wait()
if not reached then
warn(`{npc.Name} got stuck on the way to the goal`)
break
end
end
end
Part-ul Goal are CanCollide dezactivat, pentru că un traseu nu se poate termina într-un part solid: Status-ul traseului ar fi NoPath.
Tabelul pe care îl primește CreatePath descrie NPC-ul (Roblox îl numește agent), ca traseul să ocolească fantele prin care nu încape. Scriptul de mai sus setează primele trei chei la valorile implicite, ca să se vadă unde le schimbi.
| Cheie | Implicit | Ce stabilește |
|---|---|---|
AgentRadius | 2 | Raza NPC-ului în studs. Mărește-o pentru NPC-uri late, ca traseele să stea departe de pereți. |
AgentHeight | 5 | Înălțimea NPC-ului. Locurile mai joase de atât, de exemplu sub o scară, sunt considerate blocate. |
AgentCanJump | true | Permite trasee care cer o săritură. Aceste waypoint-uri au Action egal cu Jump. |
AgentCanClimb | false | Permite cățăratul pe TrussPart. Aceste waypoint-uri au eticheta Climb. |
WaypointSpacing | 4 | Distanța în studs dintre waypoint-urile intermediare. math.huge le elimină. |
Costs | niciunul | Cât de scump e să treci prin materiale și zone marcate. Vezi modificatori și legături. |
În buclă contează două detalii. Primul waypoint e chiar poziția NPC-ului, așa că bucla îl sare. Iar după fiecare MoveTo vine MoveToFinished:Wait(): un nou MoveTo înlocuiește ținta anterioară, așa că o buclă fără așteptare trimite NPC-ul direct la ultimul waypoint, chiar în peretele pe care trebuie să-l ocolească.
Pentru sărituri, Action-ul waypoint-ului e Jump, iar scriptul apelează ChangeState(Enum.HumanoidStateType.Jumping). Referința Roblox pentru Humanoid spune că un script de server poate schimba starea doar când serverul deține fizica personajului. E unul dintre motivele pentru care scriptul setează întâi proprietarul.
Pe pagina Roblox despre pathfinding, propriul personaj al jucătorului se mișcă prin Humanoid:Move(), cu verificarea sosirii la fiecare cadru, iar asta e numit cel mai bun mod de a duce un Humanoid pe un traseu. MoveTo cu MoveToFinished e mai scurt și mai clar pentru un NPC de server, de aceea ghidul îl folosește; dacă mai târziu ai nevoie de un control mai precis, studiază scriptul oficial.
Pasul 3: scriptul complet de urmărire
Acesta e scriptul pe care îl caută cei mai mulți. NPC-ul urmărește cel mai apropiat jucător în raza de 80 de studs, ocolește pereții, sare unde o cere traseul, găsește un traseu nou când ceva îl blochează și se întoarce acasă când nu e nimeni aproape.
- Șterge
WalkToGoaldin Chaser, dacă l-ai adăugat. - Treci cu mouse-ul peste Chaser, apasă +, inserează un Script numit
ChaseAIși lipește codul de mai jos. - Apasă Play, intră după un perete, apoi fugi în afara razei. NPC-ul ocolește peretele după tine, apoi se întoarce de unde a pornit.
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
-- Setări (distanțe în studs, timp în secunde)
local DETECTION_RANGE = 80 -- jucătorii mai departe de atât NPC-ul nu-i observă
local STOP_DISTANCE = 4 -- se oprește la această distanță de țintă (0 = merge până lângă ea, pentru daune la atingere)
local DIRECT_CHASE_RANGE = 30 -- mai aproape de atât sărim peste pathfinding, dacă nu e nimic în cale
local REPATH_DISTANCE = 4 -- cât trebuie să se miște ținta ca traseul să se recalculeze
local MIN_REPATH_INTERVAL = 0.5 -- nu calculăm niciodată trasee mai des de atât
local WAYPOINT_TIMEOUT = 2 -- renunțăm la traseu dacă un waypoint durează mai mult de atât
local CHASE_SPEED = 14 -- jucătorul merge implicit cu viteza 16, așa că poate fugi de acest NPC
local HOME_RADIUS = 4 -- atât de aproape de casă contează deja ca acasă
local RAY_HEIGHTS = { 0, -2 } -- raze de linie de vedere la nivelul taliei și lângă genunchi
local HOME = rootPart.Position -- unde revine NPC-ul când nu e nimeni în rază
humanoid.WalkSpeed = CHASE_SPEED
-- Lăsăm serverul să simuleze NPC-ul. Altfel Roblox îi poate da fizica dispozitivului
-- unui jucător din apropiere, iar NPC-ul sacadează când se schimbă proprietarul.
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, -- merge prin apă doar ca să nu facă un ocol mare
DangerZone = math.huge, -- nu intră niciodată în zonele marcate DangerZone
},
})
-- Traseul pe care merge NPC-ul chiar acum
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge
-- Blocked se poate declanșa pentru un waypoint pe care NPC-ul l-a trecut deja. Contează doar obstacolul din față.
path.Blocked:Connect(function(blockedIndex: number)
if blockedIndex >= nextIndex then
pathBlocked = true
end
end)
local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- part-urile cu care nu se lovește nimic nu blochează vederea
local function clearPath()
waypoints = {}
nextIndex = 0
pathGoal = nil
end
local function stopMoving()
clearPath()
humanoid:MoveTo(rootPart.Position)
end
-- HumanoidRootPart-ul celui mai apropiat jucător viu în DETECTION_RANGE sau 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 când ținta e cam la același nivel și între ei nu e nimic solid.
-- O rază liberă nu dovedește că se poate merge pe jos, așa că asta doar la distanță mică.
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)
-- Resetăm după calcul, ca Blocked de pe traseul vechi să nu-l marcheze pe cel nou
pathBlocked = false
if ok and path.Status == Enum.PathStatus.Success then
waypoints = path:GetWaypoints()
nextIndex = 2 -- waypoint-ul 1 e locul unde stă NPC-ul
pathGoal = goal
else
if not ok then
warn(`{npc.Name}: path request failed: {err}`)
end
clearPath() -- încă nu există traseu; bucla principală încearcă din nou în curând
end
end
local function needsNewPath(goal: Vector3): boolean
if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
return false -- tocmai s-a calculat: mergem pe traseul curent
end
local currentGoal = pathGoal
if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
return true
end
return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end
-- Așteaptă MoveToFinished, dar renunță după timeout secunde în loc de cele 8 integrate,
-- ca un NPC blocat să primească repede un traseu nou
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() -- blocat sau împins de pe drum: calculăm un traseu nou
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() -- destul de aproape: stăm lângă țintă
task.wait(0.2)
continue
end
if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
clearPath()
-- Dacă transmiți și un part, NPC-ul îl urmează cât se mișcă
humanoid:MoveTo(targetRoot.Position, targetRoot)
task.wait(0.15)
continue
end
goal = targetRoot.Position
else
if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
stopMoving() -- nu e nimeni aproape, iar NPC-ul e deja acasă
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) -- încă nu există un traseu funcțional, de exemplu ținta e inaccesibilă
end
end
Toate setările sunt sus. Pentru mai mulți NPC, duplică Chaser: fiecare copie își rulează propriul ChaseAI și își ține minte propria casă. Scripturile vechi filtrează razele prin FilterDescendantsInstances; referința Roblox recomandă acum pentru munca nouă ExcludeInstances, iar acest script exact pe acesta îl folosește.
Cum funcționează scriptul de urmărire
Fiecare trecere prin bucla principală ia o singură decizie și face o singură acțiune mică: stă pe loc, face un pas direct spre jucător sau merge la următorul waypoint. Nimic nu se decide pe mai mult de un waypoint, așa că NPC-ul reacționează tot timpul.
Găsirea celui mai apropiat jucător
findNearestTarget parcurge Players:GetPlayers(), îi sare pe toți cei fără personaj, Humanoid viu sau HumanoidRootPart (jucători care reapar sau ies) și returnează cel mai apropiat root part din DETECTION_RANGE. Căutarea se face la fiecare trecere, așa că NPC-ul trece singur la un jucător mai apropiat, iar un jucător care a ieșit pur și simplu nu mai e găsit: nu există nicio stare pe jucător de curățat.
Recalcularea traseului cât jucătorul se mișcă, dar nu la fiecare cadru
Calculul unui traseu cedează execuția și consumă timp de server. needsNewPath cere un traseu nou doar când nu există traseu, cel vechi s-a terminat sau e blocat ori jucătorul s-a îndepărtat la mai mult de REPATH_DISTANCE studs de capătul traseului curent, și niciodată mai devreme de MIN_REPATH_INTERVAL secunde după cel anterior. Cât se calculează traseul, NPC-ul continuă spre waypoint-ul curent, iar traseul nou se parcurge de la waypoint-ul 2, așa că NPC-ul nu se întoarce spre locul în care a început traseul.
Trasee blocate
Ușile se închid, part-urile cad. Path.Blocked se declanșează cu indexul waypoint-ului blocat, care poate fi în spatele NPC-ului, așa că scriptul reacționează doar la blockedIndex >= nextIndex: setează un flag, iar bucla calculează un traseu nou. Un waypoint spre care NPC-ul merge mai mult de WAYPOINT_TIMEOUT secunde, pentru că a fost împins sau s-a agățat, pornește și el un traseu nou.
Direct spre jucătorul vizibil
Pathfinding-ul nu e necesar când jucătorul se vede într-un loc deschis. În DIRECT_CHASE_RANGE, funcția canSeeDirectly trage două raze spre jucător, la nivelul taliei și lângă genunchi, ca să observe pereții joși, și ignoră ambele personaje. Dacă nicio rază nu a lovit nimic și jucătorul e cam la același nivel, NPC-ul apelează MoveTo(targetRoot.Position, targetRoot). Al doilea argument face ținta să se miște odată cu jucătorul, iar repetarea apelului la fiecare 0.15 secunde resetează mereu timeout-ul de 8 secunde.
O rază liberă dovedește că nu e nimic solid în cale, dar nu că acolo există podea. Dacă pe hartă, între NPC și jucători, sunt prăpăstii sau stânci, micșorează DIRECT_CHASE_RANGE sau pune 0, ca să folosești mereu pathfinding-ul.
Oprirea la distanța potrivită
Când jucătorul e mai aproape de STOP_DISTANCE, NPC-ul apelează MoveTo spre propria poziție, iar asta îl oprește. 4 studs se potrivesc unui NPC care trebuie să stea lângă jucător; pentru un animal de companie sau un însoțitor care păstrează distanța, pune 6 sau 8. Pentru un inamic care lovește la atingere, pune 0, ca să meargă până lângă el, ca la pasul 4.
De ce sacadează NPC-ul și cum repari
Dacă NPC-ul sacadează, îngheață la fiecare waypoint sau face pași înapoi, de obicei cauza e unul dintre punctele de mai jos. Scriptul de urmărire le ia deja în calcul pe toate; tabelul îți trebuie ca să repari un script scris de tine.
| Ce vezi | Cauza | Reparația |
|---|---|---|
| Lin cât e singur și sacadat când e un jucător aproape | Network ownership. Roblox dă fizica part-urilor neancorate dispozitivului unui jucător din apropiere, așa că NPC-ul poate fi simulat pe dispozitivul acelui jucător cât comenzile le dă serverul, iar fiecare predare poate arăta ca o smucitură. | Apelează o dată SetNetworkOwner(nil) pe HumanoidRootPart de pe server. Se aplică tuturor part-urilor legate de el. |
| Merge direct la ultimul waypoint și în pereți | MoveTo e apelat pentru fiecare waypoint într-o buclă fără așteptare. Fiecare apel înlocuiește ținta anterioară. | Așteaptă MoveToFinished înainte să treci la următorul waypoint. |
| Se oprește scurt la fiecare waypoint sau taie colțurile | Un task.wait() fix între waypoint-uri în loc să aștepte sosirea. Prea lung și NPC-ul stă; prea scurt și sare înainte. | Așteaptă MoveToFinished cu un timeout. |
| Sacadează sau face pași înapoi de câteva ori pe secundă | Un traseu nou la fiecare cadru. Fiecare pornește de la poziția NPC-ului, așa că drumul spre waypoint-ul 1 îl întoarce înapoi. | Recalculează traseul doar când ținta s-a mișcat câțiva studs, de cel mult două ori pe secundă, și pornește de la waypoint-ul 2. |
| Îngheață câteva secunde, apoi merge mai departe | MoveToFinished:Wait() pe un waypoint inaccesibil așteaptă timeout-ul de 8 secunde. | Folosește un timeout propriu, mai scurt, și calculează un traseu nou când a expirat. |
Ca să vezi cine deține NPC-ul, deschide Visualization Options în timpul unui playtest și activează Network owners. Part-urile simulate de clientul tău primesc un contur verde; part-urile serverului sau ale altui client au contur alb sau gri.
Pasul 4: daune pentru jucători la atingere (opțional)
Pentru un inamic, adaugă în NPC un al doilea script care dă daune jucătorilor la atingere. Rulează pe server, așa că clientul jucătorului nu poate schimba daunele sau ocoli cooldown-ul.
- În ChaseAI setează
STOP_DISTANCEla0, ca NPC-ul să meargă până lângă jucători în loc să se oprească alături. - Inserează în Chaser un Script numit
TouchDamageși lipește codul de mai jos.
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 învins nu dă daune
end
local character = hit:FindFirstAncestorOfClass("Model")
local player = character and Players:GetPlayerFromCharacter(character)
local targetHumanoid = character and character:FindFirstChildOfClass("Humanoid")
if not player or not targetHumanoid or targetHumanoid.Health <= 0 then
return
end
local now = os.clock()
local last = lastHit[player]
if last and now - last < COOLDOWN_SECONDS then
return -- Touched se declanșează de multe ori pe secundă cât part-urile se suprapun
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 ține cont de câmpurile de forță, așa că jucătorii sunt în siguranță cât durează câmpul de forță de după spawn. Ca să ignori câmpurile de forță, scade direct Humanoid.Health.
Cooldown-ul e ținut separat pentru fiecare jucător. Touched se declanșează de multe ori pe secundă cât part-urile se freacă unele de altele, iar fără cooldown o singură atingere i-ar putea goli jucătorului viața într-o clipă. Intrarea se șterge când jucătorul ei iese, așa că tabelul nu crește tot timpul cât trăiește serverul.
Ca jucătorii să se poată apăra, dă-le o sabie sau o armă pe raycast. Amândouă dau daune pe server oricărui lucru care are Humanoid, așa că îl vor lovi și pe Chaser.
Modificatori și legături de pathfinding
Implicit, traseul e drumul cel mai scurt, fără sărituri unde se poate. Poți schimba asta în trei feluri. Costurile și modificatorii merg cu scriptul de urmărire așa cum e, pentru că acesta transmite deja un tabel Costs lui CreatePath; pentru legături îți trebuie câteva rânduri proprii.
Costul materialelor
Cheile din Costs pot fi nume de materiale, de exemplu Water, Mud sau CrackedLava, atât pentru teren, cât și pentru part-uri. Implicit fiecare material costă 1. Un număr mai mare face NPC-ul să ocolească acel material dacă ocolul nu e mai rău, iar math.huge îl face de netrecut. Scriptul de urmărire setează Water = 20.
Zone de ocolit: PathfindingModifier
- Acoperă zona cu un part cu Anchored activat și CanCollide dezactivat.
- Inserează în acel part un PathfindingModifier și setează-i
LabellaDangerZone. - Asta e tot. Scriptul de urmărire îi dă deja lui
DangerZonecostulmath.huge, așa că NPC-ul ocolește această zonă. Activează Pathfinding modifiers în Visualization Options ca să vezi eticheta pe plasa de navigare.
Un modificator cu PassThrough activat face opusul: traseul trece printr-un obstacol solid, de exemplu o ușă închisă, ca și cum n-ar exista. NPC-ul tot nu poate trece prin ușă, dar merge spre ea, ca și cum ar fi auzit jucătorul de cealaltă parte.
Treceri proprii: PathfindingLink
PathfindingLink leagă două puncte între care NPC-ul de obicei nu poate trece, de exemplu malurile unui râu pe care îl traversează cu barca. Pune un Attachment la fiecare capăt, setează la legătură Attachment0 și Attachment1, dă-i un Label, de exemplu UseBoat, și adaugă UseBoat în Costs cu un cost mai mic decât al lui Water. Atunci în traseu apare un waypoint cu această etichetă: verifică waypoint.Label în walkToNextWaypoint și pornește acțiunea ta, de exemplu urcă NPC-ul în barcă, în loc de MoveTo. Legăturile merg în ambele sensuri, dacă nu dezactivezi IsBidirectional.
Erori frecvente și soluții
Verifică întâi fereastra Output. Se deschide din meniul Window sau din fila Script. Scripturile de pe această pagină afișează un avertisment când o cerere de traseu a eșuat sau rigul nu se poate mișca.
NPC-ul nu se mișcă deloc
Dacă în Output scrie că NPC-ul nu se poate mișca (cannot move), o parte a rigului e ancorată: scoate Anchored de pe HumanoidRootPart și de pe celelalte part-uri. Dacă nu, verifică dacă codul e într-un Script, nu într-un LocalScript, dacă stă în modelul din Workspace și dacă Humanoid-ul nu a murit.
Output scrie "Infinite yield possible" la WaitForChild
Scriptul așteaptă un obiect care nu există: un Humanoid sau HumanoidRootPart cu alt nume ori part-ul Goal lipsă pentru scriptul de la pasul 2. Redenumește obiectul sau rândul din script. Ghidul despre erorile din scripturi explică acest avertisment.
Traseul nu se construiește sau NPC-ul ignoră un jucător la care ar putea ajunge
Path.Status după ComputeAsync e NoPath când începutul sau sfârșitul e într-un part solid, când singurul traseu cere o săritură, iar AgentCanJump e false, sau când AgentHeight ori AgentRadius e prea mare pentru o fantă de pe drum. Documentația Roblox are și limite stricte: cel mult 3.000 de studs în linie dreaptă de la început la sfârșit și un buget de căutare de 20.000 de noduri, care poate să nu ajungă pentru lumi deschise uriașe sau labirinturi. Activează Navigation mesh ca să verifici traseul.
NPC-ul alunecă și nu-și mișcă picioarele
E o problemă de animație, nu de pathfinding. Personajele jucătorilor primesc automat scriptul Animate, iar un NPC are nevoie de propriul script ca să redea animațiile de mers. Fiecare NPC din NPC kit-ul Roblox are un Script numit Animate pe care îl poți studia. Cum încarci și redai o animație pe un NPC dintr-un Script de server vezi în secțiunea animația pe un NPC.
NPC-ul se blochează la colțuri sau sare, dar nu trece de obstacol
Mărește AgentRadius, ca traseele să stea mai departe de pereți, mai ales pentru NPC-urile late. Dacă sare, dar nu trece, obstacolul e mai înalt decât poate sări Humanoid-ul: mărește JumpHeight sau JumpPower la Humanoid ori schimbă nivelul.
Daunele la atingere se declanșează prea des sau niciodată
Prea des: nu există cooldown sau e ținut pe part, nu pe jucător. Niciodată: STOP_DISTANCE e mai mare decât 0, așa că NPC-ul se oprește de obicei înainte să atingă pe cineva, sau jucătorul încă are câmpul de forță de după spawn.
Construiește asta cu RoCode
Dacă îți e mai ușor să descrii NPC-ul decât să-l construiești manual, RoCode poate scrie aceste scripturi în place-ul pe care îl ai deschis. E un agent AI independent pentru Roblox Studio: scrii în chatul web, iar pluginul lui pentru Studio creează și editează scripturile în Explorer-ul tău.
Fă ca modelul Chaser din Workspace să urmărească prin pathfinding cel mai apropiat jucător în raza de 80 de studs, să se întoarcă acasă când nu e nimeni aproape și să dea 10 daune la atingere cu un cooldown de 1 secundă.
- Poate să se uite întâi la model prin Get Properties și să citească valori cheie, de exemplu Anchored la part-urile lui și WalkSpeed la Humanoid. Scrie / în chat ca să atașezi calea exactă a modelului
- Scrie scripturile de urmărire și de daune în model prin Create Script și poate scoate Anchored prin Set Property, dacă rigul are nevoie
- Verifică direct în Studio compilarea ambelor scripturi prin Check Script. Asta prinde erorile de compilare și lucruri precum wait() în loc de task.wait(), dar nu și bug-urile de logică, de exemplu un traseu care nu ajunge niciodată la jucător
- Trimite modificările în loturi, iar fiecare lot e un punct de anulare în istoria Studio
Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un personaj de test ca să verifice că jocul funcționează, dar în timpul jocului nu face capturi de ecran, așa că apasă Play și uită-te singur la NPC. Dacă se comportă altfel decât vrei, spune-i lui RoCode ce ai văzut: Check Output poate citi rândurile Server și Client din ultimul tău playtest. Un NPC e un sistem dintre multe; vezi cum construiești un joc Roblox întreg cu AI: întâi nucleul jucabil, apoi rundele. Cum se conectează RoCode la Studio.
Întrebări frecvente
Unde rulez pathfinding-ul NPC-ului: pe server sau pe client?
Pe server, într-un Script. Exemplul propriu de pathfinding al Roblox rulează într-un LocalScript, dar acolo se mișcă personajul jucătorului însuși. Un NPC e comun tuturor, iar daunele pe care le dă trebuie decise de server. Vezi Script, LocalScript și ModuleScript.
Câte NPC-uri cu urmărire suportă un server?
Documentația Roblox nu dă un număr exact; depinde de hartă și de cât de des se calculează traseele. Cel mai scump e calculul traseului, așa că scriptul de urmărire îl limitează la de două ori pe secundă pe NPC și îl sare când jucătorul se vede. Pentru multe NPC-uri, recomandările Roblox despre unde ții scripturile sugerează să le marchezi cu taguri și să le tratezi prin CollectionService dintr-un singur ModuleScript, nu să pui un script în fiecare model.
Cum fac un NPC să reapară după moarte?
Ține o copie a NPC-ului în ServerStorage, iar reapariția fă-o dintr-un script din ServerScriptService, pentru că un script din NPC e distrus odată cu el. Când se declanșează evenimentul Died al Humanoid-ului, așteaptă câteva secunde, distruge modelul vechi și pune un Clone() al copiei în Workspace. Scriptul ChaseAI din clonă pornește singur, pentru că scripturile de server rulează imediat ce ajung în Workspace.
Pot face ca NPC-urile să urmărească jucătorii doar în timpul unei runde?
Da. Lasă scriptul tău de runde să cloneze NPC-urile în Workspace când începe runda și să le distrugă când se termină. Ghidul despre sistemul de runde construiește bucla de pauză și rundă la care se leagă asta.
Surse și lecturi suplimentare
- Roblox Creator Docs: Pathfinding (în engleză). parametrii agentului, waypoint-uri, trasee blocate, modificatori, legături și limite
- Roblox Creator Docs: PathfindingService (în engleză). CreatePath și valorile implicite
- Roblox Creator Docs: Path (în engleză). ComputeAsync, GetWaypoints, Status și evenimentul Blocked
- Roblox Creator Docs: Humanoid (în engleză). MoveTo, timeout-ul de 8 secunde al MoveToFinished, ChangeState și TakeDamage
- Roblox Creator Docs: Network ownership (în engleză). proprietate automată, SetNetworkOwner și modul Network owners
- Roblox Creator Docs: RaycastParams (în engleză). ExcludeInstances și RespectCanCollide
- Roblox Creator Docs: NPC kit (în engleză). exemple de NPC cu propriile scripturi Animate
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.