Tutorial · Gamesystemen

NPC-pathfinding in Roblox Studio: zo laat je een NPC een speler volgen

Wil je dat een NPC om muren heen loopt en de dichtstbijzijnde speler bereikt, dan heb je drie dingen nodig: een rig die kan bewegen, een route van PathfindingService en een lus die de route volgt zonder te vechten met de physics-engine. In deze handleiding bouwen we ze alle drie, en aan het eind heb je één serverscript dat je zo in de rig van je NPC kunt zetten.

Bijgewerkt 20 november 202617 min lezenAuteur:

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 Action van een waypoint Jump is, en bereken een nieuw pad wanneer Path.Blocked afgaat voor een waypoint vóór de NPC.
  • Als de speler direct zichtbaar is, sla je pathfinding over en doe je een MoveTo rechtstreeks naar hem. Stop op een paar studs afstand, of loop helemaal tegen hem aan als de NPC schade doet bij aanraking.
Op deze pagina
  1. Hoe pathfinding werkt
  2. 1. De NPC instellen
  3. 2. Naar een punt lopen
  4. 3. Achtervolgingsscript
  5. Hoe de achtervolging werkt
  6. Haperen oplossen
  7. 4. Aanraakschade
  8. Modifiers en links
  9. Common errors
  10. With RoCode
  11. Veelgestelde vragen
  12. Bronnen en verder lezen

Hoe NPC-pathfinding werkt

IllustratieChaser vindt een pad om de muur, springt op de richel en stopt op 4 studs van je.

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's die deze handleiding gebruikt
APIWat 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.BlockedGaat af met de index van een waypoint wanneer iets de berekende route blokkeert.
Humanoid:MoveTo(position)Laat de NPC naar een punt lopen.
Humanoid.MoveToFinishedGaat 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.

Wat een NPC-model nodig heeft
VereisteWaarom het belangrijk is
Een Humanoid met de naam HumanoidMoveTo, WalkSpeed en springen horen bij de Humanoid.
HumanoidRootPartDe part die de Humanoid aanstuurt. Paden beginnen bij zijn positie.
Niets verankerdEen 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.
  1. 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.
  2. Hernoem de rig naar Chaser en zet hem op een open plek.
  3. 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.
Explorer: het NPC-model aan het eind van deze handleiding
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.

  1. 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.
  2. Ga in de Explorer met je muis over Chaser, klik op de knop + en voeg een Script in. Noem het WalkToGoal en plak de code hieronder.
  3. Druk op Play. De NPC loopt om de muur heen naar de part Goal.
Script in model Chaser met de naam 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

-- 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.

Agentparameters voor CreatePath
SleutelStandaardWat het instelt
AgentRadius2De straal van de NPC in studs. Verhoog hem voor brede NPC's, zodat paden verder van muren blijven.
AgentHeight5De hoogte van de NPC. Plekken lager dan dit, bijvoorbeeld onder een trap, gelden als geblokkeerd.
AgentCanJumptrueStaat routes toe waarvoor een sprong nodig is. Bij die waypoints is Action gelijk aan Jump.
AgentCanClimbfalseStaat klimmen op TrussParts toe. Die waypoints hebben het label Climb.
WaypointSpacing4De afstand in studs tussen tussenliggende waypoints. math.huge haalt ze weg.
CostsgeenHoe 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.

  1. Verwijder WalkToGoal uit Chaser als je het had toegevoegd.
  2. Ga met je muis over Chaser, klik op +, voeg een Script met de naam ChaseAI in en plak de code hieronder.
  3. 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.
Script in model Chaser met de naam 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

-- 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.

Haperen bij pathfinding: oorzaken en oplossingen
Wat je zietOorzaakOplossing
Vloeiend als hij alleen is, schokkerig als er een speler in de buurt isNetwork 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 murenMoveTo 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 afEen 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 achteruitElk 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 verderMoveToFinished: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.

  1. Zet in ChaseAI STOP_DISTANCE op 0, zodat de NPC helemaal tegen spelers aan loopt in plaats van naast ze te stoppen.
  2. Voeg in Chaser een Script met de naam TouchDamage in en plak de code hieronder.
Script in model Chaser met de naam 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 -- 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

  1. Bedek het gebied met een part waarbij Anchored aan en CanCollide uit staat.
  2. Voeg in die part een PathfindingModifier in en zet zijn Label op DangerZone.
  3. Dat is alles. Het achtervolgingsscript geeft DangerZone al de kosten math.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.

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.

Jij typt

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.

RoCode doet
  • 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

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.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.