Guide · Spelsystem

NPC-pathfinding i Roblox Studio: så får du en NPC att följa spelaren

För att en NPC ska gå runt väggar och nå närmaste spelare behövs tre saker: en rigg som kan röra sig, en rutt från PathfindingService och en loop som följer rutten utan att bråka med fysikmotorn. I den här guiden bygger vi alla tre och får till slut ett enda serverskript som du bara lägger i NPC:ns rigg.

Uppdaterad 20 november 202615 min läsningSkriven av

I korthet

Lägg ett Script i NPC-modellen. Skapa en väg med PathfindingService:CreatePath(), räkna ut den med path:ComputeAsync(start, goal) i pcall, och gå sedan igenom waypoints en i taget med Humanoid:MoveTo(), och vänta på MoveToFinished innan nästa. För att NPC:n ska jaga en spelare, välj närmaste figur och räkna om vägen när den har flyttat sig några studs, inte varje bildruta.

  • Du behöver en Humanoid och en HumanoidRootPart som inte är förankrad. Anropa SetNetworkOwner(nil) på root part så att servern simulerar den: det är den vanliga lösningen för en NPC som hackar nära spelare.
  • Hoppa när waypointens Action är Jump, och räkna en ny väg när Path.Blocked utlöses för en waypoint framför NPC:n.
  • När spelaren syns direkt, hoppa över pathfinding och gör MoveTo rakt mot hen. Stanna några studs bort, eller gå ända fram om NPC:n ger skada vid beröring.
På den här sidan
  1. Så fungerar pathfinding
  2. 1. Ställ in NPC:n
  3. 2. Gå till en punkt
  4. 3. Jaktskriptet
  5. Så fungerar jakten
  6. Bli av med hackandet
  7. 4. Skada vid beröring
  8. Modifierare och länkar
  9. Common errors
  10. With RoCode
  11. Vanliga frågor
  12. Källor och vidare läsning

Så fungerar NPC-pathfinding

IllustrationChaser hittar vägen runt väggen, hoppar upp på en avsats och stannar 4 studs från dig.

Roblox bygger ett navigationsnät (navigation mesh) av de ytor som en figur kan gå på. PathfindingService söker en rutt mellan två punkter i det nätet och returnerar den som en lista med waypoints: var och en har en position och en handling, till exempel gå eller hoppa. Sedan går NPC:ns Humanoid från en waypoint till nästa. Pathfinding planerar bara rutten: det är ditt skript som ska röra sig längs den.

API:er som den här guiden använder
APIVad det gör
PathfindingService:CreatePath()Skapar ett Path-objekt som kan användas många gånger, anpassat till din NPC:s storlek via agentparametrarna.
Path:ComputeAsync(start, finish)Räknar ut rutten. Den väntar (yield) och kan misslyckas, så anropa den i pcall och kontrollera Path.Status.
Path:GetWaypoints()Returnerar rutten som en array av PathWaypoint-värden, där var och en har Position, Action och Label.
Path.BlockedUtlöses med waypointens index när något blockerar den uträknade rutten.
Humanoid:MoveTo(position)Leder NPC:n till en punkt.
Humanoid.MoveToFinishedUtlöses med true när NPC:n kommer inom ungefär en stud från punkten, eller med false om den inte kom fram inom 8 sekunder.

Kör allt det här i ett Script på servern: servern ser hela kartan även med streaming, alla spelare ser samma NPC, och skadan avgörs där klienten inte kan förfalska den. Script, LocalScript och ModuleScript förklarar den uppdelningen.

Steg 1: en NPC som kan röra sig

Vilken modell som helst kan gå längs en väg om den har de tre sakerna i tabellen nedan. Riggar från Toolbox eller gamla places saknar ibland något, och då ser det oftast ut så här: NPC:n står still och inget fel visas.

