In het kort
Zet een Script in het NPC-model. Maak een pad met PathfindingService:CreatePath(), bereken het met path:ComputeAsync(start, goal) in een pcall en loop de waypoints één voor één af met Humanoid:MoveTo(), waarbij je op MoveToFinished wacht voordat je naar het volgende gaat. Wil je dat de NPC een speler achtervolgt, kies dan het dichtstbijzijnde personage en bereken het pad opnieuw zodra het een paar studs is verplaatst, niet elk frame.
- Je hebt een Humanoid en een niet-verankerde HumanoidRootPart nodig. Roep
SetNetworkOwner(nil)aan op de root part, zodat de server hem simuleert: dat is de gebruikelijke oplossing voor een NPC die hapert in de buurt van spelers. - Spring wanneer de
Actionvan een waypointJumpis, en bereken een nieuw pad wanneerPath.Blockedafgaat voor een waypoint vóór de NPC. - Als de speler direct zichtbaar is, sla je pathfinding over en doe je een
MoveTorechtstreeks naar hem. Stop op een paar studs afstand, of loop helemaal tegen hem aan als de NPC schade doet bij aanraking.
Op deze pagina
Hoe NPC-pathfinding werkt
Roblox bouwt een navigation mesh (navigatienetwerk) uit de oppervlakken waarop een personage kan lopen. PathfindingService zoekt over dat netwerk een route tussen twee punten en geeft die terug als een lijst waypoints: elk heeft een positie en een actie, bijvoorbeeld lopen of springen. Daarna loopt de Humanoid van de NPC van het ene waypoint naar het volgende. Pathfinding plant alleen de route: je script moet de NPC er zelf langs laten bewegen.
| API | Wat het doet |
|---|---|
PathfindingService:CreatePath() | Maakt een herbruikbaar Path-object, afgestemd op de grootte van je NPC via de agentparameters. |
Path:ComputeAsync(start, finish) | Berekent de route. Het yieldt en kan mislukken, dus roep het aan in een pcall en controleer Path.Status. |
Path:GetWaypoints() | Geeft de route terug als een array van PathWaypoint-waarden, elk met Position, Action en Label. |
Path.Blocked | Gaat af met de index van een waypoint wanneer iets de berekende route blokkeert. |
Humanoid:MoveTo(position) | Laat de NPC naar een punt lopen. |
Humanoid.MoveToFinished | Gaat af met true wanneer de NPC het punt tot ongeveer een stud nadert, of met false als hij er binnen 8 seconden niet is. |
Draai dit allemaal in een server-Script: de server ziet de hele map, ook met streaming, alle spelers zien dezelfde NPC en schade wordt bepaald waar de client die niet kan vervalsen. Script, LocalScript en ModuleScript legt die verdeling uit.
Stap 1: een NPC die kan bewegen
Elk model kan een pad volgen als het de drie dingen uit de tabel hieronder heeft. Bij rigs uit de Toolbox of uit oude places ontbreekt soms iets, en meestal ziet dat er zo uit: de NPC blijft staan en er is geen foutmelding.
| Vereiste | Waarom het belangrijk is |
|---|---|
Een Humanoid met de naam Humanoid | MoveTo, WalkSpeed en springen horen bij de Humanoid. |
HumanoidRootPart | De part die de Humanoid aanstuurt. Paden beginnen bij zijn positie. |
| Niets verankerd | Een verankerde part kan niet bewegen, en de parts die eraan vastzitten ook niet. Verankerde parts zijn altijd van de server, dus de oplossing voor haperen hieronder werkt er niet op. |
- Open het tabblad Avatar of Home en klik op Character om de Rig Generator te openen. Kies R15 en daarna Block Avatar. Er verschijnt een rig in Workspace. R6-rigs werken met dezelfde scripts.
- Hernoem de rig naar
Chaseren zet hem op een open plek. - Selecteer zijn HumanoidRootPart en controleer in het venster Properties dat Anchored uit staat. Doe hetzelfde voor elke andere verankerde part in het model. Om ze snel te vinden zet je Anchored parts aan in de widget Visualization Options rechtsboven in de 3D-viewport.
Workspace
Chaser Model
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (lichaamsdelen)
ChaseAI Script new
TouchDamage Script new
Wil je dat de NPC ook praat, dan voegt de handleiding voor NPC-dialogen een Talk-prompt met antwoordopties toe en legt uit wat er verandert als de NPC rondloopt. Wil je een baas met de camera laten zien voordat hij de achtervolging inzet, kijk dan in de handleiding voor cutscenes.
Stap 2: stuur de NPC naar een punt
Begin met het kleinste werkende script: naar een stilstaande part lopen. Het laat elke stap van pathfinding zien, zonder achtervolgingslogica.
- Voeg een Part in Workspace in, noem hem
Goal, zet Anchored aan, zet CanCollide uit en plaats hem zo op de vloer dat de NPC om een muur heen moet. - Ga in de Explorer met je muis over Chaser, klik op de knop + en voeg een Script in. Noem het
WalkToGoalen plak de code hieronder. - Druk op Play. De NPC loopt om de muur heen naar de part Goal.
local PathfindingService = game:GetService("PathfindingService")
local npc = script.Parent :: Model
local humanoid = npc:WaitForChild("Humanoid") :: Humanoid
local rootPart = npc:WaitForChild("HumanoidRootPart") :: BasePart
local goalPart = workspace:WaitForChild("Goal") :: BasePart
-- De server moet de fysica van de NPC bezitten, anders werkt ChangeState (springen) vanuit een Script niet
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 yieldt en kan een fout geven, daarom staat het in een 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 -- het eerste waypoint is de plek waar de NPC al staat
end
humanoid:MoveTo(waypoint.Position)
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
-- Wacht tot de NPC dit waypoint bereikt en ga pas dan naar het volgende
local reached = humanoid.MoveToFinished:Wait()
if not reached then
warn(`{npc.Name} got stuck on the way to the goal`)
break
end
end
end
Bij de part Goal staat CanCollide uit, omdat een pad niet in een massieve part kan eindigen: de Status van het pad zou dan NoPath zijn.
De tabel die CreatePath krijgt, beschrijft de NPC (Roblox noemt hem de agent), zodat de route spleten vermijdt waar hij niet doorheen past. Het script hierboven zet de eerste drie sleutels op hun standaardwaarden, zodat je ziet waar je ze aanpast.
| Sleutel | Standaard | Wat het instelt |
|---|---|---|
AgentRadius | 2 | De straal van de NPC in studs. Verhoog hem voor brede NPC's, zodat paden verder van muren blijven. |
AgentHeight | 5 | De hoogte van de NPC. Plekken lager dan dit, bijvoorbeeld onder een trap, gelden als geblokkeerd. |
AgentCanJump | true | Staat routes toe waarvoor een sprong nodig is. Bij die waypoints is Action gelijk aan Jump. |
AgentCanClimb | false | Staat klimmen op TrussParts toe. Die waypoints hebben het label Climb. |
WaypointSpacing | 4 | De afstand in studs tussen tussenliggende waypoints. math.huge haalt ze weg. |
Costs | geen | Hoe duur het is om door materialen en gelabelde gebieden te gaan. Zie modifiers en links. |
In de lus zijn twee details belangrijk. Het eerste waypoint is de positie van de NPC zelf, dus de lus slaat het over. En na elke MoveTo komt MoveToFinished:Wait(): een nieuwe MoveTo vervangt het vorige doel, dus een lus zonder wachten stuurt de NPC meteen naar het laatste waypoint, recht tegen de muur waar hij omheen moest.
Bij sprongen is de Action van het waypoint Jump, en het script roept ChangeState(Enum.HumanoidStateType.Jumping) aan. In de Roblox-referentie voor Humanoid staat dat een serverscript de state alleen kan veranderen als de server de fysica van het personage bezit. Dat is een van de redenen waarom het script eerst de eigenaar instelt.
Op de Roblox-pagina over pathfinding beweegt het eigen personage van de speler via Humanoid:Move(), met elk frame een controle of hij is aangekomen, en dat wordt de beste manier genoemd om een Humanoid langs een pad te sturen. MoveTo met MoveToFinished is korter en duidelijker voor een server-NPC, daarom gebruikt deze handleiding het; heb je later preciezere controle nodig, bestudeer dan het officiële script.
Stap 3: het volledige achtervolgingsscript
Dit is het script waar de meeste mensen naar zoeken. De NPC achtervolgt de dichtstbijzijnde speler binnen 80 studs, loopt om muren heen, springt waar de route dat vraagt, zoekt een nieuwe route als iets de weg blokkeert en gaat naar huis als er niemand in de buurt is.
- Verwijder
WalkToGoaluit Chaser als je het had toegevoegd. - Ga met je muis over Chaser, klik op +, voeg een Script met de naam
ChaseAIin en plak de code hieronder. - Druk op Play, ga achter een muur staan en ren daarna buiten bereik. De NPC loopt om de muur heen achter je aan en gaat daarna terug naar waar hij begon.
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
-- Instellingen (afstanden in studs, tijden in seconden)
local DETECTION_RANGE = 80 -- spelers verder weg dan dit ziet de NPC niet
local STOP_DISTANCE = 4 -- stop op deze afstand van het doel (0 = helemaal tegenaan lopen, voor aanraakschade)
local DIRECT_CHASE_RANGE = 30 -- dichterbij dan dit slaan we pathfinding over als er niets in de weg staat
local REPATH_DISTANCE = 4 -- hoe ver het doel moet bewegen voordat het pad opnieuw berekend wordt
local MIN_REPATH_INTERVAL = 0.5 -- bereken paden nooit vaker dan dit
local WAYPOINT_TIMEOUT = 2 -- geef het pad op als één waypoint langer duurt dan dit
local CHASE_SPEED = 14 -- een speler loopt standaard met snelheid 16, dus kan deze NPC ontlopen
local HOME_RADIUS = 4 -- zo dicht bij huis telt als thuis
local RAY_HEIGHTS = { 0, -2 } -- zichtlijnstralen op heuphoogte en bij de knieën
local HOME = rootPart.Position -- waar de NPC naartoe teruggaat als er niemand binnen bereik is
humanoid.WalkSpeed = CHASE_SPEED
-- Laat de server de NPC simuleren. Anders kan Roblox de fysica aan het apparaat
-- van een speler in de buurt geven, en de NPC hapert als de eigenaar wisselt.
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, -- alleen door water lopen om een grote omweg te vermijden
DangerZone = math.huge, -- nooit gebieden met het label DangerZone betreden
},
})
-- Het pad dat de NPC nu volgt
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge
-- Blocked kan afgaan voor een waypoint dat de NPC al voorbij is. Alleen een obstakel vooruit telt.
path.Blocked:Connect(function(blockedIndex: number)
if blockedIndex >= nextIndex then
pathBlocked = true
end
end)
local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- parts waar niets tegen botst, blokkeren het zicht niet
local function clearPath()
waypoints = {}
nextIndex = 0
pathGoal = nil
end
local function stopMoving()
clearPath()
humanoid:MoveTo(rootPart.Position)
end
-- HumanoidRootPart van de dichtstbijzijnde levende speler binnen DETECTION_RANGE, of 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 als het doel ongeveer op dezelfde hoogte is en er niets massiefs tussen zit.
-- Een vrije straal bewijst niet dat je over de grond kunt lopen, dus dit alleen op korte afstand.
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)
-- Reset na de berekening, zodat Blocked van de oude route de nieuwe niet markeert
pathBlocked = false
if ok and path.Status == Enum.PathStatus.Success then
waypoints = path:GetWaypoints()
nextIndex = 2 -- waypoint 1 is de plek waar de NPC staat
pathGoal = goal
else
if not ok then
warn(`{npc.Name}: path request failed: {err}`)
end
clearPath() -- nog geen route; de hoofdlus probeert het zo opnieuw
end
end
local function needsNewPath(goal: Vector3): boolean
if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
return false -- net berekend: volg het huidige pad
end
local currentGoal = pathGoal
if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
return true
end
return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end
-- Wacht op MoveToFinished, maar geeft na timeout seconden op in plaats van de ingebouwde 8,
-- zodat een vastgelopen NPC snel een nieuw pad krijgt
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() -- vastgelopen of van koers geduwd: bereken een nieuw pad
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() -- dichtbij genoeg: blijf naast het doel staan
task.wait(0.2)
continue
end
if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
clearPath()
-- Geef je ook de part mee, dan volgt de NPC hem terwijl hij beweegt
humanoid:MoveTo(targetRoot.Position, targetRoot)
task.wait(0.15)
continue
end
goal = targetRoot.Position
else
if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
stopMoving() -- niemand in de buurt en de NPC is al thuis
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) -- nog geen bruikbaar pad, bijvoorbeeld omdat het doel onbereikbaar is
end
end
Alle instellingen staan bovenaan. Voor meerdere NPC's dupliceer je Chaser: elke kopie draait zijn eigen ChaseAI en onthoudt zijn eigen thuis. Oudere scripts filteren stralen met FilterDescendantsInstances; de Roblox-referentie raadt voor nieuw werk nu ExcludeInstances aan, en dat gebruikt dit script.
Hoe het achtervolgingsscript werkt
Elke ronde van de hoofdlus neemt één beslissing en doet één kleine actie: blijven staan, rechtstreeks naar de speler stappen of naar het volgende waypoint lopen. Niets wordt verder dan één waypoint vooruit beslist, dus de NPC blijft steeds reageren.
De dichtstbijzijnde speler vinden
findNearestTarget loopt Players:GetPlayers() af, slaat iedereen zonder personage, levende Humanoid of HumanoidRootPart over (spelers die respawnen of weggaan) en geeft de dichtstbijzijnde root part binnen DETECTION_RANGE terug. Het zoeken gebeurt elke ronde, dus de NPC schakelt vanzelf over op een speler die dichterbij is, en een speler die weggaat wordt gewoon niet meer gevonden: er is geen status per speler die je moet opruimen.
Het pad opnieuw berekenen terwijl de speler beweegt, maar niet elk frame
Een pad berekenen yieldt en kost servertijd. needsNewPath vraagt alleen een nieuw pad als er geen pad is, het oude klaar of geblokkeerd is, of de speler meer dan REPATH_DISTANCE studs van het eind van het huidige pad is weggegaan, en nooit eerder dan MIN_REPATH_INTERVAL seconden na het vorige. Terwijl het pad berekend wordt, blijft de NPC naar het huidige waypoint lopen, en het nieuwe pad wordt vanaf waypoint 2 gevolgd, zodat de NPC niet omdraait naar de plek waar het pad begon.
Geblokkeerde paden
Deuren gaan dicht, parts vallen om. Path.Blocked gaat af met de index van het geblokkeerde waypoint, en dat kan achter de NPC liggen, dus het script reageert alleen bij blockedIndex >= nextIndex: het zet een vlag en de lus berekent een nieuwe route. Een waypoint waar de NPC langer dan WAYPOINT_TIMEOUT seconden over doet, omdat hij geduwd werd of ergens achter bleef haken, start ook een nieuwe route.
Rechtstreeks naar een zichtbare speler
Pathfinding is niet nodig als de speler in het zicht op een open plek staat. Binnen DIRECT_CHASE_RANGE schiet de functie canSeeDirectly twee stralen naar de speler, op heuphoogte en bij de knieën om lage muren op te merken, en negeert ze beide personages. Raakt geen enkele straal iets en staat de speler ongeveer op dezelfde hoogte, dan roept de NPC MoveTo(targetRoot.Position, targetRoot) aan. Door het tweede argument beweegt het doel mee met de speler, en door de aanroep elke 0,15 seconde te herhalen wordt de time-out van 8 seconden steeds gereset.
Een vrije straal bewijst dat er niets massiefs in de weg staat, maar niet dat er een vloer is. Heeft je map afgronden of kliffen tussen de NPC en de spelers, verlaag dan DIRECT_CHASE_RANGE of zet hem op 0 om altijd pathfinding te gebruiken.
Op de juiste afstand stoppen
Is de speler dichterbij dan STOP_DISTANCE, dan roept de NPC MoveTo aan op zijn eigen positie, en daardoor stopt hij. 4 studs past bij een NPC die naast de speler moet staan; voor een huisdier of begeleider die afstand houdt, kies je 6 of 8. Voor een vijand die bij aanraking slaat, zet je 0, zodat hij helemaal tegen je aan loopt, zoals in stap 4.
Waarom een NPC hapert en hoe je dat oplost
Hapert de NPC, bevriest hij bij elk waypoint of stapt hij achteruit, dan is de oorzaak meestal een van de punten hieronder. Het achtervolgingsscript houdt al met elk ervan rekening; de tabel is bedoeld om een script te repareren dat je zelf hebt geschreven.
| Wat je ziet | Oorzaak | Oplossing |
|---|---|---|
| Vloeiend als hij alleen is, schokkerig als er een speler in de buurt is | Network ownership. Roblox geeft de fysica van niet-verankerde parts aan het apparaat van een speler in de buurt, dus de NPC kan op het apparaat van die speler gesimuleerd worden terwijl de server de opdrachten geeft, en elke overdracht kan eruitzien als een schok. | Roep vanaf de server één keer SetNetworkOwner(nil) aan op de HumanoidRootPart. Dat geldt voor alle parts die eraan vastzitten. |
| Loopt rechtstreeks naar het laatste waypoint en tegen muren | MoveTo wordt in een lus voor elk waypoint aangeroepen zonder te wachten. Elke aanroep vervangt het vorige doel. | Wacht op MoveToFinished voordat je naar het volgende waypoint gaat. |
| Stopt even bij elk waypoint of snijdt hoeken af | Een vaste task.wait() tussen waypoints in plaats van wachten tot hij aankomt. Te lang en de NPC staat stil; te kort en hij schiet vooruit. | Wacht op MoveToFinished met een time-out. |
| Hapert of stapt meerdere keren per seconde achteruit | Elk frame een nieuw pad. Elk pad begint bij de positie van de NPC zelf, dus het pad naar waypoint 1 draait hem om. | Bereken het pad alleen opnieuw als het doel een paar studs is verplaatst, niet vaker dan twee keer per seconde, en begin bij waypoint 2. |
| Bevriest een paar seconden en loopt dan verder | MoveToFinished:Wait() op een onbereikbaar waypoint wacht de time-out van 8 seconden af. | Gebruik je eigen, kortere time-out en bereken een nieuw pad zodra die verloopt. |
Om te zien wie de NPC bezit, open je tijdens een playtest Visualization Options en zet je Network owners aan. Parts die je client simuleert krijgen een groene rand; parts van de server of van een andere client hebben een witte of grijze rand.
Stap 4: schade aan spelers bij aanraking (optioneel)
Voor een vijand voeg je een tweede script aan de NPC toe dat spelers schade doet als ze hem aanraken. Het draait op de server, dus de client van een speler kan de schade niet veranderen of de cooldown omzeilen.
- Zet in ChaseAI
STOP_DISTANCEop0, zodat de NPC helemaal tegen spelers aan loopt in plaats van naast ze te stoppen. - Voeg in Chaser een Script met de naam
TouchDamagein en plak de code hieronder.
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 -- een verslagen NPC doet geen schade
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 gaat vele keren per seconde af zolang parts elkaar overlappen
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 houdt rekening met forcefields, dus spelers zijn veilig zolang het forcefield na het spawnen actief is. Wil je forcefields negeren, verlaag dan Humanoid.Health rechtstreeks.
De cooldown wordt per speler bijgehouden. Touched gaat vele keren per seconde af zolang parts langs elkaar schuren, en zonder cooldown kan één aanraking de gezondheid van een speler in een oogwenk naar nul brengen. De regel wordt verwijderd als die speler weggaat, zodat de tabel niet blijft groeien zolang de server draait.
Wil je dat spelers terug kunnen vechten, geef ze dan een zwaard of een raycast-geweer. Beide doen op de server schade aan alles met een Humanoid, dus ze raken Chaser ook.
Pathfinding-modifiers en links
Standaard is een pad de kortste route, waar mogelijk zonder sprongen. Dat kun je op drie manieren veranderen. Kosten en modifiers werken zonder aanpassing met het achtervolgingsscript, omdat het al een Costs-tabel aan CreatePath geeft; voor links heb je een paar eigen regels nodig.
Kosten van materialen
De sleutels in Costs kunnen materiaalnamen zijn, zoals Water, Mud of CrackedLava, voor terrain én voor parts. Standaard kost elk materiaal 1. Een hoger getal laat de NPC om dat materiaal heen lopen als de omweg niet slechter is, en math.huge maakt het onbegaanbaar. Het achtervolgingsscript zet Water = 20.
Gebieden om te vermijden: PathfindingModifier
- Bedek het gebied met een part waarbij Anchored aan en CanCollide uit staat.
- Voeg in die part een PathfindingModifier in en zet zijn
LabelopDangerZone. - Dat is alles. Het achtervolgingsscript geeft
DangerZoneal de kostenmath.huge, dus de NPC loopt om dat gebied heen. Zet Pathfinding modifiers aan in Visualization Options om het label op de navigation mesh te zien.
Een modifier met PassThrough aan doet het omgekeerde: de route gaat door een massief obstakel heen, bijvoorbeeld een gesloten deur, alsof het er niet is. De NPC kan nog steeds niet door de deur lopen, maar loopt er wel naartoe, alsof hij de speler aan de andere kant hoorde.
Eigen overgangen: PathfindingLink
Een PathfindingLink verbindt twee punten waar een NPC normaal niet tussen kan lopen, bijvoorbeeld de oevers van een rivier die hij per boot oversteekt. Zet aan elk uiteinde een Attachment, stel Attachment0 en Attachment1 van de link in, geef hem een Label, bijvoorbeeld UseBoat, en voeg UseBoat aan Costs toe met lagere kosten dan Water. Dan krijgt het pad een waypoint met dat label: controleer waypoint.Label in walkToNextWaypoint en start je eigen actie, bijvoorbeeld de NPC in de boot zetten, in plaats van MoveTo. Links werken in beide richtingen, tenzij je IsBidirectional uitzet.
Veelvoorkomende fouten en oplossingen
Kijk eerst in het venster Output. Je opent het via het menu Window of op het tabblad Script. De scripts op deze pagina geven een waarschuwing als een padverzoek mislukt of als de rig niet kan bewegen.
De NPC beweegt helemaal niet
Staat er in Output dat de NPC niet kan bewegen (cannot move), dan is een deel van de rig verankerd: zet Anchored uit op de HumanoidRootPart en de andere parts. Zo niet, controleer dan of de code in een Script staat en niet in een LocalScript, of het in een model in Workspace zit en of de Humanoid niet dood is.
Output meldt "Infinite yield possible" bij WaitForChild
Het script wacht op een object dat er niet is: een Humanoid of HumanoidRootPart met een andere naam, of een ontbrekende part Goal voor het script uit stap 2. Hernoem het object of de regel in het script. De handleiding over scriptfouten legt deze waarschuwing uit.
Er wordt geen pad gebouwd, of de NPC negeert een speler die hij wel zou kunnen bereiken
Path.Status is na ComputeAsync gelijk aan NoPath als het begin of het eind in een massieve part ligt, als de enige route een sprong vraagt terwijl AgentCanJump false is, of als AgentHeight of AgentRadius te groot is voor een spleet op de route. De Roblox-documentatie noemt ook harde grenzen: niet meer dan 3.000 studs in een rechte lijn van begin tot eind, en een zoekbudget van 20.000 knooppunten, wat voor enorme open werelden of doolhoven niet genoeg kan zijn. Zet Navigation mesh aan om de route te controleren.
De NPC glijdt en beweegt zijn benen niet
Dat is een animatieprobleem, geen pathfinding-probleem. Personages van spelers krijgen automatisch een Animate-script, maar een NPC heeft een eigen script nodig om loopanimaties af te spelen. Elke NPC uit de NPC kit van Roblox heeft een Script met de naam Animate dat je kunt bestuderen. Hoe je een animatie op een NPC laadt en afspeelt vanuit een server-Script, lees je in het deel animatie op een NPC.
De NPC blijft haken aan hoeken of springt, maar komt niet over het obstakel
Verhoog AgentRadius, zodat routes verder van muren blijven, vooral voor brede NPC's. Springt hij wel maar komt hij er niet overheen, dan is het obstakel hoger dan de Humanoid kan springen: verhoog JumpHeight of JumpPower van de Humanoid of pas het level aan.
Aanraakschade gaat te vaak of nooit af
Te vaak: er is geen cooldown, of hij wordt per part bijgehouden in plaats van per speler. Nooit: STOP_DISTANCE is groter dan 0, dus de NPC stopt meestal voordat hij iemand raakt, of de speler heeft nog het forcefield van na het spawnen.
Bouw dit met RoCode
Beschrijf je een NPC liever dan hem met de hand te bouwen, dan kan RoCode deze scripts schrijven in de place die je open hebt. Het is een onafhankelijke AI-agent voor Roblox Studio: je typt in een webchat en de plugin voor Studio maakt en bewerkt scripts in je Explorer.
Laat het model Chaser in Workspace met pathfinding de dichtstbijzijnde speler binnen 80 studs achtervolgen, naar huis gaan als er niemand in de buurt is en 10 schade doen bij aanraking met een cooldown van 1 seconde.
- Kan eerst het model bekijken met Get Properties en de belangrijkste waarden lezen, zoals Anchored op de parts en WalkSpeed van de Humanoid. Typ / in de chat om het exacte pad naar het model toe te voegen
- Schrijft de achtervolgings- en schadescripts in het model met Create Script en kan Anchored uitzetten met Set Property als de rig dat nodig heeft
- Controleert met Check Script direct in Studio of beide scripts compileren. Dat vangt compileerfouten en dingen als wait() in plaats van task.wait() op, maar geen logische bugs zoals een route die de speler nooit bereikt
- Stuurt wijzigingen in batches, en elke batch is een ongedaan-maakpunt in de geschiedenis van Studio
Met plugin 3.9 of nieuwer kan RoCode een korte playtest starten en de fouten lezen, en met plugin 3.9.11 of nieuwer kan het een testpersonage besturen om te controleren of de game werkt, maar tijdens het spelen maakt het geen screenshots, dus druk zelf op Play en kijk naar de NPC. Gedraagt hij zich niet zoals je wilt, vertel RoCode dan wat je zag: Check Output kan de Server- en Client-regels van je laatste playtest lezen. Een NPC is één systeem van de vele; lees hoe je een hele Roblox-game bouwt met AI: eerst een speelbare kern, daarna rondes. Hoe RoCode verbinding maakt met Studio.
Veelgestelde vragen
Waar draai je NPC-pathfinding: op de server of op de client?
Op de server, in een Script. Het eigen pathfinding-voorbeeld van Roblox draait in een LocalScript, maar daar beweegt het personage van de speler zelf. Een NPC is van iedereen, en de schade die hij doet moet de server bepalen. Zie Script, LocalScript en ModuleScript.
Hoeveel achtervolgende NPC's kan één server aan?
De Roblox-documentatie noemt geen exact aantal; het hangt af van de map en van hoe vaak paden berekend worden. Het duurst is het berekenen van een pad, dus het achtervolgingsscript beperkt dat tot twee keer per seconde per NPC en slaat het over als de speler zichtbaar is. Voor veel NPC's raden de Roblox-richtlijnen over waar je scripts bewaart aan om ze te taggen en via CollectionService vanuit één ModuleScript af te handelen, in plaats van een script in elk model te zetten.
Hoe laat je een NPC respawnen na zijn dood?
Bewaar een kopie van de NPC in ServerStorage en regel het respawnen vanuit een script in ServerScriptService, want een script in de NPC wordt samen met de NPC vernietigd. Gaat het event Died van de Humanoid af, wacht dan een paar seconden, vernietig het oude model en zet een Clone() van de kopie in Workspace. Het ChaseAI-script in de kloon start vanzelf, omdat serverscripts draaien zodra ze in Workspace staan.
Kun je NPC's alleen tijdens een ronde achter spelers aan laten gaan?
Ja. Laat je rondescript de NPC's naar Workspace klonen als de ronde begint en ze vernietigen als hij eindigt. De handleiding voor een rondesysteem bouwt de lus van pauze en ronde waar je dit op aansluit.
Bronnen en verder lezen
- Roblox Creator Docs: Pathfinding (in het Engels). agentparameters, waypoints, geblokkeerde paden, modifiers, links en grenzen
- Roblox Creator Docs: PathfindingService (in het Engels). CreatePath en de standaardwaarden
- Roblox Creator Docs: Path (in het Engels). ComputeAsync, GetWaypoints, Status en het event Blocked
- Roblox Creator Docs: Humanoid (in het Engels). MoveTo, de time-out van 8 seconden van MoveToFinished, ChangeState en TakeDamage
- Roblox Creator Docs: Network ownership (in het Engels). automatisch eigenaarschap, SetNetworkOwner en de weergave Network owners
- Roblox Creator Docs: RaycastParams (in het Engels). ExcludeInstances en RespectCanCollide
- Roblox Creator Docs: NPC kit (in het Engels). voorbeeld-NPC's met hun eigen Animate-scripts
Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.