מדריך · מערכות משחק

Pathfinding ל-NPC ב-Roblox Studio: איך גורמים ל-NPC ללכת אחרי השחקן

כדי ש-NPC יעקוף קירות ויגיע לשחקן הקרוב, צריך שלושה דברים: Rig שיכול לזוז, מסלול מ-PathfindingService ולולאה שהולכת לפי המסלול ולא מתווכחת עם מנוע הפיזיקה. במדריך הזה נבנה את שלושתם, ובסוף נקבל סקריפט שרת אחד שאפשר פשוט לשים ב-Rig של ה-NPC.

עודכן 20 בנובמבר 202613 דק׳ קריאהמאת:

בקצרה

שימו Script בתוך מודל ה-NPC. צרו מסלול דרך PathfindingService:CreatePath(), חשבו אותו דרך path:ComputeAsync(start, goal) בתוך pcall, ואז עברו על נקודות הדרך אחת אחת דרך Humanoid:MoveTo(), ותחכו ל-MoveToFinished לפני הבאה. כדי שה-NPC ירדוף אחרי שחקן, בחרו את הדמות הקרובה ביותר וחשבו מחדש את המסלול כשהיא זזה כמה studs, לא בכל פריים.

  • צריך Humanoid ו-HumanoidRootPart לא מעוגן. קראו ל-SetNetworkOwner(nil) על ה-root part, כדי שהשרת ידמה אותו: זה התיקון הרגיל ל-NPC שמקפץ ליד שחקנים.
  • קפצו כשה-Action של נקודת הדרך שווה Jump, וחשבו מסלול חדש כש-Path.Blocked נורה לנקודת דרך שלפני ה-NPC.
  • כשהשחקן נראה ישירות, דלגו על ה-pathfinding ועשו MoveTo ישר אליו. עצרו כמה studs לפניו, או לכו עד אליו אם ה-NPC גורם נזק בנגיעה.
בעמוד הזה
  1. איך pathfinding עובד
  2. 1. הגדרת ה-NPC
  3. 2. הולכים לנקודה
  4. 3. סקריפט המרדף
  5. איך המרדף עובד
  6. מסירים את הקפיצות
  7. 4. נזק בנגיעה
  8. מתאמים וקישורים
  9. Common errors
  10. With RoCode
  11. שאלות נפוצות
  12. מקורות וקריאה נוספת

איך pathfinding של NPC עובד

איורChaser מוצא מסלול מסביב לקיר, קופץ על מדף ונעצר 4 studs מכם.

Roblox בונה רשת ניווט (navigation mesh) מהמשטחים שדמות יכולה ללכת עליהם. PathfindingService מחפש ברשת הזו מסלול בין שתי נקודות ומחזיר אותו כרשימת נקודות דרך (waypoints): לכל אחת יש מיקום ופעולה, למשל הליכה או קפיצה. אז ה-Humanoid של ה-NPC הולך מנקודת דרך אחת לבאה. Pathfinding רק מתכנן את המסלול: ללכת לפיו צריך הסקריפט שלכם.

ה-API שהמדריך הזה משתמש בהם
APIמה הוא עושה
PathfindingService:CreatePath()יוצר אובייקט Path שאפשר להשתמש בו הרבה פעמים, לפי הגודל של ה-NPC שלכם דרך פרמטרי הסוכן.
Path:ComputeAsync(start, finish)מחשב את המסלול. הוא מוותר על הביצוע (yield) ויכול להיכשל, ולכן קראו לו בתוך pcall ובדקו את Path.Status.
Path:GetWaypoints()מחזיר את המסלול כמערך של ערכי PathWaypoint, ולכל אחד יש Position, Action ו-Label.
Path.Blockedנורה עם האינדקס של נקודת הדרך כשמשהו חוסם את המסלול שחושב.
Humanoid:MoveTo(position)מוביל את ה-NPC לנקודה.
Humanoid.MoveToFinishedנורה עם true כשה-NPC מגיע לנקודה בטווח של בערך stud, או עם false אם הוא לא הגיע תוך 8 שניות.

