Tutorial · Sistemas de jogo

Como fazer diálogo de NPC no Roblox Studio

O diálogo de NPC no Roblox tem três peças: um prompt para começar a conversa, uma caixa que mostra o que o NPC diz com botões para as respostas do jogador, e um script que decide aonde cada resposta leva. Este guia monta as três: você escreve a conversa como uma tabela simples, os jogadores apertam E para conversar, e tudo o que uma resposta dá (uma cura, um item) é entregue pelo servidor, nunca pelo dispositivo do jogador.

Atualizado em 12 de novembro de 202624 min de leituraEscrito por

Resumo

Coloque o model do seu NPC em uma pasta chamada NPCs no Workspace e escreva a conversa dele em um ModuleScript no ReplicatedStorage: cada fala tem o texto do NPC e uma lista de escolhas que levam a outra fala. Um Script no ServerScriptService adiciona um ProximityPrompt ("Talk") a cada NPC, lembra em qual fala cada jogador está e a envia com um RemoteEvent. Um LocalScript mostra o texto e um botão por escolha, e devolve só o número do botão apertado.

  • Dê as recompensas no servidor. O evento DialogChoiceSelected do objeto Dialog nativo dispara só no cliente, então um Script de servidor nunca o escuta, e uma cura ou um item dado em um LocalScript muda só a cópia do jogo daquele jogador.
  • Mostre um balão de fala com TextChatService:DisplayBubble(npc.Head, text) em um LocalScript. O antigo serviço Chat está obsoleto e foi substituído pelo TextChatService.
  • Falas que você mesmo escreve não precisam de filtro. A regra da Roblox é filtrar todo texto exibido sobre o qual você não tem controle explícito, como o que os jogadores digitam.
Nesta página
  1. Como funciona
  2. 1. Adicione um NPC
  3. 2. Conversa
  4. 3. Script do servidor
  5. 4. Caixa de diálogo
  6. Suas ações
  7. Outros tutoriais
  8. Limites contra exploits
  9. 5. Teste
  10. Indo além
  11. Erros comuns
  12. Com o RoCode
  13. Perguntas frequentes
  14. Fontes e leitura extra

Como funciona o diálogo de NPC

IlustraçãoCada fala é digitada na caixa enquanto a fala inteira aparece em um balão, as escolhas aparecem quando a fala termina de ser digitada, e o servidor entrega a Torch quando você escolhe "Got anything for the cave?".

Um NPC que fala e funciona em um jogo publicado é dividido entre o servidor e o dispositivo de cada jogador. O dispositivo desenha a caixa e os botões. O servidor, o único lado em que dá para confiar, sabe qual fala cada jogador está lendo e decide o que cada resposta faz. Uma rodada da conversa acontece assim:

  1. O jogador anda até o NPC e aperta E no prompt Talk dele. O evento Triggered do prompt dispara no servidor com aquele jogador.
  2. O script do servidor confere se o jogador está perto o bastante, anota que ele está na fala chamada start e envia o texto dessa fala e os rótulos das escolhas só para aquele jogador.
  3. O LocalScript digita a fala na caixa de diálogo, mostra um balão de fala sobre o NPC e depois adiciona um botão por escolha.
  4. O jogador clica, toca ou seleciona uma escolha. Só o número dela volta para o servidor.
  5. O servidor procura esse número na fala que ele sabe que o jogador está lendo, roda a ação da escolha se houver uma (uma cura, um item), e envia a próxima fala ou fecha a caixa.
As peças de um NPC que fala
PeçaOnde ficaO que faz
Rig GuideWorkspace, em uma pasta chamada NPCsO NPC. O nome dele escolhe a conversa e aparece no prompt.
ModuleScript DialogueDataReplicatedStorageToda fala que o NPC pode dizer, as escolhas de cada fala e aonde cada escolha leva.
Script DialogueServiceServerScriptServiceAdiciona o prompt Talk, lembra em qual fala cada jogador está, confere todo clique e roda as ações.
RemoteEvent DialogueEventReplicatedStorage (o DialogueService cria)Leva cada fala ao jogador, e o número da escolha clicada de volta ao servidor.
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsDesenha a caixa, digita a fala, mostra o balão de fala e os botões de escolha.
Tool Torch (opcional)ServerStorage, em uma pasta chamada DialogueItemsO item que uma escolha dá. Nada do ServerStorage é enviado aos jogadores.
O Explorer quando o NPC está pronto. Quando o jogo roda, o DialogueService adiciona um RemoteEvent chamado DialogueEvent ao ReplicatedStorage e um ProximityPrompt Talk chamado TalkPrompt à HumanoidRootPart de cada NPC.
Workspace
  NPCs Folder new
    Guide Model new
      Humanoid Humanoid
      HumanoidRootPart Part
      Head, UpperTorso, LowerTorso ... (as partes do corpo)
