Útmutató · Játékrendszerek

NPC pathfinding a Roblox Studióban: így követi az NPC a játékost

Ahhoz, hogy egy NPC kikerülje a falakat és eljusson a legközelebbi játékoshoz, három dolog kell: egy rig, amely tud mozogni, egy útvonal a PathfindingService-től, és egy ciklus, amely végigmegy az útvonalon, és nem vitatkozik a fizikai motorral. Ebben az útmutatóban mindhármat összerakjuk, és a végén egyetlen szerverscriptet kapunk, amelyet egyszerűen beletehetsz az NPC rigjébe.

Frissítve 2026. november 20.15 perc olvasásSzerző:

Röviden

Tegyél egy Scriptet az NPC modelljébe. Hozz létre egy utat a PathfindingService:CreatePath() segítségével, számold ki a path:ComputeAsync(start, goal) hívással egy pcall-on belül, aztán menj végig a waypointokon egyenként a Humanoid:MoveTo() segítségével, és a következő előtt mindig várd meg a MoveToFinished eseményt. Ahhoz, hogy az NPC üldözze a játékost, válaszd ki a legközelebbi karaktert, és akkor számold újra az utat, amikor néhány studdal arrébb ment, ne minden képkockában.

  • Humanoid és nem rögzített (nem anchored) HumanoidRootPart kell. Hívd meg a SetNetworkOwner(nil)-t a root parton, hogy a szerver szimulálja: ez a szokásos javítás arra az NPC-re, amely a játékosok közelében rángatózik.
  • Ugorj, amikor a waypoint Action értéke Jump, és számolj új utat, amikor a Path.Blocked az NPC előtt lévő waypointra sül el.
  • Ha a játékos közvetlenül látható, hagyd ki a pathfindingot, és a MoveTo-val menj egyenesen hozzá. Állj meg néhány studnyira, vagy menj egészen közel, ha az NPC érintéssel sebez.
Ezen az oldalon
  1. Hogyan működik a pathfinding
  2. 1. Az NPC beállítása
  3. 2. Séta egy pontig
  4. 3. Üldözőscript
  5. Hogyan működik az üldözés
  6. A rángatózás megszüntetése
  7. 4. Érintéses sebzés
  8. Módosítók és linkek
  9. Common errors
  10. With RoCode
  11. Gyakori kérdések
  12. Források és további olvasnivaló

Hogyan működik az NPC pathfinding

IllusztrációA Chaser utat talál a fal körül, felugrik a párkányra, és 4 studnyira tőled megáll.

A Roblox navigációs hálót (navigation mesh) épít azokból a felületekből, amelyeken egy karakter járni tud. A PathfindingService ezen a hálón keres útvonalat két pont között, és waypointok listájaként adja vissza: mindegyiknek van pozíciója és művelete, például séta vagy ugrás. Aztán az NPC Humanoid-ja egyik waypointtól a másikig megy. A pathfinding csak megtervezi az útvonalat: végigmenni rajta a te scriptednek kell.

Az útmutatóban használt API-k
APIMit csinál
PathfindingService:CreatePath()Létrehoz egy többször használható Path objektumot, az ágensparaméterekkel az NPC-d méretére szabva.
Path:ComputeAsync(start, finish)Kiszámolja az útvonalat. Átadja a végrehajtást (yield), és meghiúsulhat, ezért hívd egy pcall-on belül, és ellenőrizd a Path.Status értékét.
Path:GetWaypoints()Az útvonalat PathWaypoint értékek tömbjeként adja vissza, mindegyiknek van Position, Action és Label mezője.
Path.BlockedEgy waypoint indexével sül el, amikor valami elzárja a kiszámolt útvonalat.
Humanoid:MoveTo(position)Egy pontig vezeti az NPC-t.
Humanoid.MoveToFinishedtrue értékkel sül el, amikor az NPC nagyjából egy studnyira megközelíti a pontot, vagy false értékkel, ha 8 másodperc alatt nem ért oda.

Mindezt egy szerveroldali Script-ben futtasd: a szerver streaming mellett is látja az egész térképet, minden játékos ugyanazt az NPC-t látja, a sebzésről pedig ott születik döntés, ahol a kliens nem hamisíthatja. A Script, LocalScript és ModuleScript elmagyarázza ezt a szétválasztást.

