Pe scurt
Pune modelul NPC-ului într-un folder NPCs din Workspace și scrie-i conversația într-un ModuleScript din ReplicatedStorage: fiecare replică are textul NPC-ului și o listă de variante care duc la altă replică. Un Script în ServerScriptService îi adaugă fiecărui NPC un ProximityPrompt ("Talk"), ține minte la ce replică e fiecare jucător și o trimite printr-un RemoteEvent. Un LocalScript arată textul și câte un buton pentru fiecare variantă, iar înapoi trimite doar numărul butonului apăsat.
- Dă recompensele pe server. Evenimentul
DialogChoiceSelectedal obiectului integrat Dialog se declanșează doar pe client, așa că un Script de server nu-l aude niciodată, iar o vindecare sau un obiect dat într-un LocalScript schimbă doar copia jocului de la acel jucător. - Arată balonul cu replica prin
TextChatService:DisplayBubble(npc.Head, text)dintr-un LocalScript. Vechiul serviciuChate învechit, în locul lui se folosește TextChatService. - Replicile scrise de tine nu trebuie filtrate. Regula Roblox: filtrezi orice text afișat pe care nu îl controlezi direct, de exemplu ce scriu jucătorii.
Pe această pagină
Cum funcționează un dialog cu NPC
Un NPC care vorbește și funcționează într-un joc real e împărțit între server și dispozitivul fiecărui jucător. Dispozitivul desenează fereastra și butoanele. Serverul, singura parte în care poți avea încredere, știe ce replică citește fiecare jucător și decide ce face fiecare răspuns. O tură a conversației arată așa:
- Jucătorul se apropie de NPC și apasă E pe promptul lui Talk. Evenimentul
Triggeredal promptului se declanșează pe server cu acest jucător. - Scriptul de server verifică dacă jucătorul e destul de aproape, ține minte că e la replica numită
startși îi trimite doar acestui jucător textul replicii și etichetele variantelor ei. - LocalScript-ul scrie replica în fereastra de dialog, arată balonul deasupra NPC-ului, apoi adaugă câte un buton pentru fiecare variantă.
- Jucătorul dă clic, atinge sau alege o variantă. La server se întoarce doar numărul ei.
- Serverul găsește acest număr pe replica pe care știe că o citește jucătorul, execută acțiunea variantei, dacă există (vindecare, obiect), și trimite replica următoare sau închide fereastra.
| Element | Unde se află | Ce face |
|---|---|---|
Rigul Guide | Workspace, într-un folder numit NPCs | NPC-ul însuși. Numele lui alege conversația și apare pe prompt. |
ModuleScript DialogueData | ReplicatedStorage | Toate replicile pe care le poate spune NPC-ul, variantele de sub fiecare replică și unde duce fiecare variantă. |
Script DialogueService | ServerScriptService | Adaugă promptul Talk, ține minte la ce replică e fiecare jucător, verifică fiecare clic și execută acțiunile. |
RemoteEvent DialogueEvent | ReplicatedStorage (îl creează DialogueService) | Duce fiecare replică la jucător, iar numărul variantei alese înapoi la server. |
LocalScript DialogueClient | StarterPlayer, StarterPlayerScripts | Desenează fereastra, scrie replica, arată balonul și butoanele variantelor. |
Tool Torch (opțional) | ServerStorage, într-un folder numit DialogueItems | Obiectul pe care îl dă una dintre variante. Nimic din ServerStorage nu se trimite jucătorilor. |
Workspace
NPCs Folder new
Guide Model new
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (părți ale corpului)
ReplicatedStorage
DialogueData ModuleScript new
ServerScriptService
DialogueService Script new
ServerStorage
DialogueItems Folder new
Torch Tool new
Handle Part new
StarterPlayer
StarterPlayerScripts
DialogueClient LocalScript new
Pasul 1: adaugă NPC-ul
- În fila Avatar sau Home apasă Character ca să deschizi Rig Generator. Alege R15, forma corpului și stilul. În Workspace apare un rig numit
Rig. Un rig R6 merge cu aceleași scripturi. - Redenumește-l în
Guide. Numele contează: DialogueService caută conversația după numele modelului, iar promptul îl arată jucătorilor. - Deschide rigul, selectează-i HumanoidRootPart-ul și bifează Anchored în fereastra Properties. Un part ancorat nu se mișcă niciodată din cauza fizicii, așa că NPC-ul stă unde l-ai pus, iar jucătorii nu-l pot împinge.
- Treci cu mouse-ul peste Workspace în Explorer, apasă butonul + și inserează un Folder numit
NPCs. Trage în el Guide și pune rigul unde pot ajunge jucătorii. - Opțional, pentru varianta cu obiect: treci cu mouse-ul peste ServerStorage și inserează un Folder numit
DialogueItems. Pune în el un Tool numitTorchcu un singur Part neancorat numitHandle, part-ul pe care personajul îl ține în mână. Un PointLight în Handle îl face să lumineze.
Numele țin cont de majuscule, așa că scrie NPCs, Guide, DialogueItems și Torch exact cum sunt arătate. NPC-ul poate fi orice model cu Humanoid și HumanoidRootPart, inclusiv din Toolbox, dacă stă direct în folderul NPCs.
Pasul 2: scrie conversația
Treci cu mouse-ul peste ReplicatedStorage, inserează un ModuleScript numit DialogueData și lipește în el acest cod. Nu are logică, doar cuvinte și legăturile dintre ele, așa că pe acest fișier îl vei edita cel mai des.
-- ModuleScript în ReplicatedStorage cu numele DialogueData.
-- Toate conversațiile, după numele NPC-ului din Workspace.NPCs. Fiecare replică are
-- textul NPC-ului și variantele de răspuns ale jucătorului. O variantă poate duce la altă replică (next),
-- poate încheia conversația (fără next) și îi poate cere serverului să facă ceva (action). Dacă serverul
-- nu poate executa acțiunea, arată replica failNext în loc de next.
export type Choice = {
text: string,
next: string?, -- replica de arătat după această variantă; nil încheie conversația
action: string?, -- o acțiune de server din tabelul ACTIONS din DialogueService
item: string?, -- pentru acțiunea GiveItem: numele Tool-ului din ServerStorage.DialogueItems
failNext: string?, -- replica de arătat în loc de next când acțiunea nu a putut fi executată
}
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
Rândurile export type de la început descriu cum arată o replică și o variantă. În timpul jocului nu schimbă nimic; îți descriu datele, ca verificarea de tipuri să le poată verifica.
Cum sunt legate părțile între ele:
- Fiecare NPC are un tabel numit după modelul lui din folderul NPCs, aici
Guide. Fiecare conversație începe cu replicastart. texte ce spune NPC-ul.choicessunt butoanele jucătorului, în ordine. Fereastra are loc pentru patru.nextnumește replica de arătat după această variantă. O variantă fărănext, de exemplu "Bye!", încheie conversația. Unnextsau unfailNextcare numește o replică ce lipsește din tabel o încheie și el, cu un avertisment în Output.actionnumește ce face serverul, din tabelulACTIONSdin DialogueService: aici eHealsauGiveItem.iteme pentru GiveItem: numele Tool-ului din ServerStorage, DialogueItems.failNexte replica arătată în loc denextcând acțiunea nu a putut fi executată, ca NPC-ul să nu pretindă niciodată o vindecare sau un cadou care nu au avut loc.
| Replică | Guide spune | Variante și unde duc |
|---|---|---|
start | "Welcome to the village! What can I do for you?" | "Any tips?" duce la tips. "I'm hurt. Can you help?" vindecă, apoi healed (sau healTooSoon). "Got anything for the cave?" dă Torch, apoi torch (sau hasTorch). "Bye!" încheie conversația. |
tips | "Stay off the red bricks, and come back if you get hurt." | "Anything else?" duce înapoi la start. "Thanks!" încheie conversația. |
healed | "There you go, good as new." | "Thank you!" încheie conversația. |
torch | "Take this torch. The cave is dark." | "Thanks!" încheie conversația. |
healTooSoon | "I healed you a moment ago. Come back in a little while." | "OK" încheie conversația. |
hasTorch | "You already have my torch. Keep it lit!" | "Will do!" încheie conversația. |
Acest modul îl citește doar serverul. LocalScript-ul nu-i face niciodată require: serverul trimite fiecare replică când jucătorul ajunge la ea. Dar un modul din ReplicatedStorage se copiază totuși pe dispozitivul fiecărui jucător, așa că, dacă în conversație sunt spoilere (să zicem, răspunsul la o ghicitoare), mută DialogueData în ServerStorage. Apoi, în rândul cu require din DialogueService, înlocuiește ReplicatedStorage cu ServerStorage, ca tot rândul să arate așa: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.
Pasul 3: adaugă scriptul de server
Treci cu mouse-ul peste ServerScriptService, inserează un Script numit DialogueService și lipește în el codul de mai jos. E singurul loc unde conversația avansează și singurul loc unde se dă o recompensă.
-- Script în ServerScriptService cu numele DialogueService.
-- Adaugă un prompt Talk fiecărui NPC din Workspace.NPCs și conduce fiecare conversație.
-- Dispozitivul jucătorului doar arată textul și trimite înapoi numărul variantei
-- pe care a dat clic. Serverul știe la ce replică e fiecare jucător, verifică varianta
-- și distanța și doar el vindecă sau dă obiecte.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Aceleași forme ca în DialogueData, ca verificarea de tipuri din Studio să le cunoască și aici
type Choice = { text: string, next: string?, action: string?, item: string?, failNext: string? }
type Line = { text: string, choices: { Choice } }
local DialogueData = require(ReplicatedStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }
local TALK_DISTANCE = 12 -- studs: raza promptului și cât de aproape trebuie să rămână jucătorul
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30
local npcFolder = workspace:WaitForChild("NPCs")
local itemFolder = ServerStorage:FindFirstChild("DialogueItems")
-- Scriptul acesta creează singur DialogueEvent, așa că nu-l adăuga manual
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 -- nu are personaj, e mort sau NPC-ul a dispărut
end
-- o mică rezervă, pentru că poziția jucătorului ajunge la server cu o mică întârziere
return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end
-- Ce face serverul când o variantă are o acțiune. Fiecare returnează true dacă s-a executat.
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 -- a fost vindecat prea recent
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 -- încă nu are rucsac sau are deja obiectul
end
local item = template:Clone() :: Tool
item.CanBeDropped = false -- ca nimeni să nu-l poată arunca și să ceară încă unul
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 -- vorbește deja, acest NPC nu are replica "start", e mort sau e prea departe
end
local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
conversations[player] = conversation
showLine(player, conversation)
end
-- Jucătorul a dat clic pe varianta cu numărul choiceIndex (0 înseamnă că a închis fereastra)
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
-- Prea repede. Trimitem din nou aceeași replică, pentru că fereastra a blocat deja
-- butoanele după clic și altfel ar aștepta un răspuns la nesfârșit.
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 -- pe replica pe care o citește acest jucător nu există o astfel de variantă
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 -- de exemplu "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)
-- Promptul Talk pe fiecare 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() -- o copie a NPC-ului aduce un prompt vechi pe care nu-l ascultă nimeni
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)
-- Închidem fereastra tuturor celor care au plecat sau au murit în mijlocul conversației
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 creează singur RemoteEvent-ul DialogueEvent la pornirea jocului, așa că nu trebuie să inserezi nimic manual în ReplicatedStorage. Dacă ai creat deja un RemoteEvent cu acest nume, șterge-l: LocalScript-ul l-ar putea găsi pe al tău, pe care nu-l ascultă nimeni pe server.
| Setare | Valoarea aici | Ce schimbă |
|---|---|---|
TALK_DISTANCE | 12 | Cât de aproape, în studs, trebuie să fie jucătorul ca să apară promptul Talk. Serverul îl lasă să se îndepărteze încă 4 studs înainte să închidă fereastra, pentru că poziția jucătorului ajunge la server cu o mică întârziere. |
MIN_SECONDS_BETWEEN_CHOICES | 0.3 | Cel mai scurt timp între două clicuri pe care îl acceptă serverul. La un clic mai rapid se trimite din nou aceeași replică în locul unui răspuns. |
HEAL_COOLDOWN_SECONDS | 30 | Cât așteaptă fiecare jucător între vindecările acțiunii Heal. |
Serverul ține în conversations câte o intrare pe jucător: cu ce NPC vorbește, ce replică citește și când a fost acceptat ultimul lui clic. Când se declanșează promptul Talk, startConversation creează această intrare doar dacă jucătorul nu vorbește deja, NPC-ul are o replică start, iar jucătorul e viu și în rază. După asta, fiecare clic trece prin aceste verificări:
| Verificare | Cod | Dacă nu trece |
|---|---|---|
| Jucătorul e într-o conversație | conversations[player] | Clicul e ignorat. |
| Varianta e un număr întreg | typeof și math.floor | E ignorată. Șirurile, tabelele, fracțiile și NaN se opresc aici. |
| 0 înseamnă că jucătorul a apăsat X | choiceIndex == 0 | Conversația se încheie. |
| E viu și încă la cel mult 16 studs (12 plus 4) | isClose | Conversația se încheie, iar fereastra se închide. |
| Cel puțin 0.3 secunde de la ultimul clic acceptat | conversation.lastChoice | Se trimite din nou aceeași replică, așa că fereastra primește butoane proaspete în loc să aștepte la nesfârșit. |
| Varianta există pe replica pe care o citește acest jucător | line.choices[choiceIndex] | E ignorată. |
| Acțiunea a reușit | fiecare acțiune returnează true sau false | În loc de next se arată replica failNext. |
Promptul se pune pe HumanoidRootPart-ul NPC-ului, pentru că un ProximityPrompt funcționează când stă într-un part (sau Attachment, sau model cu PrimaryPart) din Workspace. RequiresLineOfSight-ul lui e activat implicit și ascunde promptul de fiecare dată când ceva blochează vederea de la cameră la acel part. Roblox exclude part-ul propriu al promptului din această verificare, dar nu și restul corpului, iar HumanoidRootPart e în interiorul torsului, așa că scriptul dezactivează verificarea liniei de vedere. Promptul se numește TalkPrompt, iar scriptul șterge orice TalkPrompt aflat deja pe part înainte să-l adauge pe al lui: o copie a NPC-ului făcută în timpul jocului vine cu promptul originalului, pe care nu-l ascultă nimeni. Dacă în DialogueData nu există o conversație cu replica start pentru numele NPC-ului, în Output apare un avertisment cu numele acelui NPC.
O buclă verifică de două ori pe secundă fiecare conversație deschisă și o închide când jucătorul s-a îndepărtat la peste 16 studs sau personajul lui a murit, ca un jucător mort în mijlocul conversației să nu reapară cu fereastra deschisă. PlayerRemoving curăță ambele tabele când iese cineva.
Pasul 4: adaugă fereastra de dialog
Deschide StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts, inserează un LocalScript numit DialogueClient și lipește în el acest cod. Construiește fereastra de dialog în cod, așa că nu trebuie să desenezi manual un GUI.
-- LocalScript în StarterPlayer > StarterPlayerScripts cu numele DialogueClient.
-- Desenează conversația trimisă de server: numele NPC-ului, replica lui, scrisă literă
-- cu literă, un balon deasupra capului și câte un buton pentru fiecare variantă. Un clic pe
-- o variantă trimite doar numărul ei; ce urmează decide serverul.
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)
-- Fereastra de dialog, construită în cod
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) -- cu 84 de pixeli mai sus, ca bara de instrumente Roblox să nu acopere variantele
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 -- o replică lungă se micșorează ca să încapă pe ecranul mic al unui telefon
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- și nu devine niciodată mai mare de 20 de pixeli pe unul mare
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 -- crește cu fiecare replică nouă, ca vechea buclă de scriere să se oprească
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 -- se schimbă doar pe acest dispozitiv
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()
-- Balonul deasupra NPC-ului (DisplayBubble merge doar într-un LocalScript)
local head = npc:FindFirstChild("Head")
if head then
TextChatService:DisplayBubble(head, text)
end
-- Scriem replica literă cu literă. Numărul se calculează din timpul trecut,
-- așa că viteza e aceeași la orice frecvență de cadre.
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 -- această replică a fost înlocuită de una mai nouă sau de o închidere
end
shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
lineLabel.MaxVisibleGraphemes = shown
end
lineLabel.MaxVisibleGraphemes = -1
-- Câte un buton pe variantă; serverul primește doar numărul butonului
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 pe replică
dialogueEvent:FireServer(index)
end
end)
if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
GuiService.SelectedObject = button -- ca varianta să poată fi aleasă cu gamepad-ul
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)
Culorile, mărimile și LETTERS_PER_SECOND le poți schimba cum vrei. Ultimele două handler-e lasă-le cum sunt: sunt singurul mod în care fereastra comunică cu serverul.
Ce face fiecare parte din DialogueClient:
- Fereastra. Un ScreenGui cu un Frame fixat jos, în centrul ecranului, 60% din lățimea lui și 34% din înălțime, cu o limită de 720 pe 300 de pixeli prin
UISizeConstraint, ca să nu se întindă pe tot un monitor lat. Replica NPC-ului foloseșteTextScaled, care micșorează textul ca să încapă în eticheta lui pe ecranul mic al unui telefon, iarUITextSizeConstraintnu-l lasă să crească peste 20 de pixeli pe unul mare.UIGridLayoutașază variantele două câte două.ResetOnSpawne false, pentru că acest LocalScript rulează o dată pe sesiune: o fereastră ștearsă la respawn nu ar mai reveni. - Efectul de mașină de scris. Toată replica intră deodată în TextLabel, iar
MaxVisibleGraphemesdecide câte caractere se văd; e aceeași proprietate pe care o folosește exemplul propriu de mașină de scris al Roblox, împreună cuutf8.graphemes. Roblox așază textul ca și cum toate caracterele ar fi vizibile, așa că cuvintele nu sar pe un rând nou și nu își schimbă mărimea pe măsură ce apar. Scriptul calculează câte caractere să arate din timpul trecut, 45 pe secundă, așa că viteza e aceeași la orice frecvență de cadre, apoi setează proprietatea la -1, ceea ce arată tot. - Butoanele. Apar când replica e scrisă. Fiecare trimite doar numărul lui și o singură dată: verificarea
lineNumberîmpiedică un dublu clic să trimită de două ori, iar apoi fereastra așteaptă următoarea replică de la server. - Balonul cu replica.
TextChatService:DisplayBubble(head, text)pune replica într-un balon de chat deasupra Head-ului NPC-ului. Roblox permite asta doar în scripturile de client, iar bubble chat e activat implicit. Balonul îl desenează dispozitivul acestui jucător, așa că doar el îl vede. - Promptul. Cât jucătorul vorbește, copia lui a promptului Talk (găsită după numele TalkPrompt) e dezactivată, ca să nu stea peste conversație. Ceilalți jucători își văd în continuare propriile prompturi.
- Orice dispozitiv.
Activatedse declanșează la un clic de mouse, o atingere pe telefon și butonul A de pe gamepad. Un gamepad poate apăsa doar butonul selectat, așa că, atunci cândPreferredInputspune că jucătorul folosește gamepad, scriptul selectează prima variantă prinGuiService.SelectedObject. - Butonul X. Trimite 0, pe care serverul îl înțelege ca „încheie conversația”, și închide imediat fereastra.
Adaugă propriile acțiuni
O acțiune e o funcție din tabelul ACTIONS de la începutul DialogueService. Primește jucătorul și varianta și returnează true când și-a făcut treaba. Ca să adaugi una proprie, să zicem un quest dat de NPC:
- Adaugă în
ACTIONSo intrare numităStartQuest. Întâi verificarea, apoi schimbarea: dacăplayer:GetAttribute("Quest")e deja setat, returneazăfalse; altfel apeleazăplayer:SetAttribute("Quest", "Cave")și returneazătrue. - În DialogueData dă-i variantei
action = "StartQuest", o replicănextpentru reușită și o replicăfailNextpentru eșec, de exemplu "You are already on a quest." - Apasă Play și alege varianta de două ori. Dacă numele din DialogueData nu se potrivește cu cheia din
ACTIONS(majusculele contează), în Output apareDialogueService: no action named StartQuest, iar conversația trece la replicafailNext.
Reguli pentru scrierea acțiunilor:
- Fă verificarea și schimbarea în interiorul acțiunii, pe server. Singurul lucru pe care îl trimite dispozitivul jucătorului e numărul variantei.
- Ce îi trebuie acțiunii citește din variantă (ca
item) sau din starea proprie a serverului, dar niciodată dintr-un remote. - Limitează tot ce e valoros în interiorul acțiunii înseși, la fel cum Heal își ține propriul cooldown de 30 de secunde în
lastHeal. Limita de 0.3 secunde pe clic doar încetinește clicurile; nu împiedică un jucător să treacă iar și iar prin aceeași variantă. - Ca să deschidă altă fereastră, de exemplu un magazin, o acțiune poate trimite un RemoteEvent acestui jucător și poate returna
true. Tot ce se întâmplă în acea fereastră are nevoie în continuare de propriile verificări pe server, ca în secțiunea NPC-ul vânzător.
Unde greșesc alte tutoriale despre dialoguri cu NPC
Dacă compari ghidul acesta cu un videoclip sau o postare de pe forum, iată diferențele importante și motivul pentru care fiecare truc creează o problemă.
| Tutorialul | Problema | Ghidul acesta |
|---|---|---|
Folosește obiectul Dialog, iar un Script de server ascultă DialogChoiceSelected ca să dea o recompensă | Referința Roblox spune că acest eveniment funcționează doar pe partea de client și nu se declanșează pe server, așa că recompensa nu vine niciodată. | Varianta ajunge la server ca număr, iar serverul dă singur recompensa. |
| Dă recompensa dintr-un LocalScript | O schimbare făcută de un LocalScript rămâne pe acel singur dispozitiv (vezi ce se replică), iar un trișor poate rula același cod oricând. | Toate acțiunile trăiesc în DialogueService. |
Face NPC-ul să vorbească prin game:GetService("Chat"):Chat(head, text) | Serviciul Chat e învechit, în locul lui se folosește TextChatService. | TextChatService:DisplayBubble într-un LocalScript. |
| Trimite de pe client numele recompensei sau id-ul replicii următoare | Un trișor poate trimite orice nume de obiect sau poate sări direct la replica ce dă o recompensă. | Clientul trimite doar numărul variantei. Serverul îl găsește pe replica pe care știe că o citește jucătorul. |
| Nu verifică nimic după declanșarea promptului | Ghidul de securitate Roblox pune ProximityPrompt alături de remote-uri ca ceva ce clienții pot folosi abuziv și recomandă să verifici înainte de acțiune dacă jucătorul e destul de aproape. | Distanța se verifică la începutul conversației, la fiecare clic și de două ori pe secundă cât e deschisă. |
Scrie textul prin wait() într-o buclă | Funcția globală wait e învechită, în locul ei se folosește task.wait. | Calculează numărul de litere vizibile din os.clock() și așteaptă prin task.wait(). |
Ce poate și ce nu poate falsifica un jucător
Consideră că un trișor controlează tot de pe dispozitivul lui. Îți poate citi LocalScript-urile și tot ce e în ReplicatedStorage, poate declanșa DialogueEvent cu orice argumente de oricâte ori și poate declanșa promptul Talk din cod, lucru despre care avertizează ghidul de securitate Roblox. DialogueService răspunde cu verificări pe server de același fel ca cele din secțiunea verificarea argumentelor RemoteEvent. Iată ce câștigă trișorul din asta.
| Trișorul încearcă | Rezultat | De ce |
|---|---|---|
| Să declanșeze promptul Talk de la celălalt capăt al hărții | Nu se întâmplă nimic | startConversation verifică dacă e la cel mult 16 studs (12 plus 4). |
| Să trimită varianta 99, un șir, o fracție sau NaN | E ignorat | Nu e un număr întreg sau o astfel de variantă nu există pe replica pe care o citește. |
| Să trimită numele unei recompense sau id-ul unei replici | Nu se citește niciodată | Serverul citește doar numărul variantei. Recompensele vin din câmpurile item și action ale copiei de pe server a replicii. |
| Să dea clic cât de repede permite rețeaua | Un clic la 0.3 secunde pe conversație | Clicurile mai rapide primesc înapoi propria replică. Încheierea și repornirea conversației ocolesc această așteptare, de aceea Heal și GiveItem își țin propriile limite. |
| Să ceară o torță fără conversație | Imposibil | Obiectele se dau doar printr-o variantă de pe replica la care serverul știe că e jucătorul. |
| Să adune o grămadă de torțe | Câte una | Serverul caută întâi Torch în Backpack-ul și personajul lui, iar torța dată nu poate fi aruncată, așa că nu poate fi farmată aruncând-o și cerând din nou. |
| Să facă spam cu replica de vindecare | O vindecare la 30 de secunde | Cooldown-ul e ținut pe server pentru fiecare jucător, iar NPC-ul îl anunță prin replica healTooSoon. |
| Să plece și să lase fereastra deschisă | Se închide în cel mult o jumătate de secundă | Serverul verifică de două ori pe secundă fiecare conversație deschisă. |
| Să citească toată conversația, inclusiv replicile la care nu a ajuns | Posibil | DialogueData stă în ReplicatedStorage, care se copiază pe fiecare dispozitiv. Mută-l în ServerStorage dacă e important (vezi pasul 2). |
Despre o limitare merită spus direct: un trișor care merge la Guide și alege variante primește exact același lucru ca un jucător cinstit. Serverul controlează cât de des și de unde, dar nu și cine. Tot ce e rar, de exemplu o recompensă pe care fiecare jucător o poate primi o singură dată, are nevoie de o verificare deținută de server, ca un atribut setat la primire sau un flag salvat într-un depozit de date.
Pasul 5: verifică
- Apasă Play (F5) și mergi la Guide. În raza de 12 studs apare promptul Talk cu numele Guide. Apasă E.
- Fereastra arată "Guide", scrie replica de bun venit și apoi arată patru butoane. Aceeași replică apare într-un balon deasupra capului NPC-ului.
- Alege "Any tips?", apoi "Anything else?": ești din nou la prima replică. Alege "Bye!": fereastra se închide, iar promptul Talk revine.
- Dă-ți întâi daune: apasă comutatorul Client/Server ca să treci pe Server, selectează Humanoid-ul personajului tău în Workspace, setează Health la 50 în fereastra Properties și comută înapoi pe Client. Personajele jucătorilor își refac 1% din MaxHealth în fiecare secundă, așa că vorbește imediat cu Guide și alege "I'm hurt. Can you help?": viața sare la maxim. Vorbește din nou în 30 de secunde și alege asta încă o dată: nu există vindecare, iar Guide spune că te-a vindecat acum un minut.
- Alege "Got anything for the cave?": Torch apare în hotbar. Echipează-l și apasă Backspace: rămâne în mână. Cere din nou: nu primești a doua torță, iar Guide spune că o ai deja.
- Începe o conversație și îndepărtează-te. Fereastra se închide cam când ajungi la 16 studs de Guide.
- Alege Server & Clients din lista derulantă a modurilor de test, setează 2 clienți și apasă Play. Ambii jucători pot vorbi cu Guide în același timp, fiecare la propria replică.
- Verifică gamepad-ul prin Controller Emulator (Controller în fila Emulation) în timpul unui playtest. Cu gamepad-ul emulat apropie-te și apasă butonul promptului (implicit ButtonX): când apar variantele, prima e deja selectată, iar A o apasă.
- Verifică ecranul de telefon prin Device Simulator din Studio (la momentul scrierii e beta: activează New Device Simulator în File, Beta Features și repornește Studio). Alege un telefon, apasă Rotate până ajunge în orientare orizontală, apasă Play, mergi la Guide și atinge promptul Talk. Alege "Any tips?": toată replica se vede deasupra butoanelor de variante, la nevoie cu text mai mic, și nu intră peste ele.
Ține tot acest timp fereastra Output deschisă (meniul Window, apoi Output). Când aceste scripturi funcționează, nu afișează nimic, așa că orice eroare roșie sau avertisment care începe cu DialogueService: e o problemă reală. Vezi Erori frecvente.
Cum extinzi
Mai mulți NPC și conversații mai lungi
Adaugă în folderul NPCs încă un rig cu numele lui, iar în DialogueData un tabel cu același nume și o replică start. DialogueService adaugă un prompt Talk fiecărui model din folder care are HumanoidRootPart, inclusiv celor adăugate în timpul jocului; o copie a unui NPC primește un prompt nou în locul celui cu care a fost copiată. Doi NPC cu același nume folosesc același tabel. Replicile se pot lega în orice ordine, iar o variantă poate duce înapoi la o replică anterioară, ca "Anything else?". Ține cel mult patru variante pe replică, pentru că fereastra le așază două câte două.
Replici care depind de progres
Ca să-i saluți altfel pe jucătorii care revin, alege prima replică după ce deține serverul. În startConversation alege-o prin local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", verifică dacă replica există, la fel cum scriptul verifică lines.start, și folosește firstLine în loc de "start" când creezi conversația. Setează atributul într-o acțiune și adaugă replica welcomeBack în tabelul lui Guide. Atributele trăiesc o sesiune; ca să ții minte jucătorul între vizite, salvează un flag într-un depozit de date, ca în tutorialul DataStore.
NPC-ul vânzător
Construiește un magazin după ghidul despre GUI-ul de magazin, apoi adaugă o acțiune OpenShop care trimite un RemoteEvent acestui jucător și returnează true, iar LocalScript-ul magazinului să-și deschidă fereastra când vine acest eveniment. Cumpărăturile trec în continuare prin verificările proprii ale magazinului pe server. Dacă se poate cumpăra doar lângă NPC, verifică distanța și în handler-ul de cumpărare, pentru că clientul poate declanșa remote-ul magazinului de oriunde.
NPC-uri care merg
Ca Guide să umble sau să urmeze jucătorii, ia ghidul de pathfinding pentru NPC-uri și scoate Anchored de pe HumanoidRootPart, ca să se poată mișca. Promptul Talk stă pe acest part, așa că se mișcă odată cu NPC-ul, iar verificările de distanță folosesc același part. Pune mersul pe pauză cât e deschisă o conversație, altfel fereastra se închide imediat ce NPC-ul se îndepărtează de jucător la peste 16 studs.
Chei, quest-uri și alte recompense
GiveItem dă orice Tool din DialogueItems, așa că un NPC poate da cheia pe care o verifică o ușă încuiată, ca în ghidul despre uși. Despre obiecte care fac ceva la folosire, de exemplu mâncare care vindecă, citește în ghidul despre inventar.
Sunete și cameră
Pentru un clip de voce sau un sunet scurt la fiecare replică, pune un Sound în Head-ul NPC-ului și redă-l din show în DialogueClient. Ca să îndrepți camera spre NPC cât vorbește, ghidul despre cutscene-uri arată cum preia un LocalScript controlul camerei și cum îl dă înapoi.
Erori frecvente și soluții
Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Cele mai multe probleme cu dialogul afișează acolo un avertisment sau apar din cauza unui nume care nu se potrivește.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("DialogueEvent")'
DialogueClient așteaptă remote-ul pe care îl creează DialogueService, deci DialogueService nu a ajuns până acolo. Verifică dacă e un Script, nu un LocalScript, dacă stă direct în ServerScriptService și nu e dezactivat. DialogueService așteaptă întâi DialogueData în ReplicatedStorage și folderul NPCs în Workspace, așa că lipsa lor sau o greșeală în nume îl oprește și ea; atunci Output arată un avertisment infinite yield de la DialogueService cu acel nume.
Deasupra NPC-ului meu nu apare promptul Talk
DialogueService adaugă prompturi doar modelelor care stau direct în Workspace, NPCs și au un part numit HumanoidRootPart. Verifică ambele condiții și apropie-te la mai puțin de 12 studs. Un rig din Toolbox poate să nu aibă acest part sau poate fi un obiect de alt tip, învelit într-un folder.
Promptul apare, dar apăsarea lui E nu face nimic
Serverul nu a găsit o conversație pentru acest NPC, iar la pornirea jocului Output arată DialogueService: no conversation with a start line for Guide in DialogueData cu numele NPC-ului tău. Tabelul din DialogueData trebuie să se numească exact ca modelul, inclusiv majusculele, și să conțină o replică start.
O variantă închide fereastra în loc să treacă la replica următoare
Output arată DialogueService: no line named tip for Guide in DialogueData cu numele tale: next-ul (sau failNext-ul) variantei numește o replică ce nu există în tabelul acestui NPC. Numele replicilor țin cont de majuscule, așa că verifică scrierea cu tabelul, aici e tips.
Fereastra merge, dar nu apare balonul cu replica
Balonul are nevoie de un part numit Head direct în modelul NPC-ului și de bubble chat activat: în Explorer selectează BubbleChatConfiguration de sub TextChatService și verifică dacă e bifat Enabled. Implicit e activat.
În Output scrie DialogueService: no Tool named Torch in ServerStorage.DialogueItems
Serverul nu a putut găsi obiectul. Verifică dacă folderul din ServerStorage se numește DialogueItems și dacă în el stă un Tool (nu un Model și nu un Part) cu numele exact ca în item-ul variantei. Până nu repari asta, Guide răspunde cu replica hasTorch, pentru că acțiunea a eșuat.
În Output scrie DialogueService: no action named ...
action-ul variantei nu se potrivește cu nicio cheie din tabelul ACTIONS. Numele țin cont de majuscule: heal nu e Heal.
Fă-o cu RoCode
Dacă îți e mai ușor să descrii NPC-ul decât să-l construiești manual, RoCode poate scrie aceste scripturi direct în place-ul pe care îl ai deschis. E un agent AI independent pentru Roblox Studio, nu de la Roblox: scrii în chatul web, iar pluginul lui pentru Studio creează și editează scripturile în Explorer-ul tău.
Fă ca modelul Guide din Workspace.NPCs să vorbească: un prompt Talk, o fereastră de dialog cu replici scrise literă cu literă și butoane de variante, un balon deasupra capului, o variantă de vindecare cu un cooldown de 30 de secunde și o variantă care dă o singură dată instrumentul Torch din ServerStorage. Ține conversația într-un ModuleScript și dă toate recompensele pe server.
- Poate studia întâi modelul prin Get Properties, ca să citească valori cheie precum Anchored la part-urile lui și WalkSpeed la Humanoid-ul lui. Scrie / în chat ca să atașezi calea exactă a modelului
- Scrie ModuleScript-ul DialogueData, Script-ul DialogueService și LocalScript-ul DialogueClient prin Create Script
- Are instrucțiuni să verifice compilarea fiecărui script scris prin Check Script, care îl compilează în Studio fără să-l ruleze
- Trimite modificările în loturi, iar fiecare lot e un punct de anulare în istoria Studio
Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un personaj de test ca să verifice că jocul funcționează, dar în timpul jocului nu face capturi de ecran, așa că mergi singur la NPC și vorbește cu el. Dacă ceva nu merge cum trebuie, spune-i lui RoCode ce ai văzut: Check Output poate citi rândurile Server și Client din ultimul tău playtest. Un NPC care vorbește e un sistem dintre multe; pagina cum creezi un joc Roblox cu AI, câte un sistem pe prompt arată cum se îmbină. Cum se conectează RoCode la Studio.
Întrebări frecvente
Cum faci un NPC care vorbește în Roblox Studio?
Adaugă-i NPC-ului un ProximityPrompt și, când jucătorul îl declanșează, arată replica NPC-ului într-o fereastră de dialog, într-un balon sau în amândouă. Cele trei scripturi din acest ghid fac ambele și adaugă variante de răspuns. Dacă îți trebuie doar balonul, apelează TextChatService:DisplayBubble(npc.Head, "Hello!") dintr-un LocalScript când se declanșează promptul, ca în exemplul cu NPC de pe pagina Roblox despre bubble chat.
Ce să aleg: obiectul Dialog sau un GUI de dialog propriu?
Obiectul Dialog nu are nevoie de cod și arată un balon pe care se poate da clic, ceea ce ajunge pentru text decorativ. Evenimentul lui de alegere se declanșează doar pe dispozitivul jucătorului, așa că nu poate da recompense în siguranță, iar implicit poate vorbi cu el un singur jucător odată. O fereastră proprie, ca în acest ghid, îi permite serverului să dea fiecare recompensă și îi dă fiecărui jucător propria conversație.
Cum îi dai unui jucător un obiect de la un NPC?
Ține Tool-ul în ServerStorage și lasă un Script de server să-l cloneze în Backpack-ul jucătorului când acesta alege varianta, cum face acțiunea GiveItem. Verifică dacă jucătorul nu îl are deja și dezactivează CanBeDropped la copie, ca să nu poată fi aruncată și cerută din nou. Nu lăsa niciodată dispozitivul jucătorului să spună ce obiect să dai.
Cum faci o fereastră de dialog cu efect de mașină de scris?
Pune toată replica într-un TextLabel, crește-i MaxVisibleGraphemes de la 0 câte câteva caractere odată, iar la final setează-l la -1 ca să arate tot. Pagina Roblox despre animația UI folosește aceeași proprietate împreună cu utf8.graphemes. DialogueClient calculează câte caractere să arate din timpul trecut, 45 pe secundă, așa că viteza nu depinde de frecvența cadrelor.
Pot doi jucători să vorbească cu același NPC în același timp?
Cu scripturile din acest ghid, da: serverul conduce câte o conversație pe jucător, iar fiecare jucător își vede doar propria fereastră. Obiectul integrat Dialog e construit altfel: cu BehaviorType-ul lui implicit, SinglePlayer, vorbește un singur jucător odată, iar ceilalți îi văd variantele.
Trebuie filtrat textul dialogului unui NPC?
Replicile scrise de tine, nu. Roblox îți dă responsabilitatea de a filtra textul afișat pe care nu îl controlezi direct, de exemplu ce scriu jucătorii, cuvinte compuse din caractere aleatorii sau text încărcat de pe un site extern. Dacă NPC-ul repetă ceva scris de un jucător, filtrează acea parte.
Surse și lecturi suplimentare
- Roblox Creator Docs: Proximity prompts (în engleză). crearea prompturilor, MaxActivationDistance și RequiresLineOfSight
- Roblox Engine API: ProximityPrompt (în engleză). unde funcționează promptul, textul și tastele lui implicite, Triggered și verificarea liniei de vedere
- Roblox Creator Docs: Securing the client-server boundary (în engleză). ProximityPrompt ca suprafață de atac, verificări de distanță și de drepturi
- Roblox Engine API: Dialog (în engleză). BehaviorType și evenimentul DialogChoiceSelected doar pe client
- Roblox Engine API: TextChatService:DisplayBubble (în engleză). baloane cu replici pentru NPC-uri din scripturi de client
- Roblox Creator Docs: Customize bubble chat (în engleză). baloanele NPC-urilor și BubbleChatConfiguration
- Roblox Creator Docs: Text filtering (în engleză). ce text afișat trebuie filtrat
- Roblox Creator Docs: UI animation and tweens (în engleză). efectul de mașină de scris prin MaxVisibleGraphemes
- Roblox Engine API: Tool.CanBeDropped (în engleză). ce face Backspace cu un instrument
- Roblox Engine API: UserInputService.PreferredInput (în engleză). cum recunoști un jucător cu gamepad
- Roblox Creator Docs: Rig Generator (în engleză). inserarea unui rig R15 sau R6
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.