ReplicatedStorage
  DialogueData ModuleScript new
ServerScriptService
  DialogueService Script new
ServerStorage
  DialogueItems Folder new
    Torch Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    DialogueClient LocalScript new

Passo 1: Adicione um NPC

  1. Na aba Avatar ou Home, clique em Character para abrir o Rig Generator. Escolha R15, um formato de corpo e um estilo. Um rig chamado Rig aparece no Workspace. Um rig R6 funciona com os mesmos scripts.
  2. Renomeie para Guide. O nome importa: o DialogueService procura a conversa pelo nome do model, e o prompt o mostra aos jogadores.
  3. Expanda o rig, selecione a HumanoidRootPart dele e marque Anchored na janela Properties. Uma part ancorada nunca se move por causa da física, então o NPC fica onde você o colocou e os jogadores não conseguem empurrá-lo.
  4. Passe o mouse sobre Workspace no Explorer, clique no botão + e insira uma Folder chamada NPCs. Arraste o Guide para dentro dela, e coloque o rig em um lugar aonde os jogadores consigam chegar.
  5. Opcional, para a escolha do item: passe o mouse sobre ServerStorage e insira uma Folder chamada DialogueItems. Coloque dentro dela uma Tool chamada Torch, com uma Part não ancorada chamada Handle, que é a part que o personagem segura. Um PointLight dentro do Handle a faz brilhar.

Os nomes diferenciam maiúsculas de minúsculas, então digite NPCs, Guide, DialogueItems e Torch exatamente como aparecem. Qualquer model com um Humanoid e uma HumanoidRootPart pode ser um NPC, inclusive um da Toolbox, desde que fique direto dentro da pasta NPCs.

Passo 2: Escreva a conversa

Passe o mouse sobre ReplicatedStorage, insira um ModuleScript chamado DialogueData e cole isto. Ele não tem lógica, só as palavras e como elas se ligam, então este é o arquivo que você mais edita.

ModuleScript em ReplicatedStorage chamado DialogueData
-- ModuleScript no ReplicatedStorage chamado DialogueData.
-- Todas as conversas, indexadas pelo nome do NPC em Workspace.NPCs. Cada fala tem o
-- texto do NPC e as escolhas do jogador. Uma escolha pode levar a outra fala (next),
-- encerrar a conversa (sem next) e pedir ao servidor para fazer algo (action). Se o servidor
-- não conseguir fazer a ação, ele mostra a fala failNext em vez de next.

export type Choice = {
	text: string,
	next: string?, -- a fala a mostrar depois desta escolha; nil encerra a conversa
	action: string?, -- uma ação de servidor da tabela ACTIONS do DialogueService
	item: string?, -- para a ação GiveItem: o nome de uma Tool em ServerStorage.DialogueItems
	failNext: string?, -- a fala a mostrar em vez de next quando a ação não pôde ser feita
}

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

As linhas export type no topo descrevem como são uma fala e uma escolha. Elas não mudam nada quando o jogo roda; descrevem os seus dados para um verificador de tipos poder conferi-los.

Como as peças se ligam:

  • Cada NPC tem uma tabela com o nome do model dele na pasta NPCs, aqui Guide. Toda conversa começa na fala chamada start.
  • text é o que o NPC diz. choices são os botões do jogador, em ordem. A caixa tem espaço para quatro.
  • next dá o nome da fala a mostrar depois daquela escolha. Uma escolha sem next, como "Bye!", encerra a conversa. Um next ou failNext que aponta para uma fala que não existe na tabela também encerra, com um aviso no Output.
  • action dá o nome de algo que o servidor faz, da tabela ACTIONS do DialogueService: aqui, Heal ou GiveItem.
  • item é para o GiveItem: o nome de uma Tool em ServerStorage, DialogueItems.
  • failNext é a fala mostrada em vez de next quando a ação não pôde ser feita, para o NPC nunca anunciar uma cura ou um presente que não aconteceu.
A conversa do Guide, fala por fala
FalaO Guide dizEscolhas, e aonde levam
start"Welcome to the village! What can I do for you?""Any tips?" leva a tips. "I'm hurt. Can you help?" cura, depois healed (ou healTooSoon). "Got anything for the cave?" dá a Torch, depois torch (ou hasTorch). "Bye!" encerra.
tips"Stay off the red bricks, and come back if you get hurt.""Anything else?" volta para start. "Thanks!" encerra.
healed"There you go, good as new.""Thank you!" encerra.
torch"Take this torch. The cave is dark.""Thanks!" encerra.
healTooSoon"I healed you a moment ago. Come back in a little while.""OK" encerra.
hasTorch"You already have my torch. Keep it lit!""Will do!" encerra.