1. lépés: egy NPC, amely tud mozogni

Bármelyik modell tud útvonalon járni, ha megvan benne az alábbi táblázat három eleme. A Toolboxból vagy régi place-ekből származó rigekből néha hiányzik valami, és ez általában így néz ki: az NPC egy helyben áll, hiba pedig nincs.

Mi kell az NPC modelljének
KövetelményMiért fontos
Humanoid Humanoid névenA MoveTo, a WalkSpeed és az ugrások a Humanoidhoz tartoznak.
HumanoidRootPartA part, amelyet a Humanoid irányít. Az utak az ő pozíciójából indulnak.
Semmi sincs rögzítve (anchored)Egy rögzített part nem tud mozogni, ahogy a hozzá kapcsolt partok sem. A rögzített partok mindig a szerveréi, ezért a lentebb leírt rángatózás elleni javítás rájuk nem alkalmazható.
  1. Nyisd meg az Avatar vagy a Home fület, és kattints a Character gombra a Rig Generator megnyitásához. Válaszd az R15, aztán a Block Avatar lehetőséget. A Workspace-ben megjelenik egy rig. Az R6 rigek ugyanezekkel a scriptekkel működnek.
  2. Nevezd át a riget Chaser-re, és tedd egy nyílt területre.
  3. Jelöld ki a HumanoidRootPart-ját, és ellenőrizd, hogy a Properties ablakban az Anchored ki van kapcsolva. Ugyanezt tedd meg a modell minden más rögzített partjával. A gyors megtalálásukhoz kapcsold be az Anchored parts lehetőséget a Visualization Options widgetben a 3D nézetablak jobb felső sarkában.
Explorer: az NPC modellje az útmutató végén
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (testrészek)
    ChaseAI Script new
    TouchDamage Script new

Ha azt szeretnéd, hogy az NPC beszéljen is, az NPC párbeszéd útmutató hozzáad egy Talk felszólítást válaszlehetőségekkel, és elmagyarázza, mi változik, ha az NPC jár. Ha a bosst a kamerával szeretnéd bemutatni, mielőtt üldözni kezd, nézd meg az átvezető jelenet útmutatót.

2. lépés: küldjük el az NPC-t egy pontig

Kezdd a legkisebb működő scripttel: sétálj el egy mozdulatlan partig. Ez megmutatja a pathfinding minden lépését üldözési logika nélkül.

  1. Szúrj be egy Part-ot a Workspace-be, nevezd el Goal-nak, kapcsold be az Anchored, kapcsold ki a CanCollide beállítást, és tedd a padlóra úgy, hogy az NPC-nek meg kelljen kerülnie egy falat.
  2. Az Explorerben vidd az egeret a Chaser fölé, kattints a + gombra, és szúrj be egy Script-et. Nevezd el WalkToGoal-nak, és illeszd be az alábbi kódot.
  3. Nyomd meg a Play gombot. Az NPC megkerüli a falat, és a Goal parthoz sétál.
Script helye: Chaser modell neve: 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

-- Az NPC fizikája a szerveré kell legyen, különben a ChangeState (ugrás) egy Scriptből nem működik
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,
})

-- A ComputeAsync átadja a végrehajtást, és hibát dobhat, ezért pcall-on belül van
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 -- az első waypoint az a hely, ahol az NPC már áll
		end
		humanoid:MoveTo(waypoint.Position)
		if waypoint.Action == Enum.PathWaypointAction.Jump then
			humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
		end
		-- Megvárjuk, amíg az NPC eléri ezt a waypointot, és csak utána megyünk a következőhöz
		local reached = humanoid.MoveToFinished:Wait()
		if not reached then
			warn(`{npc.Name} got stuck on the way to the goal`)
			break
		end
	end
end

A Goal partnál ki van kapcsolva a CanCollide, mert egy út nem végződhet szilárd part belsejében: az út Status értéke NoPath lenne.

