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ékeJump, és számolj új utat, amikor aPath.Blockedaz 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
Hogyan működik az NPC pathfinding
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.
| API | Mit 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.Blocked | Egy waypoint indexével sül el, amikor valami elzárja a kiszámolt útvonalat. |
Humanoid:MoveTo(position) | Egy pontig vezeti az NPC-t. |
Humanoid.MoveToFinished | true é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.
| Követelmény | Miért fontos |
|---|---|
Humanoid Humanoid néven | A MoveTo, a WalkSpeed és az ugrások a Humanoidhoz tartoznak. |
HumanoidRootPart | A 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ó. |
- 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.
- Nevezd át a riget
Chaser-re, és tedd egy nyílt területre. - 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.
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.
- 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. - 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. - Nyomd meg a Play gombot. Az NPC megkerüli a falat, és a Goal parthoz sétál.
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.
| Kulcs | Alapérték | Mit állít be |
|---|---|---|
AgentRadius | 2 | Az NPC sugara studban. Széles NPC-knél növeld, hogy az utak távolabb maradjanak a falaktól. |
AgentHeight | 5 | Az NPC magassága. Az ennél alacsonyabb helyek, például egy lépcső alatt, elzártnak számítanak. |
AgentCanJump | true | Engedélyezi az ugrást igénylő útvonalakat. Az ilyen waypointok Action értéke Jump. |
AgentCanClimb | false | Engedélyezi a TrussPartokon való mászást. Az ilyen waypointok címkéje Climb. |
WaypointSpacing | 4 | A köztes waypointok közötti távolság studban. A math.huge eltávolítja őket. |
Costs | nincs | Mennyire 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.
- Töröld a
WalkToGoal-t a Chaserből, ha hozzáadtad. - Vidd az egeret a Chaser fölé, kattints a + gombra, szúrj be egy
ChaseAInevű Script-et, és illeszd be az alábbi kódot. - 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.
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.
| Amit látsz | Ok | Javítás |
|---|---|---|
| Simán megy, amíg egyedül van, és rángatva, ha játékos van a közelben | Network 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 át | A 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 sarkokat | Fix 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ábbmegy | A 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.
- A ChaseAI-ban állítsd a
STOP_DISTANCEértékét0-ra, hogy az NPC egészen a játékosokig menjen, és ne álljon meg mellettük. - Szúrj be a Chaserbe egy
TouchDamagenevű Script-et, és illeszd be az alábbi kódot.
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
- Fedd le a területet egy parttal, bekapcsolt Anchored és kikapcsolt CanCollide beállítással.
- Szúrj be ebbe a partba egy PathfindingModifier-t, és állítsd a
LabelértékétDangerZone-ra. - Ennyi. Az üldözőscript már
math.hugeköltséget ad aDangerZone-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.
Saját átjárók: PathfindingLink
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.
É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.
- 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ó
- Roblox Creator Docs: Pathfinding (angolul). ágensparaméterek, waypointok, elzárt utak, módosítók, linkek és korlátok
- Roblox Creator Docs: PathfindingService (angolul). CreatePath és az alapértékek
- Roblox Creator Docs: Path (angolul). ComputeAsync, GetWaypoints, Status és a Blocked esemény
- Roblox Creator Docs: Humanoid (angolul). MoveTo, a MoveToFinished 8 másodperces időkorlátja, ChangeState és TakeDamage
- Roblox Creator Docs: Network ownership (angolul). automatikus tulajdonjog, SetNetworkOwner és a Network owners mód
- Roblox Creator Docs: RaycastParams (angolul). ExcludeInstances és RespectCanCollide
- Roblox Creator Docs: NPC kit (angolul). NPC példák saját Animate scriptekkel
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.