Vad NPC-modellen behöver
KravVarför det spelar roll
En Humanoid med namnet HumanoidMoveTo, WalkSpeed och hopp hör till Humanoid.
HumanoidRootPartParten som Humanoid styr. Vägar börjar från dess position.
Inget är förankratEn förankrad part kan inte röra sig, och inte heller parts som är fästa vid den. Förankrade parts ägs alltid av servern, så lösningen på hackandet längre ned går inte att använda på dem.
  1. Öppna fliken Avatar eller Home och klicka på Character för att öppna Rig Generator. Välj R15, sedan Block Avatar. En rigg dyker upp i Workspace. R6-riggar fungerar med samma skript.
  2. Döp om riggen till Chaser och ställ den på en öppen plats.
  3. Markera dess HumanoidRootPart och kontrollera att Anchored i Properties-fönstret är avstängt. Gör samma sak för alla andra förankrade parts i modellen. För att snabbt hitta dem, slå på Anchored parts i widgeten Visualization Options uppe till höger i 3D-viewporten.
Explorer: NPC-modellen i slutet av den här guiden
Workspace
  Chaser Model
    Humanoid Humanoid
    HumanoidRootPart Part
    Head, UpperTorso, LowerTorso ... (kroppsdelar)
    ChaseAI Script new
    TouchDamage Script new

För att NPC:n också ska prata lägger guiden om NPC-dialog till en Talk-prompt med svarsalternativ och förklarar vad som ändras när NPC:n går. För att visa en boss med kameran innan jakten börjar, se guiden om cutscenes.

Steg 2: skicka NPC:n till en punkt

Börja med det minsta skriptet som fungerar: gå till en part som står still. Det visar varje steg i pathfinding utan jaktlogik.

  1. Infoga en Part i Workspace, döp den till Goal, slå på Anchored, stäng av CanCollide och ställ den på golvet så att NPC:n måste gå runt en vägg.
  2. I Explorer, håll muspekaren över Chaser, klicka på knappen + och infoga ett Script. Döp det till WalkToGoal och klistra in koden nedan.
  3. Tryck på Play. NPC:n går runt väggen och fram till parten Goal.
Script i modellen Chaser med namnet 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

-- Servern måste äga NPC:ns fysik, annars fungerar inte ChangeState (hopp) från ett Script
local canSetOwner, ownerProblem = rootPart:CanSetNetworkOwnership()
if not canSetOwner then
	warn(`{npc.Name} cannot move: {ownerProblem}. Untick Anchored on every part of the rig.`)
	return
end
rootPart:SetNetworkOwner(nil)

local path = PathfindingService:CreatePath({
	AgentRadius = 2,
	AgentHeight = 5,
	AgentCanJump = true,
})

-- ComputeAsync väntar (yield) och kan kasta ett fel, så den ligger i 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 -- den första waypointen är där NPC:n redan står
		end
		humanoid:MoveTo(waypoint.Position)
		if waypoint.Action == Enum.PathWaypointAction.Jump then
			humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
		end
		-- Vänta tills NPC:n når den här waypointen, och gå först sedan till nästa
		local reached = humanoid.MoveToFinished:Wait()
		if not reached then
			warn(`{npc.Name} got stuck on the way to the goal`)
			break
		end
	end
end

Parten Goal har CanCollide avstängt, eftersom en väg inte kan sluta inuti en fast part: vägens Status skulle bli NoPath.

Tabellen som CreatePath får beskriver NPC:n (Roblox kallar den en agent), så att rutten undviker springor den inte kommer igenom. Skriptet ovan sätter de tre första nycklarna till standardvärdena, så att du ser var du ändrar dem.

Agentparametrar för CreatePath
NyckelStandardVad den styr
AgentRadius2NPC:ns radie i studs. Öka den för breda NPC:er, så att vägarna håller sig längre från väggar.
AgentHeight5NPC:ns höjd. Ställen som är lägre än så, till exempel under en trappa, räknas som blockerade.
AgentCanJumptrueTillåter rutter där ett hopp behövs. Sådana waypoints har Action lika med Jump.
AgentCanClimbfalseTillåter klättring på TrussPart. Sådana waypoints har etiketten Climb.
WaypointSpacing4Avståndet i studs mellan mellanliggande waypoints. math.huge tar bort dem.
CostsingaHur dyrt det är att passera material och märkta områden. Se modifierare och länkar.