הריצו את כל זה ב-Script של שרת: השרת רואה את כל המפה גם עם סטרימינג, כל השחקנים רואים את אותו NPC, והנזק מוכרע במקום שבו הלקוח לא יכול לזייף אותו. Script, LocalScript ו-ModuleScript מסביר את ההפרדה הזו.

שלב 1: NPC שיכול לזוז

כל מודל יכול ללכת לפי מסלול, אם יש לו את שלושת הדברים מהטבלה שלמטה. ל-Rigs מה-Toolbox או מפלייסים ישנים לפעמים חסר משהו, ובדרך כלל זה נראה כך: ה-NPC עומד במקום, ואין שגיאה.

מה מודל ה-NPC צריך
דרישהלמה זה חשוב
Humanoid בשם HumanoidMoveTo, WalkSpeed וקפיצות שייכים ל-Humanoid.
HumanoidRootPartה-Part שה-Humanoid שולט בו. מסלולים מתחילים מהמיקום שלו.
שום דבר לא מעוגןPart מעוגן לא יכול לזוז, וגם לא Parts שמחוברים אליו. השרת תמיד הבעלים של Parts מעוגנים, ולכן את תיקון הקפיצות שמתואר למטה אי אפשר להחיל עליהם.
  1. פתחו את הלשונית Avatar או Home ולחצו על Character כדי לפתוח את Rig Generator. בחרו R15, ואז Block Avatar. ב-Workspace יופיע Rig. Rigs מסוג R6 עובדים עם אותם סקריפטים.
  2. שנו את השם של ה-Rig ל-Chaser והציבו אותו במקום פתוח.
  3. סמנו את ה-HumanoidRootPart שלו ובדקו ש-Anchored בחלון Properties כבוי. עשו את אותו הדבר לכל Part מעוגן אחר במודל. כדי למצוא אותם מהר, הפעילו את Anchored parts בווידג׳ט Visualization Options בפינה הימנית העליונה של ה-Viewport התלת-ממדי.
Explorer: מודל ה-NPC בסוף המדריך הזה
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (חלקי גוף)
    ChaseAI Script new
    TouchDamage Script new

כדי שה-NPC גם ידבר, המדריך לדיאלוג עם NPC מוסיף הנחיית Talk עם אפשרויות תשובה ומסביר מה משתנה כש-NPC הולך. כדי להציג בוס במצלמה לפני שהוא מתחיל במרדף, ראו את המדריך לסצנות קולנועיות.

שלב 2: שולחים את ה-NPC לנקודה

התחילו מהסקריפט הכי קטן שעובד: ללכת ל-Part קבוע. הוא מראה כל שלב של pathfinding בלי לוגיקת מרדף.

  1. הכניסו Part ל-Workspace, קראו לו Goal, הפעילו Anchored, כבו CanCollide והציבו אותו על הרצפה כך שה-NPC יצטרך לעקוף קיר.
  2. ב-Explorer רחפו מעל Chaser, לחצו על כפתור ה-+ והכניסו Script. קראו לו WalkToGoal והדביקו את הקוד שלמטה.
  3. לחצו על Play. ה-NPC עוקף את הקיר והולך ל-Part בשם 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, אחרת ChangeState (קפיצה) מ-Script לא יעבוד
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 מוותר על הביצוע ויכול לזרוק שגיאה, ולכן הוא בתוך 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 -- נקודת הדרך הראשונה היא המקום שבו ה-NPC כבר עומד
		end
		humanoid:MoveTo(waypoint.Position)
		if waypoint.Action == Enum.PathWaypointAction.Jump then
			humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
		end
		-- מחכים שה-NPC יגיע לנקודת הדרך הזו, ורק אז הולכים לבאה
		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 בשם Goal כבוי CanCollide, כי מסלול לא יכול להסתיים בתוך Part מוצק: ה-Status של המסלול היה NoPath.