Só o servidor lê este módulo. O LocalScript nunca dá require nele: o servidor envia cada fala quando o jogador chega a ela. Mesmo assim, um módulo no ReplicatedStorage é copiado para o dispositivo de todo jogador, então, se uma conversa tem spoilers (a resposta de um enigma, por exemplo), mova o DialogueData para o ServerStorage. Depois, na linha do require do DialogueService, troque ReplicatedStorage por ServerStorage, para a linha inteira ficar local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.

Passo 3: Adicione o script do servidor

Passe o mouse sobre ServerScriptService, insira um Script chamado DialogueService e cole o código abaixo. Ele é o único lugar em que uma conversa avança e o único lugar em que uma recompensa é dada.

Script em ServerScriptService chamado DialogueService
-- Script no ServerScriptService chamado DialogueService.
-- Adiciona um prompt Talk a todo NPC em Workspace.NPCs e conduz cada conversa.
-- O dispositivo do jogador só mostra o texto e devolve o número da escolha
-- em que ele clicou. O servidor sabe em qual fala cada jogador está, confere a escolha
-- e a distância, e é o único lado que cura ou entrega itens.

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

-- Os mesmos formatos do DialogueData, para o verificador de tipos do Studio conhecê-los aqui também
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: o alcance do prompt, e a distância em que o jogador precisa ficar
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30

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

-- Este script cria o DialogueEvent sozinho, então não adicione um à mão
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 -- sem personagem, personagem morto, ou o NPC sumiu
	end
	-- uma folga a mais, porque a posição do jogador chega ao servidor com um pequeno atraso
	return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end

-- O que o servidor faz quando uma escolha tem uma ação. Cada uma retorna true se fez.
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 -- curado há muito pouco tempo
		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 -- ainda sem backpack, ou ele já tem um
		end
		local item = template:Clone() :: Tool
		item.CanBeDropped = false -- para ninguém largar o item e pedir outro
		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 -- já está conversando, sem fala "start" para este NPC, morto ou longe demais
	end
	local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
	conversations[player] = conversation
	showLine(player, conversation)
end

-- O jogador clicou na escolha número choiceIndex (0 quer dizer que ele fechou a caixa)
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
		-- Rápido demais. Envia a mesma fala de novo, porque a caixa já travou os
		-- botões depois do clique e, sem isso, esperaria uma resposta para sempre.
		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 -- não existe essa escolha na fala que este jogador está lendo
	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 -- por exemplo "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)

-- Um prompt Talk em cada NPC
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() -- uma cópia de um NPC traz o prompt antigo, que ninguém escuta
	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)

-- Fecha a caixa de quem se afasta ou morre no meio da conversa
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)

O próprio DialogueService cria o RemoteEvent DialogueEvent quando o jogo começa, então não há nada para inserir à mão no ReplicatedStorage. Se você já criou um RemoteEvent com esse nome, apague: o LocalScript poderia achar o seu, que ninguém no servidor escuta.

As configurações no topo do DialogueService
ConfiguraçãoValor aquiO que muda
TALK_DISTANCE12A que distância, em studs, um jogador precisa estar para o prompt Talk aparecer. O servidor deixa ele se afastar mais 4 studs antes de fechar a caixa, porque a posição dele chega ao servidor com um pequeno atraso.
MIN_SECONDS_BETWEEN_CHOICES0.3O menor tempo entre dois cliques que o servidor aceita. Um clique mais rápido recebe a mesma fala de novo em vez de uma resposta.
HEAL_COOLDOWN_SECONDS30Quanto tempo cada jogador espera entre curas da ação Heal.

O servidor guarda uma entrada por jogador em conversations: com qual NPC ele está falando, qual fala está lendo e quando o último clique dele foi aceito. Quando o prompt Talk dispara, o startConversation cria essa entrada só se o jogador ainda não está conversando, o NPC tem uma fala start e o jogador está vivo e dentro do alcance. Depois disso, todo clique passa por estas checagens:

O que o DialogueService confere a cada clique
ChecagemCódigoSe falha
O jogador está em uma conversaconversations[player]O clique é ignorado.
A escolha é um número inteirotypeof e math.floorIgnorado. Strings, tabelas, frações e NaN param aqui.
0 quer dizer que o jogador apertou o XchoiceIndex == 0A conversa termina.
Vivo e ainda a até 16 studs (12 mais 4)isCloseA conversa termina e a caixa fecha.
Pelo menos 0,3 segundo desde o último clique aceitoconversation.lastChoiceA mesma fala é enviada de novo, então a caixa ganha botões novos em vez de esperar para sempre.
A escolha existe na fala que este jogador está lendoline.choices[choiceIndex]Ignorado.
A ação deu certocada ação retorna true ou falseA fala failNext é mostrada em vez de next.