A tábla, amelyet a CreatePath kap, leírja az NPC-t (a Roblox ágensnek hívja), hogy az útvonal elkerülje azokat a réseket, amelyeken nem fér át. A fenti script az első három kulcsot az alapértékükre állítja, hogy látszódjon, hol lehet őket megváltoztatni.

Ágensparaméterek a CreatePath-hoz
KulcsAlapértékMit állít be
AgentRadius2Az NPC sugara studban. Széles NPC-knél növeld, hogy az utak távolabb maradjanak a falaktól.
AgentHeight5Az NPC magassága. Az ennél alacsonyabb helyek, például egy lépcső alatt, elzártnak számítanak.
AgentCanJumptrueEngedélyezi az ugrást igénylő útvonalakat. Az ilyen waypointok Action értéke Jump.
AgentCanClimbfalseEngedélyezi a TrussPartokon való mászást. Az ilyen waypointok címkéje Climb.
WaypointSpacing4A köztes waypointok közötti távolság studban. A math.huge eltávolítja őket.
CostsnincsMennyire drága az anyagokon és a megjelölt területeken való áthaladás. Lásd: módosítók és linkek.

A ciklusban két részlet fontos. Az első waypoint maga az NPC pozíciója, ezért a ciklus kihagyja. És minden MoveTo után jön egy MoveToFinished:Wait(): egy új MoveTo lecseréli az előző célt, ezért egy várakozás nélküli ciklus az NPC-t egyenesen az utolsó waypointhoz küldi, pont abba a falba, amelyet meg kellene kerülnie.

Ugrásoknál a waypoint Action értéke Jump, és a script meghívja a ChangeState(Enum.HumanoidStateType.Jumping)-ot. A Roblox Humanoid referenciája szerint egy szerverscript csak akkor változtathatja az állapotot, ha a karakter fizikája a szerveré. Ez az egyik oka annak, hogy a script először a tulajdonost állítja be.

A Roblox pathfinding oldalán a játékos saját karaktere a Humanoid:Move() segítségével mozog, minden képkockában ellenőrizve az érkezést, és ezt nevezik a Humanoid úton vezetése legjobb módjának. A MoveTo a MoveToFinished-del rövidebb és érthetőbb egy szerveroldali NPC-hez, ezért az útmutató ezt használja; ha később pontosabb irányítás kell, nézd meg a hivatalos scriptet.

3. lépés: a teljes üldözőscript

Ezt a scriptet keresi a legtöbb ember. Az NPC üldözi a legközelebbi játékost 80 studon belül, kikerüli a falakat, ugrik, ahol az útvonal megkívánja, új útvonalat talál, amikor valami elzárja, és hazamegy, amikor senki sincs a közelben.

  1. Töröld a WalkToGoal-t a Chaserből, ha hozzáadtad.
  2. Vidd az egeret a Chaser fölé, kattints a + gombra, szúrj be egy ChaseAI nevű Script-et, és illeszd be az alábbi kódot.
  3. Nyomd meg a Play gombot, menj egy fal mögé, aztán fuss ki a hatótávon kívülre. Az NPC megkerüli utánad a falat, aztán visszatér oda, ahonnan indult.
Script helye: Chaser modell neve: 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

-- Beállítások (távolságok studban, idő másodpercben)
local DETECTION_RANGE = 80 -- az ennél távolabbi játékosokat az NPC nem veszi észre
local STOP_DISTANCE = 4 -- ilyen távolságra áll meg a céltól (0 = egészen közel megy, érintéses sebzéshez)
local DIRECT_CHASE_RANGE = 30 -- ennél közelebb kihagyjuk a pathfindingot, ha semmi sincs útban
local REPATH_DISTANCE = 4 -- ennyit kell elmozdulnia a célnak, hogy az út újraszámolódjon
local MIN_REPATH_INTERVAL = 0.5 -- soha ne számolj utat ennél gyakrabban
local WAYPOINT_TIMEOUT = 2 -- add fel az utat, ha egy waypoint ennél tovább tart
local CHASE_SPEED = 14 -- a játékos alapból 16-os sebességgel jár, így el tud futni ez elől az NPC elől
local HOME_RADIUS = 4 -- ilyen közel az otthonhoz már otthonnak számít
local RAY_HEIGHTS = { 0, -2 } -- rálátási sugarak derékmagasságban és térdmagasság körül