הטבלה ש-CreatePath מקבל מתארת את ה-NPC (Roblox קוראת לו סוכן), כדי שהמסלול יעקוף רווחים שהוא לא ייכנס אליהם. הסקריפט שלמעלה קובע את שלושת המפתחות הראשונים לערכי ברירת המחדל, כדי שיהיה ברור איפה משנים אותם.

פרמטרי סוכן ל-CreatePath
מפתחברירת מחדלמה הוא קובע
AgentRadius2הרדיוס של ה-NPC ב-studs. הגדילו אותו ל-NPC רחבים, כדי שהמסלולים יתרחקו מהקירות.
AgentHeight5הגובה של ה-NPC. מקומות נמוכים מזה, למשל מתחת למדרגות, נחשבים חסומים.
AgentCanJumptrueמתיר מסלולים שבהם צריך קפיצה. לנקודות דרך כאלה ה-Action שווה Jump.
AgentCanClimbfalseמתיר טיפוס על TrussPart. לנקודות דרך כאלה יש את התווית Climb.
WaypointSpacing4המרחק ב-studs בין נקודות דרך ביניים. math.huge מסיר אותן.
Costsאיןכמה יקר לעבור דרך חומרים ואזורים מסומנים. ראו מתאמים וקישורים.

בלולאה חשובים שני פרטים. נקודת הדרך הראשונה היא המיקום של ה-NPC עצמו, ולכן הלולאה מדלגת עליה. ואחרי כל MoveTo בא MoveToFinished:Wait(): MoveTo חדש מחליף את המטרה הקודמת, ולכן לולאה בלי המתנה שולחת את ה-NPC ישר לנקודת הדרך האחרונה, לתוך אותו קיר שהוא צריך לעקוף.

לקפיצות ה-Action של נקודת הדרך שווה Jump, והסקריפט קורא ל-ChangeState(Enum.HumanoidStateType.Jumping). בתיעוד של Roblox על Humanoid כתוב שסקריפט שרת יכול לשנות מצב רק כשהשרת הוא הבעלים של הפיזיקה של הדמות. זו אחת הסיבות שהסקריפט קודם קובע את הבעלים.

בעמוד של Roblox על pathfinding, הדמות של השחקן עצמו זזה דרך Humanoid:Move() עם בדיקת הגעה בכל פריים, וזה מתואר כדרך הכי טובה להוביל Humanoid לאורך מסלול. MoveTo עם MoveToFinished קצר וברור יותר ל-NPC בשרת, ולכן המדריך משתמש בו; אם תצטרכו אחר כך שליטה מדויקת יותר, פרקו את הסקריפט הרשמי.

שלב 3: סקריפט המרדף המלא

זה הסקריפט שרוב האנשים מחפשים. ה-NPC רודף אחרי השחקן הקרוב ביותר בטווח של 80 studs, עוקף קירות, קופץ במקומות שהמסלול צריך, מוצא מסלול חדש כשמשהו חוסם אותו, וחוזר הביתה כשאין אף אחד בסביבה.

  1. מחקו את WalkToGoal מ-Chaser, אם הוספתם אותו.
  2. רחפו מעל Chaser, לחצו על +, הכניסו Script בשם ChaseAI והדביקו את הקוד שלמטה.
  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 -- לנטוש מסלול אם נקודת דרך אחת לוקחת יותר מזה
local CHASE_SPEED = 14 -- שחקן הולך כברירת מחדל במהירות 16, כך שהוא יכול לברוח מה-NPC הזה
local HOME_RADIUS = 4 -- כל כך קרוב לבית כבר נחשב בית
local RAY_HEIGHTS = { 0, -2 } -- קרני קו ראייה בגובה המותניים וליד הברכיים

local HOME = rootPart.Position -- לאן ה-NPC חוזר כשאין אף אחד בטווח