O prompt vai na HumanoidRootPart do NPC, porque um ProximityPrompt funciona quando está dentro de uma part (ou de um attachment, ou de um model com PrimaryPart) no Workspace. O RequiresLineOfSight dele vem ligado por padrão, o que esconde o prompt sempre que algo bloqueia a visão da câmera até aquela part. O Roblox deixa a própria part do prompt fora dessa checagem, mas não o resto do corpo, e a HumanoidRootPart fica dentro do torso, então o script desliga a linha de visão. O prompt se chama TalkPrompt, e o script apaga qualquer TalkPrompt que já esteja na part antes de adicionar o dele: uma cópia de um NPC feita com o jogo rodando chega com o prompt do original, e ninguém escuta um prompt copiado. Se o DialogueData não tem uma conversa com uma fala start para o nome do NPC, o Output mostra um aviso com o nome do NPC.

Um loop confere toda conversa aberta duas vezes por segundo e a fecha quando o jogador está a mais de 16 studs ou o personagem dele morreu, então um jogador que morre no meio da conversa não renasce com a caixa ainda aberta. O PlayerRemoving limpa as duas tabelas quando alguém sai.

Passo 4: Adicione a caixa de diálogo

Abra o StarterPlayer, passe o mouse sobre StarterPlayerScripts, insira um LocalScript chamado DialogueClient e cole isto. Ele monta a caixa de diálogo em código, então não há GUI para desenhar à mão.

LocalScript em StarterPlayer > StarterPlayerScripts chamado DialogueClient
-- LocalScript em StarterPlayer > StarterPlayerScripts chamado DialogueClient.
-- Desenha a conversa que o servidor envia: o nome do NPC, a fala digitada letra
-- por letra, um balão de fala sobre a cabeça dele e um botão por escolha. Clicar em uma
-- escolha só envia o número dela; o servidor decide o que acontece depois.

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)

-- A caixa de diálogo, montada em código
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 acima, para a barra de tools do Roblox nunca cobrir as escolhas
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 -- uma fala longa encolhe para caber em uma tela pequena de celular
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- e nunca passa de 20 pixels em uma tela grande
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 -- sobe a cada fala nova, para um loop de digitação antigo parar

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 -- alterado só neste dispositivo
	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()

	-- Um balão de fala sobre o NPC (o DisplayBubble só funciona em um LocalScript)
	local head = npc:FindFirstChild("Head")
	if head then
		TextChatService:DisplayBubble(head, text)
	end

	-- Digita a fala, letra por letra. A contagem vem do tempo que passou,
	-- então a velocidade é a mesma em qualquer taxa de quadros.
	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 -- uma fala mais nova ou um fechamento substituiu esta
		end
		shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
		lineLabel.MaxVisibleGraphemes = shown
	end
	lineLabel.MaxVisibleGraphemes = -1

	-- Um botão por escolha; o servidor só recebe o número do botão
	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 -- um clique por fala
				dialogueEvent:FireServer(index)
			end
		end)
		if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
			GuiService.SelectedObject = button -- para um controle conseguir escolher uma opção
		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)

As cores, os tamanhos e o LETTERS_PER_SECOND são seus para mudar. Deixe os dois últimos handlers como estão: eles são o único jeito de a caixa falar com o servidor.

O que cada parte do DialogueClient faz:

  • A caixa. Um ScreenGui com um Frame ancorado no centro da parte de baixo da tela, com 60% da largura e 34% da altura dela, limitado a 720 por 300 pixels por um UISizeConstraint para não se esticar em um monitor largo. A fala do NPC usa TextScaled, que encolhe o texto para caber no label em uma tela pequena de celular, e um UITextSizeConstraint impede que ele passe de 20 pixels em uma tela grande. Um UIGridLayout distribui as escolhas de duas em duas. O ResetOnSpawn é false porque este LocalScript roda uma vez por sessão: uma caixa apagada no respawn nunca voltaria.
  • A máquina de escrever. A fala inteira entra no TextLabel de uma vez, e o MaxVisibleGraphemes decide quantos caracteres aparecem, a mesma propriedade que o exemplo de máquina de escrever da própria Roblox usa com utf8.graphemes. O Roblox distribui o texto como se todos os caracteres estivessem visíveis, então as palavras não pulam para outra linha nem mudam de tamanho enquanto aparecem. O script calcula quantos mostrar a partir do tempo que passou, 45 por segundo, então a velocidade é a mesma em qualquer taxa de quadros, e depois define a propriedade como -1, que mostra tudo.
  • Os botões. Eles aparecem quando a fala termina de ser digitada. Cada um envia só o próprio número, uma vez: a checagem do lineNumber impede que um clique duplo envie duas vezes, e a caixa então espera a próxima fala do servidor.
  • O balão de fala. TextChatService:DisplayBubble(head, text) põe a fala em um balão de chat sobre a Head do NPC. O Roblox só permite isso em scripts de cliente, e o bubble chat vem ligado por padrão. Como é o dispositivo deste jogador que o desenha, o balão é só dele.
  • O prompt. Enquanto um jogador está conversando, a cópia dele do prompt Talk (achada pelo nome, TalkPrompt) fica desligada, para não ficar por cima da conversa. Os outros jogadores continuam vendo o deles.
  • Todo dispositivo. O Activated dispara com um clique do mouse, um toque no celular e o botão A de um controle. Um controle só consegue apertar um botão que está selecionado, então, quando o PreferredInput diz que o jogador está usando um gamepad, o script seleciona a primeira escolha com GuiService.SelectedObject.
  • O botão X. Ele envia 0, que o servidor entende como "encerre a conversa", e fecha a caixa na hora.