Två detaljer i loopen är viktiga. Den första waypointen är NPC:ns egen position, så loopen hoppar över den. Och efter varje MoveTo kommer MoveToFinished:Wait(): ett nytt MoveTo ersätter det tidigare målet, så en loop utan väntan skickar NPC:n rakt mot den sista waypointen, in i just den vägg den skulle gå runt.

För hopp är waypointens Action lika med Jump, och skriptet anropar ChangeState(Enum.HumanoidStateType.Jumping). I Roblox referens för Humanoid står det att ett serverskript bara kan ändra tillståndet när servern äger figurens fysik. Det är ett av skälen till att skriptet först sätter ägaren.

På Roblox sida om pathfinding rör sig spelarens egen figur med Humanoid:Move() och en kontroll av ankomsten varje bildruta, och det kallas det bästa sättet att leda en Humanoid längs en väg. MoveTo med MoveToFinished är kortare och tydligare för en NPC på servern, så guiden använder det; om du senare behöver mer exakt kontroll, gå igenom det officiella skriptet.

Steg 3: hela jaktskriptet

Det här är skriptet som de flesta letar efter. NPC:n jagar närmaste spelare inom 80 studs, går runt väggar, hoppar där rutten kräver det, hittar en ny rutt när något blockerar den och går hem när ingen är i närheten.

  1. Ta bort WalkToGoal från Chaser om du lade till det.
  2. Håll muspekaren över Chaser, klicka på +, infoga ett Script med namnet ChaseAI och klistra in koden nedan.
  3. Tryck på Play, gå bakom en vägg och spring sedan utom räckhåll. NPC:n går runt väggen efter dig och återvänder sedan dit den började.
Script i modellen Chaser med namnet 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

-- Inställningar (avstånd i studs, tid i sekunder)
local DETECTION_RANGE = 80 -- spelare längre bort än så här märker NPC:n inte
local STOP_DISTANCE = 4 -- stanna på det här avståndet från målet (0 = gå ända fram, för skada vid beröring)
local DIRECT_CHASE_RANGE = 30 -- närmare än så här hoppar vi över pathfinding om inget är i vägen
local REPATH_DISTANCE = 4 -- hur långt målet måste flytta sig för att vägen ska räknas om
local MIN_REPATH_INTERVAL = 0.5 -- räkna aldrig vägar oftare än så här
local WAYPOINT_TIMEOUT = 2 -- ge upp vägen om en waypoint tar längre tid än så här
local CHASE_SPEED = 14 -- en spelare går som standard med hastigheten 16, så hen kan springa ifrån den här NPC:n
local HOME_RADIUS = 4 -- så här nära hemmet räknas redan som hemma
local RAY_HEIGHTS = { 0, -2 } -- siktlinjestrålar i midjehöjd och nära knäna

local HOME = rootPart.Position -- dit NPC:n går tillbaka när ingen är inom räckhåll

humanoid.WalkSpeed = CHASE_SPEED

-- Låt servern simulera NPC:n. Annars kan Roblox ge dess fysik till enheten hos
-- en spelare i närheten, och NPC:n hackar när ägaren byts.
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, -- gå genom vatten bara för att slippa en stor omväg
		DangerZone = math.huge, -- gå aldrig in i områden med etiketten DangerZone
	},
})

-- Vägen som NPC:n följer just nu
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge

-- Blocked kan utlösas för en waypoint som NPC:n redan har passerat. Bara hinder framför spelar roll.
path.Blocked:Connect(function(blockedIndex: number)
	if blockedIndex >= nextIndex then
		pathBlocked = true
	end
end)

local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- parts som inget krockar med skymmer inte sikten

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

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

