Tutoriel · Systèmes de jeu

Comment faire un dialogue de PNJ sur Roblox Studio

Un dialogue de PNJ sur Roblox, c'est trois éléments : un prompt pour commencer à parler, une boîte qui affiche ce que dit le PNJ avec des boutons pour les réponses du joueur, et un script qui décide où mène chaque réponse. Ce guide construit les trois : tu écris la conversation dans une simple table, les joueurs appuient sur E pour parler, et tout ce qu'une réponse donne (un soin, un objet) est distribué par le serveur, jamais par l'appareil du joueur.

Mis à jour le 12 novembre 202625 min de lectureÉcrit par

En bref

Mets le modèle de ton PNJ dans un dossier nommé NPCs dans Workspace et écris sa conversation dans un ModuleScript dans ReplicatedStorage : chaque ligne a le texte du PNJ et une liste de choix qui mènent à une autre ligne. Un Script dans ServerScriptService ajoute un ProximityPrompt ("Talk") à chaque PNJ, retient à quelle ligne se trouve chaque joueur et la lui envoie avec un RemoteEvent. Un LocalScript affiche le texte et un bouton par choix, et ne renvoie que le numéro du bouton pressé.

  • Donne les récompenses sur le serveur. L'événement DialogChoiceSelected de l'objet Dialog intégré ne se déclenche que sur le client, donc un Script serveur ne l'entend jamais, et un soin ou un objet donné dans un LocalScript ne change que la copie du jeu de ce joueur.
  • Affiche une bulle de dialogue avec TextChatService:DisplayBubble(npc.Head, text) depuis un LocalScript. L'ancien service Chat est obsolète, remplacé par TextChatService.
  • Les répliques que tu écris toi-même n'ont pas besoin d'être filtrées. La règle de Roblox est de filtrer tout texte affiché que tu ne contrôles pas explicitement, comme ce que tapent les joueurs.
Sur cette page
  1. Fonctionnement
  2. 1. Ajouter un PNJ
  3. 2. Conversation
  4. 3. Script serveur
  5. 4. Boîte de dialogue
  6. Tes propres actions
  7. Autres tutoriels
  8. Limites face aux exploits
  9. 5. Tester
  10. Aller plus loin
  11. Problèmes courants
  12. Avec RoCode
  13. Questions fréquentes
  14. Sources et lectures

Comment marche un dialogue de PNJ

Illustration animéeChaque réplique se tape dans la boîte pendant que la réplique entière s'affiche dans une bulle, les choix apparaissent une fois la réplique tapée, et le serveur donne la Torch quand tu choisis "Got anything for the cave?".

Un PNJ qui parle et qui marche dans un jeu en ligne est partagé entre le serveur et l'appareil de chaque joueur. L'appareil dessine la boîte et les boutons. Le serveur, le seul côté auquel tu peux faire confiance, sait quelle ligne lit chaque joueur et décide de ce que fait chaque réponse. Un tour de conversation se passe comme ça :

  1. Le joueur s'approche du PNJ et appuie sur E sur son prompt Talk. L'événement Triggered du prompt se déclenche sur le serveur avec ce joueur.
  2. Le script serveur vérifie que le joueur est assez près, note qu'il est sur la ligne appelée start, et envoie le texte de cette ligne et les libellés de ses choix à ce joueur seulement.
  3. Le LocalScript tape la réplique dans la boîte de dialogue, affiche une bulle au-dessus du PNJ, puis ajoute un bouton par choix.
  4. Le joueur clique, touche ou sélectionne un choix. Seul son numéro repart vers le serveur.
  5. Le serveur cherche ce numéro sur la ligne qu'il sait que le joueur est en train de lire, lance l'action du choix s'il en a une (un soin, un objet), et envoie la ligne suivante ou ferme la boîte.
Les éléments d'un PNJ qui parle
ÉlémentOù il se trouveCe qu'il fait
Le rig GuideWorkspace, dans un dossier nommé NPCsLe PNJ. Son nom choisit sa conversation et s'affiche sur le prompt.
Le ModuleScript DialogueDataReplicatedStorageChaque réplique que le PNJ peut dire, les choix sous chaque ligne et où mène chaque choix.
Le Script DialogueServiceServerScriptServiceAjoute le prompt Talk, retient à quelle ligne se trouve chaque joueur, vérifie chaque clic et lance les actions.
Le RemoteEvent DialogueEventReplicatedStorage (DialogueService le crée)Transporte chaque ligne vers le joueur, et le numéro du choix cliqué vers le serveur.
Le LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsDessine la boîte, tape la réplique, affiche la bulle et les boutons de choix.
Le Tool Torch (facultatif)ServerStorage, dans un dossier nommé DialogueItemsL'objet que donne un des choix. Rien de ce qui est dans ServerStorage n'est envoyé aux joueurs.
L'Explorer une fois le PNJ terminé. Quand le jeu tourne, DialogueService ajoute un RemoteEvent nommé DialogueEvent dans ReplicatedStorage et un ProximityPrompt Talk nommé TalkPrompt dans la HumanoidRootPart de chaque PNJ.
Workspace
  NPCs Folder new
    Guide Model new
      Humanoid Humanoid
      HumanoidRootPart Part
      Head, UpperTorso, LowerTorso ... (les parties du corps)
ReplicatedStorage
  DialogueData ModuleScript new
ServerScriptService
  DialogueService Script new
ServerStorage
  DialogueItems Folder new
    Torch Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    DialogueClient LocalScript new

Étape 1 : ajouter un PNJ

  1. Dans l'onglet Avatar ou Home, clique sur Character pour ouvrir le Rig Generator. Choisis R15, une morphologie et un style. Un rig nommé Rig apparaît dans Workspace. Un rig R6 marche avec les mêmes scripts.
  2. Renomme-le Guide. Le nom compte : DialogueService cherche la conversation avec le nom du modèle, et le prompt l'affiche aux joueurs.
  3. Déplie le rig, sélectionne sa HumanoidRootPart et coche Anchored dans la fenêtre Properties. Une part ancrée ne bouge jamais à cause de la physique, donc le PNJ reste là où tu l'as mis et les joueurs ne peuvent pas le pousser.
  4. Survole Workspace dans l'Explorer, clique sur le bouton + et insère un Folder nommé NPCs. Fais glisser Guide dedans, et place le rig à un endroit où les joueurs peuvent s'en approcher.
  5. Facultatif, pour le choix de l'objet : survole ServerStorage et insère un Folder nommé DialogueItems. Mets dedans un Tool nommé Torch, avec une Part non ancrée nommée Handle, qui est la part que tient un personnage. Une PointLight dans le Handle le fait briller.