Adicione as suas próprias ações

Uma ação é uma função na tabela ACTIONS, perto do topo do DialogueService. Ela recebe o jogador e a escolha, e retorna true quando fez o trabalho. Para adicionar uma, digamos uma missão que um NPC entrega:

  1. Adicione à ACTIONS uma entrada chamada StartQuest. Confira primeiro, mude depois: se player:GetAttribute("Quest") já está definido, retorne false; senão chame player:SetAttribute("Quest", "Cave") e retorne true.
  2. No DialogueData, dê a uma escolha action = "StartQuest", uma fala next para quando dá certo e uma fala failNext para quando não dá, como "You are already on a quest."
  3. Aperte Play e faça a escolha duas vezes. Se o nome no DialogueData não bate com a chave em ACTIONS (as maiúsculas contam), o Output mostra DialogueService: no action named StartQuest e a conversa vai para a fala failNext.

Regras para escrever ações:

  • Faça a checagem e a mudança dentro da ação, no servidor. A única coisa que o dispositivo do jogador envia é um número de escolha.
  • Leia o que a ação precisa da escolha (como o item) ou do estado do próprio servidor, nunca do remote.
  • Limite tudo o que tem valor dentro da própria ação, do jeito que o Heal guarda o próprio cooldown de 30 segundos em lastHeal. O limite de 0,3 segundo entre cliques só deixa os cliques mais lentos; não impede um jogador de passar pela mesma escolha de novo e de novo.
  • Para abrir outra janela, como uma loja, uma ação pode disparar um RemoteEvent para aquele jogador e retornar true. O que acontecer nessa janela ainda precisa das próprias checagens no servidor, como em Um NPC vendedor.

O que outros tutoriais de diálogo de NPC erram

Se você está comparando este guia com um vídeo ou um post de fórum, estas são as diferenças que importam, com o motivo de cada padrão ser um problema.

Padrões comuns em tutoriais de diálogo de NPC, e o que este guia faz no lugar
O tutorialO problemaEste guia
Usa o objeto Dialog, com um Script de servidor escutando o DialogChoiceSelected para dar uma recompensaA referência da Roblox diz que esse evento é só do cliente e não dispara no servidor, então a recompensa nunca chega.A escolha chega ao servidor como um número, e o servidor roda a recompensa.
Dá a recompensa em um LocalScriptUma mudança feita por um LocalScript fica naquele único dispositivo (veja o que replica (em inglês)), e um trapaceiro pode rodar o mesmo código quando quiser.Toda ação fica no DialogueService.
Faz o NPC falar com game:GetService("Chat"):Chat(head, text)O serviço Chat está obsoleto e foi substituído pelo TextChatService.TextChatService:DisplayBubble no LocalScript.
Envia do cliente o nome da recompensa ou o id da próxima falaUm trapaceiro pode enviar qualquer nome de item, ou pular direto para a fala que dá a recompensa.O cliente envia só o número da escolha. O servidor o procura na fala que ele sabe que o jogador está lendo.
Não confere nada depois que o prompt é disparadoO guia de segurança da Roblox lista os ProximityPrompts ao lado dos remotes como algo que os clientes podem abusar, e pergunta se o jogador está perto o bastante antes de agir.A distância é conferida quando a conversa começa, a cada clique e duas vezes por segundo enquanto ela está aberta.
Digita o texto com wait() em um loopO wait global está obsoleto e foi substituído pelo task.wait.Calcula as letras a mostrar a partir do os.clock(), esperando com task.wait().

O que um jogador consegue e não consegue falsificar

Parta do princípio de que um trapaceiro controla tudo no próprio dispositivo. Ele consegue ler os seus LocalScripts e tudo o que está no ReplicatedStorage, disparar o DialogueEvent com quaisquer argumentos quantas vezes quiser, e acionar o prompt Talk por código, algo sobre o qual o guia de segurança da Roblox avisa. O DialogueService responde com checagens no servidor do tipo explicado em como validar os argumentos de um RemoteEvent. Veja o que isso rende a ele.