-- HumanoidRootPart hos närmaste levande spelare inom DETECTION_RANGE, eller 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 när målet är på ungefär samma nivå och inget fast finns emellan.
-- En fri stråle bevisar inte att marken går att gå på, så det här gäller bara på kort avstånd.
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)
	-- Nollställ efter beräkningen, så att Blocked från den gamla rutten inte markerar den nya
	pathBlocked = false
	if ok and path.Status == Enum.PathStatus.Success then
		waypoints = path:GetWaypoints()
		nextIndex = 2 -- waypoint 1 är där NPC:n står
		pathGoal = goal
	else
		if not ok then
			warn(`{npc.Name}: path request failed: {err}`)
		end
		clearPath() -- ingen rutt än; huvudloopen försöker snart igen
	end
end

local function needsNewPath(goal: Vector3): boolean
	if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
		return false -- precis uträknad: följ den aktuella vägen
	end
	local currentGoal = pathGoal
	if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
		return true
	end
	return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end

-- Väntar på MoveToFinished men ger upp efter timeout sekunder i stället för de inbyggda 8,
-- så att en NPC som fastnat snabbt får en ny väg
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() -- fastnat eller knuffats ur kurs: räkna en ny väg
	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() -- nära nog: stå bredvid målet
			task.wait(0.2)
			continue
		end
		if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
			clearPath()
			-- Om du även skickar en part följer NPC:n efter den medan den rör sig
			humanoid:MoveTo(targetRoot.Position, targetRoot)
			task.wait(0.15)
			continue
		end
		goal = targetRoot.Position
	else
		if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
			stopMoving() -- ingen i närheten, och NPC:n är redan hemma
			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) -- ingen fungerande väg än, till exempel om målet inte går att nå
	end
end

Alla inställningar finns högst upp. För flera NPC:er, duplicera Chaser: varje kopia kör sitt eget ChaseAI och minns sitt eget hem. Äldre skript filtrerar strålar med FilterDescendantsInstances; Roblox referens rekommenderar nu ExcludeInstances för nytt arbete, och det är det som det här skriptet använder.

Så fungerar jaktskriptet

Varje varv i huvudloopen fattar ett beslut och gör en liten handling: stå still, ta ett steg rakt mot spelaren eller gå till nästa waypoint. Inget bestäms för längre än en waypoint i taget, så NPC:n reagerar hela tiden.

Hitta närmaste spelare

findNearestTarget går igenom Players:GetPlayers(), hoppar över alla utan figur, levande Humanoid eller HumanoidRootPart (spelare som återuppstår eller lämnar) och returnerar närmaste root part inom DETECTION_RANGE. Sökningen görs varje varv, så NPC:n byter själv till en spelare som är närmare, och en spelare som lämnat hittas helt enkelt inte längre: det finns inget tillstånd per spelare som behöver städas.

Räkna om vägen medan spelaren rör sig, men inte varje bildruta

Att räkna ut en väg väntar (yield) och tar servertid. needsNewPath ber om en ny väg bara när det inte finns någon väg, den gamla är slut eller blockerad, eller spelaren har flyttat sig mer än REPATH_DISTANCE studs från slutet av den aktuella vägen, och aldrig tidigare än MIN_REPATH_INTERVAL sekunder efter den förra. Medan vägen räknas fortsätter NPC:n mot den aktuella waypointen, och den nya vägen följs från waypoint 2, så NPC:n vänder inte tillbaka mot platsen där vägen började.

Blockerade vägar

Dörrar stängs, parts faller. Path.Blocked utlöses med indexet för den blockerade waypointen, som kan ligga bakom NPC:n, så skriptet reagerar bara när blockedIndex >= nextIndex: det sätter en flagga, och loopen räknar ut en ny rutt. En waypoint som NPC:n behöver längre tid än WAYPOINT_TIMEOUT sekunder för att nå, för att den knuffats eller fastnat, startar också en ny rutt.

Rakt mot en synlig spelare

Pathfinding behövs inte när spelaren syns på öppen mark. Inom DIRECT_CHASE_RANGE skickar funktionen canSeeDirectly två strålar mot spelaren, i midjehöjd och nära knäna, för att upptäcka låga väggar, och ignorerar båda figurerna. Om ingen stråle träffar något och spelaren är på ungefär samma nivå anropar NPC:n MoveTo(targetRoot.Position, targetRoot). Det andra argumentet får målet att följa med spelaren, och att anropa igen var 0.15:e sekund nollställer hela tiden timeouten på 8 sekunder.

