Урок · Игрови системи

Pathfinding за NPC в Roblox Studio: как NPC да следва играча

За да заобикаля NPC стени и да стига до най-близкия играч, трябват три неща: риг, който може да се движи, маршрут от PathfindingService и цикъл, който върви по маршрута и не спори с физичния енджин. В това ръководство събираме и трите и накрая получаваме един сървърен скрипт, който просто слагаш в рига на NPC.

Обновено 20 ноември 2026 г.15 мин четенеАвтор:

Накратко

Сложи Script в модела на NPC. Създай път чрез PathfindingService:CreatePath(), изчисли го чрез path:ComputeAsync(start, goal) в pcall, а после минавай вейпойнтите един по един чрез Humanoid:MoveTo(), като чакаш MoveToFinished преди следващия. За да гони NPC играча, избирай най-близкия персонаж и преизчислявай пътя, когато той се е преместил с няколко стъда, а не на всеки кадър.

  • Трябват Humanoid и HumanoidRootPart без Anchored. Извикай SetNetworkOwner(nil) върху root part, за да го симулира сървърът: това е обичайната поправка за NPC, който се дърпа на пресекулки близо до играчите.
  • Скачай, когато Action на вейпойнта е Jump, и изчислявай нов път, когато Path.Blocked се задейства за вейпойнт пред NPC.
  • Когато играчът се вижда направо, пропусни pathfinding и прави MoveTo право към него. Спирай на няколко стъда или върви плътно до него, ако 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 стъда от теб.

Roblox изгражда навигационна мрежа (navigation mesh) от повърхностите, по които може да ходи персонаж. PathfindingService търси в тази мрежа маршрут между две точки и го връща като списък от вейпойнти: всеки има позиция и действие, например ходене или скок. После 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 стигне до около стъд от точката, или с false, ако не е стигнал за 8 секунди.

Пускай всичко това в сървърен Script: сървърът вижда цялата карта дори със стрийминг, всички играчи виждат един и същ NPC, а щетата се решава там, където клиентът не може да я подправи. Script, LocalScript и ModuleScript обяснява това разделение.

Стъпка 1: NPC, който може да се движи

По път може да ходи всеки модел, ако има трите неща от таблицата по-долу. На риговете от Toolbox или от стари плейсове понякога нещо липсва и обикновено това изглежда така: NPC стои на място, а грешка няма.

Какво трябва на модела на NPC
ИзискванеЗащо е важно
Humanoid с име HumanoidMoveTo, WalkSpeed и скоковете принадлежат на Humanoid.
HumanoidRootPartПартът, който Humanoid управлява. Пътищата започват от неговата позиция.
Нищо не е AnchoredЗакотвен парт не може да се движи, нито партовете, свързани с него. Закотвените партове винаги са на сървъра, затова поправката за дърпането по-долу не може да се приложи към тях.
  1. Отвори раздела Avatar или Home и натисни Character, за да отвориш Rig Generator. Избери R15, после Block Avatar. В Workspace ще се появи риг. Риговете R6 работят със същите скриптове.
  2. Преименувай рига на Chaser и го постави на открито място.
  3. Избери неговия HumanoidRootPart и провери, че Anchored в прозореца Properties е изключено. Направи същото за всеки друг закотвен парт в модела. За да ги намериш бързо, включи Anchored parts в уиджета Visualization Options в горния десен ъгъл на 3D изгледа.
Explorer: моделът на NPC в края на това ръководство
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (части на тялото)
    ChaseAI Script new
    TouchDamage Script new

За да може NPC и да говори, ръководството за диалог с NPC добавя подкана Talk с варианти за отговор и обяснява какво се променя, когато NPC ходи. За да покажеш боса с камерата, преди да започне гонитбата, виж ръководството за катсцени.

Стъпка 2: Пращаме NPC до точка

Започни с най-малкия работещ скрипт: да стигне до неподвижен парт. Той показва всеки етап на pathfinding без логиката на гонитбата.

  1. Постави Part в Workspace, кръсти го 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 трябва да е на сървъра, иначе 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

Партът Goal е с изключено CanCollide, защото път не може да завършва в твърд парт: Status на пътя би бил NoPath.