local HOME = rootPart.Position -- ide tér vissza az NPC, ha senki sincs hatótávon belül

humanoid.WalkSpeed = CHASE_SPEED

-- Az NPC-t szimulálja a szerver. Különben a Roblox átadhatja a fizikáját egy közeli
-- játékos eszközének, és az NPC rángatózik, amikor a tulajdonos változik.
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, -- csak akkor menj át vízen, ha így elkerülsz egy nagy kerülőt
		DangerZone = math.huge, -- soha ne lépj be DangerZone címkéjű területre
	},
})

-- Az út, amelyen az NPC éppen halad
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge

-- A Blocked olyan waypointra is elsülhet, amelyen az NPC már túljutott. Csak az előtte lévő akadály számít.
path.Blocked:Connect(function(blockedIndex: number)
	if blockedIndex >= nextIndex then
		pathBlocked = true
	end
end)

local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- azok a partok, amelyekkel semmi sem ütközik, nem takarják a kilátást

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

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

-- A legközelebbi élő játékos HumanoidRootPartja DETECTION_RANGE-en belül, vagy 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, ha a cél nagyjából ugyanazon a szinten van, és nincs köztük semmi szilárd.
-- A tiszta sugár nem bizonyítja, hogy a talajon át lehet menni, ezért ez csak kis távolságon használatos.
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)
	-- A számolás után nullázzuk, hogy a régi útvonal Blocked eseménye ne jelölje meg az újat
	pathBlocked = false
	if ok and path.Status == Enum.PathStatus.Success then
		waypoints = path:GetWaypoints()
		nextIndex = 2 -- az 1-es waypoint az a hely, ahol az NPC áll
		pathGoal = goal
	else
		if not ok then
			warn(`{npc.Name}: path request failed: {err}`)
		end
		clearPath() -- még nincs útvonal; a fő ciklus hamarosan újra próbálja
	end
end

local function needsNewPath(goal: Vector3): boolean
	if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
		return false -- épp most számoltunk: haladunk a mostani úton
	end
	local currentGoal = pathGoal
	if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
		return true
	end
	return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end

-- Várja a MoveToFinished eseményt, de timeout másodperc után feladja a beépített 8 helyett,
-- hogy az elakadt NPC gyorsan új utat kapjon
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() -- elakadt, vagy letolták az útról: új utat számolunk
	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() -- elég közel: a cél mellett állunk
			task.wait(0.2)
			continue
		end
		if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
			clearPath()
			-- Ha a partot is átadjuk, az NPC követi, amíg az mozog
			humanoid:MoveTo(targetRoot.Position, targetRoot)
			task.wait(0.15)
			continue
		end
		goal = targetRoot.Position
	else
		if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
			stopMoving() -- senki sincs a közelben, és az NPC már otthon van
			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) -- még nincs működő út, például a cél elérhetetlen
	end
end

Minden beállítás fent van. Több NPC-hez duplikáld a Chasert: minden másolat a saját ChaseAI-ját futtatja, és a saját otthonát jegyzi meg. A régi scriptek a FilterDescendantsInstances segítségével szűrik a sugarakat; a Roblox referenciája új munkához most az ExcludeInstances-t ajánlja, és ez a script éppen azt használja.

Hogyan működik az üldözőscript

A fő ciklus minden menete egy döntést hoz, és egy kis műveletet végez: áll, egyenesen a játékos felé lép, vagy a következő waypointig megy. Semmiről sem dönt egy waypointnál hosszabb időre, ezért az NPC folyamatosan reagál.

A legközelebbi játékos megkeresése

A findNearestTarget végigmegy a Players:GetPlayers() listán, kihagy mindenkit, akinek nincs karaktere, élő Humanoidja vagy HumanoidRootPartja (az újraéledő vagy kilépő játékosokat), és visszaadja a legközelebbi root partot DETECTION_RANGE-en belül. A keresés minden menetben lefut, így az NPC magától átvált egy közelebbi játékosra, a kilépett játékost pedig egyszerűen nem találja meg többé: nincs játékosonkénti állapot, amelyet takarítani kellene.