En fri stråle bevisar att inget fast finns i vägen, men inte att det finns ett golv där. Om kartan har stup eller klyftor mellan NPC:n och spelarna, minska DIRECT_CHASE_RANGE eller sätt den till 0 för att alltid använda pathfinding.

Stanna på rätt avstånd

När spelaren är närmare än STOP_DISTANCE anropar NPC:n MoveTo på sin egen position, och det stoppar den. 4 studs passar en NPC som ska stå bredvid spelaren; för ett husdjur eller en följeslagare som håller avstånd, sätt 6 eller 8. För en fiende som slår vid beröring, sätt 0 så att den går ända fram, som i steg 4.

Varför NPC:n hackar och hur du rättar det

Om NPC:n hackar, fryser vid varje waypoint eller tar steg bakåt beror det oftast på något av punkterna nedan. Jaktskriptet hanterar redan var och en; tabellen är till för att rätta ett skript du skrivit själv.

Hackande pathfinding: orsaker och lösningar
Vad du serOrsakLösning
Mjukt när den är ensam och ryckigt när en spelare är näraNetwork ownership. Roblox ger fysiken för parts som inte är förankrade till en spelares enhet i närheten, så NPC:n kan simuleras på den spelarens enhet medan servern ger kommandona, och varje överlämning kan se ut som ett ryck.Anropa SetNetworkOwner(nil) en gång på HumanoidRootPart från servern. Det gäller alla parts som är fästa vid den.
Går rakt mot den sista waypointen och in i väggarMoveTo anropas för varje waypoint i en loop utan väntan. Varje anrop ersätter det tidigare målet.Vänta på MoveToFinished innan du går vidare till nästa waypoint.
Stannar kort vid varje waypoint eller genar i hörnEn fast task.wait() mellan waypoints i stället för att vänta på ankomsten. För lång, och NPC:n står still; för kort, och den hoppar framåt.Vänta på MoveToFinished med en timeout.
Hackar eller tar steg bakåt flera gånger per sekundEn ny väg varje bildruta. Varje väg börjar från NPC:ns egen position, så vägen till waypoint 1 vänder den bakåt.Räkna bara om vägen när målet har flyttat sig några studs, högst två gånger per sekund, och börja från waypoint 2.
Fryser några sekunder och fortsätter sedanMoveToFinished:Wait() på en waypoint som inte går att nå väntar ut timeouten på 8 sekunder.Använd en egen, kortare timeout och räkna en ny väg när den har gått ut.

För att se vem som äger NPC:n, öppna Visualization Options under ett speltest och slå på Network owners. Parts som din klient simulerar får en grön kontur; parts som servern eller en annan klient äger har vit eller grå kontur.

Steg 4: skada spelare vid beröring (valfritt)

För en fiende, lägg till ett andra skript i NPC:n som skadar spelare vid beröring. Det körs på servern, så spelarens klient kan inte ändra skadan eller kringgå cooldownen.

  1. I ChaseAI, sätt STOP_DISTANCE till 0 så att NPC:n går ända fram till spelarna i stället för att stanna bredvid.
  2. Infoga ett Script med namnet TouchDamage i Chaser och klistra in koden nedan.
Script i modellen Chaser med namnet 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 -- en besegrad NPC ger ingen skada
	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 utlöses många gånger per sekund medan parts överlappar
	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 tar hänsyn till ForceField, så spelarna är säkra så länge skyddet efter spawn gäller. För att ignorera ForceField, minska Humanoid.Health direkt.

Cooldownen sparas separat för varje spelare. Touched utlöses många gånger per sekund medan parts gnids mot varandra, och utan cooldown skulle en enda beröring kunna nolla spelarens hälsa på ett ögonblick. Posten tas bort när dess spelare lämnar, så tabellen växer inte så länge servern lever.