O que um trapaceiro pode tentar, e o que o DialogueService faz a respeito
O trapaceiro tentaResultadoPor quê
Acionar o prompt Talk do outro lado do mapaNada aconteceO startConversation confere se ele está a até 16 studs (12 mais 4).
Enviar a escolha 99, uma string, uma fração ou NaNIgnoradoNão é um número inteiro, ou não existe essa escolha na fala que ele está lendo.
Enviar o nome de uma recompensa ou o id de uma falaNunca é lidoO servidor lê só o número da escolha. As recompensas vêm dos campos item e action na cópia da fala que o servidor tem.
Clicar tão rápido quanto a rede permiteUm clique a cada 0,3 segundo por conversaCliques mais rápidos recebem de volta a própria fala. Encerrar e recomeçar a conversa pula essa espera, e é por isso que o Heal e o GiveItem têm os próprios limites.
Pedir a tocha sem conversarImpossívelOs itens vêm só de uma escolha na fala em que o servidor sabe que ele está.
Juntar uma pilha de tochasUma por vezO servidor confere antes se há uma Torch na Backpack e no personagem dele, e a tocha que ele entrega não pode ser largada, então não dá para farmar largando e pedindo de novo.
Dar spam na fala da curaUma cura a cada 30 segundosO cooldown é guardado por jogador no servidor, e o NPC avisa com a fala healTooSoon.
Se afastar e manter a caixa abertaFechada em até meio segundoO servidor confere toda conversa aberta duas vezes por segundo.
Ler a conversa inteira, inclusive as falas a que ainda não chegouPossívelO DialogueData está no ReplicatedStorage, que é copiado para todo dispositivo. Mova para o ServerStorage se isso importa (veja o Passo 2).

Um limite merece uma resposta direta: um trapaceiro que anda até o Guide e faz as escolhas recebe exatamente o que um jogador honesto recebe. O servidor controla a frequência e de onde, não quem. Tudo o que é escasso, como uma recompensa que cada jogador pode pegar uma vez, precisa de uma checagem que pertence ao servidor, como um atributo definido quando ela é pega ou uma marca salva com um data store.

Passo 5: Teste

  1. Aperte Play (F5) e ande até o Guide. A até 12 studs, aparece um prompt Talk com o nome Guide. Aperte E.
  2. A caixa mostra "Guide", digita a fala de boas-vindas e depois mostra quatro botões. A mesma fala aparece em um balão sobre a cabeça do NPC.
  3. Escolha "Any tips?", depois "Anything else?": você volta à primeira fala. Escolha "Bye!": a caixa fecha e o prompt Talk volta.
  4. Machuque-se primeiro: clique no botão Client/Server para mudar para Server, selecione o Humanoid do seu personagem no Workspace, defina Health como 50 na janela Properties e volte para Client. Os personagens dos jogadores recuperam 1% do MaxHealth por segundo, então fale com o Guide na hora e escolha "I'm hurt. Can you help?": a sua vida vai para o máximo. Fale de novo em menos de 30 segundos e escolha de novo: sem cura, e o Guide diz que curou você agora há pouco.
  5. Escolha "Got anything for the cave?": a Torch aparece na sua barra de itens. Equipe e aperte Backspace: ela continua na sua mão. Peça de novo: nada de segunda tocha, e o Guide diz que você já tem uma.
  6. Comece a conversar, depois se afaste. A caixa fecha mais ou menos assim que você fica a 16 studs do Guide.
  7. Escolha Server & Clients no menu de modo de teste, defina 2 clientes e aperte Play. Os dois jogadores conseguem falar com o Guide ao mesmo tempo, cada um na própria fala.
  8. Confira um controle com o Controller Emulator (Controller, na aba Emulation) durante um teste. Use o controle emulado para andar até o NPC e apertar o botão do prompt (ButtonX por padrão): quando as escolhas aparecem, a primeira está selecionada, e A a escolhe.
  9. Confira uma tela de celular com o Device Simulator do Studio (um beta no momento em que este guia foi escrito: ligue New Device Simulator em File, Beta Features, e reinicie o Studio). Escolha um celular, clique em Rotate até ficar em paisagem, aperte Play, ande até o Guide e toque no prompt Talk. Escolha "Any tips?": a fala inteira aparece acima dos botões de escolha, em texto menor se precisar, sem encostar neles.

Mantenha a janela Output aberta (menu Window, depois Output) o tempo todo. Estes scripts não imprimem nada quando funcionam, então qualquer erro vermelho ou aviso que começa com DialogueService: é um problema de verdade. Veja os Erros comuns.