Az út újraszámolása, amíg a játékos mozog, de nem minden képkockában

Az útszámolás átadja a végrehajtást, és szerveridőt fogyaszt. A needsNewPath csak akkor kér új utat, ha nincs út, a régi véget ért vagy elzáródott, vagy a játékos több mint REPATH_DISTANCE studdal eltávolodott a jelenlegi út végétől, és soha nem korábban, mint MIN_REPATH_INTERVAL másodperccel az előző után. Amíg az út számolódik, az NPC tovább megy a jelenlegi waypoint felé, az új utat pedig a 2-es waypointtól járja be, így az NPC nem fordul vissza oda, ahonnan az út indult.

Elzárt utak

Az ajtók bezáródnak, a partok leesnek. A Path.Blocked az elzárt waypoint indexével sül el, amely az NPC mögött is lehet, ezért a script csak blockedIndex >= nextIndex esetén reagál: beállít egy jelzőt, és a ciklus új útvonalat számol. Az a waypoint is új útvonalat indít, amelyhez az NPC WAYPOINT_TIMEOUT másodpercnél tovább megy, mert meglökték vagy beakadt.

Egyenesen a látható játékoshoz

Nincs szükség pathfindingra, ha a játékos nyílt terepen látható. DIRECT_CHASE_RANGE-en belül a canSeeDirectly függvény két sugarat lő a játékos felé, derékmagasságban és térdmagasság körül, hogy észrevegye az alacsony falakat, és mindkét karaktert figyelmen kívül hagyja. Ha egyik sugár sem talál el semmit, és a játékos nagyjából ugyanazon a szinten van, az NPC meghívja a MoveTo(targetRoot.Position, targetRoot)-ot. A második argumentum miatt a cél a játékossal együtt mozog, a hívás 0,15 másodpercenkénti ismétlése pedig folyamatosan nullázza a 8 másodperces időkorlátot.

A tiszta sugár azt bizonyítja, hogy nincs útban semmi szilárd, de azt nem, hogy van ott padló. Ha a térképen az NPC és a játékosok között szakadékok vagy meredélyek vannak, csökkentsd a DIRECT_CHASE_RANGE értékét, vagy állítsd 0-ra, hogy mindig pathfindingot használjon.

Megállás a megfelelő távolságban

Ha a játékos STOP_DISTANCE-nél közelebb van, az NPC a saját pozíciójára hívja meg a MoveTo-t, és ez megállítja. A 4 stud olyan NPC-hez illik, amelynek a játékos mellett kell állnia; egy háziállatnál vagy kísérőnél, amely távolságot tart, állíts 6-ot vagy 8-at. Egy érintéssel sebző ellenségnél állíts 0-t, hogy egészen közel menjen, mint a 4. lépésben.

Miért rángatózik az NPC, és hogyan javítsd

Ha az NPC rángatózik, minden waypointnál megdermed, vagy hátralép, az ok általában az alábbi pontok egyike. Az üldözőscript ezek mindegyikét már kezeli; a táblázat ahhoz kell, hogy megjavítsd a saját magad írta scriptet.

Rángatózás pathfindingnál: okok és javítások
Amit látszOkJavítás
Simán megy, amíg egyedül van, és rángatva, ha játékos van a közelbenNetwork ownership. A Roblox a nem rögzített partok fizikáját egy közeli játékos eszközének adja, így az NPC annak a játékosnak az eszközén szimulálódhat, miközben a parancsokat a szerver adja, és minden átadás rángásnak tűnhet.Egyszer hívd meg a SetNetworkOwner(nil)-t a HumanoidRootParton a szerverről. Ez minden hozzá kapcsolt partra hat.
Egyenesen az utolsó waypointhoz megy, a falakon átA MoveTo minden waypointra meghívódik egy ciklusban, várakozás nélkül. Minden hívás lecseréli az előző célt.Várd meg a MoveToFinished eseményt, mielőtt a következő waypointra lépsz.
Minden waypointnál rövid időre megáll, vagy levágja a sarkokatFix task.wait() a waypointok között az érkezés megvárása helyett. Ha túl hosszú, az NPC áll; ha túl rövid, előreugrik.Várd meg a MoveToFinished eseményt időkorláttal.
Másodpercenként többször rángatózik vagy hátralépÚj út minden képkockában. Mindegyik az NPC saját pozíciójából indul, ezért az 1-es waypointhoz vezető út visszafordítja.Csak akkor számold újra az utat, ha a cél néhány studdal elmozdult, legfeljebb másodpercenként kétszer, és a 2-es waypointtól kezdd.
Néhány másodpercre megdermed, aztán továbbmegyA MoveToFinished:Wait() egy elérhetetlen waypointon kivárja a 8 másodperces időkorlátot.Használj saját, rövidebb időkorlátot, és számolj új utat, amikor lejárt.