Таблицата, която получава CreatePath, описва NPC (Roblox го нарича агент), за да заобикаля маршрутът процепи, през които той не може да мине. Скриптът горе задава първите три ключа на стойностите им по подразбиране, за да се вижда къде да ги промениш.

Параметри на агента за CreatePath
КлючПо подразбиранеКакво задава
AgentRadius2Радиусът на NPC в стъдове. Увеличи го за широки NPC, за да стоят пътищата по-далеч от стените.
AgentHeight5Височината на NPC. Места, по-ниски от нея, например под стълбище, се смятат за преградени.
AgentCanJumptrueПозволява маршрути, при които трябва скок. При тези вейпойнти Action е Jump.
AgentCanClimbfalseПозволява катерене по TrussPart. Тези вейпойнти имат етикет Climb.
WaypointSpacing4Разстоянието в стъдове между междинните вейпойнти. 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 стъда, заобикаля стени, скача там, където маршрутът го изисква, намира нов маршрут, когато нещо го прегради, и се прибира у дома, когато наоколо няма никой.

  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

-- Настройки (разстояния в стъдове, време в секунди)
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 -- партове, с които нищо не се сблъсква, не пречат на видимостта

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()
			-- Ако подадем и парта, 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: всяко копие пуска свой ChaseAI и помни своя дом. По-старите скриптове филтрират лъчите чрез FilterDescendantsInstances; справката на Roblox вече препоръчва за нова работа ExcludeInstances и този скрипт използва именно него.

Как работи скриптът за гонитба

Всяко минаване на главния цикъл взема едно решение и прави едно малко действие: да стои, да пристъпи право към играча или да отиде до следващия вейпойнт. Нищо не се решава за повече от един вейпойнт напред, затова NPC реагира през цялото време.

Търсене на най-близкия играч

findNearestTarget обхожда Players:GetPlayers(), пропуска всеки без персонаж, жив Humanoid или HumanoidRootPart (играчи, които се прераждат или излизат) и връща най-близкия root part в рамките на DETECTION_RANGE. Търсенето става при всяко минаване, затова NPC сам превключва към по-близък играч, а излязъл играч просто вече не се намира: няма състояние за всеки играч, което трябва да се чисти.

Преизчисляване на пътя, докато играчът се движи, но не на всеки кадър

Изчисляването на път отстъпва изпълнението и харчи време на сървъра. needsNewPath иска нов път само когато няма път, старият е свършил или е преграден, или играчът се е отдалечил с повече от REPATH_DISTANCE стъда от края на текущия път, и никога по-рано от MIN_REPATH_INTERVAL секунди след предишния. Докато пътят се изчислява, NPC продължава към текущия вейпойнт, а новият път се минава от вейпойнт 2, затова NPC не се обръща към мястото, откъдето пътят е започнал.

Преградени пътища

Вратите се затварят, партовете падат. 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 стъда стават за NPC, който трябва да стои до играча; за домашен любимец или придружител, който пази дистанция, сложи 6 или 8. За враг, който удря с докосване, сложи 0, за да върви плътно до играча, както в стъпка 4.

Защо NPC се дърпа и как да го поправиш

Ако NPC се дърпа на пресекулки, замръзва на всеки вейпойнт или пристъпва назад, обикновено причината е една от точките по-долу. Скриптът за гонитба вече отчита всяка от тях; таблицата е, за да поправиш скрипт, който си написал сам.

Дърпане при pathfinding: причини и поправки
Какво виждашПричинаПоправка
Плавно, докато е сам, и на пресекулки, когато наблизо има играчNetwork ownership. Roblox дава физиката на партовете без Anchored на устройството на близък играч, затова NPC може да се симулира на устройството на този играч, докато командите идват от сървъра, и всяко предаване може да изглежда като дръпване.Извикай веднъж SetNetworkOwner(nil) върху HumanoidRootPart от сървъра. Това важи за всички партове, свързани с него.
Върви право към последния вейпойнт и в стенитеMoveTo се вика за всеки вейпойнт в цикъла без чакане. Всяко извикване заменя предишната цел.Чакай MoveToFinished, преди да минеш към следващия вейпойнт.
Спира за кратко на всеки вейпойнт или реже ъглитеФиксиран task.wait() между вейпойнтите вместо чакане на пристигането. Твърде дълго и NPC стои; твърде кратко и прескача напред.Чакай MoveToFinished с ограничение на времето.
Дърпа се или пристъпва назад няколко пъти в секундаНов път на всеки кадър. Всеки започва от позицията на самия NPC, затова пътят към вейпойнт 1 го обръща назад.Преизчислявай пътя само когато целта се е преместила с няколко стъда, не повече от два пъти в секунда, и започвай от вейпойнт 2.
Замръзва за няколко секунди, после продължаваMoveToFinished:Wait() на недостижим вейпойнт чака 8-секундното изчакване.Използвай свое, по-кратко ограничение на времето и изчисли нов път, когато изтече.

