ट्यूटोरियल · गेम सिस्टम

Roblox Studio में NPC pathfinding: NPC को प्लेयर के पीछे कैसे चलाएँ

NPC दीवारों के चारों ओर घूमकर सबसे नज़दीकी प्लेयर तक पहुँचे, इसके लिए तीन चीज़ें चाहिए: एक रिग जो चल सके, PathfindingService से एक रास्ता, और एक लूप जो उस रास्ते पर चले और फ़िज़िक्स इंजन से न टकराए। इस गाइड में हम तीनों बनाते हैं और आख़िर में एक सर्वर स्क्रिप्ट मिलती है जिसे आप सीधे NPC के रिग में रख सकते हैं।

अपडेट किया गया 20 नवंबर 202617 मिनट में पढ़ेंलेखक:

संक्षेप में

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 का Action Jump हो तो कूदें, और जब NPC के आगे वाले waypoint के लिए Path.Blocked चले तो नया रास्ता गिनें।
  • जब प्लेयर सीधे दिख रहा हो, तो pathfinding छोड़ें और सीधे उसकी ओर MoveTo करें। कुछ studs पर रुकें, या अगर NPC छूकर डैमेज देता है तो बिल्कुल पास तक जाएँ।
इस पेज पर
  1. pathfinding कैसे काम करता है
  2. 1. NPC सेटअप
  3. 2. पॉइंट तक चलना
  4. 3. पीछा करने की स्क्रिप्ट
  5. पीछा कैसे काम करता है
  6. झटके ठीक करना
  7. 4. छूने पर डैमेज
  8. Modifiers और links
  9. Common errors
  10. With RoCode
  11. अक्सर पूछे जाने वाले सवाल
  12. स्रोत और आगे पढ़ें

NPC pathfinding कैसे काम करता है

उदाहरणChaser दीवार के चारों ओर रास्ता ढूँढता है, ऊँचे हिस्से पर कूदता है और आपसे 4 studs पर रुक जाता है।

Roblox उन सतहों से एक नेविगेशन मेश (navigation mesh) बनाता है जिन पर कैरेक्टर चल सकता है। PathfindingService इस मेश पर दो पॉइंट के बीच रास्ता ढूँढता है और उसे waypoints की लिस्ट के रूप में लौटाता है: हर एक की एक पोज़ीशन और एक action होता है, जैसे चलना या कूदना। फिर NPC का Humanoid एक waypoint से अगले तक चलता है। Pathfinding सिर्फ़ रास्ता प्लान करता है: उस पर चलाना आपकी स्क्रिप्ट का काम है।

इस गाइड में इस्तेमाल होने वाले API
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 अपनी जगह खड़ा रहता है और कोई एरर नहीं आता।

NPC मॉडल को क्या चाहिए
ज़रूरतयह क्यों ज़रूरी है
Humanoid नाम का HumanoidMoveTo, WalkSpeed और कूदना Humanoid के हिस्से हैं।
HumanoidRootPartवह पार्ट जिसे Humanoid चलाता है। रास्ते उसी की पोज़ीशन से शुरू होते हैं।
कुछ भी Anchored नहींAnchored पार्ट हिल नहीं सकता, न ही उससे जुड़े पार्ट। Anchored पार्ट हमेशा सर्वर के होते हैं, इसलिए नीचे बताया गया झटकों का इलाज उन पर लागू नहीं होता।
  1. Avatar या Home टैब खोलें और Rig Generator खोलने के लिए Character दबाएँ। R15 चुनें, फिर Block Avatar। Workspace में एक रिग आ जाएगा। R6 रिग भी इन्हीं स्क्रिप्ट के साथ काम करते हैं।
  2. रिग का नाम बदलकर Chaser करें और उसे खुली जगह पर रखें।
  3. उसका HumanoidRootPart चुनें और देखें कि Properties विंडो में Anchored बंद है। मॉडल के किसी भी दूसरे Anchored पार्ट के लिए भी यही करें। उन्हें जल्दी ढूँढने के लिए 3D viewport के ऊपरी दाएँ कोने में Visualization Options विजेट में Anchored parts चालू करें।
Explorer: इस गाइड के आख़िर में NPC मॉडल
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (शरीर के हिस्से)
    ChaseAI Script new
    TouchDamage Script new

NPC बात भी करे, इसके लिए NPC डायलॉग गाइड जवाब के विकल्पों वाला Talk prompt जोड़ती है और समझाती है कि NPC के चलने पर क्या बदलता है। पीछा शुरू करने से पहले बॉस को कैमरे से दिखाने के लिए कटसीन गाइड देखें।

स्टेप 2: NPC को एक पॉइंट तक भेजना

सबसे छोटी काम करने वाली स्क्रिप्ट से शुरू करें: एक स्थिर पार्ट तक चलना। यह pathfinding का हर स्टेप बिना पीछा करने वाले लॉजिक के दिखाती है।

  1. Workspace में एक Part डालें, उसका नाम Goal रखें, Anchored चालू करें, CanCollide बंद करें और उसे फ़र्श पर ऐसी जगह रखें कि NPC को दीवार के चारों ओर जाना पड़े।
  2. Explorer में Chaser पर कर्सर ले जाएँ, + बटन दबाएँ और एक Script डालें। उसका नाम WalkToGoal रखें और नीचे का कोड पेस्ट करें।
  3. Play दबाएँ। NPC दीवार के चारों ओर घूमकर Goal पार्ट तक जाता है।