Ha látni szeretnéd, kié az NPC, nyisd meg a Visualization Options widgetet playtest közben, és kapcsold be a Network owners lehetőséget. Azok a partok, amelyeket a te kliensed szimulál, zöld körvonalat kapnak; a szerver vagy egy másik kliens partjai fehér vagy szürke körvonalat.

4. lépés: sebzés érintésre (opcionális)

Ellenség esetén adj az NPC-hez egy második scriptet, amely érintésre sebzi a játékosokat. A szerveren fut, így a játékos kliense nem változtathatja meg a sebzést, és nem kerülheti meg a cooldownt.

  1. A ChaseAI-ban állítsd a STOP_DISTANCE értékét 0-ra, hogy az NPC egészen a játékosokig menjen, és ne álljon meg mellettük.
  2. Szúrj be a Chaserbe egy TouchDamage nevű Script-et, és illeszd be az alábbi kódot.
Script helye: Chaser modell neve: 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 -- a legyőzött NPC nem sebez
	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 -- a Touched másodpercenként sokszor elsül, amíg a partok átfedik egymást
	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)

A TakeDamage figyelembe veszi az erőtereket, így a játékosok biztonságban vannak, amíg a spawn utáni erőtér tart. Ha figyelmen kívül szeretnéd hagyni az erőtereket, közvetlenül csökkentsd a Humanoid.Health értékét.

A cooldown játékosonként külön tárolódik. A Touched másodpercenként sokszor elsül, amíg a partok egymáshoz dörzsölődnek, és cooldown nélkül egyetlen érintés egy pillanat alatt lenullázhatná a játékos életerejét. A bejegyzés törlődik, amikor a játékosa kilép, így a tábla nem nő folyamatosan, amíg a szerver él.

Ha azt szeretnéd, hogy a játékosok visszavághassanak, adj nekik kardot vagy raycastos fegyvert. Mindkettő a szerveren sebez mindent, amiben Humanoid van, így a Chasert is eltalálják.

Pathfinding módosítók és linkek

Alapból az út a legrövidebb útvonal, amelyen lehetőség szerint nincs ugrás. Ezt háromféleképpen változtathatod meg. A költségek és a módosítók változtatás nélkül működnek az üldözőscripttel, mert az már átad egy Costs táblát a CreatePath-nak; a linkekhez néhány saját sor kell.

Anyagok költsége

A Costs kulcsai lehetnek anyagnevek, például Water, Mud vagy CrackedLava, terrainre és partokra egyaránt. Alapból minden anyag 1-be kerül. Egy nagyobb szám arra készteti az NPC-t, hogy kikerülje ezt az anyagot, ha a kerülő nem rosszabb, a math.huge pedig járhatatlanná teszi. Az üldözőscript Water = 20 értéket állít be.

Elkerülendő területek: PathfindingModifier

  1. Fedd le a területet egy parttal, bekapcsolt Anchored és kikapcsolt CanCollide beállítással.
  2. Szúrj be ebbe a partba egy PathfindingModifier-t, és állítsd a Label értékét DangerZone-ra.
  3. Ennyi. Az üldözőscript már math.huge költséget ad a DangerZone-nak, így az NPC kikerüli ezt a területet. Kapcsold be a Pathfinding modifiers lehetőséget a Visualization Options-ben, hogy lásd a címkét a navigációs hálón.

