בקצרה
שימו 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 גורם נזק בנגיעה.
בעמוד הזה
איך pathfinding של NPC עובד
Roblox בונה רשת ניווט (navigation mesh) מהמשטחים שדמות יכולה ללכת עליהם. PathfindingService מחפש ברשת הזו מסלול בין שתי נקודות ומחזיר אותו כרשימת נקודות דרך (waypoints): לכל אחת יש מיקום ופעולה, למשל הליכה או קפיצה. אז ה-Humanoid של ה-NPC הולך מנקודת דרך אחת לבאה. Pathfinding רק מתכנן את המסלול: ללכת לפיו צריך הסקריפט שלכם.
| 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 עומד במקום, ואין שגיאה.
| דרישה | למה זה חשוב |
|---|---|
Humanoid בשם Humanoid | MoveTo, WalkSpeed וקפיצות שייכים ל-Humanoid. |
HumanoidRootPart | ה-Part שה-Humanoid שולט בו. מסלולים מתחילים מהמיקום שלו. |
| שום דבר לא מעוגן | Part מעוגן לא יכול לזוז, וגם לא Parts שמחוברים אליו. השרת תמיד הבעלים של Parts מעוגנים, ולכן את תיקון הקפיצות שמתואר למטה אי אפשר להחיל עליהם. |
- פתחו את הלשונית Avatar או Home ולחצו על Character כדי לפתוח את Rig Generator. בחרו R15, ואז Block Avatar. ב-Workspace יופיע Rig. Rigs מסוג R6 עובדים עם אותם סקריפטים.
- שנו את השם של ה-Rig ל-
Chaserוהציבו אותו במקום פתוח. - סמנו את ה-HumanoidRootPart שלו ובדקו ש-Anchored בחלון Properties כבוי. עשו את אותו הדבר לכל Part מעוגן אחר במודל. כדי למצוא אותם מהר, הפעילו את Anchored parts בווידג׳ט Visualization Options בפינה הימנית העליונה של ה-Viewport התלת-ממדי.
Workspace
Chaser Model
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (חלקי גוף)
ChaseAI Script new
TouchDamage Script new
כדי שה-NPC גם ידבר, המדריך לדיאלוג עם NPC מוסיף הנחיית Talk עם אפשרויות תשובה ומסביר מה משתנה כש-NPC הולך. כדי להציג בוס במצלמה לפני שהוא מתחיל במרדף, ראו את המדריך לסצנות קולנועיות.
שלב 2: שולחים את ה-NPC לנקודה
התחילו מהסקריפט הכי קטן שעובד: ללכת ל-Part קבוע. הוא מראה כל שלב של pathfinding בלי לוגיקת מרדף.
- הכניסו Part ל-Workspace, קראו לו
Goal, הפעילו Anchored, כבו CanCollide והציבו אותו על הרצפה כך שה-NPC יצטרך לעקוף קיר. - ב-Explorer רחפו מעל Chaser, לחצו על כפתור ה-+ והכניסו Script. קראו לו
WalkToGoalוהדביקו את הקוד שלמטה. - לחצו על Play. ה-NPC עוקף את הקיר והולך ל-Part בשם 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, אחרת 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 קוראת לו סוכן), כדי שהמסלול יעקוף רווחים שהוא לא ייכנס אליהם. הסקריפט שלמעלה קובע את שלושת המפתחות הראשונים לערכי ברירת המחדל, כדי שיהיה ברור איפה משנים אותם.
| מפתח | ברירת מחדל | מה הוא קובע |
|---|---|---|
AgentRadius | 2 | הרדיוס של ה-NPC ב-studs. הגדילו אותו ל-NPC רחבים, כדי שהמסלולים יתרחקו מהקירות. |
AgentHeight | 5 | הגובה של ה-NPC. מקומות נמוכים מזה, למשל מתחת למדרגות, נחשבים חסומים. |
AgentCanJump | true | מתיר מסלולים שבהם צריך קפיצה. לנקודות דרך כאלה ה-Action שווה Jump. |
AgentCanClimb | false | מתיר טיפוס על TrussPart. לנקודות דרך כאלה יש את התווית Climb. |
WaypointSpacing | 4 | המרחק ב-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, עוקף קירות, קופץ במקומות שהמסלול צריך, מוצא מסלול חדש כשמשהו חוסם אותו, וחוזר הביתה כשאין אף אחד בסביבה.
- מחקו את
WalkToGoalמ-Chaser, אם הוספתם אותו. - רחפו מעל Chaser, לחצו על +, הכניסו Script בשם
ChaseAIוהדביקו את הקוד שלמטה. - לחצו על 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 -- לנטוש מסלול אם נקודת דרך אחת לוקחת יותר מזה
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 מקפץ, קופא בכל נקודת דרך או צועד אחורה, הסיבה היא בדרך כלל אחד הסעיפים שלמטה. סקריפט המרדף כבר מתחשב בכל אחד מהם; הטבלה נועדה לתקן סקריפט שכתבתם בעצמכם.
| מה אתם רואים | סיבה | תיקון |
|---|---|---|
| חלק כשהוא לבד, ובקפיצות כשיש שחקן לידו | 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 סקריפט שני שגורם נזק לשחקנים בנגיעה. הוא רץ בשרת, ולכן הלקוח של השחקן לא יכול לשנות את הנזק או לעקוף את זמן ההמתנה.
- ב-ChaseAI קבעו את
STOP_DISTANCEל-0, כדי שה-NPC ילך עד לשחקנים ולא ייעצר לידם. - הכניסו ל-Chaser Script בשם
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
- כסו את האזור ב-Part עם Anchored מופעל ו-CanCollide כבוי.
- הכניסו ל-Part הזה PathfindingModifier וקבעו את ה-
Labelשלו ל-DangerZone. - זהו. סקריפט המרדף כבר נותן ל-
DangerZoneעלות שלmath.huge, ולכן ה-NPC עוקף את האזור הזה. הפעילו את Pathfinding modifiers ב-Visualization Options כדי לראות את התווית על רשת הניווט.
מתאם עם PassThrough מופעל עושה את ההפך: המסלול עובר דרך מכשול מוצק, למשל דלת סגורה, כאילו הוא לא קיים. ה-NPC עדיין לא יכול לעבור דרך הדלת, אבל הולך אליה, כאילו שמע את השחקן מהצד השני.
מעברים משלכם: PathfindingLink
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 נזק בנגיעה עם זמן המתנה של שנייה אחת.
- יכול קודם לסרוק את המודל עם 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 כשסיבוב מתחיל, ולהשמיד אותם כשהוא נגמר. המדריך למערכת סיבובים בונה את לולאת ההפסקה והסיבוב שזה מתחבר אליה.
מקורות וקריאה נוספת
- Roblox Creator Docs: Pathfinding (באנגלית). פרמטרי סוכן, נקודות דרך, מסלולים חסומים, מתאמים, קישורים ומגבלות
- Roblox Creator Docs: PathfindingService (באנגלית). CreatePath וערכי ברירת המחדל
- Roblox Creator Docs: Path (באנגלית). ComputeAsync, GetWaypoints, Status והאירוע Blocked
- Roblox Creator Docs: Humanoid (באנגלית). MoveTo, זמן הקיצוב של 8 שניות של MoveToFinished, ChangeState ו-TakeDamage
- Roblox Creator Docs: Network ownership (באנגלית). בעלות אוטומטית, SetNetworkOwner והמצב Network owners
- Roblox Creator Docs: RaycastParams (באנגלית). ExcludeInstances ו-RespectCanCollide
- Roblox Creator Docs: NPC kit (באנגלית). דוגמאות NPC עם סקריפטי Animate משלהם
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.