Tutorial · Sistemi di gioco

Come fare i dialoghi degli NPC in Roblox Studio

Un dialogo con un NPC in Roblox è fatto di tre parti: un prompt per iniziare a parlare, una finestra che mostra le parole dell'NPC e i pulsanti con le risposte del giocatore, e uno script che decide a cosa porta ogni risposta. In questa guida le costruiamo tutte e tre: scrivi la conversazione come una semplice tabella, i giocatori premono E per parlare, e tutto ciò che una risposta dà (una cura, un oggetto) lo dà il server, non il dispositivo del giocatore.

Aggiornato il 20 novembre 202623 min di letturaScritto da

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 DialogChoiceSelected dell'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 servizio Chat è 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
  1. Come funziona
  2. 1. Aggiungere l'NPC
  3. 2. Conversazione
  4. 3. Script server
  5. 4. Finestra di dialogo
  6. Azioni personalizzate
  7. Altri tutorial
  8. Limiti della protezione
  9. 5. Prova
  10. Ampliamenti
  11. Common errors
  12. Con RoCode
  13. Domande frequenti
  14. Fonti e letture

Come funziona un dialogo con un NPC

IllustrazioneOgni battuta si scrive nella finestra mentre è visibile per intero nel fumetto, le scelte appaiono quando la battuta è scritta e il server dà la Torch quando scegli "Got anything for the cave?".

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ì:

  1. Il giocatore si avvicina all'NPC e preme E sul suo prompt Talk. L'evento Triggered del prompt scatta sul server con quel giocatore.
  2. Lo script server controlla che il giocatore sia abbastanza vicino, ricorda che si trova sulla battuta chiamata start e invia il testo di quella battuta e le etichette delle sue scelte solo a quel giocatore.
  3. Il LocalScript scrive la battuta nella finestra di dialogo, mostra un fumetto sopra l'NPC, poi aggiunge un pulsante per ogni scelta.
  4. Il giocatore clicca, tocca o seleziona una scelta. Al server torna solo il suo numero.
  5. 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.
Di cosa è fatto un NPC che parla
ElementoDove si trovaCosa fa
Rig GuideWorkspace, in una cartella chiamata NPCsL'NPC vero e proprio. Il suo nome sceglie la conversazione e compare sul prompt.
ModuleScript DialogueDataReplicatedStorageTutte le battute che l'NPC può dire, le scelte sotto ogni battuta e dove porta ogni scelta.
Script DialogueServiceServerScriptServiceAggiunge il prompt Talk, ricorda a quale battuta è ogni giocatore, controlla ogni clic ed esegue le azioni.
RemoteEvent DialogueEventReplicatedStorage (lo crea DialogueService)Porta ogni battuta al giocatore e il numero della scelta fatta di nuovo al server.
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsDisegna la finestra, scrive la battuta, mostra il fumetto e i pulsanti delle scelte.
Tool Torch (facoltativo)ServerStorage, in una cartella chiamata DialogueItemsL'oggetto che dà una delle scelte. Niente in ServerStorage viene inviato ai giocatori.
L'Explorer quando l'NPC è pronto. Quando il gioco è avviato, DialogueService aggiunge un RemoteEvent chiamato DialogueEvent in ReplicatedStorage e un ProximityPrompt Talk chiamato TalkPrompt nell'HumanoidRootPart di ogni NPC.
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

  1. 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.
  2. Rinominalo Guide. Il nome conta: DialogueService cerca la conversazione in base al nome del modello e il prompt lo mostra ai giocatori.
  3. 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.
  4. 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.
  5. Facoltativo, per la scelta con l'oggetto: passa il mouse su ServerStorage e inserisci un Folder chiamato DialogueItems. Mettici dentro un Tool chiamato Torch con una sola Part non ancorata chiamata Handle, 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
-- 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 battuta start.
  • text è ciò che dice l'NPC. choices sono i pulsanti del giocatore, in ordine. Nella finestra c'è posto per quattro.
  • next indica la battuta da mostrare dopo questa scelta. Una scelta senza next, come "Bye!", chiude la conversazione. Anche un next o un failNext che indica una battuta assente dalla tabella la chiude, con un avviso nell'Output.
  • action indica cosa fa il server, dalla tabella ACTIONS in DialogueService: qui Heal o GiveItem.
  • item serve per GiveItem: è il nome del Tool in ServerStorage, DialogueItems.
  • failNext è la battuta mostrata al posto di next quando l'azione non è riuscita, così l'NPC non dichiara mai una cura o un regalo che non ci sono stati.