humanoid.WalkSpeed = CHASE_SPEED

-- שהשרת ידמה את ה-NPC. אחרת Roblox עלולה לתת את הפיזיקה שלו למכשיר
-- של שחקן קרוב, וה-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
	},
})

-- המסלול שה-NPC הולך בו עכשיו
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge

-- Blocked יכול לירות לנקודת דרך שה-NPC כבר עבר. חשוב רק מכשול שלפניו.
path.Blocked:Connect(function(blockedIndex: number)
	if blockedIndex >= nextIndex then
		pathBlocked = true
	end
end)

local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- Parts שאף דבר לא מתנגש בהם לא חוסמים את הראייה

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

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

-- ה-HumanoidRootPart של השחקן החי הקרוב ביותר בתוך DETECTION_RANGE, או 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 כשהמטרה בערך באותו גובה ואין ביניהם שום דבר מוצק.
-- קרן נקייה לא מוכיחה שאפשר ללכת על הקרקע, ולכן זה רק בטווח קצר.
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 -- נקודת דרך 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, אבל מוותר אחרי timeout שניות במקום ה-8 המובנות,
-- כדי ש-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()
			-- אם מעבירים גם Part, ה-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

כל ההגדרות למעלה. לכמה NPCs, שכפלו את Chaser: כל עותק מריץ ChaseAI משלו וזוכר את הבית שלו. סקריפטים ישנים מסננים קרניים דרך FilterDescendantsInstances; התיעוד של Roblox ממליץ היום לעבודה חדשה על ExcludeInstances, והסקריפט הזה משתמש בו.

איך סקריפט המרדף עובד

כל מעבר של הלולאה הראשית מקבל החלטה אחת ועושה פעולה קטנה אחת: לעמוד, לצעוד ישר לשחקן או ללכת לנקודת הדרך הבאה. שום דבר לא מוחלט ליותר מנקודת דרך אחת, ולכן ה-NPC מגיב כל הזמן.

חיפוש השחקן הקרוב ביותר

findNearestTarget עובר על Players:GetPlayers(), מדלג על כל מי שאין לו דמות, Humanoid חי או HumanoidRootPart (שחקנים שנולדים מחדש או יוצאים), ומחזיר את ה-root part הקרוב ביותר בתוך DETECTION_RANGE. החיפוש רץ בכל מעבר, ולכן ה-NPC עובר לבד לשחקן קרוב יותר, ושחקן שיצא פשוט כבר לא נמצא: אין שום מצב לכל שחקן שצריך לנקות.

חישוב מסלול מחדש בזמן שהשחקן זז, אבל לא בכל פריים

חישוב מסלול מוותר על הביצוע וצורך זמן שרת. needsNewPath מבקש מסלול חדש רק כשאין מסלול, הישן נגמר או נחסם, או שהשחקן התרחק יותר מ-REPATH_DISTANCE studs מסוף המסלול הנוכחי, ואף פעם לא לפני MIN_REPATH_INTERVAL שניות מהקודם. בזמן שהמסלול מחושב, ה-NPC ממשיך ללכת לנקודת הדרך הנוכחית, והמסלול החדש נעבר מנקודת דרך 2, ולכן ה-NPC לא מסתובב למקום שבו המסלול התחיל.

מסלולים חסומים

דלתות נסגרות, Parts נופלים. Path.Blocked נורה עם האינדקס של נקודת הדרך החסומה, שיכולה להיות מאחורי ה-NPC, ולכן הסקריפט מגיב רק כש-blockedIndex >= nextIndex: הוא מציב דגל, והלולאה מחשבת מסלול חדש. נקודת דרך שה-NPC הולך אליה יותר מ-WAYPOINT_TIMEOUT שניות, כי דחפו אותו או שהוא נתקע, גם היא מפעילה מסלול חדש.

ישר לשחקן שנראה