Les noms tiennent compte des majuscules, donc tape NPCs, Guide, DialogueItems et Torch exactement comme indiqué. N'importe quel modèle avec un Humanoid et une HumanoidRootPart peut être un PNJ, y compris un modèle de la Toolbox, du moment qu'il se trouve directement dans le dossier NPCs.

Étape 2 : écrire la conversation

Survole ReplicatedStorage, insère un ModuleScript nommé DialogueData et colle ceci dedans. Il ne contient aucune logique, seulement les mots et la façon dont ils s'enchaînent, donc c'est le fichier que tu modifieras le plus.

ModuleScript dans ReplicatedStorage nommé DialogueData
-- ModuleScript dans ReplicatedStorage nommé DialogueData.
-- Toutes les conversations, rangées par nom de PNJ dans Workspace.NPCs. Chaque ligne a le
-- texte du PNJ et les choix du joueur. Un choix peut mener à une autre ligne (next),
-- terminer la discussion (pas de next) et demander au serveur de faire quelque chose (action). Si le serveur
-- ne peut pas faire l'action, il affiche la ligne failNext à la place de next.

export type Choice = {
	text: string,
	next: string?, -- la ligne à afficher après ce choix ; nil termine la conversation
	action: string?, -- une action serveur de la table ACTIONS de DialogueService
	item: string?, -- pour l'action GiveItem : le nom d'un Tool dans ServerStorage.DialogueItems
	failNext: string?, -- la ligne à afficher à la place de next quand l'action n'a pas pu être faite
}

export type Line = {
	text: string,
	choices: { Choice },
}

local DialogueData: { [string]: { [string]: Line } } = {
	Guide = {
		start = {
			text = "Welcome to the village! What can I do for you?",
			choices = {
				{ text = "Any tips?", next = "tips" },
				{ text = "I'm hurt. Can you help?", next = "healed", action = "Heal", failNext = "healTooSoon" },
				{ text = "Got anything for the cave?", next = "torch", action = "GiveItem", item = "Torch", failNext = "hasTorch" },
				{ text = "Bye!" },
			},
		},
		tips = {
			text = "Stay off the red bricks, and come back if you get hurt.",
			choices = {
				{ text = "Anything else?", next = "start" },
				{ text = "Thanks!" },
			},
		},
		healed = {
			text = "There you go, good as new.",
			choices = {
				{ text = "Thank you!" },
			},
		},
		torch = {
			text = "Take this torch. The cave is dark.",
			choices = {
				{ text = "Thanks!" },
			},
		},
		healTooSoon = {
			text = "I healed you a moment ago. Come back in a little while.",
			choices = {
				{ text = "OK" },
			},
		},
		hasTorch = {
			text = "You already have my torch. Keep it lit!",
			choices = {
				{ text = "Will do!" },
			},
		},
	},
}

return DialogueData

Les lignes export type du haut décrivent à quoi ressemblent une ligne et un choix. Elles ne changent rien quand le jeu tourne ; elles décrivent tes données pour qu'un vérificateur de types puisse les contrôler.

Comment les éléments s'enchaînent :

  • Chaque PNJ a une table qui porte le nom de son modèle dans le dossier NPCs, ici Guide. Chaque conversation commence à la ligne appelée start.
  • text est ce que dit le PNJ. choices sont les boutons du joueur, dans l'ordre. La boîte a de la place pour quatre.
  • next nomme la ligne à afficher après ce choix. Un choix sans next, comme "Bye!", termine la conversation. Un next ou un failNext qui nomme une ligne absente de la table la termine aussi, avec un avertissement dans Output.
  • action nomme quelque chose que fait le serveur, pris dans la table ACTIONS de DialogueService : ici Heal ou GiveItem.
  • item sert à GiveItem : le nom d'un Tool dans ServerStorage, DialogueItems.
  • failNext est la ligne affichée à la place de next quand l'action n'a pas pu être faite, pour que le PNJ n'annonce jamais un soin ou un cadeau qui n'a pas eu lieu.
La conversation du Guide, ligne par ligne
LigneLe Guide ditLes choix, et où ils mènent
start"Welcome to the village! What can I do for you?""Any tips?" mène à tips. "I'm hurt. Can you help?" soigne, puis healed (ou healTooSoon). "Got anything for the cave?" donne la Torch, puis torch (ou hasTorch). "Bye!" termine.
tips"Stay off the red bricks, and come back if you get hurt.""Anything else?" revient à start. "Thanks!" termine.
healed"There you go, good as new.""Thank you!" termine.
torch"Take this torch. The cave is dark.""Thanks!" termine.
healTooSoon"I healed you a moment ago. Come back in a little while.""OK" termine.
hasTorch"You already have my torch. Keep it lit!""Will do!" termine.

Seul le serveur lit ce module. Le LocalScript ne fait jamais de require dessus : le serveur envoie chaque ligne quand le joueur y arrive. Un module dans ReplicatedStorage est quand même copié sur l'appareil de chaque joueur, donc si une conversation contient des spoilers (la réponse d'une énigme, par exemple), déplace DialogueData dans ServerStorage. Ensuite, dans la ligne require de DialogueService, remplace ReplicatedStorage par ServerStorage, pour que la ligne entière soit local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.

Étape 3 : ajouter le script serveur

Survole ServerScriptService, insère un Script nommé DialogueService et colle le code ci-dessous. C'est le seul endroit où une conversation avance et le seul endroit où une récompense est donnée.

Script dans ServerScriptService nommé DialogueService
-- Script dans ServerScriptService nommé DialogueService.
-- Ajoute un prompt Talk à chaque PNJ de Workspace.NPCs et gère chaque conversation.
-- L'appareil du joueur ne fait qu'afficher le texte et renvoyer le numéro du choix
-- cliqué. Le serveur sait à quelle ligne se trouve chaque joueur, vérifie le choix
-- et la distance, et il est le seul côté qui soigne ou donne des objets.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Les mêmes formes que dans DialogueData, pour que le vérificateur de types de Studio les connaisse ici aussi
type Choice = { text: string, next: string?, action: string?, item: string?, failNext: string? }
type Line = { text: string, choices: { Choice } }
local DialogueData = require(ReplicatedStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }

local TALK_DISTANCE = 12 -- studs : la portée du prompt, et la distance à laquelle un joueur doit rester
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30

local npcFolder = workspace:WaitForChild("NPCs")
local itemFolder = ServerStorage:FindFirstChild("DialogueItems")