Indo além

Mais NPCs e conversas mais longas

Adicione outro rig à pasta NPCs com o próprio nome, e uma tabela com o mesmo nome no DialogueData que tenha uma fala start. O DialogueService adiciona o prompt Talk a todo model da pasta que tem uma HumanoidRootPart, inclusive os adicionados com o jogo rodando; uma cópia de um NPC ganha um prompt novo no lugar daquele com que foi copiada. Dois NPCs com o mesmo nome usam a mesma tabela. As falas podem se ligar em qualquer ordem, e uma escolha pode voltar a uma fala anterior, como faz "Anything else?". Mantenha cada fala com até quatro escolhas, porque a caixa as distribui de duas em duas.

Falas que dependem do progresso

Para cumprimentar de outro jeito quem está voltando, escolha a primeira fala a partir de algo que pertence ao servidor. No startConversation, escolha com local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", confira se a fala existe do jeito que o script confere lines.start, e use firstLine em vez de "start" quando a conversa é criada. Defina o atributo em uma ação, e adicione uma fala welcomeBack à tabela do Guide. Atributos duram uma sessão; para lembrar do jogador entre visitas, salve a marca com um data store como no tutorial de DataStore.

Um NPC vendedor

Monte a loja com o guia de GUI de loja, depois adicione uma ação OpenShop que dispara um RemoteEvent para aquele jogador e retorna true, e faça o LocalScript da loja abrir a janela quando esse evento chegar. As compras continuam passando pelas checagens de servidor da própria loja. Se comprar só deve funcionar perto do NPC, confira a distância também dentro do handler de compra, porque um cliente pode chamar o remote da loja de qualquer lugar.

NPCs que andam

Para fazer o Guide vagar ou seguir jogadores, use o guia de pathfinding de NPC e desmarque Anchored na HumanoidRootPart para ele poder se mover. O prompt Talk fica nessa part, então se move com o NPC, e as checagens de distância usam a mesma part. Pause a caminhada enquanto uma conversa está aberta, senão a caixa fecha assim que o NPC se afasta mais de 16 studs do jogador.

Chaves, missões e outras recompensas

O GiveItem entrega qualquer Tool de DialogueItems, então um NPC pode dar a chave que uma porta trancada procura, como no guia de porta. Para itens que fazem algo quando usados, como comida que cura, veja o guia de inventário.

Sons e a câmera

Para um clipe de voz ou um bipe a cada fala, coloque um Sound na Head do NPC e toque a partir do show no DialogueClient. Para apontar a câmera para o NPC enquanto ele fala, o guia de cutscene mostra como um LocalScript assume a câmera e a devolve.

Erros comuns e como resolver

Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas de diálogo imprime um aviso ali ou vem de um nome que não bate.

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

O DialogueClient está esperando o remote que o DialogueService cria, então o DialogueService não chegou até lá. Confira que ele é um Script, não um LocalScript, direto dentro do ServerScriptService, e que não está desativado. O DialogueService espera primeiro o DialogueData no ReplicatedStorage e a pasta NPCs no Workspace, então um deles faltando ou com o nome errado também o trava; o Output mostra então um aviso de infinite yield do DialogueService com o nome dele.

Nenhum prompt Talk aparece sobre o meu NPC

O DialogueService só adiciona prompts a models direto dentro de Workspace, NPCs que tenham uma part chamada HumanoidRootPart. Confira as duas coisas, e chegue a até 12 studs. Um rig da Toolbox pode não ter essa part, ou pode ser outro tipo de objeto dentro de uma pasta.

O prompt aparece, mas apertar E não faz nada

O servidor não achou conversa para aquele NPC, e quando o jogo começa o Output mostra DialogueService: no conversation with a start line for Guide in DialogueData, com o nome do seu NPC. A tabela no DialogueData precisa ter exatamente o nome do model, inclusive as maiúsculas, e uma fala chamada start.

Uma escolha fecha a caixa em vez de ir para a próxima fala

O Output mostra DialogueService: no line named tip for Guide in DialogueData, com os seus nomes: o next (ou failNext) da escolha aponta para uma fala que não está na tabela daquele NPC. Os nomes das falas diferenciam maiúsculas de minúsculas, então compare a grafia com a tabela, aqui tips.

A caixa funciona, mas não há balão de fala

O balão precisa de uma part chamada Head direto dentro do model do NPC, e do bubble chat ligado: no Explorer, selecione BubbleChatConfiguration dentro de TextChatService e confira que Enabled está marcado. Ele vem ligado por padrão.

O Output diz DialogueService: no Tool named Torch in ServerStorage.DialogueItems