För att spelarna ska kunna slå tillbaka, ge dem ett svärd eller ett vapen med raycast. Båda ger skada på servern till allt som har en Humanoid, så de träffar Chaser också.

Modifierare och länkar i pathfinding

Som standard är vägen den kortaste rutten, med så få hopp som möjligt. Du kan ändra det på tre sätt. Kostnader och modifierare fungerar med jaktskriptet som det är, eftersom det redan skickar en Costs-tabell till CreatePath; länkar kräver några egna rader.

Kostnad för material

Nycklarna i Costs kan vara namn på material, till exempel Water, Mud eller CrackedLava, både för terräng och parts. Som standard kostar varje material 1. Ett högre tal får NPC:n att gå runt materialet om omvägen inte är sämre, och math.huge gör det omöjligt att passera. Jaktskriptet sätter Water = 20.

Områden att undvika: PathfindingModifier

  1. Täck området med en part som har Anchored påslaget och CanCollide avstängt.
  2. Infoga en PathfindingModifier i den parten och sätt dess Label till DangerZone.
  3. Klart. Jaktskriptet ger redan DangerZone kostnaden math.huge, så NPC:n går runt området. Slå på Pathfinding modifiers i Visualization Options för att se etiketten på navigationsnätet.

En modifierare med PassThrough påslaget gör tvärtom: rutten går genom ett fast hinder, till exempel en stängd dörr, som om det inte fanns. NPC:n kan ändå inte gå genom dörren, men går fram till den som om den hört spelaren på andra sidan.

PathfindingLink kopplar ihop två punkter som NPC:n normalt inte kan ta sig mellan, till exempel stränderna på en flod som den korsar med båt. Sätt en Attachment i varje ände, ange länkens Attachment0 och Attachment1, ge den en Label, till exempel UseBoat, och lägg till UseBoat i Costs med en lägre kostnad än Water. Då dyker en waypoint med den etiketten upp i vägen: kontrollera waypoint.Label i walkToNextWaypoint och kör din egen handling, till exempel att sätta NPC:n i båten, i stället för MoveTo. Länkar fungerar åt båda hållen om du inte stänger av IsBidirectional.

Vanliga fel och lösningar

Kontrollera först Output-fönstret. Det öppnas från menyn Window eller på fliken Script. Skripten på den här sidan skriver ut en varning när en vägförfrågan misslyckades eller riggen inte kan röra sig.

NPC:n rör sig inte alls

Om Output säger att NPC:n inte kan röra sig (cannot move) är en del av riggen förankrad: ta bort Anchored från HumanoidRootPart och de andra parts. Om inte, kontrollera att koden är i ett Script och inte i ett LocalScript, att det ligger i modellen i Workspace och att Humanoid inte har dött.

Output skriver "Infinite yield possible" på WaitForChild

Skriptet väntar på ett objekt som inte finns: en Humanoid eller HumanoidRootPart med ett annat namn, eller en saknad Goal-part för skriptet i steg 2. Byt namn på objektet eller på raden i skriptet. Guiden om skriptfel förklarar den varningen.

Ingen väg byggs, eller NPC:n ignorerar en spelare den skulle kunna nå

Path.Status efter ComputeAsync är NoPath när början eller slutet är inuti en fast part, när den enda rutten kräver ett hopp men AgentCanJump är false, eller när AgentHeight eller AgentRadius är för stor för en springa på vägen. Roblox dokumentation har också hårda gränser: högst 3,000 studs fågelvägen från början till slut, och en sökbudget på 20,000 noder, som kanske inte räcker för enorma öppna världar eller labyrinter. Slå på Navigation mesh för att kontrollera rutten.

NPC:n glider och rör inte benen

Det är ett animationsproblem, inte pathfinding. Spelarfigurer får skriptet Animate automatiskt, men en NPC behöver ett eget skript för att spela gånganimationer. Varje NPC i Roblox NPC kit har ett Script med namnet Animate som du kan studera. Hur du laddar och spelar en animation på en NPC från ett Script på servern finns i avsnittet animation på NPC:er.