-- Ce script crée DialogueEvent lui-même, donc n'en ajoute pas à la main
local dialogueEvent = Instance.new("RemoteEvent")
dialogueEvent.Name = "DialogueEvent"
dialogueEvent.Parent = ReplicatedStorage

type Conversation = { npc: Model, npcName: string, lineId: string, lastChoice: number }
local conversations: { [Player]: Conversation } = {}
local lastHeal: { [Player]: number } = {}

local function rootOf(model: Model?): BasePart?
	local root = model and model:FindFirstChild("HumanoidRootPart")
	return if root and root:IsA("BasePart") then root else nil
end

local function isClose(player: Player, npc: Model): boolean
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local playerRoot = rootOf(character)
	local npcRoot = rootOf(npc)
	if not (humanoid and humanoid.Health > 0 and playerRoot and npcRoot) then
		return false -- pas de personnage, un personnage mort, ou le PNJ a disparu
	end
	-- un peu de marge, parce que la position du joueur arrive au serveur avec un léger retard
	return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end

-- Ce que fait le serveur quand un choix a une action. Chacune renvoie true si elle l'a fait.
local ACTIONS: { [string]: (player: Player, choice: Choice) -> boolean } = {
	Heal = function(player)
		local now = os.clock()
		if now - (lastHeal[player] or -math.huge) < HEAL_COOLDOWN_SECONDS then
			return false -- soigné trop récemment
		end
		local character = player.Character
		local humanoid = character and character:FindFirstChildOfClass("Humanoid")
		if not (humanoid and humanoid.Health > 0) then
			return false
		end
		lastHeal[player] = now
		humanoid.Health = humanoid.MaxHealth
		return true
	end,
	GiveItem = function(player, choice)
		local itemName = choice.item
		local template = itemFolder and itemName and itemFolder:FindFirstChild(itemName)
		if not (itemName and template and template:IsA("Tool")) then
			warn(`DialogueService: no Tool named {itemName} in ServerStorage.DialogueItems`)
			return false
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		local character = player.Character
		if not backpack or backpack:FindFirstChild(itemName) or (character and character:FindFirstChild(itemName)) then
			return false -- pas encore de backpack, ou il en a déjà un
		end
		local item = template:Clone() :: Tool
		item.CanBeDropped = false -- pour que personne ne puisse le lâcher et en redemander un
		item.Parent = backpack
		return true
	end,
}

local function showLine(player: Player, conversation: Conversation)
	local line = DialogueData[conversation.npcName][conversation.lineId]
	local choiceTexts = {}
	for _, choice in line.choices do
		table.insert(choiceTexts, choice.text)
	end
	dialogueEvent:FireClient(player, "show", conversation.npc, line.text, choiceTexts)
end

local function endConversation(player: Player)
	if conversations[player] then
		conversations[player] = nil
		dialogueEvent:FireClient(player, "close")
	end
end

local function startConversation(player: Player, npc: Model)
	local npcName = npc.Name
	local lines = DialogueData[npcName]
	if conversations[player] or not (lines and lines.start) or not isClose(player, npc) then
		return -- déjà en train de parler, pas de ligne "start" pour ce PNJ, mort ou trop loin
	end
	local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
	conversations[player] = conversation
	showLine(player, conversation)
end

