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
DialogChoiceSelecteddo 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çoChatestá 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
Como funciona o diálogo de NPC
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:
- O jogador anda até o NPC e aperta E no prompt Talk dele. O evento
Triggereddo prompt dispara no servidor com aquele jogador. - O script do servidor confere se o jogador está perto o bastante, anota que ele está na fala chamada
starte envia o texto dessa fala e os rótulos das escolhas só para aquele jogador. - 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.
- O jogador clica, toca ou seleciona uma escolha. Só o número dela volta para o servidor.
- 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.
| Peça | Onde fica | O que faz |
|---|---|---|
Rig Guide | Workspace, em uma pasta chamada NPCs | O NPC. O nome dele escolhe a conversa e aparece no prompt. |
ModuleScript DialogueData | ReplicatedStorage | Toda fala que o NPC pode dizer, as escolhas de cada fala e aonde cada escolha leva. |
Script DialogueService | ServerScriptService | Adiciona o prompt Talk, lembra em qual fala cada jogador está, confere todo clique e roda as ações. |
RemoteEvent DialogueEvent | ReplicatedStorage (o DialogueService cria) | Leva cada fala ao jogador, e o número da escolha clicada de volta ao servidor. |
LocalScript DialogueClient | StarterPlayer, StarterPlayerScripts | Desenha 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 DialogueItems | O item que uma escolha dá. Nada do ServerStorage é enviado aos jogadores. |
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
- 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
Rigaparece no Workspace. Um rig R6 funciona com os mesmos scripts. - Renomeie para
Guide. O nome importa: o DialogueService procura a conversa pelo nome do model, e o prompt o mostra aos jogadores. - 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.
- 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. - Opcional, para a escolha do item: passe o mouse sobre ServerStorage e insira uma Folder chamada
DialogueItems. Coloque dentro dela uma Tool chamadaTorch, com uma Part não ancorada chamadaHandle, 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 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 chamadastart. texté o que o NPC diz.choicessão os botões do jogador, em ordem. A caixa tem espaço para quatro.nextdá o nome da fala a mostrar depois daquela escolha. Uma escolha semnext, como "Bye!", encerra a conversa. UmnextoufailNextque aponta para uma fala que não existe na tabela também encerra, com um aviso no Output.actiondá o nome de algo que o servidor faz, da tabelaACTIONSdo DialogueService: aqui,HealouGiveItem.itemé para o GiveItem: o nome de uma Tool em ServerStorage, DialogueItems.failNexté a fala mostrada em vez denextquando a ação não pôde ser feita, para o NPC nunca anunciar uma cura ou um presente que não aconteceu.
| Fala | O Guide diz | Escolhas, 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 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.
| Configuração | Valor aqui | O que muda |
|---|---|---|
TALK_DISTANCE | 12 | A 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_CHOICES | 0.3 | O 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_SECONDS | 30 | Quanto 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:
| Checagem | Código | Se falha |
|---|---|---|
| O jogador está em uma conversa | conversations[player] | O clique é ignorado. |
| A escolha é um número inteiro | typeof e math.floor | Ignorado. Strings, tabelas, frações e NaN param aqui. |
| 0 quer dizer que o jogador apertou o X | choiceIndex == 0 | A conversa termina. |
| Vivo e ainda a até 16 studs (12 mais 4) | isClose | A conversa termina e a caixa fecha. |
| Pelo menos 0,3 segundo desde o último clique aceito | conversation.lastChoice | A 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á lendo | line.choices[choiceIndex] | Ignorado. |
| A ação deu certo | cada ação retorna true ou false | A 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.
-- 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
UISizeConstraintpara não se esticar em um monitor largo. A fala do NPC usaTextScaled, que encolhe o texto para caber no label em uma tela pequena de celular, e umUITextSizeConstraintimpede que ele passe de 20 pixels em uma tela grande. UmUIGridLayoutdistribui as escolhas de duas em duas. OResetOnSpawné 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
MaxVisibleGraphemesdecide quantos caracteres aparecem, a mesma propriedade que o exemplo de máquina de escrever da própria Roblox usa comutf8.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
lineNumberimpede 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
Activateddispara 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 oPreferredInputdiz que o jogador está usando um gamepad, o script seleciona a primeira escolha comGuiService.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:
- Adicione à
ACTIONSuma entrada chamadaStartQuest. Confira primeiro, mude depois: seplayer:GetAttribute("Quest")já está definido, retornefalse; senão chameplayer:SetAttribute("Quest", "Cave")e retornetrue. - No DialogueData, dê a uma escolha
action = "StartQuest", uma falanextpara quando dá certo e uma falafailNextpara quando não dá, como "You are already on a quest." - 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 mostraDialogueService: no action named StartQueste a conversa vai para a falafailNext.
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.
| O tutorial | O problema | Este guia |
|---|---|---|
Usa o objeto Dialog, com um Script de servidor escutando o DialogChoiceSelected para dar uma recompensa | A 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 LocalScript | Uma 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 fala | Um 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 é disparado | O 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 loop | O 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 trapaceiro tenta | Resultado | Por quê |
|---|---|---|
| Acionar o prompt Talk do outro lado do mapa | Nada acontece | O startConversation confere se ele está a até 16 studs (12 mais 4). |
| Enviar a escolha 99, uma string, uma fração ou NaN | Ignorado | Nã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 fala | Nunca é lido | O 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 permite | Um clique a cada 0,3 segundo por conversa | Cliques 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 conversar | Impossível | Os itens vêm só de uma escolha na fala em que o servidor sabe que ele está. |
| Juntar uma pilha de tochas | Uma por vez | O 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 cura | Uma cura a cada 30 segundos | O cooldown é guardado por jogador no servidor, e o NPC avisa com a fala healTooSoon. |
| Se afastar e manter a caixa aberta | Fechada em até meio segundo | O servidor confere toda conversa aberta duas vezes por segundo. |
| Ler a conversa inteira, inclusive as falas a que ainda não chegou | Possível | O 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
- Aperte Play (F5) e ande até o Guide. A até 12 studs, aparece um prompt Talk com o nome Guide. Aperte E.
- 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.
- Escolha "Any tips?", depois "Anything else?": você volta à primeira fala. Escolha "Bye!": a caixa fecha e o prompt Talk volta.
- 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.
- 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.
- Comece a conversar, depois se afaste. A caixa fecha mais ou menos assim que você fica a 16 studs do Guide.
- 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.
- 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.
- 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.
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.
- 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
- Roblox Creator Docs: Proximity prompts (em inglês). criar prompts, MaxActivationDistance e RequiresLineOfSight
- Roblox Engine API: ProximityPrompt (em inglês). onde um prompt funciona, o texto e as teclas padrão, Triggered e a checagem de linha de visão
- Roblox Creator Docs: Securing the client-server boundary (em inglês). ProximityPrompts como superfície de ataque, e checagens de distância e permissão
- Roblox Engine API: Dialog (em inglês). BehaviorType e o evento DialogChoiceSelected, só do cliente
- Roblox Engine API: TextChatService:DisplayBubble (em inglês). balões de fala para NPCs em scripts de cliente
- Roblox Creator Docs: Customize bubble chat (em inglês). balões de NPC e BubbleChatConfiguration
- Roblox Creator Docs: Text filtering (em inglês). qual texto exibido você precisa filtrar
- Roblox Creator Docs: UI animation and tweens (em inglês). o efeito de máquina de escrever com MaxVisibleGraphemes
- Roblox Engine API: Tool.CanBeDropped (em inglês). o que o Backspace faz com uma tool
- Roblox Engine API: UserInputService.PreferredInput (em inglês). detectar um jogador com controle
- Roblox Creator Docs: Rig Generator (em inglês). inserir um rig R15 ou R6
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.