A bekapcsolt PassThrough beállítású módosító az ellenkezőjét teszi: az útvonal átmegy egy szilárd akadályon, például egy zárt ajtón, mintha ott sem lenne. Az NPC így sem tud átmenni az ajtón, de odamegy hozzá, mintha meghallotta volna a játékost a másik oldalon.

A PathfindingLink két olyan pontot köt össze, amelyek között az NPC általában nem tud átjutni, például egy folyó partjait, amelyen csónakkal kel át. Tegyél egy Attachmentet mindkét végre, állítsd be a link Attachment0 és Attachment1 értékét, adj neki egy Label-t, például UseBoat, és vedd fel a UseBoat-ot a Costs táblába a Water-nél alacsonyabb költséggel. Ekkor az útban megjelenik egy ilyen címkéjű waypoint: ellenőrizd a waypoint.Label értékét a walkToNextWaypoint-ban, és a MoveTo helyett indítsd a saját műveletedet, például ültesd csónakba az NPC-t. A linkek mindkét irányban működnek, hacsak ki nem kapcsolod az IsBidirectional beállítást.

Gyakori hibák és megoldásaik

Először nézd meg az Output ablakot. A Window menüből vagy a Script fülön nyílik meg. Az oldal scriptjei figyelmeztetést írnak ki, ha egy útkérés nem sikerült, vagy a rig nem tud mozogni.

Az NPC egyáltalán nem mozog

Ha az Output azt írja, hogy az NPC nem tud mozogni (cannot move), a rig egy része rögzítve van: vedd ki az Anchored jelölést a HumanoidRootPartnál és a többi partnál. Ha nem, ellenőrizd, hogy a kód egy Script-ben van, nem LocalScriptben, hogy a Workspace-ben lévő modellen belül van, és hogy a Humanoid nem halt meg.

Az Output "Infinite yield possible" üzenetet ír a WaitForChildnál

A script egy nem létező objektumra vár: más nevű Humanoidra vagy HumanoidRootPartra, vagy a 2. lépés scriptjénél hiányzó Goal partra. Nevezd át az objektumot vagy a sort a scriptben. A scripthibák útmutató elmagyarázza ezt a figyelmeztetést.

Nem épül fel az út, vagy az NPC figyelmen kívül hagy egy játékost, akihez el tudna jutni

A Path.Status értéke a ComputeAsync után NoPath, ha a kezdet vagy a vég szilárd part belsejében van, ha az egyetlen útvonal ugrást igényel, a AgentCanJump pedig false, vagy ha az AgentHeight vagy az AgentRadius túl nagy egy útba eső réshez. A Roblox dokumentációjában szigorú korlátok is vannak: legfeljebb 3000 stud légvonalban a kezdettől a végéig, és egy 20 000 csomópontos keresési keret, amely hatalmas nyílt világokhoz vagy labirintusokhoz kevés lehet. Kapcsold be a Navigation mesh lehetőséget az útvonal ellenőrzéséhez.

Az NPC csúszik, és nem mozgatja a lábát

Ez animációs probléma, nem pathfinding. A játékosok karakterei automatikusan kapnak Animate scriptet, egy NPC-nek viszont saját script kell a sétaanimációk lejátszásához. A Roblox NPC kitjének minden NPC-jében van egy Animate nevű Script, amelyet tanulmányozhatsz. Hogyan tölts be és játssz le animációt egy NPC-n szerveroldali Scriptből, azt az animáció NPC-n részben nézd meg.

Az NPC elakad a sarkokon, vagy ugrik, de nem ugorja át az akadályt

Növeld az AgentRadius értékét, hogy az útvonalak távolabb maradjanak a falaktól, főleg széles NPC-knél. Ha ugrik, de sehogy sem jut át, az akadály magasabb, mint amennyit a Humanoid ugrani tud: növeld a Humanoid JumpHeight vagy JumpPower értékét, vagy változtasd meg a pályát.

Az érintéses sebzés túl gyakran vagy soha nem lép életbe

Túl gyakran: nincs cooldown, vagy partonként tárolódik, nem játékosonként. Soha: a STOP_DISTANCE nagyobb 0-nál, így az NPC általában megáll, mielőtt bárkit megérintene, vagy a játékosnak még tart a spawn utáni erőtere.

Építsd meg a RoCode-dal