O servidor não conseguiu achar o item. Confira que a pasta no ServerStorage se chama DialogueItems e que ela tem uma Tool (não um Model nem uma Part) com exatamente o nome que está no item da escolha. Até você corrigir, o Guide responde com a fala hasTorch, porque a ação falhou.

O Output diz DialogueService: no action named ...

O action de uma escolha não bate com nenhuma chave da tabela ACTIONS. Os nomes diferenciam maiúsculas de minúsculas: heal não é Heal.

Crie com o RoCode

Se você prefere descrever o NPC a ligar tudo à mão, o RoCode pode escrever estes scripts no jogo que você tem aberto. Ele é um agente de IA independente para Roblox Studio, não feito pela Roblox: você digita em um chat na web, e o plugin dele para o Studio cria e edita os scripts no seu Explorer.

Você digita

Faça o model Guide em Workspace.NPCs falar: um prompt Talk, uma caixa de diálogo com falas digitadas letra por letra e botões de escolha, um balão de fala, uma escolha de cura com cooldown de 30 segundos e uma escolha que dá a tool Torch do ServerStorage uma vez. Guarde a conversa em um ModuleScript e dê toda recompensa no servidor.

O RoCode faz
  • Pode olhar o model primeiro, usando Get Properties para ler valores importantes como o Anchored das parts e o WalkSpeed do Humanoid. Digite / no chat para anexar o caminho exato do model
  • Escreve o ModuleScript DialogueData, o Script DialogueService e o LocalScript DialogueClient com Create Script
  • É instruído a checar a compilação de cada script que escreve com Check Script, que compila o script no Studio sem rodá-lo
  • Envia as mudanças em lotes, e cada lote é um ponto de desfazer no histórico do Studio

Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.11 ou mais recente ele pode controlar um personagem de teste para conferir se o jogo funciona, mas ele não tira capturas de tela com o jogo rodando, então ande até o NPC e fale com ele você mesmo. Se algo se comportar mal, conte ao RoCode o que você viu: o Check Output consegue ler as linhas de Server e Client do seu último teste. Um NPC que fala é um sistema entre muitos; criar um jogo Roblox com IA, um sistema por prompt mostra como eles se encaixam. Como o RoCode se conecta ao Studio.

Perguntas frequentes

Como fazer um NPC falar no Roblox Studio?

Adicione um ProximityPrompt ao NPC e, quando um jogador o acionar, mostre a fala do NPC em uma caixa de diálogo, em um balão de fala ou nos dois. Os três scripts deste guia fazem as duas coisas e adicionam escolhas. Para só um balão, chame TextChatService:DisplayBubble(npc.Head, "Hello!") em um LocalScript quando o prompt for acionado, como no exemplo de NPC da página de bubble chat da Roblox.

Devo usar o objeto Dialog ou uma GUI de diálogo própria?

O objeto Dialog não precisa de código e mostra um balão de fala clicável, o que basta para texto de ambientação. O evento de escolha dele só dispara no dispositivo do jogador, então ele não consegue dar recompensas com segurança, e por padrão só um jogador pode falar com ele por vez. Uma caixa própria como a deste guia deixa o servidor rodar toda recompensa e dá a cada jogador a própria conversa.

Como dar um item ao jogador por um NPC?

Guarde a Tool no ServerStorage e faça um Script de servidor cloná-la para a Backpack do jogador quando ele fizer aquela escolha, como faz a ação GiveItem. Confira que ele ainda não tem uma, e desligue o CanBeDropped da cópia para ela não poder ser largada e pedida de novo. Nunca deixe o dispositivo do jogador dizer qual item dar.

Como fazer uma caixa de diálogo com efeito de máquina de escrever?

Coloque a fala inteira em um TextLabel, aumente o MaxVisibleGraphemes dele a partir de 0, alguns caracteres por vez, e defina como -1 no fim para mostrar tudo. A página de animação de UI da Roblox usa a mesma propriedade com utf8.graphemes. O DialogueClient calcula quantos caracteres mostrar a partir do tempo que passou, 45 por segundo, então a velocidade não depende da taxa de quadros.

Dois jogadores conseguem falar com o mesmo NPC ao mesmo tempo?

Com os scripts deste guia, sim: o servidor guarda uma conversa por jogador, e cada jogador vê só a própria caixa. O objeto Dialog nativo é diferente: com o BehaviorType padrão, SinglePlayer, um jogador fala por vez e os outros veem as escolhas dele.

Preciso filtrar o texto do diálogo de NPC?

Não as falas que você mesmo escreveu. A Roblox responsabiliza você por filtrar o texto exibido sobre o qual você não tem controle explícito, como o que os jogadores digitam, palavras geradas a partir de caracteres aleatórios, ou texto buscado em um site externo. Se um NPC repete algo que um jogador digitou, filtre essa parte.

Fontes e leitura extra

Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 12 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.