संक्षेप में
NPC मॉडल के अंदर एक Script रखें। PathfindingService:CreatePath() से रास्ता बनाएँ, pcall के अंदर path:ComputeAsync(start, goal) से उसे गिनें, फिर Humanoid:MoveTo() से waypoints पर एक-एक करके चलें, और अगले पर जाने से पहले MoveToFinished का इंतज़ार करें। NPC प्लेयर का पीछा करे, इसके लिए सबसे नज़दीकी कैरेक्टर चुनें और रास्ता तब दोबारा गिनें जब वह कुछ studs हिल चुका हो, हर फ़्रेम नहीं।
- Humanoid और बिना Anchored वाला HumanoidRootPart चाहिए। root part पर
SetNetworkOwner(nil)कॉल करें ताकि उसे सर्वर simulate करे: प्लेयर के पास झटके खाने वाले NPC का यही आम इलाज है। - जब waypoint का
ActionJumpहो तो कूदें, और जब NPC के आगे वाले waypoint के लिएPath.Blockedचले तो नया रास्ता गिनें। - जब प्लेयर सीधे दिख रहा हो, तो pathfinding छोड़ें और सीधे उसकी ओर
MoveToकरें। कुछ studs पर रुकें, या अगर NPC छूकर डैमेज देता है तो बिल्कुल पास तक जाएँ।
इस पेज पर
NPC pathfinding कैसे काम करता है
Roblox उन सतहों से एक नेविगेशन मेश (navigation mesh) बनाता है जिन पर कैरेक्टर चल सकता है। PathfindingService इस मेश पर दो पॉइंट के बीच रास्ता ढूँढता है और उसे waypoints की लिस्ट के रूप में लौटाता है: हर एक की एक पोज़ीशन और एक action होता है, जैसे चलना या कूदना। फिर NPC का Humanoid एक waypoint से अगले तक चलता है। Pathfinding सिर्फ़ रास्ता प्लान करता है: उस पर चलाना आपकी स्क्रिप्ट का काम है।
| API | क्या करता है |
|---|---|
PathfindingService:CreatePath() | एक Path ऑब्जेक्ट बनाता है जिसे कई बार इस्तेमाल कर सकते हैं, agent parameters से आपके NPC के साइज़ के हिसाब से। |
Path:ComputeAsync(start, finish) | रास्ता गिनता है। यह yield करता है और फ़ेल हो सकता है, इसलिए इसे pcall के अंदर कॉल करें और Path.Status जाँचें। |
Path:GetWaypoints() | रास्ते को PathWaypoint वैल्यू की array के रूप में लौटाता है, हर एक में Position, Action और Label होता है। |
Path.Blocked | जब कोई चीज़ गिने हुए रास्ते को रोकती है, तो waypoint के index के साथ चलता है। |
Humanoid:MoveTo(position) | NPC को एक पॉइंट तक ले जाता है। |
Humanoid.MoveToFinished | जब NPC पॉइंट के लगभग एक stud तक पहुँचता है तो true के साथ चलता है, या false के साथ अगर वह 8 सेकंड में नहीं पहुँचा। |
यह सब एक सर्वर Script में चलाएँ: streaming के साथ भी सर्वर पूरा मैप देखता है, सारे प्लेयर एक ही NPC देखते हैं, और डैमेज वहाँ तय होता है जहाँ क्लाइंट उसे नकली नहीं बना सकता। Script, LocalScript और ModuleScript यह बँटवारा समझाती है।
स्टेप 1: एक NPC जो चल सके
कोई भी मॉडल रास्ते पर चल सकता है, अगर उसमें नीचे की टेबल वाली तीन चीज़ें हों। Toolbox या पुराने places के रिग में कभी-कभी कुछ कमी होती है, और आमतौर पर यह ऐसा दिखता है: NPC अपनी जगह खड़ा रहता है और कोई एरर नहीं आता।
| ज़रूरत | यह क्यों ज़रूरी है |
|---|---|
Humanoid नाम का Humanoid | MoveTo, WalkSpeed और कूदना Humanoid के हिस्से हैं। |
HumanoidRootPart | वह पार्ट जिसे Humanoid चलाता है। रास्ते उसी की पोज़ीशन से शुरू होते हैं। |
| कुछ भी Anchored नहीं | Anchored पार्ट हिल नहीं सकता, न ही उससे जुड़े पार्ट। Anchored पार्ट हमेशा सर्वर के होते हैं, इसलिए नीचे बताया गया झटकों का इलाज उन पर लागू नहीं होता। |
- Avatar या Home टैब खोलें और Rig Generator खोलने के लिए Character दबाएँ। R15 चुनें, फिर Block Avatar। Workspace में एक रिग आ जाएगा। R6 रिग भी इन्हीं स्क्रिप्ट के साथ काम करते हैं।
- रिग का नाम बदलकर
Chaserकरें और उसे खुली जगह पर रखें। - उसका HumanoidRootPart चुनें और देखें कि Properties विंडो में Anchored बंद है। मॉडल के किसी भी दूसरे Anchored पार्ट के लिए भी यही करें। उन्हें जल्दी ढूँढने के लिए 3D viewport के ऊपरी दाएँ कोने में Visualization Options विजेट में Anchored parts चालू करें।
Workspace
Chaser Model
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (शरीर के हिस्से)
ChaseAI Script new
TouchDamage Script new
NPC बात भी करे, इसके लिए NPC डायलॉग गाइड जवाब के विकल्पों वाला Talk prompt जोड़ती है और समझाती है कि NPC के चलने पर क्या बदलता है। पीछा शुरू करने से पहले बॉस को कैमरे से दिखाने के लिए कटसीन गाइड देखें।
स्टेप 2: NPC को एक पॉइंट तक भेजना
सबसे छोटी काम करने वाली स्क्रिप्ट से शुरू करें: एक स्थिर पार्ट तक चलना। यह pathfinding का हर स्टेप बिना पीछा करने वाले लॉजिक के दिखाती है।
- Workspace में एक Part डालें, उसका नाम
Goalरखें, Anchored चालू करें, CanCollide बंद करें और उसे फ़र्श पर ऐसी जगह रखें कि NPC को दीवार के चारों ओर जाना पड़े। - Explorer में Chaser पर कर्सर ले जाएँ, + बटन दबाएँ और एक Script डालें। उसका नाम
WalkToGoalरखें और नीचे का कोड पेस्ट करें। - Play दबाएँ। NPC दीवार के चारों ओर घूमकर 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
-- NPC की फ़िज़िक्स सर्वर के पास होनी चाहिए, वरना Script से ChangeState (कूदना) काम नहीं करेगा
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 yield करता है और एरर दे सकता है, इसलिए यह 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 -- पहला waypoint वह जगह है जहाँ NPC पहले से खड़ा है
end
humanoid:MoveTo(waypoint.Position)
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
-- NPC के इस waypoint तक पहुँचने का इंतज़ार करते हैं, उसके बाद ही अगले की ओर चलते हैं
local reached = humanoid.MoveToFinished:Wait()
if not reached then
warn(`{npc.Name} got stuck on the way to the goal`)
break
end
end
end
Goal पार्ट का CanCollide बंद है, क्योंकि रास्ता किसी ठोस पार्ट के अंदर ख़त्म नहीं हो सकता: रास्ते का Status NoPath होता।
CreatePath को मिलने वाली टेबल NPC का वर्णन करती है (Roblox इसे agent कहता है), ताकि रास्ता उन दरारों से बचे जिनमें से वह नहीं निकल सकता। ऊपर की स्क्रिप्ट पहली तीन keys को डिफ़ॉल्ट वैल्यू पर सेट करती है, ताकि दिखे कि उन्हें कहाँ बदलना है।
| Key | डिफ़ॉल्ट | क्या तय करती है |
|---|---|---|
AgentRadius | 2 | studs में NPC की त्रिज्या। चौड़े NPC के लिए इसे बढ़ाएँ ताकि रास्ते दीवारों से दूर रहें। |
AgentHeight | 5 | NPC की ऊँचाई। इससे नीची जगहें, जैसे सीढ़ी के नीचे, बंद मानी जाती हैं। |
AgentCanJump | true | ऐसे रास्ते की अनुमति देती है जिनमें कूदना पड़े। ऐसे waypoints का Action Jump होता है। |
AgentCanClimb | false | TrussPart पर चढ़ने की अनुमति देती है। ऐसे waypoints का label Climb होता है। |
WaypointSpacing | 4 | बीच के waypoints के बीच studs में दूरी। math.huge उन्हें हटा देता है। |
Costs | कोई नहीं | materials और label वाले हिस्सों से गुज़रना कितना महँगा है। देखें modifiers और links। |
लूप में दो बातें ज़रूरी हैं। पहला waypoint NPC की अपनी पोज़ीशन है, इसलिए लूप उसे छोड़ देता है। और हर MoveTo के बाद MoveToFinished:Wait() आता है: नया MoveTo पिछले टारगेट की जगह ले लेता है, इसलिए बिना इंतज़ार वाला लूप NPC को सीधे आख़िरी waypoint की ओर भेज देता है, ठीक उसी दीवार में जिसके चारों ओर उसे जाना था।
कूदने के लिए waypoint का Action Jump होता है, और स्क्रिप्ट ChangeState(Enum.HumanoidStateType.Jumping) कॉल करती है। Humanoid पर Roblox डॉक्यूमेंटेशन कहता है कि सर्वर स्क्रिप्ट स्टेट तभी बदल सकती है जब कैरेक्टर की फ़िज़िक्स सर्वर के पास हो। यही एक वजह है कि स्क्रिप्ट पहले owner सेट करती है।
Roblox के pathfinding पेज पर प्लेयर का अपना कैरेक्टर Humanoid:Move() से चलता है, हर फ़्रेम पहुँचने की जाँच के साथ, और इसे Humanoid को रास्ते पर चलाने का सबसे अच्छा तरीक़ा बताया गया है। सर्वर NPC के लिए MoveToFinished के साथ MoveTo छोटा और समझने में आसान है, इसलिए यह गाइड उसे इस्तेमाल करती है; अगर बाद में ज़्यादा सटीक कंट्रोल चाहिए, तो आधिकारिक स्क्रिप्ट देखें।
स्टेप 3: पीछा करने की पूरी स्क्रिप्ट
यही स्क्रिप्ट ज़्यादातर लोग ढूँढते हैं। NPC 80 studs के अंदर सबसे नज़दीकी प्लेयर का पीछा करता है, दीवारों के चारों ओर जाता है, जहाँ रास्ते को ज़रूरत हो वहाँ कूदता है, कुछ रास्ता रोके तो नया रास्ता ढूँढता है, और आसपास कोई न हो तो घर लौट जाता है।
- अगर आपने
WalkToGoalजोड़ी थी, तो उसे Chaser से हटा दें। - Chaser पर कर्सर ले जाएँ, + दबाएँ,
ChaseAIनाम की Script डालें और नीचे का कोड पेस्ट करें। - Play दबाएँ, दीवार के पीछे जाएँ, फिर रेंज से बाहर भाग जाएँ। NPC दीवार के चारों ओर आपके पीछे आता है, फिर वहीं लौट जाता है जहाँ से शुरू किया था।
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
-- सेटिंग्स (दूरी studs में, समय सेकंड में)
local DETECTION_RANGE = 80 -- इससे दूर के प्लेयर को यह NPC नहीं देखता
local STOP_DISTANCE = 4 -- टारगेट से इतनी दूरी पर रुकना (0 = बिल्कुल पास तक जाना, छूकर डैमेज के लिए)
local DIRECT_CHASE_RANGE = 30 -- इससे नज़दीक हो और रास्ते में कुछ न हो तो pathfinding छोड़ते हैं
local REPATH_DISTANCE = 4 -- रास्ता दोबारा गिनने के लिए टारगेट को कितना हिलना चाहिए
local MIN_REPATH_INTERVAL = 0.5 -- इससे ज़्यादा बार रास्ता कभी न गिनें
local WAYPOINT_TIMEOUT = 2 -- अगर एक waypoint इससे ज़्यादा समय ले तो रास्ता छोड़ दें
local CHASE_SPEED = 14 -- प्लेयर डिफ़ॉल्ट रूप से 16 की स्पीड से चलता है, इसलिए इस NPC से भाग सकता है
local HOME_RADIUS = 4 -- घर के इतने पास को घर ही माना जाता है
local RAY_HEIGHTS = { 0, -2 } -- सीधी नज़र की rays कमर के स्तर पर और घुटनों के पास
local HOME = rootPart.Position -- आसपास कोई न हो तो NPC यहाँ लौटता है
humanoid.WalkSpeed = CHASE_SPEED
-- NPC को सर्वर simulate करे। वरना Roblox उसकी फ़िज़िक्स पास के
-- प्लेयर के डिवाइस को दे सकता है, और owner बदलने पर NPC झटका खाता है।
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, -- पानी से तभी जाना जब बड़ा चक्कर बचाना हो
DangerZone = math.huge, -- DangerZone label वाले हिस्सों में कभी न जाना
},
})
-- वह रास्ता जिस पर NPC अभी चल रहा है
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge
-- Blocked उस waypoint के लिए भी चल सकता है जिसे NPC पार कर चुका है। सिर्फ़ आगे की रुकावट मायने रखती है।
path.Blocked:Connect(function(blockedIndex: number)
if blockedIndex >= nextIndex then
pathBlocked = true
end
end)
local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- जिन पार्ट से कुछ नहीं टकराता, वे नज़र नहीं रोकते
local function clearPath()
waypoints = {}
nextIndex = 0
pathGoal = nil
end
local function stopMoving()
clearPath()
humanoid:MoveTo(rootPart.Position)
end
-- DETECTION_RANGE के अंदर सबसे नज़दीकी ज़िंदा प्लेयर का HumanoidRootPart या 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, जब टारगेट लगभग उसी स्तर पर है और बीच में कुछ ठोस नहीं है।
-- साफ़ ray यह साबित नहीं करती कि ज़मीन पर चला जा सकता है, इसलिए यह सिर्फ़ कम दूरी पर है।
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)
-- गिनने के बाद रीसेट करते हैं, ताकि पुराने रास्ते का Blocked नए को मार्क न करे
pathBlocked = false
if ok and path.Status == Enum.PathStatus.Success then
waypoints = path:GetWaypoints()
nextIndex = 2 -- waypoint 1 वह जगह है जहाँ NPC खड़ा है
pathGoal = goal
else
if not ok then
warn(`{npc.Name}: path request failed: {err}`)
end
clearPath() -- अभी कोई रास्ता नहीं; मुख्य लूप जल्द फिर कोशिश करेगा
end
end
local function needsNewPath(goal: Vector3): boolean
if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
return false -- अभी-अभी गिना: मौजूदा रास्ते पर चलते हैं
end
local currentGoal = pathGoal
if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
return true
end
return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end
-- MoveToFinished का इंतज़ार करता है, लेकिन बिल्ट-इन 8 के बजाय timeout सेकंड बाद हार मान लेता है,
-- ताकि अटके NPC को जल्दी नया रास्ता मिले
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() -- अटक गया या उसे रास्ते से धकेल दिया गया: नया रास्ता गिनते हैं
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() -- काफ़ी पास: टारगेट के पास खड़े रहते हैं
task.wait(0.2)
continue
end
if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
clearPath()
-- अगर साथ में पार्ट भी दें, तो NPC उसके हिलते रहने तक उसके पीछे चलता है
humanoid:MoveTo(targetRoot.Position, targetRoot)
task.wait(0.15)
continue
end
goal = targetRoot.Position
else
if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
stopMoving() -- आसपास कोई नहीं, और NPC पहले से घर पर है
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) -- अभी कोई काम करने वाला रास्ता नहीं, जैसे टारगेट तक पहुँचा नहीं जा सकता
end
end
सारी सेटिंग्स ऊपर हैं। कई NPC के लिए Chaser को duplicate करें: हर कॉपी अपनी ChaseAI चलाती है और अपना घर याद रखती है। पुरानी स्क्रिप्ट rays को FilterDescendantsInstances से फ़िल्टर करती हैं; Roblox डॉक्यूमेंटेशन अब नए काम के लिए ExcludeInstances सुझाता है, और यह स्क्रिप्ट वही इस्तेमाल करती है।
पीछा करने की स्क्रिप्ट कैसे काम करती है
मुख्य लूप का हर चक्कर एक फ़ैसला लेता है और एक छोटा काम करता है: खड़े रहना, सीधे प्लेयर की ओर एक क़दम, या अगले waypoint तक चलना। कोई भी फ़ैसला एक waypoint से ज़्यादा आगे का नहीं होता, इसलिए NPC हर समय रिएक्ट करता रहता है।
सबसे नज़दीकी प्लेयर ढूँढना
findNearestTarget Players:GetPlayers() पर चलता है, उन सबको छोड़ देता है जिनके पास कैरेक्टर, ज़िंदा Humanoid या HumanoidRootPart नहीं है (जो प्लेयर respawn हो रहे हैं या निकल रहे हैं), और DETECTION_RANGE के अंदर सबसे नज़दीकी root part लौटाता है। खोज हर चक्कर में होती है, इसलिए NPC अपने आप ज़्यादा नज़दीकी प्लेयर पर चला जाता है, और निकला हुआ प्लेयर बस अब मिलता नहीं: हर प्लेयर की कोई स्टेट नहीं है जिसे साफ़ करना पड़े।
प्लेयर के चलते समय रास्ता दोबारा गिनना, पर हर फ़्रेम नहीं
रास्ता गिनना yield करता है और सर्वर का समय लेता है। needsNewPath नया रास्ता तभी माँगता है जब रास्ता न हो, पुराना ख़त्म या रुका हो, या प्लेयर मौजूदा रास्ते के आख़िर से REPATH_DISTANCE studs से ज़्यादा दूर चला गया हो, और पिछले से MIN_REPATH_INTERVAL सेकंड से पहले कभी नहीं। जब तक रास्ता गिना जा रहा है, NPC मौजूदा waypoint की ओर चलता रहता है, और नया रास्ता waypoint 2 से शुरू होता है, इसलिए NPC उस जगह की ओर नहीं मुड़ता जहाँ रास्ता शुरू हुआ था।
रुके हुए रास्ते
दरवाज़े बंद होते हैं, पार्ट गिरते हैं। Path.Blocked रुके हुए waypoint के index के साथ चलता है, जो NPC के पीछे भी हो सकता है, इसलिए स्क्रिप्ट सिर्फ़ blockedIndex >= nextIndex होने पर रिएक्ट करती है: वह एक flag सेट करती है, और लूप नया रास्ता गिनता है। जिस waypoint तक पहुँचने में NPC को WAYPOINT_TIMEOUT सेकंड से ज़्यादा लगे, क्योंकि उसे धक्का दिया गया या वह कहीं अटक गया, वह भी नया रास्ता शुरू करता है।
दिखते प्लेयर की ओर सीधे
जब प्लेयर खुली जगह पर दिख रहा हो, तो pathfinding की ज़रूरत नहीं। DIRECT_CHASE_RANGE के अंदर canSeeDirectly फ़ंक्शन प्लेयर की ओर दो rays भेजता है, कमर के स्तर पर और घुटनों के पास, ताकि नीची दीवारें पकड़ी जा सकें, और दोनों कैरेक्टर को नज़रअंदाज़ करता है। अगर कोई ray किसी चीज़ से नहीं टकराई और प्लेयर लगभग उसी स्तर पर है, तो NPC MoveTo(targetRoot.Position, targetRoot) कॉल करता है। दूसरा argument टारगेट को प्लेयर के साथ चलाता है, और हर 0.15 सेकंड में दोबारा कॉल 8 सेकंड का timeout लगातार रीसेट करती रहती है।
साफ़ ray साबित करती है कि रास्ते में कुछ ठोस नहीं है, लेकिन यह नहीं कि वहाँ फ़र्श है। अगर मैप पर NPC और प्लेयर के बीच खाई या ढलान है, तो DIRECT_CHASE_RANGE कम करें या 0 कर दें, ताकि हमेशा pathfinding इस्तेमाल हो।
सही दूरी पर रुकना
जब प्लेयर STOP_DISTANCE से नज़दीक हो, NPC अपनी ही पोज़ीशन पर MoveTo कॉल करता है, और इससे वह रुक जाता है। 4 studs उस NPC के लिए ठीक हैं जिसे प्लेयर के पास खड़ा होना है; दूरी रखने वाले pet या साथी के लिए 6 या 8 करें। छूकर मारने वाले दुश्मन के लिए 0 करें, ताकि वह बिल्कुल पास तक जाए, जैसे स्टेप 4 में।
NPC झटके क्यों खाता है और इसे कैसे ठीक करें
अगर NPC झटके खाता है, हर waypoint पर रुक जाता है या पीछे क़दम लेता है, तो आमतौर पर वजह नीचे में से एक होती है। पीछा करने वाली स्क्रिप्ट हर एक को पहले से संभालती है; यह टेबल आपकी अपनी लिखी स्क्रिप्ट ठीक करने के लिए है।
| आप क्या देखते हैं | वजह | इलाज |
|---|---|---|
| अकेले में स्मूद, प्लेयर पास हो तो झटकेदार | Network ownership। Roblox बिना Anchored पार्ट की फ़िज़िक्स पास के प्लेयर के डिवाइस को दे देता है, इसलिए NPC उस प्लेयर के डिवाइस पर simulate हो सकता है जबकि कमांड सर्वर देता है, और हर हस्तांतरण झटके जैसा दिख सकता है। | सर्वर से HumanoidRootPart पर एक बार SetNetworkOwner(nil) कॉल करें। यह उससे जुड़े सारे पार्ट पर असर करता है। |
| सीधे आख़िरी waypoint की ओर और दीवारों में जाता है | लूप में हर waypoint के लिए बिना इंतज़ार MoveTo कॉल होता है। हर कॉल पिछले टारगेट की जगह ले लेती है। | अगले waypoint पर जाने से पहले MoveToFinished का इंतज़ार करें। |
| हर waypoint पर थोड़ी देर रुकता है या कोने काटता है | पहुँचने के इंतज़ार की जगह waypoints के बीच तय task.wait()। बहुत लंबा हो तो NPC खड़ा रहता है; बहुत छोटा हो तो वह आगे कूद जाता है। | timeout के साथ MoveToFinished का इंतज़ार करें। |
| एक सेकंड में कई बार झटका खाता है या पीछे क़दम लेता है | हर फ़्रेम नया रास्ता। हर रास्ता NPC की अपनी पोज़ीशन से शुरू होता है, इसलिए waypoint 1 का रास्ता उसे पीछे मोड़ देता है। | रास्ता तभी दोबारा गिनें जब टारगेट कुछ studs हिल चुका हो, सेकंड में दो बार से ज़्यादा नहीं, और waypoint 2 से शुरू करें। |
| कुछ सेकंड के लिए रुक जाता है, फिर आगे चलता है | न पहुँचने लायक़ waypoint पर MoveToFinished:Wait() 8 सेकंड के timeout का इंतज़ार करता है। | अपना, छोटा timeout इस्तेमाल करें और उसके ख़त्म होने पर नया रास्ता गिनें। |
NPC का owner कौन है, यह देखने के लिए playtest के दौरान Visualization Options खोलें और Network owners चालू करें। जिन पार्ट को आपका क्लाइंट simulate करता है, उनकी हरी outline होती है; सर्वर या दूसरे क्लाइंट के पार्ट सफ़ेद या ग्रे outline में होते हैं।
स्टेप 4: छूने पर प्लेयर को डैमेज (वैकल्पिक)
दुश्मन के लिए NPC में दूसरी स्क्रिप्ट जोड़ें जो छूने पर प्लेयर को डैमेज दे। यह सर्वर पर चलती है, इसलिए प्लेयर का क्लाइंट डैमेज नहीं बदल सकता और cooldown को बायपास नहीं कर सकता।
- ChaseAI में
STOP_DISTANCEको0करें, ताकि NPC पास रुकने के बजाय प्लेयर तक बिल्कुल पहुँचे। - Chaser में
TouchDamageनाम की Script डालें और नीचे का कोड पेस्ट करें।
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 -- हारा हुआ NPC डैमेज नहीं देता
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 सेकंड में कई बार चलता है
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 force fields का ध्यान रखता है, इसलिए स्पॉन के बाद force field रहने तक प्लेयर सुरक्षित हैं। force fields को नज़रअंदाज़ करने के लिए Humanoid.Health सीधे घटाएँ।
cooldown हर प्लेयर के लिए अलग रखा जाता है। जब पार्ट एक-दूसरे से रगड़ते हैं तो Touched सेकंड में कई बार चलता है, और cooldown के बिना एक छुअन पल भर में प्लेयर की health शून्य कर सकती थी। प्लेयर के निकलने पर उसकी entry हटा दी जाती है, इसलिए सर्वर के चलते रहने तक टेबल बढ़ती नहीं रहती।
प्लेयर पलटवार कर सकें, इसके लिए उन्हें तलवार या raycast वाली गन दें। दोनों सर्वर पर हर उस चीज़ को डैमेज देते हैं जिसमें Humanoid है, इसलिए Chaser को भी लगेंगे।
pathfinding के modifiers और links
डिफ़ॉल्ट रूप से रास्ता सबसे छोटा रास्ता होता है, जिसमें जहाँ तक हो सके कूदना न पड़े। इसे तीन तरीक़ों से बदल सकते हैं। Costs और modifiers पीछा करने वाली स्क्रिप्ट के साथ जैसे हैं वैसे काम करते हैं, क्योंकि वह पहले से CreatePath को Costs टेबल देती है; links के लिए अपनी कुछ लाइनें चाहिए।
Materials की cost
Costs में keys materials के नाम हो सकते हैं, जैसे Water, Mud या CrackedLava, terrain और पार्ट दोनों के लिए। डिफ़ॉल्ट रूप से हर material की cost 1 है। बड़ी संख्या NPC को उस material से बचने पर मजबूर करती है अगर घुमावदार रास्ता बहुत बुरा न हो, और math.huge उसे पार न करने लायक़ बना देता है। पीछा करने वाली स्क्रिप्ट Water = 20 सेट करती है।
जिन हिस्सों से बचना है: PathfindingModifier
- उस हिस्से को एक पार्ट से ढकें जिसका Anchored चालू और CanCollide बंद हो।
- उस पार्ट में एक PathfindingModifier डालें और उसका
LabelDangerZoneकरें। - बस इतना ही। पीछा करने वाली स्क्रिप्ट पहले से
DangerZoneकोmath.hugecost देती है, इसलिए NPC उस हिस्से से बचता है। नेविगेशन मेश पर label देखने के लिए Visualization Options में Pathfinding modifiers चालू करें।
PassThrough चालू वाला modifier उल्टा करता है: रास्ता किसी ठोस रुकावट, जैसे बंद दरवाज़े, से ऐसे गुज़रता है जैसे वह हो ही नहीं। NPC फिर भी दरवाज़े के आर-पार नहीं जा सकता, लेकिन उसकी ओर ऐसे जाता है जैसे उसने दूसरी तरफ़ प्लेयर की आवाज़ सुनी हो।
अपने रास्ते: PathfindingLink
PathfindingLink दो ऐसे पॉइंट जोड़ता है जिनके बीच NPC आमतौर पर नहीं जा सकता, जैसे नदी के किनारे, जिसे वह नाव से पार करता है। हर सिरे पर एक Attachment रखें, link का Attachment0 और Attachment1 सेट करें, उसे Label दें, जैसे UseBoat, और Costs में UseBoat को Water से कम cost के साथ जोड़ें। तब रास्ते में उस label वाला waypoint आएगा: walkToNextWaypoint में waypoint.Label जाँचें और MoveTo के बजाय अपना action चलाएँ, जैसे NPC को नाव में बिठाना। Links दोनों तरफ़ काम करते हैं, जब तक आप IsBidirectional बंद न करें।
आम गलतियाँ और उनके हल
पहले Output विंडो देखें। यह Window मेन्यू से या Script टैब पर खुलती है। इस पेज की स्क्रिप्ट तब चेतावनी दिखाती हैं जब रास्ते का अनुरोध फ़ेल हो या रिग चल न सके।
NPC बिल्कुल नहीं चलता
अगर Output में लिखा है कि NPC चल नहीं सकता (cannot move), तो रिग का कोई हिस्सा Anchored है: HumanoidRootPart और बाक़ी पार्ट से Anchored हटाएँ। अगर नहीं, तो देखें कि कोड Script में है, LocalScript में नहीं, कि वह Workspace के मॉडल के अंदर है और Humanoid मरा नहीं है।
Output WaitForChild पर "Infinite yield possible" लिखता है
स्क्रिप्ट ऐसे ऑब्जेक्ट का इंतज़ार कर रही है जो है ही नहीं: दूसरे नाम वाला Humanoid या HumanoidRootPart, या स्टेप 2 की स्क्रिप्ट के लिए ग़ायब Goal पार्ट। ऑब्जेक्ट का नाम या स्क्रिप्ट की लाइन बदलें। स्क्रिप्ट एरर गाइड यह चेतावनी समझाती है।
रास्ता नहीं बनता, या NPC उस प्लेयर को नज़रअंदाज़ करता है जिस तक वह पहुँच सकता था
ComputeAsync के बाद Path.Status NoPath होता है जब शुरुआत या अंत किसी ठोस पार्ट के अंदर हो, जब इकलौते रास्ते में कूदना पड़े और AgentCanJump false हो, या जब रास्ते की किसी दरार के लिए AgentHeight या AgentRadius बहुत बड़ा हो। Roblox डॉक्यूमेंटेशन में सख़्त सीमाएँ भी हैं: शुरुआत से अंत तक सीधी रेखा में 3,000 studs से ज़्यादा नहीं, और 20,000 nodes का search budget, जो बहुत बड़ी खुली दुनिया या भूलभुलैया के लिए काफ़ी नहीं हो सकता। रास्ता जाँचने के लिए Navigation mesh चालू करें।
NPC फिसलता है और पैर नहीं हिलाता
यह एनिमेशन की समस्या है, pathfinding की नहीं। प्लेयर के कैरेक्टर को Animate स्क्रिप्ट अपने आप मिलती है, लेकिन NPC को चलने के एनिमेशन चलाने के लिए अपनी स्क्रिप्ट चाहिए। Roblox के NPC kit के हर NPC में Animate नाम की Script है, जिसे आप देख सकते हैं। सर्वर Script से NPC पर एनिमेशन लोड करके चलाने का तरीक़ा NPC पर एनिमेशन सेक्शन में देखें।
NPC कोनों पर अटक जाता है या कूदता है पर रुकावट पार नहीं करता
AgentRadius बढ़ाएँ ताकि रास्ते दीवारों से दूर रहें, ख़ासकर चौड़े NPC के लिए। अगर वह कूदता है पर पार नहीं कर पाता, तो रुकावट उससे ऊँची है जितना Humanoid कूद सकता है: Humanoid का JumpHeight या JumpPower बढ़ाएँ या लेवल बदलें।
छूने पर डैमेज बहुत बार होता है या कभी नहीं
बहुत बार: cooldown नहीं है, या वह हर प्लेयर के बजाय हर पार्ट के लिए रखा गया है। कभी नहीं: STOP_DISTANCE 0 से ज़्यादा है, इसलिए NPC आमतौर पर किसी को छूने से पहले रुक जाता है, या प्लेयर पर स्पॉन के बाद का force field अभी भी है।
इसे RoCode से बनाएँ
अगर आपके लिए NPC को हाथ से बनाने के बजाय उसका वर्णन करना आसान है, तो RoCode ये स्क्रिप्ट आपके खुले place में लिख सकता है। यह Roblox Studio के लिए एक स्वतंत्र AI एजेंट है: आप वेब चैट में लिखते हैं, और इसका Studio प्लगइन आपके Explorer में स्क्रिप्ट बनाता और बदलता है।
Workspace के Chaser मॉडल को pathfinding से 80 studs के अंदर सबसे नज़दीकी प्लेयर का पीछा करने दो, आसपास कोई न हो तो घर लौटे, और छूने पर 1 सेकंड के cooldown के साथ 10 डैमेज दे।
- पहले Get Properties से मॉडल देख सकता है और ज़रूरी वैल्यू पढ़ सकता है, जैसे उसके पार्ट पर Anchored और Humanoid का WalkSpeed। मॉडल का सटीक path जोड़ने के लिए चैट में / टाइप करें
- Create Script से मॉडल के अंदर पीछा और डैमेज की स्क्रिप्ट लिखता है, और अगर रिग को ज़रूरत हो तो Set Property से Anchored हटा सकता है
- Studio में ही Check Script से दोनों स्क्रिप्ट का compile जाँचता है। यह compile की गलतियाँ और task.wait() की जगह wait() जैसी चीज़ें पकड़ता है, लेकिन ऐसे लॉजिक बग नहीं जैसे कोई रास्ता जो कभी प्लेयर तक नहीं पहुँचता
- बदलाव समूहों में भेजता है, और हर समूह Studio की history में एक undo पॉइंट है
प्लगइन 3.9 या नए के साथ RoCode एक छोटा playtest चलाकर एरर पढ़ सकता है, और प्लगइन 3.9.11 या नए के साथ गेम काम कर रहा है यह जाँचने के लिए एक टेस्ट कैरेक्टर चला सकता है, लेकिन खेल के दौरान यह स्क्रीनशॉट नहीं लेता, इसलिए Play दबाकर NPC को ख़ुद देखें। अगर वह ठीक व्यवहार नहीं करता, तो RoCode को बताएँ कि आपने क्या देखा: Check Output आपके पिछले playtest की Server और Client लाइनें पढ़ सकता है। NPC कई सिस्टम में से एक है; देखें AI से पूरा Roblox गेम कैसे बनाएँ: पहले खेलने लायक़ कोर, फिर राउंड। RoCode Studio से कैसे जुड़ता है।
अक्सर पूछे जाने वाले सवाल
NPC pathfinding कहाँ चलाएँ: सर्वर पर या क्लाइंट पर?
सर्वर पर, Script में। Roblox का अपना pathfinding उदाहरण LocalScript में चलता है, लेकिन वहाँ प्लेयर का अपना कैरेक्टर चलता है। NPC सबके लिए साझा है, और उसका डैमेज सर्वर को तय करना चाहिए। देखें Script, LocalScript और ModuleScript।
एक सर्वर कितने पीछा करने वाले NPC संभाल सकता है?
Roblox डॉक्यूमेंटेशन में कोई तय संख्या नहीं है; यह मैप पर और इस पर निर्भर करता है कि रास्ते कितनी बार गिने जाते हैं। सबसे महँगा रास्ता गिनना है, इसलिए पीछा करने वाली स्क्रिप्ट इसे हर NPC के लिए सेकंड में दो बार तक सीमित रखती है और प्लेयर दिखने पर छोड़ देती है। बहुत सारे NPC के लिए स्क्रिप्ट कहाँ रखें, इस पर Roblox की सलाह है कि उन्हें tags दें और हर मॉडल में स्क्रिप्ट रखने के बजाय एक ModuleScript से CollectionService के ज़रिए संभालें।
मरने के बाद NPC respawn कैसे हो?
NPC की एक कॉपी ServerStorage में रखें, और respawn ServerScriptService की स्क्रिप्ट से करें, क्योंकि NPC के अंदर की स्क्रिप्ट उसके साथ ही नष्ट हो जाती है। जब Humanoid का Died इवेंट चले, कुछ सेकंड रुकें, पुराना मॉडल नष्ट करें और कॉपी का Clone() Workspace में रखें। क्लोन के अंदर की ChaseAI स्क्रिप्ट अपने आप चल जाएगी, क्योंकि सर्वर स्क्रिप्ट Workspace में आते ही चलने लगती हैं।
क्या NPC सिर्फ़ राउंड के दौरान प्लेयर का पीछा कर सकते हैं?
हाँ। अपनी राउंड स्क्रिप्ट से राउंड शुरू होने पर NPC को Workspace में क्लोन करें, और ख़त्म होने पर नष्ट करें। राउंड सिस्टम गाइड ब्रेक और राउंड का वह लूप बनाती है जिससे यह जुड़ता है।
स्रोत और आगे पढ़ें
- Roblox Creator Docs: Pathfinding (अंग्रेज़ी में). agent parameters, waypoints, रुके हुए रास्ते, modifiers, links और सीमाएँ
- Roblox Creator Docs: PathfindingService (अंग्रेज़ी में). CreatePath और डिफ़ॉल्ट वैल्यू
- Roblox Creator Docs: Path (अंग्रेज़ी में). ComputeAsync, GetWaypoints, Status और Blocked इवेंट
- Roblox Creator Docs: Humanoid (अंग्रेज़ी में). MoveTo, MoveToFinished का 8 सेकंड का timeout, ChangeState और TakeDamage
- Roblox Creator Docs: Network ownership (अंग्रेज़ी में). अपने आप ownership, SetNetworkOwner और Network owners मोड
- Roblox Creator Docs: RaycastParams (अंग्रेज़ी में). ExcludeInstances और RespectCanCollide
- Roblox Creator Docs: NPC kit (अंग्रेज़ी में). अपनी Animate स्क्रिप्ट वाले NPC उदाहरण
कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।