לא צריך pathfinding כשהשחקן גלוי במקום פתוח. בטווח של DIRECT_CHASE_RANGE הפונקציה canSeeDirectly יורה לשחקן שתי קרניים, בגובה המותניים וליד הברכיים, כדי לזהות קירות נמוכים, ומתעלמת משתי הדמויות. אם אף קרן לא פגעה בכלום והשחקן בערך באותו גובה, ה-NPC קורא ל-MoveTo(targetRoot.Position, targetRoot). הארגומנט השני גורם למטרה לזוז יחד עם השחקן, וחזרה על הקריאה כל 0.15 שנייה מאפסת כל הזמן את זמן הקיצוב של 8 שניות.

קרן נקייה מוכיחה שאין בדרך שום דבר מוצק, אבל לא שיש שם רצפה. אם במפה בין ה-NPC לשחקנים יש תהומות או צוקים, הקטינו את DIRECT_CHASE_RANGE או קבעו 0, כדי להשתמש תמיד ב-pathfinding.

עצירה במרחק הנכון

כשהשחקן קרוב יותר מ-STOP_DISTANCE, ה-NPC קורא ל-MoveTo למיקום שלו עצמו, וזה עוצר אותו. 4 studs מתאימים ל-NPC שצריך לעמוד ליד השחקן; לחיית מחמד או למלווה ששומר מרחק קבעו 6 או 8. לאויב שמכה בנגיעה קבעו 0, כדי שילך עד אליו, כמו בשלב 4.

למה ה-NPC מקפץ ואיך מתקנים

אם ה-NPC מקפץ, קופא בכל נקודת דרך או צועד אחורה, הסיבה היא בדרך כלל אחד הסעיפים שלמטה. סקריפט המרדף כבר מתחשב בכל אחד מהם; הטבלה נועדה לתקן סקריפט שכתבתם בעצמכם.

קפיצות ב-pathfinding: סיבות ותיקונים
מה אתם רואיםסיבהתיקון
חלק כשהוא לבד, ובקפיצות כשיש שחקן לידוNetwork ownership. Roblox נותנת את הפיזיקה של Parts לא מעוגנים למכשיר של שחקן קרוב, ולכן ה-NPC יכול להיות מדומה במכשיר של השחקן הזה בזמן שהשרת נותן את הפקודות, וכל העברה יכולה להיראות כמו קפיצה.קראו פעם אחת ל-SetNetworkOwner(nil) על ה-HumanoidRootPart מהשרת. זה משפיע על כל ה-Parts שמחוברים אליו.
הולך ישר לנקודת הדרך האחרונה ולתוך קירותקוראים ל-MoveTo לכל נקודת דרך בלולאה בלי המתנה. כל קריאה מחליפה את המטרה הקודמת.חכו ל-MoveToFinished לפני המעבר לנקודת הדרך הבאה.
נעצר לרגע בכל נקודת דרך או חותך פינותtask.wait() קבוע בין נקודות דרך במקום המתנה להגעה. ארוך מדי, וה-NPC עומד; קצר מדי, והוא מדלג קדימה.חכו ל-MoveToFinished עם זמן קיצוב.
מקפץ או צועד אחורה כמה פעמים בשנייהמסלול חדש בכל פריים. כל אחד מתחיל מהמיקום של ה-NPC עצמו, ולכן המסלול לנקודת דרך 1 מסובב אותו אחורה.חשבו מסלול מחדש רק כשהמטרה זזה כמה studs, לא יותר מפעמיים בשנייה, והתחילו מנקודת דרך 2.
קופא לכמה שניות, ואז ממשיךMoveToFinished:Wait() בנקודת דרך שאי אפשר להגיע אליה מחכה לזמן הקיצוב של 8 שניות.השתמשו בזמן קיצוב משלכם, קצר יותר, וחשבו מסלול חדש כשהוא נגמר.