Script स्थान: Chaser मॉडल नाम: WalkToGoal
local PathfindingService = game:GetService("PathfindingService")

local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local rootPart = npc:WaitForChild("HumanoidRootPart") :: BasePart
local goalPart = workspace:WaitForChild("Goal") :: BasePart

-- 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 को डिफ़ॉल्ट वैल्यू पर सेट करती है, ताकि दिखे कि उन्हें कहाँ बदलना है।

CreatePath के लिए agent parameters
Keyडिफ़ॉल्टक्या तय करती है
AgentRadius2studs में NPC की त्रिज्या। चौड़े NPC के लिए इसे बढ़ाएँ ताकि रास्ते दीवारों से दूर रहें।
AgentHeight5NPC की ऊँचाई। इससे नीची जगहें, जैसे सीढ़ी के नीचे, बंद मानी जाती हैं।
AgentCanJumptrueऐसे रास्ते की अनुमति देती है जिनमें कूदना पड़े। ऐसे waypoints का Action Jump होता है।
AgentCanClimbfalseTrussPart पर चढ़ने की अनुमति देती है। ऐसे waypoints का label Climb होता है।
WaypointSpacing4बीच के 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 के अंदर सबसे नज़दीकी प्लेयर का पीछा करता है, दीवारों के चारों ओर जाता है, जहाँ रास्ते को ज़रूरत हो वहाँ कूदता है, कुछ रास्ता रोके तो नया रास्ता ढूँढता है, और आसपास कोई न हो तो घर लौट जाता है।

  1. अगर आपने WalkToGoal जोड़ी थी, तो उसे Chaser से हटा दें।
  2. Chaser पर कर्सर ले जाएँ, + दबाएँ, ChaseAI नाम की Script डालें और नीचे का कोड पेस्ट करें।
  3. Play दबाएँ, दीवार के पीछे जाएँ, फिर रेंज से बाहर भाग जाएँ। NPC दीवार के चारों ओर आपके पीछे आता है, फिर वहीं लौट जाता है जहाँ से शुरू किया था।
Script स्थान: Chaser मॉडल नाम: ChaseAI
local Players = game:GetService("Players")
local PathfindingService = game:GetService("PathfindingService")

local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local rootPart = npc:WaitForChild("HumanoidRootPart") :: BasePart

-- सेटिंग्स (दूरी 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 पर रुक जाता है या पीछे क़दम लेता है, तो आमतौर पर वजह नीचे में से एक होती है। पीछा करने वाली स्क्रिप्ट हर एक को पहले से संभालती है; यह टेबल आपकी अपनी लिखी स्क्रिप्ट ठीक करने के लिए है।

pathfinding में झटके: वजहें और इलाज
आप क्या देखते हैंवजहइलाज
अकेले में स्मूद, प्लेयर पास हो तो झटकेदार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 को बायपास नहीं कर सकता।

  1. ChaseAI में STOP_DISTANCE को 0 करें, ताकि NPC पास रुकने के बजाय प्लेयर तक बिल्कुल पहुँचे।
  2. Chaser में TouchDamage नाम की Script डालें और नीचे का कोड पेस्ट करें।
Script स्थान: Chaser मॉडल नाम: TouchDamage
local Players = game:GetService("Players")

local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid

local DAMAGE = 10
local COOLDOWN_SECONDS = 1

local lastHit: { [Player]: number } = {}

local function onTouched(hit: BasePart)
	if humanoid.Health <= 0 then
		return -- हारा हुआ 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

  1. उस हिस्से को एक पार्ट से ढकें जिसका Anchored चालू और CanCollide बंद हो।
  2. उस पार्ट में एक PathfindingModifier डालें और उसका Label DangerZone करें।
  3. बस इतना ही। पीछा करने वाली स्क्रिप्ट पहले से DangerZone को math.huge cost देती है, इसलिए NPC उस हिस्से से बचता है। नेविगेशन मेश पर label देखने के लिए Visualization Options में Pathfinding modifiers चालू करें।

PassThrough चालू वाला modifier उल्टा करता है: रास्ता किसी ठोस रुकावट, जैसे बंद दरवाज़े, से ऐसे गुज़रता है जैसे वह हो ही नहीं। NPC फिर भी दरवाज़े के आर-पार नहीं जा सकता, लेकिन उसकी ओर ऐसे जाता है जैसे उसने दूसरी तरफ़ प्लेयर की आवाज़ सुनी हो।

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 डैमेज दे।

RoCode करता है
  • पहले 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 API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।

अपने गेम में RoCode आज़माएँ।

हर दिन मुफ़्त क्रेडिट, कार्ड की ज़रूरत नहीं। प्लगइन इंस्टॉल करें, फ़ीचर बताएँ और देखें कि Studio में क्या बना।