En bref
Mets un Script dans le modèle du PNJ. Crée un chemin avec PathfindingService:CreatePath(), calcule-le avec path:ComputeAsync(start, goal) dans un pcall, puis parcours les waypoints un par un avec Humanoid:MoveTo(), en attendant MoveToFinished avant le suivant. Pour poursuivre un joueur, choisis le personnage le plus proche et recalcule le chemin quand il s'est déplacé de quelques studs, pas à chaque frame.
- Le PNJ a besoin d'un Humanoid et d'un HumanoidRootPart non ancré. Appelle
SetNetworkOwner(nil)sur la root part pour que le serveur la simule : c'est la solution habituelle pour un PNJ qui saccade près des joueurs. - Saute quand l'
Actiond'un waypoint vautJump, et calcule un nouveau chemin quandPath.Blockedse déclenche pour un waypoint devant le PNJ. - Quand le joueur est bien en vue, saute le pathfinding et fais un
MoveTodirectement vers lui. Arrête-toi à quelques studs, ou continue si le PNJ fait des dégâts au contact.
Sur cette page
Comment marche le pathfinding d'un PNJ
Roblox construit un maillage de navigation (navigation mesh) à partir des surfaces sur lesquelles un personnage pourrait marcher. PathfindingService cherche sur ce maillage un itinéraire entre deux points et le renvoie sous forme de liste de waypoints, chacun étant une position plus une action comme marcher ou sauter. Le Humanoid du PNJ marche ensuite d'un waypoint au suivant. Le pathfinding ne fait que planifier l'itinéraire : avancer le long de cet itinéraire, c'est le travail de ton script.
| API | Ce qu'elle fait |
|---|---|
PathfindingService:CreatePath() | Crée un objet Path réutilisable, adapté à la taille de ton PNJ avec les paramètres d'agent. |
Path:ComputeAsync(start, finish) | Calcule l'itinéraire. La fonction yield et peut échouer, donc appelle-la dans un pcall et vérifie Path.Status. |
Path:GetWaypoints() | Renvoie l'itinéraire sous forme de tableau de valeurs PathWaypoint, chacune avec une Position, une Action et un Label. |
Path.Blocked | Se déclenche avec un index de waypoint quand quelque chose bloque l'itinéraire calculé. |
Humanoid:MoveTo(position) | Fait marcher le PNJ vers un point. |
Humanoid.MoveToFinished | Se déclenche avec true quand le PNJ arrive à environ un stud du point, ou avec false s'il n'est pas arrivé au bout de 8 secondes. |
Fais tourner tout ça dans un Script serveur : le serveur voit toute la map même avec le streaming activé, chaque joueur voit le même PNJ, et les dégâts sont décidés là où un client ne peut pas les truquer. Script vs LocalScript vs ModuleScript (en anglais) explique la séparation.
Étape 1 : préparer un PNJ qui peut bouger
N'importe quel modèle peut suivre un chemin s'il a les trois choses ci-dessous. Il manque parfois l'une d'elles aux rigs de la Toolbox ou des vieux jeux, et le symptôme habituel est un PNJ qui reste immobile sans aucune erreur.
| Condition | Pourquoi c'est important |
|---|---|
Un Humanoid nommé Humanoid | MoveTo, WalkSpeed et le saut appartiennent tous au Humanoid. |
Un HumanoidRootPart | La part que le Humanoid fait bouger. Les chemins partent de sa position. |
| Rien d'ancré | Une part ancrée ne peut pas bouger, et les parts qui y sont reliées non plus. Le serveur possède toujours les parts ancrées, donc la solution contre les saccades plus bas ne peut pas s'appliquer à elles. |
- Ouvre l'onglet Avatar ou Home et clique sur Character pour ouvrir le Rig Generator. Choisis R15, puis Block Avatar. Un rig apparaît dans Workspace. Les rigs R6 marchent avec les mêmes scripts.
- Renomme le rig
Chaseret pose-le sur un terrain dégagé. - Sélectionne son HumanoidRootPart et vérifie que Anchored est décoché dans la fenêtre Properties. Fais pareil pour toute autre part ancrée du modèle. Pour les repérer vite, active Anchored parts dans le widget Visualization Options en haut à droite de la vue 3D.
Workspace
Chaser Model
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (the body parts)
ChaseAI Script new
TouchDamage Script new
Pour que le PNJ parle aussi, le guide du dialogue de PNJ ajoute un prompt Talk avec des réponses à choisir, et explique ce qui change quand le PNJ marche. Pour montrer un boss avec la caméra avant qu'il commence la poursuite, vois le guide des cinématiques.
Étape 2 : faire marcher le PNJ jusqu'à un point
Commence par le plus petit script qui marche : aller jusqu'à une part fixe. Il montre chaque étape du pathfinding sans la logique de poursuite.
- Insère une Part dans Workspace, nomme-la
Goal, coche Anchored et décoche CanCollide, puis pose-la au sol à un endroit où le PNJ doit contourner un mur pour l'atteindre. - Dans l'Explorer, survole Chaser, clique sur le bouton + et insère un Script. Nomme-le
WalkToGoalet colle le code ci-dessous. - Appuie sur Play. Le PNJ contourne le mur jusqu'à la 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
-- Le serveur doit posséder la physique du PNJ pour que ChangeState (le saut) marche depuis un 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 yield et peut lever une erreur, donc il va dans un 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 -- le premier waypoint est l'endroit où le PNJ se trouve déjà
end
humanoid:MoveTo(waypoint.Position)
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
-- Attendre d'avoir atteint ce waypoint avant de passer au suivant
local reached = humanoid.MoveToFinished:Wait()
if not reached then
warn(`{npc.Name} got stuck on the way to the goal`)
break
end
end
end
La part Goal a CanCollide décoché parce qu'un chemin ne peut pas se terminer à l'intérieur d'une part solide : le Status du chemin serait NoPath.
La table passée à CreatePath décrit le PNJ, que Roblox appelle l'agent, pour que l'itinéraire évite les passages trop étroits pour lui. Le script ci-dessus règle les trois premières clés sur leurs valeurs par défaut pour que tu voies où les changer.
| Clé | Par défaut | Ce qu'elle règle |
|---|---|---|
AgentRadius | 2 | Le rayon du PNJ en studs. Augmente-le pour les PNJ larges, pour que les chemins restent à distance des murs. |
AgentHeight | 5 | La hauteur du PNJ. Les espaces plus bas, comme sous un escalier, comptent comme bloqués. |
AgentCanJump | true | Autorise les itinéraires qui demandent un saut. Ces waypoints ont leur Action réglée sur Jump. |
AgentCanClimb | false | Autorise l'escalade des TrussParts. Ces waypoints ont le label Climb. |
WaypointSpacing | 4 | L'espacement en studs entre les waypoints intermédiaires. math.huge les supprime. |
Costs | aucun | Le coût pour traverser des matériaux et des zones avec un label. Vois modificateurs et liens. |
Deux détails de la boucle comptent. Le premier waypoint est la position du PNJ lui-même, donc la boucle le saute. Et chaque MoveTo est suivi de MoveToFinished:Wait() : un nouveau MoveTo remplace le but précédent, donc une boucle qui n'attend pas envoie le PNJ droit vers le dernier waypoint, dans le mur qu'il devait contourner.
Pour les sauts, l'Action du waypoint vaut Jump et le script appelle ChangeState(Enum.HumanoidStateType.Jumping). La référence Humanoid de Roblox précise qu'un script serveur ne peut changer un état que si le serveur possède la physique du personnage, une des raisons pour lesquelles le script règle d'abord le propriétaire réseau.
La page pathfinding de Roblox déplace le personnage du joueur lui-même avec Humanoid:Move() et une vérification d'arrivée à chaque frame, et présente ça comme la meilleure façon de déplacer un Humanoid le long d'un chemin. MoveTo avec MoveToFinished est plus court et plus facile à suivre pour un PNJ serveur, donc ce guide l'utilise ; étudie le script officiel si tu as besoin d'un contrôle plus fin plus tard.
Étape 3 : le script de poursuite complet
C'est le script que la plupart des gens cherchent. Le PNJ poursuit le joueur le plus proche dans un rayon de 80 studs, contourne les murs, saute là où l'itinéraire le demande, trouve un nouvel itinéraire quand quelque chose le bloque, et rentre chez lui quand personne n'est proche.
- Supprime
WalkToGoalde Chaser si tu l'as ajouté. - Survole Chaser, clique sur +, insère un Script nommé
ChaseAIet colle le code ci-dessous. - Appuie sur Play, passe derrière un mur, puis cours hors de portée. Le PNJ te suit autour du mur, puis retourne à son point de départ.
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
-- Réglages (distances en studs, durées en secondes)
local DETECTION_RANGE = 80 -- les joueurs plus loin que ça sont ignorés
local STOP_DISTANCE = 4 -- s'arrêter à cette distance de la cible (0 = lui rentrer dedans, pour les dégâts au contact)
local DIRECT_CHASE_RANGE = 30 -- dans ce rayon, sauter le pathfinding quand rien ne bloque le passage
local REPATH_DISTANCE = 4 -- de combien la cible doit bouger avant que le chemin soit recalculé
local MIN_REPATH_INTERVAL = 0.5 -- ne jamais calculer de chemin plus souvent que ça
local WAYPOINT_TIMEOUT = 2 -- abandonner un chemin si un waypoint prend plus longtemps que ça
local CHASE_SPEED = 14 -- un joueur marche à 16 par défaut, donc il peut semer ce PNJ
local HOME_RADIUS = 4 -- à cette distance de la maison, on compte comme rentré
local RAY_HEIGHTS = { 0, -2 } -- rayons de ligne de vue à hauteur de taille et près des genoux
local HOME = rootPart.Position -- là où le PNJ retourne quand personne n'est à portée
humanoid.WalkSpeed = CHASE_SPEED
-- Laisser le serveur simuler le PNJ. Sinon Roblox peut confier sa physique à l'appareil
-- d'un joueur proche, et le PNJ saccade à chaque changement.
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, -- traverser l'eau seulement pour éviter un long détour
DangerZone = math.huge, -- ne jamais entrer dans les zones avec le label DangerZone
},
})
-- Le chemin que le PNJ suit en ce moment
local waypoints: { PathWaypoint } = {}
local nextIndex = 0
local pathGoal: Vector3? = nil
local pathBlocked = false
local lastComputeTime = -math.huge
-- Blocked peut se déclencher pour un waypoint que le PNJ a déjà dépassé. Seul un blocage devant compte.
path.Blocked:Connect(function(blockedIndex: number)
if blockedIndex >= nextIndex then
pathBlocked = true
end
end)
local rayParams = RaycastParams.new()
rayParams.RespectCanCollide = true -- les parts avec lesquelles rien ne peut entrer en collision ne bloquent pas la vue
local function clearPath()
waypoints = {}
nextIndex = 0
pathGoal = nil
end
local function stopMoving()
clearPath()
humanoid:MoveTo(rootPart.Position)
end
-- Le HumanoidRootPart du joueur vivant le plus proche dans DETECTION_RANGE, ou 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 quand la cible est à peu près au même niveau et que rien de solide n'est entre les deux.
-- Un rayon dégagé ne prouve pas que le sol est praticable, donc on ne s'en sert qu'à courte distance.
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)
-- Remettre à zéro après le calcul, pour qu'un événement Blocked de l'ancien itinéraire ne marque pas le nouveau
pathBlocked = false
if ok and path.Status == Enum.PathStatus.Success then
waypoints = path:GetWaypoints()
nextIndex = 2 -- le waypoint 1 est l'endroit où se tient le PNJ
pathGoal = goal
else
if not ok then
warn(`{npc.Name}: path request failed: {err}`)
end
clearPath() -- pas d'itinéraire pour l'instant ; la boucle principale réessaie bientôt
end
end
local function needsNewPath(goal: Vector3): boolean
if os.clock() - lastComputeTime < MIN_REPATH_INTERVAL then
return false -- calculé il y a un instant : continuer sur le chemin actuel
end
local currentGoal = pathGoal
if currentGoal == nil or pathBlocked or nextIndex > #waypoints then
return true
end
return (goal - currentGoal).Magnitude > REPATH_DISTANCE
end
-- Attend MoveToFinished, mais abandonne au bout de `timeout` secondes au lieu des
-- 8 prévues par Roblox, pour qu'un PNJ coincé obtienne vite un nouveau chemin
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() -- coincé ou poussé hors de sa route : calculer un nouveau chemin
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() -- assez près : rester à côté de la cible
task.wait(0.2)
continue
end
if distance <= DIRECT_CHASE_RANGE and canSeeDirectly(targetRoot) then
clearPath()
-- Passer aussi la part fait suivre au PNJ ses déplacements
humanoid:MoveTo(targetRoot.Position, targetRoot)
task.wait(0.15)
continue
end
goal = targetRoot.Position
else
if (HOME - rootPart.Position).Magnitude <= HOME_RADIUS then
stopMoving() -- personne autour et déjà rentré
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) -- pas encore de chemin utilisable, par exemple la cible est hors d'atteinte
end
end
Tous les réglages sont en haut. Pour plus de PNJ, duplique Chaser : chaque copie fait tourner son propre ChaseAI et se souvient de sa propre maison. Les anciens scripts filtrent les rayons avec FilterDescendantsInstances ; la référence de Roblox recommande maintenant ExcludeInstances pour le nouveau code, et c'est ce que ce script utilise.
Comment marche le script de poursuite
Chaque tour de la boucle principale prend une décision, puis fait une seule petite chose : rester immobile, avancer droit vers le joueur ou marcher jusqu'au waypoint suivant. Rien n'est engagé pour plus d'un waypoint, donc le PNJ continue à réagir.
Trouver le joueur le plus proche
findNearestTarget parcourt Players:GetPlayers(), ignore tous ceux qui n'ont pas de personnage, de Humanoid vivant ou de HumanoidRootPart (les joueurs en train de réapparaître ou de quitter le jeu), et renvoie la root part la plus proche dans DETECTION_RANGE. La recherche tourne à chaque tour, donc le PNJ passe tout seul à un joueur plus proche, et un joueur qui quitte le jeu n'est simplement plus trouvé : il n'y a aucune donnée par joueur à nettoyer.
Recalculer quand le joueur bouge, sans le faire à chaque frame
Calculer un chemin yield et coûte du temps serveur. needsNewPath n'en demande un que s'il n'y a pas de chemin, si l'ancien est terminé ou bloqué, ou si le joueur s'est éloigné de plus de REPATH_DISTANCE studs de l'endroit où finit le chemin actuel, et jamais moins de MIN_REPATH_INTERVAL secondes après le précédent. Pendant le calcul, le PNJ continue de marcher vers son waypoint actuel, et le nouveau chemin est suivi à partir du waypoint 2, donc le PNJ ne fait pas demi-tour vers l'endroit où le chemin commençait.
Chemins bloqués
Les portes se ferment et les parts tombent. Path.Blocked se déclenche avec l'index du waypoint bloqué, qui peut être derrière le PNJ, donc le script ne réagit que si blockedIndex >= nextIndex : il lève un drapeau et la boucle calcule un nouvel itinéraire. Un waypoint qui met plus de WAYPOINT_TIMEOUT secondes à être atteint, parce que le PNJ a été poussé ou s'est accroché, déclenche aussi un nouvel itinéraire.
Foncer droit sur un joueur visible
Le pathfinding ne sert à rien quand le joueur est bien en vue sur un terrain dégagé. Dans DIRECT_CHASE_RANGE, canSeeDirectly lance deux rayons vers le joueur, à hauteur de taille et près des genoux pour attraper les murets, en ignorant les deux personnages. Si aucun ne touche rien et que le joueur est à peu près au même niveau, le PNJ appelle MoveTo(targetRoot.Position, targetRoot). Le deuxième argument fait bouger le but avec le joueur, et répéter l'appel toutes les 0,15 seconde remet sans cesse à zéro le délai de 8 secondes.
Un rayon dégagé prouve que rien de solide ne bloque le passage, pas qu'il y a un sol sur lequel marcher. Si ta map a des trous ou des chutes entre le PNJ et les joueurs, baisse DIRECT_CHASE_RANGE, ou règle-le sur 0 pour toujours utiliser le pathfinding.
S'arrêter à la bonne distance
Quand le joueur est à moins de STOP_DISTANCE, le PNJ appelle MoveTo sur sa propre position, ce qui l'arrête. 4 studs conviennent à un PNJ qui doit se tenir à côté d'un joueur ; monte à 6 ou 8 pour un familier ou une escorte qui garde un peu de distance. Pour un ennemi qui blesse au contact, règle-le sur 0 pour qu'il rentre dans le joueur, comme à l'étape 4.
Pourquoi les PNJ saccadent, et comment corriger ça
Un PNJ qui avance par à-coups, s'arrête à chaque waypoint ou recule par petits sursauts a en général une des causes ci-dessous. Le script de poursuite gère déjà chacune d'elles ; le tableau sert à réparer un script que tu as écrit toi-même.
| Ce que tu vois | Cause | Solution |
|---|---|---|
| Fluide quand il est seul, saccadé dès qu'un joueur approche | La propriété réseau (network ownership). Roblox confie la physique des parts non ancrées à l'appareil d'un joueur proche, donc le PNJ peut finir simulé sur l'appareil de ce joueur pendant que le serveur donne les ordres, et chaque passage de relais peut se voir comme un accroc. | Appelle SetNetworkOwner(nil) une fois sur le HumanoidRootPart, depuis le serveur. Ça s'applique à toutes les parts qui y sont reliées. |
| Marche droit vers le dernier waypoint et dans les murs | MoveTo appelé pour chaque waypoint dans une boucle sans attente. Chaque appel remplace le but précédent. | Attends MoveToFinished avant de passer au waypoint suivant. |
| S'arrête un instant à chaque waypoint, ou coupe les virages | Un task.wait() fixe entre les waypoints au lieu d'attendre l'arrivée. Trop long et le PNJ reste planté ; trop court et il saute des étapes. | Attends MoveToFinished, avec un délai maximum. |
| Sursaute ou recule plusieurs fois par seconde | Un nouveau chemin à chaque frame. Chacun commence à la position du PNJ lui-même, donc marcher vers le waypoint 1 le fait se retourner. | Recalcule seulement quand la cible a bougé de quelques studs, deux fois par seconde au maximum, et commence au waypoint 2. |
| Se fige plusieurs secondes, puis repart | MoveToFinished:Wait() sur un waypoint qu'il ne peut pas atteindre attend le délai de 8 secondes. | Utilise ton propre délai, plus court, et calcule un nouveau chemin quand il expire. |
Pour voir qui possède le PNJ, ouvre Visualization Options pendant un test et active Network owners. Les parts que ton client simule ont un contour vert ; les parts possédées par le serveur ou un autre client ont un contour blanc ou gris.
Étape 4 : blesser les joueurs au contact (optionnel)
Pour un ennemi, ajoute au PNJ un deuxième script qui blesse les joueurs qu'il touche. Il tourne sur le serveur, donc le client d'un joueur ne peut ni changer les dégâts ni sauter le temps de recharge.
- Dans ChaseAI, règle
STOP_DISTANCEsur0pour que le PNJ rentre dans les joueurs au lieu de s'arrêter à côté d'eux. - Insère un Script nommé
TouchDamagedans Chaser et colle le code ci-dessous.
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 -- un PNJ vaincu ne fait pas de dégâts
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 se déclenche plusieurs fois par seconde tant que des parts se chevauchent
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 respecte les force fields, donc les joueurs sont protégés tant que dure le force field d'apparition. Pour ignorer les force fields, baisse plutôt Humanoid.Health directement.
Le temps de recharge est gardé par joueur. Touched se déclenche plusieurs fois par seconde tant que des parts frottent l'une contre l'autre, et sans temps de recharge un seul contact pourrait vider la vie d'un joueur en un instant. Chaque entrée est supprimée quand son joueur part, donc la table ne grossit pas pendant toute la vie du serveur.
Pour que les joueurs puissent se défendre, donne-leur l'épée ou le pistolet à raycast (en anglais). Les deux infligent leurs dégâts sur le serveur à tout ce qui a un Humanoid, donc ils touchent aussi le Chaser.
Modificateurs et liens de pathfinding
Par défaut, un chemin est l'itinéraire le plus court, qui évite les sauts quand c'est possible. Trois outils changent ça. Les coûts et les modificateurs marchent avec le script de poursuite tel quel, parce qu'il passe déjà une table Costs à CreatePath ; les liens demandent quelques lignes de ton côté.
Coût des matériaux
Les clés de Costs peuvent être des noms de matériaux comme Water, Mud ou CrackedLava, pour le terrain comme pour les parts. Chaque matériau coûte 1 par défaut. Un nombre plus élevé fait éviter ce matériau au PNJ sauf si le détour est pire, et math.huge le rend infranchissable. Le script de poursuite règle Water = 20.
Zones à éviter : PathfindingModifier
- Couvre la zone avec une part, avec Anchored coché et CanCollide décoché.
- Insère un PathfindingModifier dans cette part et règle son
LabelsurDangerZone. - C'est tout. Le script de poursuite donne déjà à
DangerZoneun coût demath.huge, donc le PNJ contourne la zone. Active Pathfinding modifiers dans Visualization Options pour voir le label sur le maillage de navigation.
Un modificateur avec PassThrough activé fait l'inverse : l'itinéraire passe à travers un obstacle solide, comme une porte fermée, comme s'il n'était pas là. Le PNJ ne peut toujours pas traverser la porte, mais il se dirige vers elle, comme s'il entendait le joueur de l'autre côté.
Passages sur mesure : PathfindingLink
Un PathfindingLink relie deux points entre lesquels le PNJ ne pourrait normalement pas passer, comme les deux rives d'une rivière qu'il traverse en bateau. Mets un Attachment à chaque bout, règle Attachment0 et Attachment1 du lien, donne-lui un Label comme UseBoat, et ajoute UseBoat à Costs avec un coût plus bas que Water. Le chemin contient alors un waypoint avec ce label : vérifie waypoint.Label dans walkToNextWaypoint et lance ta propre action, comme asseoir le PNJ dans le bateau, au lieu de MoveTo. Les liens marchent dans les deux sens, sauf si tu désactives IsBidirectional.
Problèmes courants
Regarde d'abord la fenêtre Output. Ouvre-la depuis le menu Window ou l'onglet Script. Les scripts de cette page affichent un avertissement quand une demande de chemin échoue ou que le rig ne peut pas bouger.
Le PNJ ne bouge pas du tout
Si Output dit que le PNJ ne peut pas bouger, une partie du rig est ancrée : décoche Anchored sur le HumanoidRootPart et les autres parts. Sinon, vérifie que le code est dans un Script, pas un LocalScript, qu'il se trouve dans le modèle dans Workspace, et que le Humanoid n'est pas mort.
Output affiche "Infinite yield possible" sur WaitForChild
Le script attend un objet qui n'existe pas : un Humanoid ou un HumanoidRootPart avec un autre nom, ou aucune part nommée Goal pour le script de l'étape 2. Renomme l'objet ou la chaîne dans le script. Le guide des erreurs de script explique cet avertissement.
Le chemin échoue, ou le PNJ ignore un joueur qu'il pourrait atteindre
Path.Status vaut NoPath après ComputeAsync quand le départ ou l'arrivée est dans une part solide, quand le seul itinéraire demande un saut et que AgentCanJump vaut false, ou quand AgentHeight ou AgentRadius est trop grand pour un passage sur le trajet. Roblox documente aussi des limites fixes : au maximum 3 000 studs en ligne droite entre le départ et l'arrivée, et un budget de recherche de 20 000 nœuds que des mondes ouverts immenses ou des labyrinthes peuvent épuiser. Active Navigation mesh pour vérifier l'itinéraire.
Le PNJ glisse sans bouger les jambes
C'est un problème d'animation, pas de pathfinding. Les personnages des joueurs reçoivent automatiquement un script Animate, mais un PNJ a besoin de son propre script pour jouer les animations de marche. Chaque PNJ du NPC kit de Roblox contient un Script nommé Animate que tu peux étudier. Pour charger et jouer une animation sur un PNJ depuis un Script serveur, vois jouer une animation sur un PNJ.
Le PNJ reste coincé dans les coins ou saute sans franchir un obstacle
Augmente AgentRadius pour que les itinéraires restent plus loin des murs, surtout pour les PNJ larges. S'il saute sans jamais passer, l'obstacle est plus haut que ce que le Humanoid peut sauter : augmente le JumpHeight ou le JumpPower du Humanoid, ou modifie le niveau.
Les dégâts au contact touchent trop souvent, ou jamais
Trop souvent : le temps de recharge manque, ou il est gardé par part au lieu d'être gardé par joueur. Jamais : STOP_DISTANCE est au-dessus de 0, donc le PNJ s'arrête en général avant de toucher qui que ce soit, ou le joueur a encore un force field d'apparition.
Le faire avec RoCode
Si tu préfères décrire le PNJ plutôt que tout brancher à la main, RoCode peut écrire ces scripts dans le jeu que tu as ouvert. C'est un agent IA indépendant pour Roblox Studio : tu écris dans un chat web, et son plugin pour Studio crée et modifie les scripts dans ton Explorer.
Fais que le modèle Chaser dans Workspace poursuive le joueur le plus proche dans un rayon de 80 studs avec le pathfinding, rentre chez lui quand personne n'est proche, et fasse 10 dégâts au contact avec un temps de recharge de 1 seconde.
- Peut d'abord examiner le modèle, avec Get Properties pour lire des valeurs importantes comme Anchored sur ses parts et WalkSpeed sur son Humanoid. Tape / dans le chat pour joindre le chemin exact du modèle
- Écrit les scripts de poursuite et de dégâts dans le modèle avec Create Script, et peut décocher Anchored avec Set Property si le rig en a besoin
- Vérifie la compilation des deux scripts avec Check Script dans Studio. Ça attrape les erreurs de compilation et des habitudes comme wait() au lieu de task.wait(), pas les bugs de logique comme un itinéraire qui n'atteint jamais le joueur
- Envoie ses changements par lots, et chaque lot est un point d'annulation dans l'historique de Studio
Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.11 ou plus récent il peut contrôler un personnage de test pour vérifier que le jeu marche, mais il ne prend pas de captures d'écran pendant que le jeu tourne, donc appuie sur Play et regarde le PNJ toi-même. S'il se comporte mal, dis à RoCode ce que tu as vu : Check Output peut lire les lignes Server et Client de ton dernier test. Les PNJ sont un système parmi d'autres ; vois comment construire un jeu Roblox complet avec l'IA, d'abord un cœur jouable, puis d'autres demandes. Comment RoCode se connecte à Studio.
Questions fréquentes
Le pathfinding d'un PNJ doit-il tourner sur le serveur ou sur le client ?
Sur le serveur, dans un Script. L'exemple de pathfinding de Roblox lui-même tourne dans un LocalScript, mais il déplace le personnage du joueur. Un PNJ est partagé par tout le monde, et les dégâts qu'il fait doivent être décidés par le serveur. Vois Script vs LocalScript vs ModuleScript (en anglais).
Combien de PNJ poursuivants un serveur peut-il gérer ?
La documentation de Roblox ne donne pas de nombre fixe ; ça dépend de ta map et de la fréquence de calcul des chemins. Le calcul des chemins est la partie coûteuse, c'est pourquoi le script de poursuite le limite à deux fois par seconde par PNJ et le saute quand le joueur est en vue. Avec beaucoup de PNJ, les conseils de Roblox sur l'emplacement des scripts suggèrent de les taguer et de les gérer avec CollectionService depuis un seul ModuleScript, au lieu d'un script dans chaque modèle.
Comment faire réapparaître le PNJ après sa mort ?
Garde une copie du PNJ dans ServerStorage, et gère la réapparition depuis un script dans ServerScriptService, puisqu'un script à l'intérieur du PNJ est détruit avec lui. Quand l'événement Died du Humanoid se déclenche, attends quelques secondes, détruis l'ancien modèle et place un Clone() de la copie dans Workspace. Le script ChaseAI du clone démarre tout seul, parce que les scripts serveur tournent dès qu'ils sont dans Workspace.
Les PNJ peuvent-ils poursuivre les joueurs seulement pendant une manche ?
Oui. Fais cloner les PNJ dans Workspace par ton script de manches au début d'une manche, et fais-les détruire à la fin. Le guide du système de manches construit la boucle d'intermission et de manche à laquelle tu brancherais ça.
Sources et lectures
- Roblox Creator Docs : Pathfinding (en anglais). paramètres d'agent, waypoints, chemins bloqués, modificateurs, liens et limites
- Roblox Creator Docs : PathfindingService (en anglais). CreatePath et ses valeurs par défaut
- Roblox Creator Docs : Path (en anglais). ComputeAsync, GetWaypoints, Status et l'événement Blocked
- Roblox Creator Docs : Humanoid (en anglais). MoveTo, le délai de 8 secondes de MoveToFinished, ChangeState et TakeDamage
- Roblox Creator Docs : Network ownership (en anglais). la propriété automatique, SetNetworkOwner et la vue Network owners
- Roblox Creator Docs : RaycastParams (en anglais). ExcludeInstances et RespectCanCollide
- Roblox Creator Docs : NPC kit (en anglais). des exemples de PNJ avec leurs propres scripts Animate
Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.