כדי לראות מי הבעלים של ה-NPC, פתחו את Visualization Options בזמן בדיקת משחק והפעילו את Network owners. Parts שהלקוח שלכם מדמה מקבלים מסגרת ירוקה; Parts של השרת או של לקוח אחר מוקפים בלבן או באפור.

שלב 4: נזק לשחקנים בנגיעה (לא חובה)

לאויב, הוסיפו ל-NPC סקריפט שני שגורם נזק לשחקנים בנגיעה. הוא רץ בשרת, ולכן הלקוח של השחקן לא יכול לשנות את הנזק או לעקוף את זמן ההמתנה.

  1. ב-ChaseAI קבעו את STOP_DISTANCE ל-0, כדי שה-NPC ילך עד לשחקנים ולא ייעצר לידם.
  2. הכניסו ל-Chaser Script בשם TouchDamage והדביקו את הקוד שלמטה.
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 נורה הרבה פעמים בשנייה בזמן שה-Parts חותכים זה את זה
	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 מתחשב בשדות כוח, ולכן שחקנים בטוחים כל עוד שדה הכוח שאחרי הלידה פעיל. כדי להתעלם משדות כוח, הורידו את Humanoid.Health ישירות.

זמן ההמתנה נשמר בנפרד לכל שחקן. Touched נורה הרבה פעמים בשנייה בזמן שה-Parts מתחככים, ובלי זמן המתנה נגיעה אחת הייתה יכולה לאפס ברגע את החיים של שחקן. הרשומה נמחקת כשהשחקן שלה יוצא, ולכן הטבלה לא גדלה כל הזמן שהשרת חי.

כדי ששחקנים יוכלו להשיב מלחמה, תנו להם חרב או רובה על raycast. שניהם גורמים נזק בשרת לכל מה שיש לו Humanoid, כך שהם יפגעו גם ב-Chaser.

מתאמים וקישורים של pathfinding

כברירת מחדל המסלול הוא הדרך הקצרה ביותר, ובה כמה שאפשר בלי קפיצות. אפשר לשנות את זה בשלוש דרכים. עלויות ומתאמים עובדים עם סקריפט המרדף כמו שהוא, כי הוא כבר מעביר טבלת Costs ל-CreatePath; לקישורים צריך כמה שורות משלכם.

עלות חומרים

המפתחות ב-Costs יכולים להיות שמות של חומרים, למשל Water, Mud או CrackedLava, גם ל-Terrain וגם ל-Parts. כברירת מחדל כל חומר עולה 1. מספר גדול יותר גורם ל-NPC לעקוף את החומר הזה אם העיקוף לא גרוע יותר, ו-math.huge הופך אותו לבלתי עביר. סקריפט המרדף קובע Water = 20.

אזורים שצריך לעקוף: PathfindingModifier

  1. כסו את האזור ב-Part עם Anchored מופעל ו-CanCollide כבוי.
  2. הכניסו ל-Part הזה PathfindingModifier וקבעו את ה-Label שלו ל-DangerZone.
  3. זהו. סקריפט המרדף כבר נותן ל-DangerZone עלות של math.huge, ולכן ה-NPC עוקף את האזור הזה. הפעילו את Pathfinding modifiers ב-Visualization Options כדי לראות את התווית על רשת הניווט.

מתאם עם PassThrough מופעל עושה את ההפך: המסלול עובר דרך מכשול מוצק, למשל דלת סגורה, כאילו הוא לא קיים. ה-NPC עדיין לא יכול לעבור דרך הדלת, אבל הולך אליה, כאילו שמע את השחקן מהצד השני.

PathfindingLink מחבר שתי נקודות שבדרך כלל ה-NPC לא יכול לעבור ביניהן, למשל גדות של נהר שהוא חוצה בסירה. שימו Attachment בכל קצה, קבעו לקישור את Attachment0 ואת Attachment1, תנו לו Label, למשל UseBoat, והוסיפו את UseBoat ל-Costs עם עלות נמוכה מזו של Water. אז במסלול תופיע נקודת דרך עם התווית הזו: בדקו את waypoint.Label ב-walkToNextWaypoint והפעילו את הפעולה שלכם, למשל הושבת ה-NPC בסירה, במקום MoveTo. קישורים עובדים לשני הכיוונים, אלא אם מכבים את IsBidirectional.