Ha egyszerűbb leírnod az NPC-t, mint kézzel összerakni, a RoCode megírhatja ezeket a scripteket a nálad nyitott place-ben. Ez egy független AI-ügynök a Roblox Studióhoz: a webes chatben írsz, a Studio pluginja pedig scripteket hoz létre és szerkeszt az Explorerben.

Te írod

Érd el, hogy a Workspace-ben lévő Chaser modell pathfindinggal üldözze a legközelebbi játékost 80 studon belül, menjen haza, ha senki sincs a közelben, és érintésre 10 sebzést okozzon 1 másodperces cooldownnal.

A RoCode elvégzi
  • Előbb átnézheti a modellt a Get Properties segítségével, és kiolvashatja a fontos értékeket, például az Anchored beállítást a partjain és a Humanoid WalkSpeed értékét. Írj / jelet a chatbe, hogy csatold a modell pontos elérési útját
  • A Create Script segítségével megírja az üldöző- és a sebzőscriptet a modellen belül, és a Set Property segítségével kiveheti az Anchored jelölést, ha a rignek erre van szüksége
  • A Check Script segítségével közvetlenül a Studióban ellenőrzi mindkét script fordítását. Ez elkapja a fordítási hibákat és az olyan dolgokat, mint a wait() a task.wait() helyett, de az olyan logikai hibákat nem, mint egy útvonal, amely soha nem jut el a játékosig
  • A változtatásokat csomagokban küldi, és minden csomag egy visszavonási pont a Studio előzményeiben

A 3.9-es vagy újabb pluginnal a RoCode rövid playtestet indíthat és kiolvashatja a hibákat, a 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, hogy ellenőrizze, működik-e a játék, de játék közben nem készít képernyőképeket, ezért nyomd meg a Play gombot, és nézd meg az NPC-t magad. Ha nem úgy viselkedik, ahogy kellene, mondd el a RoCode-nak, mit láttál: a Check Output kiolvashatja a Server és Client sorokat a legutóbbi playtestedből. Az NPC egy rendszer a sok közül; nézd meg, hogyan rakj össze egy egész Roblox játékot AI-val: előbb a játszható mag, aztán a körök. Hogyan kapcsolódik a RoCode a Studióhoz.

Gyakori kérdések

Hol futtassam az NPC pathfindingot: a szerveren vagy a kliensen?

A szerveren, egy Scriptben. A Roblox saját pathfinding példája LocalScriptben fut, de ott a játékos saját karaktere mozog. Az NPC mindenkié, és az általa okozott sebzésről a szervernek kell döntenie. Lásd: Script, LocalScript és ModuleScript.

Hány üldöző NPC-t bír el egy szerver?

A Roblox dokumentációjában nincs pontos szám; ez a térképtől és attól függ, milyen gyakran számolódnak az utak. A legdrágább az útszámolás, ezért az üldözőscript NPC-nként másodpercenként kétszerre korlátozza, és kihagyja, ha a játékos látható. Sok NPC esetén a Roblox ajánlásai a scriptek tárolási helyéről azt tanácsolják, hogy jelöld meg őket tagekkel, és egyetlen ModuleScriptből kezeld őket a CollectionService segítségével, ahelyett hogy minden modellbe scriptet tennél.

Hogyan éledjen újra az NPC a halála után?

Tarts egy másolatot az NPC-ről a ServerStorage-ban, az újraéledést pedig egy ServerScriptService-beli scriptből intézd, mert az NPC-n belüli script vele együtt megsemmisül. Amikor a Humanoid Died eseménye elsül, várj néhány másodpercet, semmisítsd meg a régi modellt, és tedd a másolat Clone()-ját a Workspace-be. A klónban lévő ChaseAI script magától elindul, mert a szerverscriptek azonnal futnak, amint a Workspace-be kerülnek.

Megoldható, hogy az NPC-k csak kör alatt üldözzék a játékosokat?

Igen. A körscripted klónozza az NPC-ket a Workspace-be, amikor a kör kezdődik, és semmisítse meg őket, amikor véget ér. A körrendszer útmutató felépíti a szünet és a kör ciklusát, amelyhez ez kapcsolódik.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.