In breve
Metti il modello dell'NPC in una cartella NPCs in Workspace e scrivi la sua conversazione in un ModuleScript in ReplicatedStorage: ogni battuta ha il testo dell'NPC e un elenco di scelte che portano a un'altra battuta. Uno Script in ServerScriptService aggiunge a ogni NPC un ProximityPrompt ("Talk"), ricorda a quale battuta si trova ogni giocatore e la invia tramite un RemoteEvent. Un LocalScript mostra il testo e un pulsante per ogni scelta, e rimanda indietro solo il numero del pulsante premuto.
- Dai le ricompense sul server. L'evento
DialogChoiceSelecteddell'oggetto Dialog integrato scatta solo sul client, quindi uno Script sul server non lo sente mai, e una cura o un oggetto dati in un LocalScript cambiano solo la copia del gioco di quel giocatore. - Mostra un fumetto con la battuta tramite
TextChatService:DisplayBubble(npc.Head, text)da un LocalScript. Il vecchio servizioChatè deprecato, al suo posto si usa TextChatService. - Le battute che hai scritto tu non vanno filtrate. La regola di Roblox: filtrare qualsiasi testo mostrato che non controlli direttamente, per esempio quello che scrivono i giocatori.
In questa pagina
Come funziona un dialogo con un NPC
Un NPC che parla e funziona in un gioco vero è diviso tra il server e il dispositivo di ogni giocatore. Il dispositivo disegna la finestra e i pulsanti. Il server, l'unica parte di cui ci si può fidare, sa quale battuta sta leggendo ogni giocatore e decide cosa fa ogni risposta. Un turno della conversazione funziona così:
- Il giocatore si avvicina all'NPC e preme E sul suo prompt Talk. L'evento
Triggereddel prompt scatta sul server con quel giocatore. - Lo script server controlla che il giocatore sia abbastanza vicino, ricorda che si trova sulla battuta chiamata
starte invia il testo di quella battuta e le etichette delle sue scelte solo a quel giocatore. - Il LocalScript scrive la battuta nella finestra di dialogo, mostra un fumetto sopra l'NPC, poi aggiunge un pulsante per ogni scelta.
- Il giocatore clicca, tocca o seleziona una scelta. Al server torna solo il suo numero.
- Il server trova quel numero sulla battuta che sa che il giocatore sta leggendo, esegue l'azione della scelta se c'è (una cura, un oggetto) e invia la battuta successiva oppure chiude la finestra.
| Elemento | Dove si trova | Cosa fa |
|---|---|---|
Rig Guide | Workspace, in una cartella chiamata NPCs | L'NPC vero e proprio. Il suo nome sceglie la conversazione e compare sul prompt. |
ModuleScript DialogueData | ReplicatedStorage | Tutte le battute che l'NPC può dire, le scelte sotto ogni battuta e dove porta ogni scelta. |
Script DialogueService | ServerScriptService | Aggiunge il prompt Talk, ricorda a quale battuta è ogni giocatore, controlla ogni clic ed esegue le azioni. |
RemoteEvent DialogueEvent | ReplicatedStorage (lo crea DialogueService) | Porta ogni battuta al giocatore e il numero della scelta fatta di nuovo al server. |
LocalScript DialogueClient | StarterPlayer, StarterPlayerScripts | Disegna la finestra, scrive la battuta, mostra il fumetto e i pulsanti delle scelte. |
Tool Torch (facoltativo) | ServerStorage, in una cartella chiamata DialogueItems | L'oggetto che dà una delle scelte. Niente in ServerStorage viene inviato ai giocatori. |
Workspace
NPCs Folder new
Guide Model new
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (parti del 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: aggiungi l'NPC
- Nella scheda Avatar o Home clicca su Character per aprire il Rig Generator. Scegli R15, una forma del corpo e uno stile. In Workspace appare un rig chiamato
Rig. Un rig R6 funziona con gli stessi script. - Rinominalo
Guide. Il nome conta: DialogueService cerca la conversazione in base al nome del modello e il prompt lo mostra ai giocatori. - Espandi il rig, seleziona il suo HumanoidRootPart e spunta Anchored nella finestra Properties. Una parte ancorata non si muove mai per effetto della fisica, quindi l'NPC resta dove l'hai messo e i giocatori non possono spingerlo.
- Passa il mouse su Workspace nell'Explorer, clicca sul pulsante + e inserisci un Folder chiamato
NPCs. Trascinaci dentro Guide e posiziona il rig dove i giocatori possono raggiungerlo. - Facoltativo, per la scelta con l'oggetto: passa il mouse su ServerStorage e inserisci un Folder chiamato
DialogueItems. Mettici dentro un Tool chiamatoTorchcon una sola Part non ancorata chiamataHandle, che è la parte che il personaggio tiene in mano. Una PointLight dentro Handle la fa brillare.
I nomi distinguono maiuscole e minuscole, quindi scrivi NPCs, Guide, DialogueItems e Torch esattamente come mostrato. L'NPC può essere qualsiasi modello con Humanoid e HumanoidRootPart, anche dalla Toolbox, purché stia direttamente nella cartella NPCs.
Passo 2: scrivi la conversazione
Passa il mouse su ReplicatedStorage, inserisci un ModuleScript chiamato DialogueData e incollaci questo codice. Non contiene logica, solo le parole e i collegamenti tra loro, quindi è il file che modificherai più spesso.
-- ModuleScript in ReplicatedStorage chiamato DialogueData.
-- Tutte le conversazioni, per nome dell'NPC in Workspace.NPCs. Ogni battuta ha
-- il testo dell'NPC e le risposte del giocatore. Una scelta può portare a un'altra battuta (next),
-- chiudere la conversazione (senza next) e chiedere al server di fare qualcosa (action). Se il server
-- non riesce a eseguire l'azione, mostra la battuta failNext al posto di next.
export type Choice = {
text: string,
next: string?, -- battuta da mostrare dopo questa scelta; nil chiude la conversazione
action: string?, -- azione del server dalla tabella ACTIONS in DialogueService
item: string?, -- per l'azione GiveItem: nome del Tool in ServerStorage.DialogueItems
failNext: string?, -- battuta da mostrare al posto di next quando l'azione non è riuscita
}
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
Le righe export type all'inizio descrivono com'è fatta una battuta e una scelta. Durante il gioco non cambiano nulla; descrivono i tuoi dati così che il controllo dei tipi possa verificarli.
Come sono collegate le parti:
- Ogni NPC ha una tabella che porta il nome del suo modello nella cartella NPCs, qui
Guide. Ogni conversazione inizia dalla battutastart. textè ciò che dice l'NPC.choicessono i pulsanti del giocatore, in ordine. Nella finestra c'è posto per quattro.nextindica la battuta da mostrare dopo questa scelta. Una scelta senzanext, come "Bye!", chiude la conversazione. Anche unnexto unfailNextche indica una battuta assente dalla tabella la chiude, con un avviso nell'Output.actionindica cosa fa il server, dalla tabellaACTIONSin DialogueService: quiHealoGiveItem.itemserve per GiveItem: è il nome del Tool in ServerStorage, DialogueItems.failNextè la battuta mostrata al posto dinextquando l'azione non è riuscita, così l'NPC non dichiara mai una cura o un regalo che non ci sono stati.
| Battuta | Guide dice | Scelte e dove portano |
|---|---|---|
start | "Welcome to the village! What can I do for you?" | "Any tips?" porta a tips. "I'm hurt. Can you help?" cura, poi healed (o healTooSoon). "Got anything for the cave?" dà la Torch, poi torch (o hasTorch). "Bye!" chiude la conversazione. |
tips | "Stay off the red bricks, and come back if you get hurt." | "Anything else?" torna a start. "Thanks!" chiude la conversazione. |
healed | "There you go, good as new." | "Thank you!" chiude la conversazione. |
torch | "Take this torch. The cave is dark." | "Thanks!" chiude la conversazione. |
healTooSoon | "I healed you a moment ago. Come back in a little while." | "OK" chiude la conversazione. |
hasTorch | "You already have my torch. Keep it lit!" | "Will do!" chiude la conversazione. |
Questo modulo lo legge solo il server. Il LocalScript non gli fa mai require: il server invia ogni battuta quando il giocatore ci arriva. Però un modulo in ReplicatedStorage viene comunque copiato sul dispositivo di ogni giocatore, quindi se la conversazione contiene spoiler (per esempio la soluzione di un indovinello), sposta DialogueData in ServerStorage. Poi nella riga con require in DialogueService sostituisci ReplicatedStorage con ServerStorage, così che l'intera riga sia: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.
Passo 3: aggiungi lo script server
Passa il mouse su ServerScriptService, inserisci uno Script chiamato DialogueService e incollaci il codice qui sotto. È l'unico punto in cui la conversazione va avanti e l'unico punto in cui si dà una ricompensa.
-- Script in ServerScriptService chiamato DialogueService.
-- Aggiunge un prompt Talk a ogni NPC in Workspace.NPCs e gestisce ogni conversazione.
-- Il dispositivo del giocatore mostra solo il testo e rimanda indietro il numero della scelta
-- su cui ha cliccato. Il server sa a quale battuta è ogni giocatore, controlla la scelta
-- e la distanza, e solo lui cura o dà oggetti.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Le stesse forme di DialogueData, così il controllo dei tipi di Studio le conosce anche qui
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 -- stud: raggio del prompt e quanto vicino deve restare il giocatore
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30
local npcFolder = workspace:WaitForChild("NPCs")
local itemFolder = ServerStorage:FindFirstChild("DialogueItems")
-- Questo script crea da solo DialogueEvent, quindi non aggiungerlo a mano
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 -- nessun personaggio, è morto oppure l'NPC è sparito
end
-- un piccolo margine, perché la posizione del giocatore arriva al server con un leggero ritardo
return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end
-- Cosa fa il server quando una scelta ha un'azione. Ognuna restituisce true se è stata eseguita.
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 -- curato troppo di recente
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 -- lo zaino non c'è ancora oppure ha già l'oggetto
end
local item = template:Clone() :: Tool
item.CanBeDropped = false -- così nessuno può buttarlo via e chiederne un altro
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 -- sta già parlando, questo NPC non ha una battuta "start", è morto o troppo lontano
end
local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
conversations[player] = conversation
showLine(player, conversation)
end
-- Il giocatore ha cliccato la scelta numero choiceIndex (0 significa che ha chiuso la finestra)
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
-- Troppo veloce. Rimandiamo la stessa battuta, perché la finestra ha già bloccato
-- i pulsanti dopo il clic e altrimenti aspetterebbe una risposta per 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 -- sulla battuta che questo giocatore sta leggendo non c'è questa scelta
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 -- per esempio "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)
-- Il prompt Talk su ogni 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() -- una copia dell'NPC porta con sé un vecchio prompt che nessuno ascolta
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)
-- Chiudiamo la finestra a chi si è allontanato o è morto a metà conversazione
task.spawn(function()
while true do
task.wait(0.5)
for player, conversation in conversations do
if not isClose(player, conversation.npc) then
endConversation(player)
end
end
end
end)
Players.PlayerRemoving:Connect(function(player: Player)
conversations[player] = nil
lastHeal[player] = nil
end)
DialogueService crea da solo il RemoteEvent DialogueEvent all'avvio del gioco, quindi non devi inserire nulla a mano in ReplicatedStorage. Se hai già creato un RemoteEvent con quel nome, eliminalo: il LocalScript potrebbe trovare il tuo, e sul server nessuno lo ascolta.
| Impostazione | Valore qui | Cosa cambia |
|---|---|---|
TALK_DISTANCE | 12 | Quanto vicino, in stud, deve essere il giocatore perché compaia il prompt Talk. Il server gli lascia altri 4 stud prima di chiudere la finestra, perché la posizione del giocatore arriva al server con un leggero ritardo. |
MIN_SECONDS_BETWEEN_CHOICES | 0.3 | Il tempo più breve tra due clic che il server accetta. A un clic più rapido, invece di una risposta viene rimandata la stessa battuta. |
HEAL_COOLDOWN_SECONDS | 30 | Quanto aspetta ogni giocatore tra una cura e l'altra dell'azione Heal. |
Il server tiene in conversations una voce per giocatore: con quale NPC sta parlando, quale battuta sta leggendo e quando è stato accettato il suo ultimo clic. Quando scatta il prompt Talk, startConversation crea quella voce solo se il giocatore non sta già parlando, l'NPC ha una battuta start e il giocatore è vivo e dentro il raggio. Dopo di che ogni clic passa per questi controlli:
| Controllo | Codice | Se non lo supera |
|---|---|---|
| Il giocatore è in una conversazione | conversations[player] | Il clic viene ignorato. |
| La scelta è un numero intero | typeof e math.floor | Ignorato. Stringhe, tabelle, decimali e NaN si fermano qui. |
| 0 significa che il giocatore ha premuto X | choiceIndex == 0 | La conversazione finisce. |
| Vivo e ancora entro 16 stud (12 più 4) | isClose | La conversazione finisce e la finestra si chiude. |
| Almeno 0.3 secondi dall'ultimo clic accettato | conversation.lastChoice | Viene rimandata la stessa battuta, così la finestra riceve pulsanti nuovi invece di aspettare per sempre. |
| La scelta esiste sulla battuta che questo giocatore sta leggendo | line.choices[choiceIndex] | Ignorato. |
| L'azione ha funzionato | ogni azione restituisce true o false | Al posto di next viene mostrata la battuta failNext. |
Il prompt va sull'HumanoidRootPart dell'NPC, perché un ProximityPrompt funziona quando sta dentro una parte (o un Attachment, o un modello con PrimaryPart) in Workspace. Il suo RequiresLineOfSight è attivo per impostazione predefinita e nasconde il prompt ogni volta che qualcosa blocca la vista dalla camera a quella parte. Roblox esclude da questo controllo la parte del prompt stesso, ma non il resto del corpo, e l'HumanoidRootPart sta dentro il torso, quindi lo script disattiva il controllo della linea di vista. Il prompt si chiama TalkPrompt e lo script elimina qualsiasi TalkPrompt già presente sulla parte prima di aggiungere il suo: una copia dell'NPC fatta durante il gioco arriva con il prompt dell'originale, e quello copiato non lo ascolta nessuno. Se in DialogueData non c'è una conversazione con una battuta start per il nome dell'NPC, nell'Output compare un avviso con il nome di quell'NPC.
Un ciclo controlla due volte al secondo ogni conversazione aperta e la chiude quando il giocatore si è allontanato oltre 16 stud o il suo personaggio è morto, così un giocatore morto a metà conversazione non ricompare con la finestra aperta. PlayerRemoving pulisce entrambe le tabelle quando qualcuno esce.
Passo 4: aggiungi la finestra di dialogo
Apri StarterPlayer, passa il mouse su StarterPlayerScripts, inserisci un LocalScript chiamato DialogueClient e incollaci questo codice. Costruisce la finestra di dialogo nel codice, quindi non devi disegnare la GUI a mano.
-- LocalScript in StarterPlayer > StarterPlayerScripts chiamato DialogueClient.
-- Disegna la conversazione che manda il server: il nome dell'NPC, la sua battuta scritta lettera
-- per lettera, un fumetto sopra la testa e un pulsante per ogni scelta. Un clic su
-- una scelta invia solo il suo numero; cosa succede dopo lo decide il server.
local GuiService = game:GetService("GuiService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TextChatService = game:GetService("TextChatService")
local UserInputService = game:GetService("UserInputService")
local dialogueEvent = ReplicatedStorage:WaitForChild("DialogueEvent") :: RemoteEvent
local player = Players.LocalPlayer
local LETTERS_PER_SECOND = 45
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)
-- La finestra di dialogo, costruita nel codice
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 pixel più in alto, così la barra degli strumenti di Roblox non copre le scelte
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 -- una battuta lunga si rimpicciolisce per stare nello schermo piccolo di un telefono
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- e non diventa mai più grande di 20 pixel su uno schermo 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 -- cresce a ogni nuova battuta, così il vecchio ciclo di scrittura si ferma
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 -- cambia solo su questo 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()
-- Fumetto sopra l'NPC (DisplayBubble funziona solo in un LocalScript)
local head = npc:FindFirstChild("Head")
if head then
TextChatService:DisplayBubble(head, text)
end
-- Scriviamo la battuta lettera per lettera. Il numero si calcola dal tempo trascorso,
-- così la velocità è la stessa a qualsiasi frame rate.
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 -- questa battuta è stata sostituita da una più nuova o da una chiusura
end
shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
lineLabel.MaxVisibleGraphemes = shown
end
lineLabel.MaxVisibleGraphemes = -1
-- Un pulsante per scelta; il server riceve solo il numero del pulsante
for index, choiceText in choices do
local button = Instance.new("TextButton")
button.LayoutOrder = index
button.BackgroundColor3 = Color3.fromRGB(124, 77, 255)
button.TextColor3 = Color3.new(1, 1, 1)
button.TextScaled = true
button.FontFace = BOLD
button.Text = choiceText
local buttonCorner = Instance.new("UICorner")
buttonCorner.CornerRadius = UDim.new(0, 8)
buttonCorner.Parent = button
button.Parent = choiceList
button.Activated:Connect(function()
if lineNumber == thisLine then
lineNumber += 1 -- un clic per battuta
dialogueEvent:FireServer(index)
end
end)
if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
GuiService.SelectedObject = button -- così la scelta si può selezionare con il gamepad
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)
Colori, dimensioni e LETTERS_PER_SECOND puoi cambiarli come vuoi. Lascia invariati gli ultimi due gestori: sono l'unico modo in cui la finestra comunica con il server.
Cosa fa ogni parte di DialogueClient:
- La finestra. Una ScreenGui con un Frame fissato in basso al centro dello schermo, largo il 60% e alto il 34%, con un limite di 720 per 300 pixel tramite
UISizeConstraint, così non si allarga su tutto un monitor largo. La battuta dell'NPC usaTextScaled, che rimpicciolisce il testo per farlo stare nella sua etichetta sullo schermo piccolo di un telefono, eUITextSizeConstraintgli impedisce di superare i 20 pixel su uno schermo grande.UIGridLayoutdispone le scelte due per due.ResetOnSpawnè false perché questo LocalScript parte una volta per sessione: una finestra eliminata al respawn non tornerebbe più. - L'effetto macchina da scrivere. Tutta la battuta entra subito nella TextLabel, e
MaxVisibleGraphemesdecide quanti caratteri sono visibili; è la stessa proprietà che usa l'esempio di macchina da scrivere di Roblox insieme autf8.graphemes. Roblox impagina il testo come se tutti i caratteri fossero visibili, quindi le parole non saltano a capo e non cambiano dimensione mentre appaiono. Lo script calcola quanti caratteri mostrare dal tempo trascorso, 45 al secondo, così la velocità è la stessa a qualsiasi frame rate, e poi imposta la proprietà a -1, che mostra tutto. - I pulsanti. Appaiono quando la battuta è scritta. Ognuno invia solo il proprio numero, e una sola volta: il controllo di
lineNumberimpedisce che un doppio clic invii due volte, e poi la finestra aspetta la battuta successiva dal server. - Il fumetto con la battuta.
TextChatService:DisplayBubble(head, text)mette la battuta in un fumetto della chat sopra la Head dell'NPC. Roblox lo permette solo negli script client, e la bubble chat è attiva per impostazione predefinita. Il fumetto lo disegna il dispositivo di quel giocatore, quindi lo vede solo lui. - Il prompt. Mentre il giocatore parla, la sua copia del prompt Talk (trovata per nome, TalkPrompt) è disattivata, così non resta sopra la conversazione. Gli altri giocatori continuano a vedere la propria.
- Qualsiasi dispositivo.
Activatedscatta con un clic del mouse, un tocco sul telefono e il pulsante A del gamepad. Un gamepad può premere solo il pulsante selezionato, quindi quandoPreferredInputdice che il giocatore usa un gamepad, lo script seleziona la prima scelta tramiteGuiService.SelectedObject. - Il pulsante X. Invia 0, che il server interpreta come «chiudi la conversazione», e chiude subito la finestra.
Aggiungi le tue azioni
Un'azione è una funzione nella tabella ACTIONS all'inizio di DialogueService. Riceve il giocatore e la scelta e restituisce true quando ha fatto il suo lavoro. Per aggiungerne una tua, per esempio una missione che dà l'NPC:
- Aggiungi in
ACTIONSuna voce chiamataStartQuest. Prima il controllo, poi la modifica: seplayer:GetAttribute("Quest")è già impostato, restituiscifalse; altrimenti chiamaplayer:SetAttribute("Quest", "Cave")e restituiscitrue. - In DialogueData dai alla scelta
action = "StartQuest", una battutanextper il caso di successo e una battutafailNextper il caso di fallimento, per esempio "You are already on a quest." - Premi Play e scegli l'opzione due volte. Se il nome in DialogueData non corrisponde alla chiave in
ACTIONS(maiuscole e minuscole contano), nell'Output compareDialogueService: no action named StartQueste la conversazione passa alla battutafailNext.
Regole per scrivere le azioni:
- Fai il controllo e la modifica dentro l'azione, sul server. L'unica cosa che invia il dispositivo del giocatore è il numero della scelta.
- Ciò che serve all'azione leggilo dalla scelta (come
item) o dallo stato del server stesso, mai da un remote. - Limita tutto ciò che ha valore dentro l'azione stessa, come Heal tiene il proprio cooldown di 30 secondi in
lastHeal. Il limite di 0.3 secondi per clic rallenta solo i clic; non impedisce a un giocatore di ripassare per la stessa scelta più e più volte. - Per aprire un'altra finestra, per esempio un negozio, un'azione può inviare un RemoteEvent a quel giocatore e restituire
true. Tutto ciò che succede in quella finestra richiede comunque i propri controlli sul server, come nella sezione NPC negoziante.
Dove sbagliano gli altri tutorial sui dialoghi NPC
Se confronti questa guida con un video o un post sul forum, ecco le differenze importanti e il motivo per cui ogni trucco crea un problema.
| Tutorial | Problema | Questa guida |
|---|---|---|
Usa l'oggetto Dialog e uno Script sul server ascolta DialogChoiceSelected per dare la ricompensa | Il riferimento di Roblox dice che questo evento funziona solo lato client e sul server non scatta, quindi la ricompensa non arriva mai. | La scelta arriva al server come numero e il server dà la ricompensa da solo. |
| Dà la ricompensa da un LocalScript | Una modifica fatta da un LocalScript resta su quel solo dispositivo (vedi cosa si replica), e un cheater può eseguire lo stesso codice quando vuole. | Tutte le azioni vivono in DialogueService. |
Fa parlare l'NPC con game:GetService("Chat"):Chat(head, text) | Il servizio Chat è deprecato, al suo posto si usa TextChatService. | TextChatService:DisplayBubble in un LocalScript. |
| Invia dal client il nome della ricompensa o l'id della battuta successiva | Un cheater può inviare qualsiasi nome di oggetto o saltare direttamente alla battuta che dà la ricompensa. | Il client invia solo il numero della scelta. Il server lo trova sulla battuta che sa che il giocatore sta leggendo. |
| Non controlla nulla dopo che il prompt è scattato | La guida di Roblox sulla sicurezza mette i ProximityPrompt accanto ai remote come qualcosa di cui i client possono abusare, e consiglia di controllare prima dell'azione se il giocatore è abbastanza vicino. | La distanza si controlla all'inizio della conversazione, a ogni clic e due volte al secondo mentre è aperta. |
Scrive il testo con wait() in un ciclo | Il wait globale è deprecato, al suo posto si usa task.wait. | Calcola il numero di lettere visibili da os.clock() e aspetta con task.wait(). |
Cosa un giocatore può e non può falsificare
Dai per scontato che un cheater controlli tutto sul proprio dispositivo. Può leggere i tuoi LocalScript e tutto ciò che c'è in ReplicatedStorage, chiamare DialogueEvent con qualsiasi argomento quante volte vuole e attivare il prompt Talk da codice, come avverte la guida di Roblox sulla sicurezza. DialogueService risponde con controlli sul server dello stesso tipo di quelli spiegati nella sezione validare gli argomenti di un RemoteEvent. Ecco cosa ci guadagna il cheater.
| Il cheater prova a | Risultato | Perché |
|---|---|---|
| Attivare il prompt Talk dall'altro capo della mappa | Non succede nulla | startConversation controlla che non sia oltre 16 stud (12 più 4). |
| Inviare la scelta 99, una stringa, un decimale o NaN | Ignorato | Non è un numero intero, oppure quella scelta non esiste sulla battuta che sta leggendo. |
| Inviare il nome di una ricompensa o l'id di una battuta | Mai letto | Il server legge solo il numero della scelta. Le ricompense vengono dai campi item e action della copia della battuta sul server. |
| Cliccare veloce quanto permette la rete | Un clic ogni 0.3 secondi per conversazione | Ai clic più rapidi torna indietro la loro stessa battuta. Chiudere e riaprire la conversazione aggira questa attesa, per questo Heal e GiveItem hanno limiti propri. |
| Chiedere la torcia senza parlare | Impossibile | Gli oggetti si danno solo tramite una scelta sulla battuta a cui il server sa che si trova il giocatore. |
| Accumulare un mucchio di torce | Una alla volta | Il server cerca prima la Torch nel suo Backpack e nel personaggio, e una torcia data non si può buttare via, quindi non si può farmare buttandola e chiedendola di nuovo. |
| Spammare la battuta della cura | Una cura ogni 30 secondi | Il cooldown è salvato sul server per ogni giocatore e l'NPC lo comunica con la battuta healTooSoon. |
| Allontanarsi lasciando la finestra aperta | Si chiude entro mezzo secondo | Il server controlla ogni conversazione aperta due volte al secondo. |
| Leggere tutta la conversazione, comprese le battute a cui non è arrivato | Possibile | DialogueData sta in ReplicatedStorage, che viene copiato su ogni dispositivo. Spostalo in ServerStorage se è importante (vedi il passo 2). |
Un limite va detto chiaramente: un cheater che si avvicina a Guide e sceglie le opzioni ottiene esattamente ciò che ottiene un giocatore onesto. Il server controlla quanto spesso e da dove, ma non chi. Tutto ciò che è raro, per esempio una ricompensa che ogni giocatore può ottenere una sola volta, richiede un controllo di proprietà del server, come un attributo impostato al momento della consegna o un flag salvato in un data store.
Passo 5: provalo
- Premi Play (F5) e avvicinati a Guide. Entro 12 stud compare il prompt Talk con il nome di Guide. Premi E.
- La finestra mostra "Guide", scrive la battuta di benvenuto e poi mostra quattro pulsanti. La stessa battuta compare in un fumetto sopra la testa dell'NPC.
- Scegli "Any tips?", poi "Anything else?": sei di nuovo sulla prima battuta. Scegli "Bye!": la finestra si chiude e il prompt Talk ritorna.
- Prima fatti del danno: clicca sull'interruttore Client/Server per passare a Server, seleziona lo Humanoid del tuo personaggio in Workspace, imposta Health a 50 nella finestra Properties e torna a Client. I personaggi dei giocatori recuperano l'1% della MaxHealth ogni secondo, quindi parla subito con Guide e scegli "I'm hurt. Can you help?": la salute torna al massimo. Parla di nuovo entro 30 secondi e scegli di nuovo la stessa opzione: nessuna cura, e Guide dice che ti ha curato un momento fa.
- Scegli "Got anything for the cave?": la Torch compare nella hotbar. Equipaggiala e premi Backspace: resta in mano. Chiedila di nuovo: nessuna seconda torcia, e Guide dice che ce l'hai già.
- Inizia una conversazione e allontanati. La finestra si chiude più o meno quando ti trovi a 16 stud da Guide.
- Scegli Server & Clients nel menu a tendina delle modalità di test, imposta 2 client e premi Play. Entrambi i giocatori possono parlare con Guide nello stesso momento, ognuno sulla propria battuta.
- Prova il gamepad con il Controller Emulator (Controller nella scheda Emulation) durante il playtest. Con il gamepad emulato avvicinati e premi il pulsante del prompt (di default ButtonX): quando appaiono le scelte, la prima è già selezionata e A la preme.
- Prova lo schermo di un telefono con il Device Simulator di Studio (al momento della stesura è in beta: attiva New Device Simulator in File, Beta Features e riavvia Studio). Scegli un telefono, premi Rotate finché non è in orizzontale, premi Play, avvicinati a Guide e tocca il prompt Talk. Scegli "Any tips?": tutta la battuta è visibile sopra i pulsanti delle scelte, se serve con un testo più piccolo, e non si sovrappone a loro.
Tieni sempre aperta la finestra Output (menu Window, poi Output). Quando questi script funzionano non stampano nulla, quindi qualsiasi errore rosso o avviso che inizia con DialogueService: è un problema reale. Vedi Errori frequenti.
Come ampliarlo
Più NPC e conversazioni più lunghe
Aggiungi nella cartella NPCs un altro rig con un nome suo, e in DialogueData una tabella con lo stesso nome e una battuta start. DialogueService aggiunge il prompt Talk a ogni modello della cartella che ha un HumanoidRootPart, compresi quelli aggiunti durante il gioco; una copia dell'NPC riceve un prompt nuovo al posto di quello con cui è stata copiata. Due NPC con lo stesso nome usano la stessa tabella. Le battute si possono collegare in qualsiasi ordine e una scelta può riportare a una battuta precedente, come "Anything else?". Tieni al massimo quattro scelte per battuta, perché la finestra le dispone due per due.
Battute che dipendono dai progressi
Per salutare in modo diverso i giocatori che tornano, scegli la prima battuta in base a ciò che possiede il server. In startConversation sceglila con local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", controlla che la battuta esista, come lo script controlla lines.start, e usa firstLine al posto di "start" quando crei la conversazione. Imposta l'attributo in un'azione e aggiungi una battuta welcomeBack alla tabella di Guide. Gli attributi durano una sessione; per ricordare il giocatore tra una visita e l'altra, salva un flag in un data store, come nel tutorial sui DataStore.
NPC negoziante
Costruisci il negozio con la guida alla GUI del negozio, poi aggiungi un'azione OpenShop che invia un RemoteEvent a quel giocatore e restituisce true, e fai in modo che il LocalScript del negozio apra la sua finestra quando arriva quell'evento. Gli acquisti passano comunque per i controlli sul server del negozio stesso. Se si può comprare solo vicino all'NPC, controlla la distanza anche dentro il gestore dell'acquisto, perché il client può chiamare il remote del negozio da qualsiasi punto.
NPC che camminano
Per far girovagare Guide o fargli seguire i giocatori, usa la guida al pathfinding per NPC e togli Anchored all'HumanoidRootPart così può muoversi. Il prompt Talk sta su quella parte, quindi si sposta con l'NPC, e i controlli di distanza usano la stessa parte. Metti in pausa la camminata mentre una conversazione è aperta, altrimenti la finestra si chiude appena l'NPC si allontana dal giocatore oltre 16 stud.
Chiavi, missioni e altre ricompense
GiveItem dà qualsiasi Tool presente in DialogueItems, quindi un NPC può dare una chiave che una porta chiusa controlla, come nella guida alle porte. Per oggetti che fanno qualcosa quando li usi, come un cibo che cura, leggi la guida all'inventario.
Suoni e camera
Per una clip vocale o un breve suono a ogni battuta, metti un Sound nella Head dell'NPC e riproducilo da show in DialogueClient. Per puntare la camera sull'NPC mentre parla, la guida alle cutscene mostra come un LocalScript prende il controllo della camera e lo restituisce.
Errori comuni e soluzioni
Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi con i dialoghi stampa lì un avviso o nasce da un nome che non corrisponde.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("DialogueEvent")'
DialogueClient aspetta il remote che crea DialogueService, quindi DialogueService non è arrivato a quel punto. Controlla che sia uno Script, non un LocalScript, che stia direttamente in ServerScriptService e che non sia disattivato. DialogueService aspetta prima DialogueData in ReplicatedStorage e la cartella NPCs in Workspace, quindi anche la loro assenza o un errore di battitura nel nome lo bloccano; in quel caso l'Output mostra un avviso infinite yield di DialogueService con quel nome.
Sopra il mio NPC non compare il prompt Talk
DialogueService aggiunge i prompt solo ai modelli che stanno direttamente in Workspace, NPCs e che hanno una parte chiamata HumanoidRootPart. Controlla entrambe le condizioni e avvicinati entro 12 stud. Un rig della Toolbox potrebbe non avere quella parte, oppure potrebbe essere un oggetto di un altro tipo avvolto in una cartella.
Il prompt compare, ma premere E non fa nulla
Il server non ha trovato una conversazione per questo NPC, e all'avvio del gioco l'Output mostra DialogueService: no conversation with a start line for Guide in DialogueData con il nome del tuo NPC. La tabella in DialogueData deve chiamarsi esattamente come il modello, maiuscole comprese, e contenere una battuta start.
Una scelta chiude la finestra invece di passare alla battuta successiva
L'Output mostra DialogueService: no line named tip for Guide in DialogueData con i tuoi nomi: il next (o failNext) della scelta indica una battuta che non c'è nella tabella di questo NPC. I nomi delle battute distinguono maiuscole e minuscole, quindi confronta l'ortografia con la tabella, qui tips.
La finestra funziona, ma il fumetto con la battuta non c'è
Il fumetto ha bisogno di una parte chiamata Head direttamente dentro il modello dell'NPC e della bubble chat attiva: nell'Explorer seleziona BubbleChatConfiguration sotto TextChatService e controlla che Enabled sia spuntato. Per impostazione predefinita è attiva.
Nell'Output c'è scritto DialogueService: no Tool named Torch in ServerStorage.DialogueItems
Il server non ha trovato l'oggetto. Controlla che la cartella in ServerStorage si chiami DialogueItems e che contenga un Tool (non un Model né una Part) con il nome esattamente uguale a item della scelta. Finché non lo correggi, Guide risponde con la battuta hasTorch, perché l'azione non è riuscita.
Nell'Output c'è scritto DialogueService: no action named ...
L'action della scelta non corrisponde a nessuna chiave della tabella ACTIONS. I nomi distinguono maiuscole e minuscole: heal non è Heal.
Farlo con RoCode
Se ti viene più facile descrivere l'NPC che costruirlo a mano, RoCode può scrivere questi script direttamente nel place che hai aperto. È un agente IA indipendente per Roblox Studio, non di Roblox: scrivi in una chat web e il suo plugin per Studio crea e modifica gli script nel tuo Explorer.
Fai parlare il modello Guide in Workspace.NPCs: un prompt Talk, una finestra di dialogo con battute che si scrivono da sole e pulsanti per le scelte, un fumetto sopra la testa, una scelta che cura con un cooldown di 30 secondi e una scelta che dà una sola volta lo strumento Torch da ServerStorage. Tieni la conversazione in un ModuleScript e dai tutte le ricompense sul server.
- Può prima esaminare il modello con Get Properties per leggere valori chiave come Anchored delle sue parti e WalkSpeed del suo Humanoid. Scrivi / nella chat per allegare il percorso esatto del modello
- Scrive il ModuleScript DialogueData, lo Script DialogueService e il LocalScript DialogueClient con Create Script
- Ha l'istruzione di verificare che ogni script scritto compili con Check Script, che lo compila in Studio senza eseguirlo
- Invia le modifiche a blocchi, e ogni blocco è un punto di annullamento nella cronologia di Studio
Con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o successivo può guidare un personaggio di prova per controllare che il gioco funzioni, ma durante il gioco non fa screenshot, quindi avvicinati all'NPC e parlaci tu. Se qualcosa non funziona come dovrebbe, racconta a RoCode cosa hai visto: Check Output può leggere le righe Server e Client del tuo ultimo playtest. Un NPC che parla è un sistema tra tanti; la pagina come creare un gioco Roblox con l'IA, un sistema per prompt mostra come si mettono insieme. Come RoCode si collega a Studio.
Domande frequenti
Come si fa un NPC che parla in Roblox Studio?
Aggiungi all'NPC un ProximityPrompt e, quando il giocatore lo attiva, mostra la battuta dell'NPC in una finestra di dialogo, in un fumetto o in entrambi. I tre script di questa guida fanno l'una e l'altra cosa e aggiungono le scelte di risposta. Se ti serve solo il fumetto, chiama TextChatService:DisplayBubble(npc.Head, "Hello!") da un LocalScript quando scatta il prompt, come nell'esempio con un NPC nella pagina di Roblox sulla bubble chat.
Cosa scegliere: l'oggetto Dialog o una GUI di dialogo personalizzata?
L'oggetto Dialog non richiede codice e mostra un fumetto cliccabile, che basta per un testo decorativo. Il suo evento di scelta scatta solo sul dispositivo del giocatore, quindi non può dare ricompense in modo sicuro, e per impostazione predefinita può parlarci un solo giocatore alla volta. Una finestra personalizzata, come in questa guida, permette al server di dare ogni ricompensa e dà a ogni giocatore la sua conversazione.
Come faccio a dare un oggetto a un giocatore da un NPC?
Tieni il Tool in ServerStorage e fai in modo che uno Script sul server lo cloni nel Backpack del giocatore quando sceglie quell'opzione, come fa l'azione GiveItem. Controlla che il giocatore non lo abbia già e disattiva CanBeDropped sulla copia, così non può buttarla via e chiederla di nuovo. Non lasciare mai che il dispositivo del giocatore dica quale oggetto dare.
Come si fa una finestra di dialogo con l'effetto macchina da scrivere?
Metti tutta la battuta in una TextLabel, aumenta il suo MaxVisibleGraphemes da 0 di qualche carattere alla volta e alla fine impostalo a -1 per mostrare tutto. La pagina di Roblox sulle animazioni della UI usa la stessa proprietà insieme a utf8.graphemes. DialogueClient calcola quanti caratteri mostrare dal tempo trascorso, 45 al secondo, quindi la velocità non dipende dal frame rate.
Due giocatori possono parlare con lo stesso NPC nello stesso momento?
Con gli script di questa guida sì: il server gestisce una conversazione per giocatore e ogni giocatore vede solo la propria finestra. L'oggetto Dialog integrato funziona diversamente: con il suo BehaviorType predefinito, SinglePlayer, parla un giocatore alla volta e gli altri vedono le sue scelte.
Devo filtrare il testo dei dialoghi degli NPC?
Le battute che hai scritto tu no. Roblox ti rende responsabile del filtraggio del testo mostrato che non controlli direttamente, per esempio quello che scrivono i giocatori, parole composte da caratteri casuali o testo caricato da un sito esterno. Se l'NPC ripete qualcosa scritto da un giocatore, filtra quella parte.
Fonti e letture
- Roblox Creator Docs: Proximity prompts (in inglese). creare prompt, MaxActivationDistance e RequiresLineOfSight
- Roblox Engine API: ProximityPrompt (in inglese). dove funziona il prompt, il suo testo e i tasti predefiniti, Triggered e il controllo della linea di vista
- Roblox Creator Docs: Securing the client-server boundary (in inglese). ProximityPrompt come superficie di attacco, controlli di distanza e permessi
- Roblox Engine API: Dialog (in inglese). BehaviorType e l'evento DialogChoiceSelected solo lato client
- Roblox Engine API: TextChatService:DisplayBubble (in inglese). fumetti con le battute per gli NPC dagli script client
- Roblox Creator Docs: Customize bubble chat (in inglese). fumetti degli NPC e BubbleChatConfiguration
- Roblox Creator Docs: Text filtering (in inglese). quale testo mostrato va filtrato
- Roblox Creator Docs: UI animation and tweens (in inglese). effetto macchina da scrivere con MaxVisibleGraphemes
- Roblox Engine API: Tool.CanBeDropped (in inglese). cosa fa Backspace con uno strumento
- Roblox Engine API: UserInputService.PreferredInput (in inglese). come riconoscere un giocatore con il gamepad
- Roblox Creator Docs: Rig Generator (in inglese). inserire un rig R15 o R6
Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.