שגיאות נפוצות ופתרונות

קודם בדקו את חלון ה-Output. הוא נפתח מתפריט Window או בלשונית Script. הסקריפטים בעמוד הזה מדפיסים אזהרה כשבקשת מסלול נכשלה או שה-Rig לא יכול לזוז.

ה-NPC בכלל לא זז

אם ב-Output כתוב שה-NPC לא יכול לזוז (cannot move), חלק מה-Rig מעוגן: הסירו את Anchored מה-HumanoidRootPart ומשאר ה-Parts. אם לא, בדקו שהקוד ב-Script, לא ב-LocalScript, שהוא נמצא בתוך המודל ב-Workspace ושה-Humanoid לא מת.

ה-Output כותב "Infinite yield possible" על WaitForChild

הסקריפט מחכה לאובייקט שלא קיים: Humanoid או HumanoidRootPart עם שם אחר, או Part בשם Goal שחסר לסקריפט משלב 2. שנו את השם של האובייקט או את השורה בסקריפט. המדריך לשגיאות בסקריפטים מסביר את האזהרה הזו.

המסלול לא נבנה, או שה-NPC מתעלם משחקן שהוא יכול היה להגיע אליו

Path.Status אחרי ComputeAsync שווה NoPath כשההתחלה או הסוף בתוך Part מוצק, כשהמסלול היחיד דורש קפיצה ו-AgentCanJump שווה false, או כש-AgentHeight או AgentRadius גדולים מדי לרווח בדרך. בתיעוד של Roblox יש גם מגבלות קשיחות: לא יותר מ-3,000 studs בקו ישר מההתחלה לסוף, ותקציב חיפוש של 20,000 צמתים, שעלול לא להספיק לעולמות פתוחים ענקיים או למבוכים. הפעילו את Navigation mesh כדי לבדוק את המסלול.

ה-NPC מחליק ולא מזיז את הרגליים

זו בעיה של אנימציה, לא של pathfinding. דמויות של שחקנים מקבלות את הסקריפט Animate אוטומטית, ו-NPC צריך סקריפט משלו כדי להפעיל אנימציות הליכה. בכל NPC מה-NPC kit של Roblox יש Script בשם Animate שאפשר לפרק. איך טוענים ומפעילים אנימציה על NPC מ-Script של שרת, ראו בפרק אנימציה על NPC.

ה-NPC נתקע בפינות, או קופץ אבל לא עובר את המכשול

הגדילו את AgentRadius, כדי שהמסלולים יתרחקו מהקירות, במיוחד ל-NPCs רחבים. אם הוא קופץ אבל לא מצליח לעבור, המכשול גבוה ממה שה-Humanoid יכול לקפוץ: הגדילו את JumpHeight או את JumpPower של ה-Humanoid, או שנו את השלב.

נזק בנגיעה נורה לעיתים קרובות מדי או אף פעם

לעיתים קרובות מדי: אין זמן המתנה, או שהוא נשמר לכל Part ולא לכל שחקן. אף פעם: STOP_DISTANCE גדול מ-0, ולכן ה-NPC בדרך כלל נעצר לפני שהוא נוגע במישהו, או שלשחקן עדיין פעיל שדה הכוח שאחרי הלידה.

בנו את זה עם RoCode

אם קל לכם יותר לתאר NPC מאשר לבנות אותו ביד, RoCode יכול לכתוב את הסקריפטים האלה בפלייס שפתוח אצלכם. זה סוכן AI עצמאי ל-Roblox Studio: אתם כותבים בצ׳אט באתר, והפלאגין שלו ל-Studio יוצר ועורך סקריפטים ב-Explorer שלכם.