За да видиш кой притежава NPC, отвори Visualization Options по време на плейтест и включи Network owners. Партовете, които симулира твоят клиент, получават зелен контур; партовете на сървъра или на друг клиент са с бял или сив контур.

Стъпка 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 се задейства много пъти в секунда, докато партовете се пресичат
	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 се задейства много пъти в секунда, докато партовете се трият един в друг, и без кулдаун едно докосване би могло за миг да свали здравето на играча до нула. Записът се изтрива, когато играчът му излезе, затова таблицата не расте през целия живот на сървъра.

За да могат играчите да се защитават, дай им меч или оръжие с рейкаст. И двете нанасят щета на сървъра на всичко, което има Humanoid, така че ще уцелят и Chaser.

Модификатори и връзки в pathfinding

По подразбиране пътят е най-краткият маршрут, по възможност без скокове. Това може да се промени по три начина. Цените и модификаторите работят със скрипта за гонитба както си е, защото той вече подава таблица Costs на CreatePath; за връзките трябват няколко твои реда.

Цена на материалите

Ключове в Costs могат да са имена на материали, например Water, Mud или CrackedLava, и за терена, и за партовете. По подразбиране всеки материал струва 1. По-голямо число кара NPC да заобикаля този материал, ако обиколката не е по-лоша, а math.huge го прави непроходим. Скриптът за гонитба задава Water = 20.

Области за заобикаляне: PathfindingModifier

  1. Покрий областта с парт с включено Anchored и изключено CanCollide.
  2. Постави в този парт 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. Скриптовете на тази страница извеждат предупреждение, когато заявката за път не е успяла или ригът не може да се движи.

NPC изобщо не се движи

Ако в Output пише, че NPC не може да се движи (cannot move), част от рига е закотвена: махни Anchored от HumanoidRootPart и останалите партове. Ако не, провери, че кодът е в Script, а не в LocalScript, че е в модела в Workspace и че Humanoid не е умрял.

Output пише "Infinite yield possible" при WaitForChild

Скриптът чака обект, който го няма: Humanoid или HumanoidRootPart с друго име или липсващ парт Goal за скрипта от стъпка 2. Преименувай обекта или реда в скрипта. Ръководството за грешки в скриптовете обяснява това предупреждение.

Пътят не се изгражда или NPC пренебрегва играч, до когото би могъл да стигне

Path.Status след ComputeAsync е NoPath, когато началото или краят е в твърд парт, когато единственият маршрут изисква скок, а AgentCanJump е false, или когато AgentHeight или AgentRadius е твърде голям за процеп по пътя. В документацията на Roblox има и твърди ограничения: не повече от 3,000 стъда по права линия от началото до края и бюджет за търсене от 20,000 възела, който за огромни отворени светове или лабиринти може да не стигне. Включи Navigation mesh, за да провериш маршрута.

NPC се плъзга и не движи краката си

Това е проблем с анимацията, а не с pathfinding. Персонажите на играчите получават скрипта Animate автоматично, а на NPC му трябва собствен скрипт, за да пуска анимациите за ходене. Всеки NPC от NPC kit на Roblox има Script с име Animate, който можеш да разгледаш. Как да заредиш и пуснеш анимация на NPC от сървърен Script, виж в раздела анимация на NPC.

NPC засяда на ъглите или скача, но не прескача пречката

Увеличи AgentRadius, за да стоят маршрутите по-далеч от стените, особено за широки NPC. Ако скача, но все не успява да мине, пречката е по-висока, отколкото Humanoid може да скочи: увеличи JumpHeight или JumpPower на Humanoid или промени нивото.