La conversazione di Guide, battuta per battuta
BattutaGuide diceScelte 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
-- 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.

Impostazioni all'inizio di DialogueService
ImpostazioneValore quiCosa cambia
TALK_DISTANCE12Quanto 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_CHOICES0.3Il 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_SECONDS30Quanto 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:

Cosa controlla DialogueService a ogni clic
ControlloCodiceSe non lo supera
Il giocatore è in una conversazioneconversations[player]Il clic viene ignorato.
La scelta è un numero interotypeof e math.floorIgnorato. Stringhe, tabelle, decimali e NaN si fermano qui.
0 significa che il giocatore ha premuto XchoiceIndex == 0La conversazione finisce.
Vivo e ancora entro 16 stud (12 più 4)isCloseLa conversazione finisce e la finestra si chiude.
Almeno 0.3 secondi dall'ultimo clic accettatoconversation.lastChoiceViene rimandata la stessa battuta, così la finestra riceve pulsanti nuovi invece di aspettare per sempre.
La scelta esiste sulla battuta che questo giocatore sta leggendoline.choices[choiceIndex]Ignorato.
L'azione ha funzionatoogni azione restituisce true o falseAl 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
-- 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 usa TextScaled, che rimpicciolisce il testo per farlo stare nella sua etichetta sullo schermo piccolo di un telefono, e UITextSizeConstraint gli impedisce di superare i 20 pixel su uno schermo grande. UIGridLayout dispone 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 MaxVisibleGraphemes decide quanti caratteri sono visibili; è la stessa proprietà che usa l'esempio di macchina da scrivere di Roblox insieme a utf8.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 lineNumber impedisce 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. Activated scatta con un clic del mouse, un tocco sul telefono e il pulsante A del gamepad. Un gamepad può premere solo il pulsante selezionato, quindi quando PreferredInput dice che il giocatore usa un gamepad, lo script seleziona la prima scelta tramite GuiService.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:

  1. Aggiungi in ACTIONS una voce chiamata StartQuest. Prima il controllo, poi la modifica: se player:GetAttribute("Quest") è già impostato, restituisci false; altrimenti chiama player:SetAttribute("Quest", "Cave") e restituisci true.
  2. In DialogueData dai alla scelta action = "StartQuest", una battuta next per il caso di successo e una battuta failNext per il caso di fallimento, per esempio "You are already on a quest."
  3. 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 compare DialogueService: no action named StartQuest e la conversazione passa alla battuta failNext.

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.

Trucchi frequenti nei tutorial sui dialoghi NPC e cosa fa questa guida al loro posto
TutorialProblemaQuesta guida
Usa l'oggetto Dialog e uno Script sul server ascolta DialogChoiceSelected per dare la ricompensaIl 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 LocalScriptUna 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 successivaUn 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 è scattatoLa 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 cicloIl 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.

Cosa può provare un cheater e cosa ne fa DialogueService
Il cheater prova aRisultatoPerché
Attivare il prompt Talk dall'altro capo della mappaNon succede nullastartConversation controlla che non sia oltre 16 stud (12 più 4).
Inviare la scelta 99, una stringa, un decimale o NaNIgnoratoNon è un numero intero, oppure quella scelta non esiste sulla battuta che sta leggendo.
Inviare il nome di una ricompensa o l'id di una battutaMai lettoIl 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 reteUn clic ogni 0.3 secondi per conversazioneAi 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 parlareImpossibileGli oggetti si danno solo tramite una scelta sulla battuta a cui il server sa che si trova il giocatore.
Accumulare un mucchio di torceUna alla voltaIl 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 curaUna cura ogni 30 secondiIl cooldown è salvato sul server per ogni giocatore e l'NPC lo comunica con la battuta healTooSoon.
Allontanarsi lasciando la finestra apertaSi chiude entro mezzo secondoIl server controlla ogni conversazione aperta due volte al secondo.
Leggere tutta la conversazione, comprese le battute a cui non è arrivatoPossibileDialogueData 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

  1. Premi Play (F5) e avvicinati a Guide. Entro 12 stud compare il prompt Talk con il nome di Guide. Premi E.
  2. 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.
  3. Scegli "Any tips?", poi "Anything else?": sei di nuovo sulla prima battuta. Scegli "Bye!": la finestra si chiude e il prompt Talk ritorna.
  4. 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.
  5. 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à.
  6. Inizia una conversazione e allontanati. La finestra si chiude più o meno quando ti trovi a 16 stud da Guide.
  7. 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.
  8. 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.
  9. 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.

Tu scrivi

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.

RoCode fa
  • 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

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.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.