אתם כותבים

תגרום למודל Chaser ב-Workspace לרדוף אחרי השחקן הקרוב ביותר בטווח של 80 studs דרך pathfinding, לחזור הביתה כשאין אף אחד בסביבה, ולגרום 10 נזק בנגיעה עם זמן המתנה של שנייה אחת.

RoCode עושה
  • יכול קודם לסרוק את המודל עם Get Properties ולקרוא ערכי מפתח, למשל Anchored על ה-Parts שלו ו-WalkSpeed של ה-Humanoid. הקלידו / בצ׳אט כדי לצרף את הנתיב המדויק למודל
  • כותב את סקריפטי המרדף והנזק בתוך המודל עם Create Script, ויכול להסיר Anchored עם Set Property אם ה-Rig צריך את זה
  • בודק את הקומפילציה של שני הסקריפטים עם Check Script ישירות ב-Studio. זה תופס שגיאות קומפילציה ודברים כמו wait() במקום task.wait(), אבל לא באגים לוגיים כמו מסלול שאף פעם לא מגיע לשחקן
  • שולח את השינויים בקבוצות, וכל קבוצה היא נקודת ביטול בהיסטוריה של Studio

עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.11 ומעלה יכול לשלוט בדמות בדיקה כדי לבדוק שהמשחק עובד, אבל בזמן המשחק הוא לא מצלם מסך, אז לחצו על Play והסתכלו על ה-NPC בעצמכם. אם הוא מתנהג לא כמו שצריך, ספרו ל-RoCode מה ראיתם: Check Output יכול לקרוא את שורות ה-Server וה-Client מבדיקת המשחק האחרונה שלכם. NPC הוא מערכת אחת מתוך הרבה; ראו איך לבנות משחק Roblox שלם עם AI: קודם ליבה שאפשר לשחק בה, אחר כך סיבובים. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איפה מריצים pathfinding של NPC: בשרת או בלקוח?

בשרת, ב-Script. הדוגמה של Roblox עצמה ל-pathfinding רצה ב-LocalScript, אבל שם זזה הדמות של השחקן עצמו. NPC משותף לכולם, ואת הנזק שהוא גורם צריך להכריע השרת. ראו Script, LocalScript ו-ModuleScript.

כמה NPCs עם מרדף שרת אחד יעמוד בהם?

בתיעוד של Roblox אין מספר מדויק; זה תלוי במפה ובכמה פעמים מחשבים מסלולים. הכי יקר זה חישוב מסלול, ולכן סקריפט המרדף מגביל אותו לפעמיים בשנייה לכל NPC ומדלג עליו כשהשחקן נראה. להרבה NPCs, ההמלצות של Roblox על איפה לשמור סקריפטים מציעות לסמן אותם בתגים ולטפל בהם דרך CollectionService מ-ModuleScript אחד, ולא לשים סקריפט בכל מודל.

איך גורמים ל-NPC לחזור לחיים אחרי מוות?

שמרו עותק של ה-NPC ב-ServerStorage, ועשו את הלידה מחדש מסקריפט ב-ServerScriptService, כי סקריפט בתוך ה-NPC מושמד יחד איתו. כשהאירוע Died של ה-Humanoid נורה, חכו כמה שניות, השמידו את המודל הישן ושימו Clone() של העותק ב-Workspace. הסקריפט ChaseAI בתוך השכפול ירוץ לבד, כי סקריפטים של שרת רצים ברגע שהם נמצאים ב-Workspace.

אפשר לגרום ל-NPCs לרדוף אחרי שחקנים רק בזמן סיבוב?

כן. תנו לסקריפט הסיבובים שלכם לשכפל NPCs ל-Workspace כשסיבוב מתחיל, ולהשמיד אותם כשהוא נגמר. המדריך למערכת סיבובים בונה את לולאת ההפסקה והסיבוב שזה מתחבר אליה.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.