Щетата с докосване се задейства твърде често или никога

Твърде често: няма кулдаун или той се пази за всеки парт, а не за всеки играч. Никога: STOP_DISTANCE е над 0, затова NPC обикновено спира, преди да докосне някого, или играчът още има силово поле след появата.

Направи го с RoCode

Ако ти е по-лесно да опишеш NPC, отколкото да го сглобиш на ръка, RoCode може да напише тези скриптове в плейса, който имаш отворен. Той е независим ИИ агент за Roblox Studio: пишеш в уеб чата, а плъгинът му за Studio създава и редактира скриптовете в твоя Explorer.

Ти пишеш

Направи така, че моделът Chaser в Workspace да гони най-близкия играч в рамките на 80 стъда чрез pathfinding, да се прибира у дома, когато наоколо няма никой, и да нанася 10 точки щета с докосване с кулдаун 1 секунда.

RoCode прави
  • Може първо да прегледа модела чрез Get Properties и да прочете ключовите стойности, например Anchored на партовете му и WalkSpeed на Humanoid. Напиши / в чата, за да прикачиш точния път до модела
  • Пише скриптовете за гонитба и щета в модела чрез Create Script и може да махне Anchored чрез Set Property, ако ригът има нужда
  • Проверява компилацията на двата скрипта чрез Check Script направо в Studio. Това хваща грешки при компилация и неща като wait() вместо task.wait(), но не и логически бъгове като маршрут, който никога не стига до играча
  • Изпраща промените на пакети и всеки пакет е точка за отмяна в историята на Studio

С плъгин 3.9 или по-нов RoCode може да пусне кратък плейтест и да прочете грешките, а с плъгин 3.9.11 или по-нов може да управлява тестов персонаж, за да провери, че играта работи, но по време на игра не прави скрийншоти, затова натисни Play и погледни NPC сам. Ако не се държи както трябва, кажи на RoCode какво си видял: Check Output може да прочете редовете Server и Client от последния ти плейтест. NPC е една система от много; виж как да изградиш цяла Roblox игра с ИИ: първо играемо ядро, после рундове. Как RoCode се свързва със Studio.

Често задавани въпроси

Къде да пускам pathfinding за NPC: на сървъра или на клиента?

На сървъра, в Script. Собственият пример за pathfinding на Roblox работи в LocalScript, но там се движи персонажът на самия играч. NPC е общ за всички, а щетата, която нанася, трябва да се решава от сървъра. Виж Script, LocalScript и ModuleScript.

Колко NPC с гонитба издържа един сървър?

В документацията на Roblox няма точно число; зависи от картата и от това колко често се изчисляват пътищата. Най-скъпо е изчисляването на пътя, затова скриптът за гонитба го ограничава до два пъти в секунда на NPC и го пропуска, когато играчът се вижда. За голям брой NPC препоръките на Roblox за това къде да държиш скриптовете съветват да ги маркираш с тагове и да ги обработваш чрез CollectionService от един ModuleScript, вместо да слагаш скрипт във всеки модел.

Как да накарам NPC да се преражда след смърт?

Пази копие на NPC в ServerStorage, а прераждането прави от скрипт в ServerScriptService, защото скриптът в NPC се унищожава заедно с него. Когато се задейства събитието Died на Humanoid, изчакай няколко секунди, унищожи стария модел и сложи Clone() на копието в Workspace. Скриптът ChaseAI в клонинга ще тръгне сам, защото сървърните скриптове работят веднага щом попаднат в Workspace.

Може ли NPC да гонят играчите само по време на рунд?

Да. Нека твоят скрипт за рундове клонира NPC в Workspace, когато рундът започне, и ги унищожава, когато свърши. Ръководството за система от рундове изгражда цикъла почивка и рунд, към който се свързва това.

Източници и какво да прочетеш

Как е проверен кодът: всеки скрипт на тази страница минава строга проверка на типовете в Luau с дефинициите на Roblox API (luau-lsp, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.

Пробвай RoCode в своята игра.

Безплатни кредити всеки ден, без карта. Инсталирай плъгина, опиши функцията и виж какво се е появило в Studio.