NPC:n fastnar i hörn, eller hoppar men tar sig inte över hindret

Öka AgentRadius så att rutterna håller sig längre från väggar, särskilt för breda NPC:er. Om den hoppar men aldrig kommer över är hindret högre än Humanoid kan hoppa: öka JumpHeight eller JumpPower på Humanoid, eller ändra banan.

Skadan vid beröring utlöses för ofta eller aldrig

För ofta: det finns ingen cooldown, eller den sparas per part i stället för per spelare. Aldrig: STOP_DISTANCE är större än 0, så NPC:n stannar oftast innan den rör vid någon, eller så har spelaren fortfarande ForceField efter spawn.

Bygg det med RoCode

Om du hellre beskriver NPC:n än bygger den för hand kan RoCode skriva de här skripten i den place du har öppen. Det är en oberoende AI-agent för Roblox Studio: du skriver i webbchatten, och dess Studio-plugin skapar och redigerar skript i din Explorer.

Du skriver

Få modellen Chaser i Workspace att jaga närmaste spelare inom 80 studs med pathfinding, gå hem när ingen är i närheten och ge 10 i skada vid beröring med en cooldown på 1 sekund.

RoCode gör
  • Kan först gå igenom modellen med Get Properties och läsa viktiga värden, till exempel Anchored på dess parts och WalkSpeed på Humanoid. Skriv / i chatten för att bifoga den exakta sökvägen till modellen
  • Skriver jakt- och skadeskripten i modellen med Create Script och kan stänga av Anchored med Set Property om riggen behöver det
  • Kontrollerar att båda skripten kompilerar med Check Script direkt i Studio. Det fångar kompileringsfel och sådant som wait() i stället för task.wait(), men inte logiska buggar som en rutt som aldrig når spelaren
  • Skickar ändringarna i omgångar, och varje omgång är en ångrapunkt i Studios historik

Med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.11 eller nyare kan den styra en testfigur för att kontrollera att spelet fungerar, men den tar inga skärmbilder medan spelet körs, så tryck på Play och titta på NPC:n själv. Om den beter sig fel, berätta för RoCode vad du såg: Check Output kan läsa Server- och Client-raderna från ditt senaste speltest. En NPC är ett system av många; se hur du bygger ett helt Roblox-spel med AI: först en spelbar kärna, sedan rundor. Så ansluter RoCode till Studio.

Vanliga frågor

Var ska NPC-pathfinding köras: på servern eller på klienten?

På servern, i ett Script. Roblox eget pathfinding-exempel körs i ett LocalScript, men där är det spelarens egen figur som rör sig. En NPC delas av alla, och skadan den ger måste avgöras av servern. Se Script, LocalScript och ModuleScript.

Hur många jagande NPC:er klarar en server?

Roblox dokumentation anger inget exakt tal; det beror på kartan och på hur ofta vägar räknas ut. Det dyraste är att räkna ut vägen, så jaktskriptet begränsar det till två gånger per sekund per NPC och hoppar över det när spelaren syns. För många NPC:er rekommenderar Roblox riktlinjer om var skript ska ligga att du taggar dem och hanterar dem via CollectionService från ett enda ModuleScript, i stället för att lägga ett skript i varje modell.

Hur får man en NPC att återuppstå efter att den dött?

Spara en kopia av NPC:n i ServerStorage och gör återuppståndelsen från ett skript i ServerScriptService, eftersom ett skript i NPC:n förstörs tillsammans med den. När händelsen Died på Humanoid utlöses, vänta några sekunder, förstör den gamla modellen och lägg en Clone() av kopian i Workspace. Skriptet ChaseAI i klonen startar av sig självt, eftersom serverskript körs så fort de hamnar i Workspace.

Kan man få NPC:er att jaga spelare bara under en runda?

Ja. Låt ditt rundskript klona NPC:erna till Workspace när rundan börjar och förstöra dem när den slutar. Guiden om rundsystem bygger loopen med paus och runda som det kopplas till.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.