-- Le joueur a cliqué sur le choix numéro choiceIndex (0 veut dire qu'il a fermé la boîte)
dialogueEvent.OnServerEvent:Connect(function(player: Player, choiceIndex: unknown)
	local conversation = conversations[player]
	if not conversation then
		return
	end
	if typeof(choiceIndex) ~= "number" or choiceIndex ~= math.floor(choiceIndex) then
		return
	end
	if choiceIndex == 0 or not isClose(player, conversation.npc) then
		endConversation(player)
		return
	end
	local now = os.clock()
	if now - conversation.lastChoice < MIN_SECONDS_BETWEEN_CHOICES then
		-- Trop rapide. Renvoie la même ligne, parce que la boîte a déjà verrouillé ses
		-- boutons après le clic et attendrait sinon une réponse pour toujours.
		showLine(player, conversation)
		return
	end
	conversation.lastChoice = now

	local line = DialogueData[conversation.npcName][conversation.lineId]
	local choice = line.choices[choiceIndex]
	if not choice then
		return -- ce choix n'existe pas sur la ligne que ce joueur lit
	end
	local nextLine = choice.next
	if choice.action then
		local action = ACTIONS[choice.action]
		local done = false
		if action then
			done = action(player, choice)
		else
			warn(`DialogueService: no action named {choice.action}`)
		end
		if not done and choice.failNext then
			nextLine = choice.failNext -- par exemple "I healed you a moment ago"
		end
	end
	if nextLine and not DialogueData[conversation.npcName][nextLine] then
		warn(`DialogueService: no line named {nextLine} for {conversation.npcName} in DialogueData`)
		nextLine = nil
	end
	if nextLine then
		conversation.lineId = nextLine
		showLine(player, conversation)
	else
		endConversation(player)
	end
end)

-- Un prompt Talk sur chaque PNJ
local function setUpNpc(npc: Instance)
	local root = if npc:IsA("Model") then rootOf(npc) else nil
	if not (npc:IsA("Model") and root) then
		return
	end
	if not (DialogueData[npc.Name] and DialogueData[npc.Name].start) then
		warn(`DialogueService: no conversation with a start line for {npc.Name} in DialogueData`)
	end
	local leftover = root:FindFirstChild("TalkPrompt")
	if leftover then
		leftover:Destroy() -- la copie d'un PNJ apporte l'ancien prompt, que rien n'écoute
	end
	local prompt = Instance.new("ProximityPrompt")
	prompt.Name = "TalkPrompt"
	prompt.ActionText = "Talk"
	prompt.ObjectText = npc.Name
	prompt.MaxActivationDistance = TALK_DISTANCE
	prompt.RequiresLineOfSight = false
	prompt.Parent = root
	prompt.Triggered:Connect(function(player: Player)
		startConversation(player, npc)
	end)
end

for _, npc in npcFolder:GetChildren() do
	setUpNpc(npc)
end
npcFolder.ChildAdded:Connect(setUpNpc)

-- Ferme la boîte de ceux qui s'éloignent ou meurent en pleine conversation
task.spawn(function()
	while true do
		task.wait(0.5)
		for player, conversation in conversations do
			if not isClose(player, conversation.npc) then
				endConversation(player)
			end
		end
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	conversations[player] = nil
	lastHeal[player] = nil
end)

DialogueService crée lui-même le RemoteEvent DialogueEvent au démarrage du jeu, donc il n'y a rien à insérer à la main dans ReplicatedStorage. Si tu as déjà créé un RemoteEvent avec ce nom, supprime-le : le LocalScript pourrait trouver le tien, que rien n'écoute sur le serveur.

Les réglages en haut de DialogueService
RéglageValeur iciCe qu'il change
TALK_DISTANCE12La distance, en studs, à laquelle un joueur doit se trouver pour que le prompt Talk apparaisse. Le serveur le laisse s'éloigner de 4 studs de plus avant de fermer la boîte, parce que sa position arrive au serveur avec un léger retard.
MIN_SECONDS_BETWEEN_CHOICES0.3Le temps minimum entre deux clics que le serveur accepte. Un clic plus rapide reçoit la même ligne de nouveau au lieu d'une réponse.
HEAL_COOLDOWN_SECONDS30Le temps que chaque joueur attend entre deux soins de l'action Heal.

Le serveur garde une entrée par joueur dans conversations : à quel PNJ il parle, quelle ligne il lit et quand son dernier clic a été accepté. Quand le prompt Talk se déclenche, startConversation ne crée cette entrée que si le joueur ne parle pas déjà, que le PNJ a une ligne start et que le joueur est en vie et à portée. Ensuite, chaque clic passe par ces vérifications :

Ce que DialogueService vérifie à chaque clic
VérificationCodeSi elle échoue
Le joueur est dans une conversationconversations[player]Le clic est ignoré.
Le choix est un nombre entiertypeof et math.floorIgnoré. Les chaînes, les tables, les fractions et NaN s'arrêtent tous ici.
0 veut dire que le joueur a appuyé sur XchoiceIndex == 0La conversation se termine.
En vie et toujours à moins de 16 studs (12 plus 4)isCloseLa conversation se termine et la boîte se ferme.
Au moins 0,3 seconde depuis le dernier clic acceptéconversation.lastChoiceLa même ligne est renvoyée, donc la boîte reçoit de nouveaux boutons au lieu d'attendre pour toujours.
Le choix existe sur la ligne que ce joueur litline.choices[choiceIndex]Ignoré.
L'action a marchéchaque action renvoie true ou falseLa ligne failNext est affichée à la place de next.

Le prompt va sur la HumanoidRootPart du PNJ, parce qu'un ProximityPrompt marche quand il est dans une part (ou un attachment, ou un modèle avec une PrimaryPart) de Workspace. Son RequiresLineOfSight est activé par défaut, ce qui cache le prompt dès que quelque chose bloque la vue entre la caméra et cette part. Roblox exclut de ce test la part du prompt elle-même, mais pas le reste du corps, et la HumanoidRootPart se trouve à l'intérieur du torse, donc le script désactive la ligne de vue. Le prompt s'appelle TalkPrompt, et le script supprime tout TalkPrompt déjà présent sur la part avant d'ajouter le sien : la copie d'un PNJ faite pendant que le jeu tourne arrive avec le prompt de l'original, et rien n'écoute un prompt copié. Si DialogueData n'a pas de conversation avec une ligne start pour le nom du PNJ, Output affiche un avertissement qui nomme le PNJ.

Une boucle vérifie chaque conversation ouverte deux fois par seconde et la ferme quand le joueur est à plus de 16 studs ou que son personnage est mort, donc un joueur qui meurt en pleine conversation ne réapparaît pas avec la boîte encore ouverte. PlayerRemoving vide les deux tables quand quelqu'un part.

Étape 4 : ajouter la boîte de dialogue

Ouvre StarterPlayer, survole StarterPlayerScripts, insère un LocalScript nommé DialogueClient et colle ceci dedans. Il construit la boîte de dialogue en code, donc il n'y a aucune interface à dessiner à la main.

LocalScript dans StarterPlayer > StarterPlayerScripts nommé DialogueClient
-- LocalScript dans StarterPlayer > StarterPlayerScripts nommé DialogueClient.
-- Dessine la conversation qu'envoie le serveur : le nom du PNJ, sa réplique tapée lettre
-- par lettre, une bulle au-dessus de sa tête et un bouton par choix. Cliquer sur un
-- choix n'envoie que son numéro ; le serveur décide de la suite.

local GuiService = game:GetService("GuiService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TextChatService = game:GetService("TextChatService")
local UserInputService = game:GetService("UserInputService")

local dialogueEvent = ReplicatedStorage:WaitForChild("DialogueEvent") :: RemoteEvent
local player = Players.LocalPlayer

local LETTERS_PER_SECOND = 45
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

-- La boîte de dialogue, construite en code
local gui = Instance.new("ScreenGui")
gui.Name = "Dialogue"
gui.ResetOnSpawn = false
gui.Enabled = false

local box = Instance.new("Frame")
box.AnchorPoint = Vector2.new(0.5, 1)
box.Position = UDim2.new(0.5, 0, 1, -84) -- 84 pixels plus haut, pour que la barre d'objets de Roblox ne couvre jamais les choix
box.Size = UDim2.fromScale(0.6, 0.34)
box.BackgroundColor3 = Color3.fromRGB(24, 24, 32)
box.BackgroundTransparency = 0.1
box.Parent = gui
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = box
local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(720, 300)
sizeLimit.Parent = box

local nameLabel = Instance.new("TextLabel")
nameLabel.Position = UDim2.fromScale(0.04, 0.04)
nameLabel.Size = UDim2.fromScale(0.8, 0.14)
nameLabel.BackgroundTransparency = 1
nameLabel.TextXAlignment = Enum.TextXAlignment.Left
nameLabel.TextColor3 = Color3.fromRGB(190, 160, 255)
nameLabel.TextScaled = true
nameLabel.FontFace = BOLD
nameLabel.Parent = box

local lineLabel = nameLabel:Clone()
lineLabel.Position = UDim2.fromScale(0.04, 0.2)
lineLabel.Size = UDim2.fromScale(0.92, 0.3)
lineLabel.TextColor3 = Color3.new(1, 1, 1)
lineLabel.TextScaled = true -- une longue réplique rétrécit pour tenir sur un petit écran de téléphone
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- et ne dépasse jamais 20 pixels sur un grand
lineTextLimit.Parent = lineLabel

local closeButton = Instance.new("TextButton")
closeButton.AnchorPoint = Vector2.new(1, 0)
closeButton.Position = UDim2.new(1, -8, 0, 8)
closeButton.Size = UDim2.fromOffset(32, 32)
closeButton.BackgroundTransparency = 1
closeButton.Text = "X"
closeButton.TextColor3 = Color3.new(1, 1, 1)
closeButton.TextSize = 20
closeButton.FontFace = BOLD
closeButton.Parent = box

local choiceList = Instance.new("Frame")
choiceList.Position = UDim2.fromScale(0.04, 0.52)
choiceList.Size = UDim2.fromScale(0.92, 0.44)
choiceList.BackgroundTransparency = 1
choiceList.Parent = box
local layout = Instance.new("UIGridLayout")
layout.CellSize = UDim2.new(0.5, -6, 0.5, -6)
layout.CellPadding = UDim2.fromOffset(6, 6)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = choiceList

gui.Parent = player:WaitForChild("PlayerGui")

local talkingTo: Model? = nil
local lineNumber = 0 -- augmente à chaque nouvelle ligne, pour qu'une ancienne boucle de frappe s'arrête

local function setPromptVisible(npc: Model?, visible: boolean)
	local root = npc and npc:FindFirstChild("HumanoidRootPart")
	local prompt = root and root:FindFirstChild("TalkPrompt")
	if prompt and prompt:IsA("ProximityPrompt") then
		prompt.Enabled = visible -- changé sur cet appareil seulement
	end
end

local function clearChoices()
	for _, child in choiceList:GetChildren() do
		if child:IsA("TextButton") then
			child:Destroy()
		end
	end
end

local function close()
	lineNumber += 1
	clearChoices()
	gui.Enabled = false
	setPromptVisible(talkingTo, true)
	talkingTo = nil
	GuiService.SelectedObject = nil
end

local function show(npc: Model, text: string, choices: { string })
	lineNumber += 1
	local thisLine = lineNumber
	if talkingTo ~= npc then
		setPromptVisible(talkingTo, true)
		talkingTo = npc
		setPromptVisible(npc, false)
	end
	gui.Enabled = true
	nameLabel.Text = npc.Name
	clearChoices()

	-- Une bulle au-dessus du PNJ (DisplayBubble ne marche que dans un LocalScript)
	local head = npc:FindFirstChild("Head")
	if head then
		TextChatService:DisplayBubble(head, text)
	end

	-- Tape la réplique, lettre par lettre. Le compte vient du temps écoulé,
	-- donc la vitesse est la même à n'importe quelle fréquence d'images.
	lineLabel.Text = text
	lineLabel.MaxVisibleGraphemes = 0
	local letters = 0
	for _ in utf8.graphemes(text) do
		letters += 1
	end
	local startTime = os.clock()
	local shown = 0
	while shown < letters do
		task.wait()
		if lineNumber ~= thisLine then
			return -- une ligne plus récente ou une fermeture a remplacé celle-ci
		end
		shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
		lineLabel.MaxVisibleGraphemes = shown
	end
	lineLabel.MaxVisibleGraphemes = -1

	-- Un bouton par choix ; le serveur ne reçoit jamais que le numéro du bouton
	for index, choiceText in choices do
		local button = Instance.new("TextButton")
		button.LayoutOrder = index
		button.BackgroundColor3 = Color3.fromRGB(124, 77, 255)
		button.TextColor3 = Color3.new(1, 1, 1)
		button.TextScaled = true
		button.FontFace = BOLD
		button.Text = choiceText
		local buttonCorner = Instance.new("UICorner")
		buttonCorner.CornerRadius = UDim.new(0, 8)
		buttonCorner.Parent = button
		button.Parent = choiceList
		button.Activated:Connect(function()
			if lineNumber == thisLine then
				lineNumber += 1 -- un clic par ligne
				dialogueEvent:FireServer(index)
			end
		end)
		if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
			GuiService.SelectedObject = button -- pour qu'une manette puisse prendre un choix
		end
	end
end

closeButton.Activated:Connect(function()
	dialogueEvent:FireServer(0)
	close()
end)

dialogueEvent.OnClientEvent:Connect(function(kind: string, npc: Model?, text: string?, choices: { string }?)
	if kind == "show" and npc and text and choices then
		show(npc, text, choices)
	elseif kind == "close" then
		close()
	end
end)

Les couleurs, les tailles et LETTERS_PER_SECOND sont à toi de changer. Garde les deux derniers gestionnaires tels quels : ils sont le seul moyen par lequel la boîte parle au serveur.

Ce que fait chaque partie de DialogueClient :

  • La boîte. Un ScreenGui avec une Frame ancrée en bas au centre de l'écran, 60 % de sa largeur et 34 % de sa hauteur, plafonnée à 720 par 300 pixels par un UISizeConstraint pour qu'elle ne s'étire pas sur un écran large. La réplique du PNJ utilise TextScaled, qui réduit le texte pour qu'il tienne dans son label sur un petit écran de téléphone, et un UITextSizeConstraint l'empêche de dépasser 20 pixels sur un grand. Un UIGridLayout dispose les choix deux par deux. ResetOnSpawn vaut false parce que ce LocalScript ne tourne qu'une fois par session : une boîte supprimée à la réapparition ne reviendrait jamais.
  • La machine à écrire. La réplique entière va d'un coup dans le TextLabel, et MaxVisibleGraphemes décide combien de caractères s'affichent, la même propriété que l'exemple de machine à écrire de Roblox utilise avec utf8.graphemes. Roblox met le texte en page comme si tous les caractères étaient visibles, donc les mots ne sautent pas à la ligne et ne changent pas de taille en apparaissant. Le script calcule combien en afficher à partir du temps écoulé, 45 par seconde, donc la vitesse est la même à n'importe quelle fréquence d'images, puis règle la propriété sur -1, ce qui affiche tout.
  • Les boutons. Ils apparaissent une fois la réplique entièrement tapée. Chacun n'envoie que son numéro, une seule fois : la vérification de lineNumber empêche un double clic d'envoyer deux fois, et la boîte attend ensuite la ligne suivante du serveur.
  • La bulle. TextChatService:DisplayBubble(head, text) met la réplique dans une bulle de chat au-dessus de la Head du PNJ. Roblox ne l'autorise que dans les scripts client, et le chat à bulles est activé par défaut. Comme c'est l'appareil de ce joueur qui la dessine, la bulle n'est visible que pour lui.
  • Le prompt. Pendant qu'un joueur parle, sa copie du prompt Talk (trouvée par son nom, TalkPrompt) est désactivée, pour qu'elle ne se superpose pas à la conversation. Les autres joueurs voient toujours la leur.
  • Tous les appareils. Activated se déclenche pour un clic de souris, un appui sur un téléphone et le bouton A d'une manette. Une manette ne peut appuyer que sur un bouton sélectionné, donc quand PreferredInput indique que le joueur utilise une manette, le script sélectionne le premier choix avec GuiService.SelectedObject.
  • Le bouton X. Il envoie 0, que le serveur comprend comme "termine la conversation", et ferme la boîte tout de suite.

Ajouter tes propres actions

Une action est une fonction de la table ACTIONS près du haut de DialogueService. Elle reçoit le joueur et le choix, et renvoie true quand elle a fait son travail. Pour en ajouter une, par exemple une quête que donne un PNJ :

  1. Ajoute à ACTIONS une entrée nommée StartQuest. Vérifie d'abord, change ensuite : si player:GetAttribute("Quest") est déjà réglé, renvoie false ; sinon appelle player:SetAttribute("Quest", "Cave") et renvoie true.
  2. Dans DialogueData, donne à un choix action = "StartQuest", une ligne next pour quand ça marche et une ligne failNext pour quand ça ne marche pas, par exemple "You are already on a quest."
  3. Appuie sur Play et prends le choix deux fois. Si le nom dans DialogueData ne correspond pas à la clé dans ACTIONS (les majuscules comptent), Output affiche DialogueService: no action named StartQuest et la conversation passe à la ligne failNext.

Règles pour écrire des actions :

  • Fais la vérification et le changement à l'intérieur de l'action, sur le serveur. La seule chose qu'envoie l'appareil du joueur est un numéro de choix.
  • Lis ce dont l'action a besoin dans le choix (comme item) ou dans l'état du serveur lui-même, jamais dans le remote.
  • Limite tout ce qui a de la valeur à l'intérieur de l'action elle-même, comme Heal garde son propre délai de 30 secondes dans lastHeal. La limite de 0,3 seconde entre les clics ne fait que ralentir les clics ; elle n'empêche pas un joueur de repasser par le même choix encore et encore.
  • Pour ouvrir une autre fenêtre, comme une boutique, une action peut envoyer un RemoteEvent à ce joueur et renvoyer true. Ce qui se passe dans cette fenêtre a quand même besoin de ses propres vérifications serveur, comme dans Un PNJ marchand.

Les erreurs des autres tutoriels de dialogue de PNJ

Si tu compares ce guide avec une vidéo ou un message de forum, voici les différences qui comptent, avec la raison pour laquelle chaque méthode pose problème.

Méthodes courantes des tutoriels de dialogue de PNJ, et ce que ce guide fait à la place
Le tutorielLe problèmeCe guide
Utilise l'objet Dialog, avec un Script serveur qui écoute DialogChoiceSelected pour donner une récompenseLa référence de Roblox dit que cet événement est réservé au client et ne se déclenchera pas sur le serveur, donc la récompense n'arrive jamais.Le choix arrive au serveur sous forme de numéro, et le serveur gère la récompense.
Donne la récompense depuis un LocalScriptUn changement fait par un LocalScript reste sur ce seul appareil (vois ce qui est répliqué (en anglais)), et un tricheur peut lancer le même code quand il veut.Chaque action vit dans DialogueService.
Fait parler le PNJ avec game:GetService("Chat"):Chat(head, text)Le service Chat est obsolète, remplacé par TextChatService.TextChatService:DisplayBubble dans le LocalScript.
Envoie le nom de la récompense ou l'identifiant de la ligne suivante depuis le clientUn tricheur peut envoyer n'importe quel nom d'objet, ou sauter directement à la ligne qui donne la récompense.Le client n'envoie que le numéro du choix. Le serveur le cherche sur la ligne qu'il sait que le joueur est en train de lire.
Ne vérifie rien une fois le prompt déclenchéLe guide de sécurité de Roblox cite les ProximityPrompts à côté des remotes comme quelque chose que les clients peuvent détourner, et demande de vérifier que le joueur est assez près avant d'agir.La distance est vérifiée au début de la conversation, à chaque clic et deux fois par seconde tant qu'elle est ouverte.
Tape le texte avec wait() dans une boucleLe wait global est obsolète, remplacé par task.wait.Calcule les lettres à afficher à partir de os.clock(), en attendant avec task.wait().

Ce qu'un joueur peut falsifier et ce qu'il ne peut pas

Pars du principe qu'un tricheur contrôle tout sur son propre appareil. Il peut lire tes LocalScripts et tout ce qui est dans ReplicatedStorage, déclencher DialogueEvent avec n'importe quels arguments aussi souvent qu'il veut, et déclencher le prompt Talk par du code, ce contre quoi le guide de sécurité de Roblox met en garde. DialogueService répond par des vérifications serveur du genre de celles expliquées dans la validation des arguments d'un RemoteEvent. Voici ce que ça lui rapporte.

Ce qu'un tricheur peut tenter, et ce que DialogueService fait contre ça
Un tricheur essaie deRésultatPourquoi
Déclencher le prompt Talk depuis l'autre bout de la carteRien ne se passestartConversation vérifie qu'il est à moins de 16 studs (12 plus 4).
Envoyer le choix 99, une chaîne, une fraction ou NaNIgnoréCe n'est pas un nombre entier, ou ce choix n'existe pas sur la ligne qu'il lit.
Envoyer un nom de récompense ou un identifiant de ligneJamais luLe serveur ne lit que le numéro du choix. Les récompenses viennent des champs item et action de la copie de la ligne que détient le serveur.
Cliquer aussi vite que le réseau le permetUn clic toutes les 0,3 seconde par conversationLes clics plus rapides reçoivent en retour leur propre ligne. Terminer et relancer la conversation évite cette attente, et c'est pour ça que Heal et GiveItem gardent leurs propres limites.
Demander la torche sans parlerImpossibleLes objets ne viennent que d'un choix sur la ligne où le serveur sait qu'il se trouve.
Ramasser un tas de torchesUne à la foisLe serveur cherche d'abord une Torch dans son Backpack et son personnage, et la torche qu'il donne ne peut pas être lâchée, donc on ne peut pas en accumuler en la lâchant puis en redemandant.
Spammer la ligne du soinUn soin toutes les 30 secondesLe délai est gardé par joueur sur le serveur, et le PNJ le dit avec la ligne healTooSoon.
S'éloigner et garder la boîte ouverteFermée en une demi-secondeLe serveur vérifie chaque conversation ouverte deux fois par seconde.
Lire toute la conversation, y compris les lignes qu'il n'a pas atteintesPossibleDialogueData est dans ReplicatedStorage, qui est copié sur chaque appareil. Déplace-le dans ServerStorage si ça compte (vois l'étape 2).

Une limite mérite une réponse franche : un tricheur qui s'approche du Guide et prend les choix obtient exactement ce qu'obtient un joueur honnête. Le serveur contrôle à quelle fréquence et depuis où, pas qui. Tout ce qui est rare, comme une récompense que chaque joueur ne peut réclamer qu'une fois, a besoin d'une vérification qui appartient au serveur, comme un attribut réglé au moment où elle est réclamée ou un indicateur sauvegardé avec un DataStore.

Étape 5 : tester

  1. Appuie sur Play (F5) et va jusqu'au Guide. À moins de 12 studs, un prompt Talk avec le nom Guide apparaît. Appuie sur E.
  2. La boîte affiche "Guide", tape la réplique de bienvenue puis affiche quatre boutons. La même réplique apparaît dans une bulle au-dessus de la tête du PNJ.
  3. Choisis "Any tips?", puis "Anything else?" : tu es revenu à la première ligne. Choisis "Bye!" : la boîte se ferme et le prompt Talk revient.
  4. Blesse-toi d'abord : clique sur le bouton Client/Server pour passer en Server, sélectionne le Humanoid de ton personnage dans Workspace, règle Health sur 50 dans la fenêtre Properties et repasse en Client. Les personnages des joueurs regagnent 1 % de leur MaxHealth chaque seconde, donc parle au Guide tout de suite et choisis "I'm hurt. Can you help?" : ta vie remonte au maximum. Reparle-lui dans les 30 secondes et refais ce choix : pas de soin, et le Guide dit qu'il t'a soigné il y a un instant.
  5. Choisis "Got anything for the cave?" : la Torch apparaît dans ta barre d'objets. Équipe-la et appuie sur Retour arrière : elle reste dans ta main. Redemande : pas de deuxième torche, et le Guide dit que tu l'as déjà.
  6. Commence à parler, puis éloigne-toi. La boîte se ferme à peu près dès que tu es à 16 studs du Guide.
  7. Choisis Server & Clients dans le menu déroulant du mode de test, règle 2 clients et appuie sur Play. Les deux joueurs peuvent parler au Guide en même temps, chacun sur sa propre ligne.
  8. Vérifie avec une manette grâce au Controller Emulator (Controller, dans l'onglet Emulation) pendant un test. Utilise la manette émulée pour t'approcher et appuyer sur le bouton du prompt (ButtonX par défaut) : quand les choix apparaissent, le premier est sélectionné, et A le valide.
  9. Vérifie sur un écran de téléphone avec le Device Simulator de Studio (une bêta au moment de la rédaction : active New Device Simulator dans File, Beta Features, et redémarre Studio). Choisis un téléphone, clique sur Rotate jusqu'à ce qu'il soit en paysage, appuie sur Play, va jusqu'au Guide et touche le prompt Talk. Choisis "Any tips?" : la réplique entière s'affiche au-dessus des boutons de choix, en texte plus petit s'il le faut, sans empiéter sur eux.

Garde la fenêtre Output ouverte (menu Window, puis Output) pendant tout ce temps. Ces scripts n'affichent rien quand ils marchent, donc toute erreur rouge ou tout avertissement qui commence par DialogueService: est un vrai problème. Vois les problèmes courants.

Aller plus loin

Plus de PNJ et des conversations plus longues

Ajoute un autre rig dans le dossier NPCs avec son propre nom, et dans DialogueData une table du même nom qui a une ligne start. DialogueService ajoute le prompt Talk à chaque modèle du dossier qui a une HumanoidRootPart, y compris ceux ajoutés pendant que le jeu tourne ; la copie d'un PNJ reçoit un prompt neuf à la place de celui avec lequel elle a été copiée. Deux PNJ du même nom utilisent la même table. Les lignes peuvent s'enchaîner dans n'importe quel ordre, et un choix peut ramener à une ligne précédente, comme le fait "Anything else?". Limite chaque ligne à quatre choix, parce que la boîte les dispose deux par deux.

Des répliques qui dépendent de la progression

Pour accueillir différemment les joueurs qui reviennent, choisis la première ligne à partir de quelque chose qui appartient au serveur. Dans startConversation, choisis-la avec local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", vérifie que la ligne existe comme le script vérifie lines.start, et utilise firstLine à la place de "start" quand la conversation est créée. Règle l'attribut dans une action, et ajoute une ligne welcomeBack à la table du Guide. Les attributs durent une session ; pour te souvenir du joueur d'une visite à l'autre, sauvegarde l'indicateur avec un DataStore comme dans le tutoriel DataStore.

Un PNJ marchand

Construis la boutique à partir du guide de l'interface de boutique, puis ajoute une action OpenShop qui envoie un RemoteEvent à ce joueur et renvoie true, et fais ouvrir sa fenêtre au LocalScript de la boutique quand cet événement arrive. Les achats continuent de passer par les vérifications serveur de la boutique. Si l'achat ne doit marcher que près du PNJ, vérifie aussi la distance dans le gestionnaire d'achat, parce qu'un client peut appeler le remote de la boutique depuis n'importe où.

Des PNJ qui marchent

Pour que le Guide se promène ou suive les joueurs, utilise le guide du pathfinding de PNJ et décoche Anchored sur la HumanoidRootPart pour qu'il puisse bouger. Le prompt Talk se trouve sur cette part, donc il se déplace avec le PNJ, et les vérifications de distance utilisent la même part. Mets la marche en pause pendant qu'une conversation est ouverte, sinon la boîte se ferme dès que le PNJ s'éloigne à plus de 16 studs du joueur.

Clés, quêtes et autres récompenses

GiveItem distribue n'importe quel Tool de DialogueItems, donc un PNJ peut donner la clé que vérifie une porte verrouillée, comme dans le guide des portes. Pour les objets qui font quelque chose quand on les utilise, comme de la nourriture qui soigne, vois le guide de l'inventaire.

Les sons et la caméra

Pour une voix ou un petit son à chaque réplique, mets un Sound dans la Head du PNJ et joue-le depuis show dans DialogueClient. Pour tourner la caméra vers le PNJ pendant qu'il parle, le guide des cinématiques montre comment un LocalScript prend le contrôle de la caméra et le rend.

Problèmes courants

Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes de dialogue y affichent un avertissement ou viennent d'un nom qui ne correspond pas.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("DialogueEvent")'

DialogueClient attend le remote que crée DialogueService, donc DialogueService n'est pas arrivé jusque-là. Vérifie que c'est un Script, pas un LocalScript, directement dans ServerScriptService, et qu'il n'est pas désactivé. DialogueService attend d'abord DialogueData dans ReplicatedStorage et le dossier NPCs dans Workspace, donc un élément manquant ou mal écrit le bloque aussi ; Output affiche alors un avertissement infinite yield de DialogueService qui le nomme.

Aucun prompt Talk n'apparaît sur mon PNJ

DialogueService n'ajoute des prompts qu'aux modèles placés directement dans Workspace, NPCs qui ont une part nommée HumanoidRootPart. Vérifie les deux, et approche-toi à moins de 12 studs. Il peut manquer cette part à un rig de la Toolbox, ou ce peut être un autre type d'objet emballé dans un dossier.

Le prompt apparaît, mais appuyer sur E ne fait rien

Le serveur n'a trouvé aucune conversation pour ce PNJ, et au démarrage du jeu Output affiche DialogueService: no conversation with a start line for Guide in DialogueData, avec le nom de ton PNJ. La table dans DialogueData doit porter exactement le nom du modèle, majuscules comprises, et avoir une ligne appelée start.

Un choix ferme la boîte au lieu de passer à la ligne suivante

Output affiche DialogueService: no line named tip for Guide in DialogueData, avec tes noms : le next (ou le failNext) du choix nomme une ligne qui n'est pas dans la table de ce PNJ. Les noms de lignes tiennent compte des majuscules, donc compare l'orthographe avec la table, ici tips.

La boîte marche, mais il n'y a pas de bulle

La bulle a besoin d'une part nommée Head directement dans le modèle du PNJ, et du chat à bulles activé : dans l'Explorer, sélectionne BubbleChatConfiguration sous TextChatService et vérifie que Enabled est coché. Il l'est par défaut.

Output affiche DialogueService: no Tool named Torch in ServerStorage.DialogueItems

Le serveur n'a pas trouvé l'objet. Vérifie que le dossier dans ServerStorage s'appelle DialogueItems et qu'il contient un Tool (pas un Model ni une Part) nommé exactement comme le item du choix. Tant que tu ne l'as pas corrigé, le Guide répond avec la ligne hasTorch, parce que l'action a échoué.

Output affiche DialogueService: no action named ...

L'action d'un choix ne correspond à aucune clé de la table ACTIONS. Les noms tiennent compte des majuscules : heal n'est pas Heal.

Le faire avec RoCode

Si tu préfères décrire le PNJ plutôt que de 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, qui n'est pas fait par Roblox : tu écris dans un chat web, et son plugin pour Studio crée et modifie les scripts dans ton Explorer.

Tu écris

Fais parler le modèle Guide dans Workspace.NPCs : un prompt Talk, une boîte de dialogue avec des répliques tapées lettre par lettre et des boutons de choix, une bulle, un choix de soin avec un délai de 30 secondes et un choix qui donne une seule fois le Tool Torch de ServerStorage. Garde la conversation dans un ModuleScript et donne chaque récompense sur le serveur.

RoCode fait
  • Peut d'abord inspecter le modèle, avec Get Properties pour lire des valeurs clés comme Anchored sur ses parts et WalkSpeed sur son Humanoid. Tape / dans le chat pour joindre le chemin exact du modèle
  • Écrit le ModuleScript DialogueData, le Script DialogueService et le LocalScript DialogueClient avec Create Script
  • A pour consigne de vérifier la compilation de chaque script qu'il écrit avec Check Script, qui le compile dans Studio sans le lancer
  • 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 aucune capture d'écran pendant que le jeu tourne, donc approche-toi du PNJ et parle-lui toi-même. Si quelque chose se comporte mal, dis à RoCode ce que tu as vu : Check Output peut lire les lignes Server et Client de ton dernier test. Un PNJ qui parle est un système parmi d'autres ; créer un jeu Roblox avec l'IA, un système par prompt montre comment ils s'assemblent. Comment RoCode se connecte à Studio.

Questions fréquentes

Comment faire parler un PNJ sur Roblox Studio ?

Ajoute un ProximityPrompt au PNJ et, quand un joueur le déclenche, affiche la réplique du PNJ dans une boîte de dialogue, une bulle ou les deux. Les trois scripts de ce guide font les deux et ajoutent des choix. Pour une bulle seulement, appelle TextChatService:DisplayBubble(npc.Head, "Hello!") depuis un LocalScript quand le prompt est déclenché, comme dans l'exemple de PNJ de la page de Roblox sur le chat à bulles.

Faut-il utiliser l'objet Dialog ou une interface de dialogue sur mesure ?

L'objet Dialog ne demande aucun code et affiche une bulle cliquable, ce qui suffit pour du texte d'ambiance. Son événement de choix ne se déclenche que sur l'appareil du joueur, donc il ne peut pas donner de récompenses de façon sûre, et par défaut un seul joueur peut lui parler à la fois. Une boîte sur mesure comme celle de ce guide laisse le serveur gérer chaque récompense et donne à chaque joueur sa propre conversation.

Comment donner un objet au joueur depuis un PNJ ?

Garde le Tool dans ServerStorage et fais-le cloner par un Script serveur dans le Backpack du joueur quand il prend ce choix, comme le fait l'action GiveItem. Vérifie qu'il n'en a pas déjà un, et désactive CanBeDropped sur la copie pour qu'elle ne puisse pas être lâchée puis redemandée. Ne laisse jamais l'appareil du joueur dire quel objet donner.

Comment faire une boîte de dialogue avec un effet machine à écrire ?

Mets la réplique entière dans un TextLabel, augmente son MaxVisibleGraphemes à partir de 0 de quelques caractères à la fois, et règle-le sur -1 à la fin pour tout afficher. La page de Roblox sur l'animation d'interface utilise la même propriété avec utf8.graphemes. DialogueClient calcule combien de caractères afficher à partir du temps écoulé, 45 par seconde, donc la vitesse ne dépend pas de la fréquence d'images.

Deux joueurs peuvent-ils parler au même PNJ en même temps ?

Avec les scripts de ce guide, oui : le serveur garde une conversation par joueur, et chaque joueur ne voit que sa propre boîte. L'objet Dialog intégré est différent : avec son BehaviorType par défaut, SinglePlayer, un seul joueur parle à la fois et les autres voient les choix de ce joueur.

Faut-il filtrer le texte des dialogues de PNJ ?

Pas les répliques que tu as écrites toi-même. Roblox te rend responsable du filtrage du texte affiché que tu ne contrôles pas explicitement, comme ce que tapent les joueurs, des mots générés à partir de caractères aléatoires, ou du texte récupéré sur un site externe. Si un PNJ répète quelque chose qu'un joueur a tapé, filtre cette partie.

Sources et lectures

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

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.