I korthet
Lägg NPC-modellen i mappen NPCs i Workspace och skriv dess samtal i ett ModuleScript i ReplicatedStorage: varje replik har NPC:ns text och en lista med alternativ som leder till en annan replik. Ett Script i ServerScriptService lägger till en ProximityPrompt ("Talk") på varje NPC, minns vilken replik varje spelare är på och skickar den via en RemoteEvent. Ett LocalScript visar texten och en knapp för varje alternativ, och skickar bara tillbaka numret på knappen som trycktes.
- Dela ut belöningar på servern. Händelsen
DialogChoiceSelectedpå det inbyggda Dialog-objektet utlöses bara på klienten, så ett Script på servern hör den aldrig, och en helning eller ett föremål som delas ut i ett LocalScript ändrar bara den spelarens kopia av spelet. - Visa en pratbubbla med repliken med
TextChatService:DisplayBubble(npc.Head, text)från ett LocalScript. Den gamla tjänstenChatär föråldrad, och TextChatService används i stället. - Repliker som du skrivit själv behöver inte filtreras. Roblox regel: filtrera all visad text som du inte kontrollerar direkt, till exempel det som spelare skriver.
På den här sidan
Så fungerar en NPC-dialog
En NPC som pratar och som fungerar i ett riktigt spel är uppdelad mellan servern och varje spelares enhet. Enheten ritar fönstret och knapparna. Servern, den enda sidan som går att lita på, vet vilken replik varje spelare läser och bestämmer vad varje svar gör. En tur i samtalet ser ut så här:
- Spelaren går fram till NPC:n och trycker på E på dess Talk-prompt. Promptens händelse
Triggeredutlöses på servern med den spelaren. - Serverskriptet kontrollerar att spelaren är tillräckligt nära, minns att hen är på repliken med namnet
startoch skickar den replikens text och etiketterna för dess alternativ bara till den spelaren. - LocalScript skriver ut repliken i dialogfönstret, visar en pratbubbla ovanför NPC:n och lägger sedan till en knapp för varje alternativ.
- Spelaren klickar, trycker eller väljer ett alternativ. Bara dess nummer skickas tillbaka till servern.
- Servern hittar det numret på repliken som den vet att spelaren läser, utför alternativets handling om det finns en (helning, ett föremål) och skickar nästa replik eller stänger fönstret.
| Del | Var den finns | Vad den gör |
|---|---|---|
Riggen Guide | Workspace, i en mapp med namnet NPCs | Själva NPC:n. Dess namn väljer samtalet och visas på prompten. |
ModuleScript DialogueData | ReplicatedStorage | Alla repliker som NPC:n kan säga, alternativen under varje replik och vart varje alternativ leder. |
Script DialogueService | ServerScriptService | Lägger till Talk-prompten, minns vilken replik varje spelare är på, kontrollerar varje klick och utför handlingarna. |
RemoteEvent DialogueEvent | ReplicatedStorage (skapas av DialogueService) | Bär varje replik till spelaren, och numret på det valda alternativet tillbaka till servern. |
LocalScript DialogueClient | StarterPlayer, StarterPlayerScripts | Ritar fönstret, skriver ut repliken, visar pratbubblan och knapparna med alternativ. |
Tool Torch (valfritt) | ServerStorage, i en mapp med namnet DialogueItems | Föremålet som ett av alternativen ger. Inget från ServerStorage skickas till spelarna. |
Workspace
NPCs Folder new
Guide Model new
Humanoid Humanoid
HumanoidRootPart Part
Head, UpperTorso, LowerTorso ... (kroppsdelar)
ReplicatedStorage
DialogueData ModuleScript new
ServerScriptService
DialogueService Script new
ServerStorage
DialogueItems Folder new
Torch Tool new
Handle Part new
StarterPlayer
StarterPlayerScripts
DialogueClient LocalScript new
Steg 1: lägg till NPC:n
- På fliken Avatar eller Home, klicka på Character för att öppna Rig Generator. Välj R15, en kroppsform och en stil. En rigg med namnet
Rigdyker upp i Workspace. En R6-rigg fungerar med samma skript. - Döp om den till
Guide. Namnet är viktigt: DialogueService letar upp samtalet efter modellens namn, och prompten visar det för spelarna. - Fäll ut riggen, markera dess HumanoidRootPart och bocka i Anchored i Properties-fönstret. En förankrad part rör sig aldrig på grund av fysiken, så NPC:n står där du ställde den, och spelarna kan inte knuffa den.
- Håll muspekaren över Workspace i Explorer, klicka på knappen + och infoga en Folder med namnet
NPCs. Dra Guide in i den och ställ riggen där spelarna kan gå fram till den. - Valfritt, för alternativet med föremålet: håll muspekaren över ServerStorage och infoga en Folder med namnet
DialogueItems. Lägg ett Tool med namnetTorchi den, med en enda Part som inte är förankrad och heterHandle, den part som figuren håller i handen. En PointLight i Handle får den att lysa.
Namnen är skiftlägeskänsliga, så skriv NPCs, Guide, DialogueItems och Torch exakt som de visas. NPC:n kan vara vilken modell som helst med en Humanoid och en HumanoidRootPart, även en från Toolbox, så länge den ligger direkt i mappen NPCs.
Steg 2: skriv samtalet
Håll muspekaren över ReplicatedStorage, infoga ett ModuleScript med namnet DialogueData och klistra in den här koden. Det finns ingen logik i den, bara ord och kopplingarna mellan dem, så det är den här filen du kommer att redigera oftast.
-- ModuleScript i ReplicatedStorage med namnet DialogueData.
-- Alla samtal, efter NPC:ns namn i Workspace.NPCs. Varje replik har
-- NPC:ns text och spelarens svarsalternativ. Ett alternativ kan leda till en annan replik (next),
-- avsluta samtalet (utan next) och be servern göra något (action). Om servern
-- inte kan utföra handlingen visar den repliken failNext i stället för next.
export type Choice = {
text: string,
next: string?, -- repliken som ska visas efter det här alternativet; nil avslutar samtalet
action: string?, -- en serverhandling från tabellen ACTIONS i DialogueService
item: string?, -- för handlingen GiveItem: namnet på ett Tool i ServerStorage.DialogueItems
failNext: string?, -- repliken som ska visas i stället för next när handlingen inte kunde utföras
}
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
Raderna export type i början beskriver hur en replik och ett alternativ ser ut. Under spelet ändrar de ingenting; de beskriver din data så att typkontrollen kan kontrollera den.
Så hänger delarna ihop:
- Varje NPC har en tabell som heter som dess modell i mappen NPCs, här
Guide. Varje samtal börjar med replikenstart. textär det som NPC:n säger.choicesär spelarens knappar, i ordning. Fönstret har plats för fyra.nextanger repliken som ska visas efter det här alternativet. Ett alternativ utannext, till exempel "Bye!", avslutar samtalet. EnnextellerfailNextsom anger en replik som saknas i tabellen avslutar det också, med en varning i Output.actionanger vad servern gör, från tabellenACTIONSi DialogueService: härHealellerGiveItem.itembehövs för GiveItem: det är namnet på ett Tool i ServerStorage, DialogueItems.failNextär repliken som visas i stället förnextnär handlingen inte kunde utföras, så att NPC:n aldrig påstår en helning eller en gåva som inte blev av.
| Replik | Guide säger | Alternativ och vart de leder |
|---|---|---|
start | "Welcome to the village! What can I do for you?" | "Any tips?" leder till tips. "I'm hurt. Can you help?" helar, sedan healed (eller healTooSoon). "Got anything for the cave?" delar ut Torch, sedan torch (eller hasTorch). "Bye!" avslutar samtalet. |
tips | "Stay off the red bricks, and come back if you get hurt." | "Anything else?" går tillbaka till start. "Thanks!" avslutar samtalet. |
healed | "There you go, good as new." | "Thank you!" avslutar samtalet. |
torch | "Take this torch. The cave is dark." | "Thanks!" avslutar samtalet. |
healTooSoon | "I healed you a moment ago. Come back in a little while." | "OK" avslutar samtalet. |
hasTorch | "You already have my torch. Keep it lit!" | "Will do!" avslutar samtalet. |
Bara servern läser den här modulen. LocalScript gör aldrig require på den: servern skickar varje replik när spelaren kommer till den. Men en modul i ReplicatedStorage kopieras ändå till varje spelares enhet, så om samtalet innehåller spoilers (till exempel svaret på en gåta), flytta DialogueData till ServerStorage. Byt sedan ReplicatedStorage mot ServerStorage på raden med require i DialogueService, så att hela raden ser ut så här: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.
Steg 3: lägg till serverskriptet
Håll muspekaren över ServerScriptService, infoga ett Script med namnet DialogueService och klistra in koden nedan. Det är det enda stället där samtalet går framåt, och det enda stället där en belöning delas ut.
-- Script i ServerScriptService med namnet DialogueService.
-- Lägger till en Talk-prompt på varje NPC i Workspace.NPCs och leder varje samtal.
-- Spelarens enhet visar bara texten och skickar tillbaka numret på alternativet
-- som hen klickade på. Servern vet vilken replik varje spelare är på, kontrollerar alternativet
-- och avståndet, och bara servern helar eller delar ut föremål.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Samma former som i DialogueData, så att Studios typkontroll känner till dem här också
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: promptens radie och hur nära spelaren måste stanna
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30
local npcFolder = workspace:WaitForChild("NPCs")
local itemFolder = ServerStorage:FindFirstChild("DialogueItems")
-- Det här skriptet skapar själv DialogueEvent, så lägg inte till den för hand
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 -- ingen figur, den är död eller så har NPC:n försvunnit
end
-- en liten marginal, eftersom spelarens position når servern med en liten fördröjning
return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end
-- Vad servern gör när ett alternativ har en handling. Var och en returnerar true om den utfördes.
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 -- helade för nyligen
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 -- ingen ryggsäck än, eller så har hen redan föremålet
end
local item = template:Clone() :: Tool
item.CanBeDropped = false -- så att ingen kan kasta det och be om ett till
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 -- pratar redan, den här NPC:n har ingen replik "start", död eller för långt bort
end
local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
conversations[player] = conversation
showLine(player, conversation)
end
-- Spelaren klickade på alternativet med numret choiceIndex (0 betyder att hen stängde fönstret)
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
-- För snabbt. Skicka samma replik igen, eftersom fönstret redan har låst
-- knapparna efter klicket och annars skulle vänta på svar för evigt.
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 -- repliken som den här spelaren läser har inget sådant alternativ
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 -- till exempel "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)
-- Talk-prompten på varje 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() -- en kopia av en NPC tar med sig en gammal prompt som ingen lyssnar på
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)
-- Stäng fönstret för alla som gått iväg eller dött mitt i ett samtal
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 skapar själv RemoteEvent DialogueEvent när spelet startar, så du behöver inte infoga något i ReplicatedStorage för hand. Om du redan har skapat en RemoteEvent med det namnet, ta bort den: LocalScript skulle kunna hitta din, och på servern lyssnar ingen på den.
| Inställning | Värde här | Vad den ändrar |
|---|---|---|
TALK_DISTANCE | 12 | Hur nära, i studs, spelaren måste vara för att Talk-prompten ska dyka upp. Servern låter hen gå ytterligare 4 studs bort innan fönstret stängs, eftersom spelarens position når servern med en liten fördröjning. |
MIN_SECONDS_BETWEEN_CHOICES | 0.3 | Den kortaste tiden mellan två klick som servern godtar. Vid ett snabbare klick skickas samma replik igen i stället för ett svar. |
HEAL_COOLDOWN_SECONDS | 30 | Hur länge varje spelare väntar mellan helningar från handlingen Heal. |
Servern sparar en post per spelare i conversations: vilken NPC hen pratar med, vilken replik hen läser och när hens senaste klick godtogs. När Talk-prompten utlöses skapar startConversation den posten bara om spelaren inte redan pratar, NPC:n har en replik start, och spelaren lever och är inom räckhåll. Efter det går varje klick igenom de här kontrollerna:
| Kontroll | Kod | Om den inte går igenom |
|---|---|---|
| Spelaren är i ett samtal | conversations[player] | Klicket ignoreras. |
| Alternativet är ett heltal | typeof och math.floor | Ignoreras. Strängar, tabeller, decimaltal och NaN stoppas här. |
| 0 betyder att spelaren tryckte på X | choiceIndex == 0 | Samtalet avslutas. |
| Lever och är fortfarande inte längre bort än 16 studs (12 plus 4) | isClose | Samtalet avslutas, och fönstret stängs. |
| Minst 0.3 sekunder sedan senaste godtagna klick | conversation.lastChoice | Samma replik skickas igen, så fönstret får nya knappar i stället för att vänta för evigt. |
| Alternativet finns på repliken som den här spelaren läser | line.choices[choiceIndex] | Ignoreras. |
| Handlingen lyckades | varje handling returnerar true eller false | Repliken failNext visas i stället för next. |
Prompten sätts på NPC:ns HumanoidRootPart, eftersom en ProximityPrompt fungerar när den ligger i en part (eller en Attachment, eller en modell med PrimaryPart) i Workspace. Dess RequiresLineOfSight är påslagen som standard och döljer prompten varje gång något skymmer sikten från kameran till den parten. Roblox undantar promptens egen part från kontrollen, men inte resten av kroppen, och HumanoidRootPart sitter inne i torson, så skriptet stänger av siktkontrollen. Prompten heter TalkPrompt, och skriptet tar bort alla TalkPrompt som redan ligger på parten innan det lägger till sin egen: en kopia av en NPC som görs under spelet kommer med originalets prompt, och på den kopierade lyssnar ingen. Om DialogueData inte har något samtal med en replik start för NPC:ns namn visas en varning med den NPC:ns namn i Output.
En loop kontrollerar varje öppet samtal två gånger per sekund och stänger det när spelaren har gått längre bort än 16 studs eller hens figur har dött, så att en spelare som dör mitt i ett samtal inte återuppstår med fönstret öppet. PlayerRemoving rensar båda tabellerna när någon lämnar.
Steg 4: lägg till dialogfönstret
Öppna StarterPlayer, håll muspekaren över StarterPlayerScripts, infoga ett LocalScript med namnet DialogueClient och klistra in den här koden. Det bygger dialogfönstret i kod, så du behöver inte rita något GUI för hand.
-- LocalScript i StarterPlayer > StarterPlayerScripts med namnet DialogueClient.
-- Ritar samtalet som servern skickar: NPC:ns namn, dess replik som skrivs ut bokstav
-- för bokstav, en pratbubbla ovanför huvudet och en knapp för varje alternativ. Ett klick på
-- ett alternativ skickar bara dess nummer; vad som händer sedan bestämmer servern.
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)
-- Dialogfönstret, byggt i kod
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 pixlar högre, så att Roblox verktygsfält inte täcker alternativen
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 -- en lång replik krymper för att få plats på en liten mobilskärm
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- och blir aldrig större än 20 pixlar på en stor
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 -- ökar för varje ny replik, så att den gamla utskriftsloopen stannar
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 -- ändras bara på den här enheten
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()
-- Pratbubbla ovanför NPC:n (DisplayBubble fungerar bara i ett LocalScript)
local head = npc:FindFirstChild("Head")
if head then
TextChatService:DisplayBubble(head, text)
end
-- Skriv ut repliken bokstav för bokstav. Antalet räknas från den tid som gått,
-- så hastigheten är densamma oavsett bildfrekvens.
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 -- den här repliken har ersatts av en nyare eller av en stängning
end
shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
lineLabel.MaxVisibleGraphemes = shown
end
lineLabel.MaxVisibleGraphemes = -1
-- En knapp per alternativ; servern får bara knappens nummer
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 -- ett klick per replik
dialogueEvent:FireServer(index)
end
end)
if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
GuiService.SelectedObject = button -- så att alternativet kan väljas med en handkontroll
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)
Färger, storlekar och LETTERS_PER_SECOND kan du ändra som du vill. Låt de två sista hanterarna vara som de är: de är det enda sättet som fönstret pratar med servern på.
Vad varje del av DialogueClient gör:
- Fönstret. En ScreenGui med en Frame förankrad längst ned i mitten av skärmen, 60% av dess bredd och 34% av höjden, begränsad till 720 gånger 300 pixlar med
UISizeConstraintså att den inte sträcks ut över en hel bred skärm. NPC:ns replik använderTextScaled, som krymper texten så att den får plats i sin etikett på en liten mobilskärm, ochUITextSizeConstrainthindrar den från att bli större än 20 pixlar på en stor.UIGridLayoutlägger ut alternativen två och två.ResetOnSpawnär false, eftersom det här LocalScript körs en gång per session: ett fönster som togs bort vid återuppståndelse skulle aldrig komma tillbaka. - Skrivmaskinseffekten. Hela repliken hamnar i TextLabel på en gång, och
MaxVisibleGraphemesbestämmer hur många tecken som syns; det är samma egenskap som Roblox eget skrivmaskinsexempel använder tillsammans medutf8.graphemes. Roblox lägger ut texten som om alla tecken syntes, så orden hoppar inte till en ny rad och ändrar inte storlek medan de dyker upp. Skriptet räknar ut hur många tecken som ska visas från den tid som gått, 45 per sekund, så hastigheten är densamma oavsett bildfrekvens, och sätter sedan egenskapen till -1, vilket visar allt. - Knapparna. De dyker upp när repliken är utskriven. Var och en skickar bara sitt nummer, och bara en gång: kontrollen av
lineNumberhindrar ett dubbelklick från att skicka två gånger, och sedan väntar fönstret på nästa replik från servern. - Pratbubblan.
TextChatService:DisplayBubble(head, text)lägger repliken i en chattbubbla ovanför NPC:ns Head. Roblox tillåter det bara i klientskript, och bubble chat är påslaget som standard. Bubblan ritas av den här spelarens enhet, så bara hen ser den. - Prompten. Medan spelaren pratar är hens kopia av Talk-prompten (den hittas med namnet TalkPrompt) avstängd, så att den inte hänger ovanpå samtalet. Andra spelare ser fortfarande sina.
- Alla enheter.
Activatedutlöses av ett musklick, ett tryck på mobilen och knappen A på en handkontroll. En handkontroll kan bara trycka på den valda knappen, så närPreferredInputsäger att spelaren använder handkontroll väljer skriptet det första alternativet medGuiService.SelectedObject. - Knappen X. Den skickar 0, vilket servern tolkar som "avsluta samtalet", och stänger fönstret direkt.
Lägg till egna handlingar
En handling är en funktion i tabellen ACTIONS i början av DialogueService. Den får spelaren och alternativet och returnerar true när den har gjort sitt. Så här lägger du till en egen, till exempel ett uppdrag som NPC:n delar ut:
- Lägg till en post med namnet
StartQuestiACTIONS. Först kontrollen, sedan ändringen: omplayer:GetAttribute("Quest")redan är satt, returnerafalse; annars anropaplayer:SetAttribute("Quest", "Cave")och returneratrue. - I DialogueData, ge alternativet
action = "StartQuest", en repliknextför när det lyckas och en replikfailNextför när det misslyckas, till exempel "You are already on a quest." - Tryck på Play och välj alternativet två gånger. Om namnet i DialogueData inte stämmer med nyckeln i
ACTIONS(skiftläget spelar roll) visasDialogueService: no action named StartQuesti Output, och samtalet går till replikenfailNext.
Regler för att skriva handlingar:
- Gör kontrollen och ändringen i handlingen, på servern. Det enda som spelarens enhet skickar är alternativets nummer.
- Läs det som handlingen behöver från alternativet (som
item) eller från serverns eget tillstånd, men aldrig från remoten. - Begränsa allt värdefullt i själva handlingen, på samma sätt som Heal har en egen cooldown på 30 sekunder i
lastHeal. Gränsen på 0.3 sekunder per klick saktar bara ned klicken; den hindrar inte spelaren från att gå igenom samma alternativ om och om igen. - För att öppna ett annat fönster, till exempel en butik, kan handlingen skicka en RemoteEvent till den spelaren och returnera
true. Allt som händer i det fönstret kräver ändå sina egna kontroller på servern, som i avsnittet NPC som säljer.
Vad andra guider om NPC-dialog gör fel
Om du jämför den här guiden med en video eller ett foruminlägg, här är de viktiga skillnaderna och skälet till att varje knep skapar problem.
| Guiden | Problemet | Den här guiden |
|---|---|---|
Använder Dialog-objektet, och ett Script på servern lyssnar på DialogChoiceSelected för att dela ut belöningen | Roblox referens säger att den händelsen bara fungerar på klientsidan och inte utlöses på servern, så belöningen kommer aldrig. | Alternativet når servern som ett tal, och servern delar själv ut belöningen. |
| Delar ut belöningen från ett LocalScript | En ändring som görs av ett LocalScript stannar på den enda enheten (se vad som replikeras), och en fuskare kan köra samma kod när som helst. | Alla handlingar bor i DialogueService. |
Får NPC:n att prata med game:GetService("Chat"):Chat(head, text) | Tjänsten Chat är föråldrad, och TextChatService används i stället. | TextChatService:DisplayBubble i ett LocalScript. |
| Skickar belöningens namn eller nästa replikens id från klienten | En fuskare kan skicka vilket föremålsnamn som helst eller hoppa direkt till repliken som ger belöningen. | Klienten skickar bara alternativets nummer. Servern hittar det på repliken som den vet att spelaren läser. |
| Kontrollerar ingenting efter att prompten utlösts | Roblox säkerhetsguide sätter ProximityPrompt bredvid remotes som något som klienter kan missbruka, och råder dig att kontrollera att spelaren är tillräckligt nära innan handlingen. | Avståndet kontrolleras när samtalet startar, vid varje klick och två gånger per sekund medan det är öppet. |
Skriver ut texten med wait() i en loop | Den globala wait är föråldrad, och task.wait används i stället. | Räknar ut antalet synliga bokstäver från os.clock() och väntar med task.wait(). |
Vad en spelare kan och inte kan förfalska
Utgå från att en fuskare styr allt på sin enhet. Hen kan läsa dina LocalScript och allt i ReplicatedStorage, anropa DialogueEvent med vilka argument som helst hur många gånger som helst och utlösa Talk-prompten från kod, vilket Roblox säkerhetsguide varnar för. DialogueService svarar med kontroller på servern av samma slag som i avsnittet kontroll av argument till RemoteEvent. Här är vad fuskaren får ut av det.
| Fuskaren försöker | Resultat | Varför |
|---|---|---|
| Utlösa Talk-prompten från andra sidan kartan | Ingenting händer | startConversation kontrollerar att hen inte är längre bort än 16 studs (12 plus 4). |
| Skicka alternativ 99, en sträng, ett decimaltal eller NaN | Ignoreras | Det är inget heltal, eller så finns inget sådant alternativ på repliken hen läser. |
| Skicka en belönings namn eller en repliks id | Läses aldrig | Servern läser bara alternativets nummer. Belöningar tas från fälten item och action i serverns kopia av repliken. |
| Klicka så snabbt som nätverket tillåter | Ett klick var 0.3:e sekund per samtal | Snabbare klick får tillbaka sin egen replik. Att avsluta och starta om samtalet kringgår den väntan, så Heal och GiveItem har egna gränser. |
| Be om facklan utan att prata | Omöjligt | Föremål delas bara ut via ett alternativ på repliken som servern vet att spelaren är på. |
| Samla en hög med facklor | En i taget | Servern letar först efter Torch i hens Backpack och figur, och en utdelad fackla kan inte kastas, så den går inte att farma genom att kasta och be igen. |
| Spamma repliken med helningen | En helning var 30:e sekund | Cooldownen sparas på servern för varje spelare, och NPC:n säger det med repliken healTooSoon. |
| Gå iväg och lämna fönstret öppet | Stängs inom en halv sekund | Servern kontrollerar varje öppet samtal två gånger per sekund. |
| Läsa hela samtalet, även repliker hen inte har kommit till | Möjligt | DialogueData ligger i ReplicatedStorage, som kopieras till varje enhet. Flytta den till ServerStorage om det spelar roll (se steg 2). |
En begränsning är värd att säga rakt ut: en fuskare som går fram till Guide och väljer alternativ får exakt samma sak som en ärlig spelare. Servern styr hur ofta och varifrån, men inte vem. Allt sällsynt, till exempel en belöning som varje spelare får en gång, kräver en kontroll som servern äger, som ett attribut som sätts när belöningen tas emot, eller en flagga som sparas i ett datalager.
Steg 5: testa
- Tryck på Play (F5) och gå fram till Guide. Inom 12 studs dyker en Talk-prompt med namnet Guide upp. Tryck på E.
- Fönstret visar "Guide", skriver ut välkomstrepliken och visar sedan fyra knappar. Samma replik dyker upp i en pratbubbla ovanför NPC:ns huvud.
- Välj "Any tips?", sedan "Anything else?": du är tillbaka på den första repliken. Välj "Bye!": fönstret stängs, och Talk-prompten kommer tillbaka.
- Skada dig själv först: klicka på växlingsknappen Client/Server för att byta till Server, markera din figurs Humanoid i Workspace, sätt Health till 50 i Properties-fönstret och byt tillbaka till Client. Spelarfigurer återfår 1% av MaxHealth varje sekund, så prata direkt med Guide och välj "I'm hurt. Can you help?": hälsan hoppar upp till full. Prata igen inom 30 sekunder och välj det en gång till: ingen helning, och Guide säger att han helade dig för en stund sedan.
- Välj "Got anything for the cave?": Torch dyker upp i hotbaren. Utrusta den och tryck på Backspace: den stannar i handen. Be igen: ingen andra fackla, och Guide säger att du redan har den.
- Starta ett samtal och gå iväg. Fönstret stängs ungefär när du är 16 studs från Guide.
- Välj Server & Clients i listan med testlägen, ställ in 2 klienter och tryck på Play. Båda spelarna kan prata med Guide samtidigt, var och en på sin egen replik.
- Testa handkontroll med Controller Emulator (Controller på fliken Emulation) under ett speltest. Gå fram med den emulerade handkontrollen och tryck på promptens knapp (som standard ButtonX): när alternativen dyker upp är det första redan valt, och A trycker på det.
- Testa en mobilskärm med Device Simulator i Studio (när detta skrivs är det en beta: slå på New Device Simulator i File, Beta Features och starta om Studio). Välj en telefon, klicka på Rotate tills den är i liggande läge, tryck på Play, gå fram till Guide och tryck på Talk-prompten. Välj "Any tips?": hela repliken syns ovanför knapparna med alternativ, vid behov med mindre text, och hamnar inte över dem.
Ha hela tiden Output-fönstret öppet (menyn Window, sedan Output). När de här skripten fungerar skriver de inte ut något, så varje rött fel eller varning som börjar med DialogueService: är ett verkligt problem. Se Vanliga fel.
Så bygger du vidare
Fler NPC:er och längre samtal
Lägg till ytterligare en rigg med ett eget namn i mappen NPCs, och i DialogueData en tabell med samma namn och en replik start. DialogueService lägger till en Talk-prompt på varje modell i mappen som har en HumanoidRootPart, även de som läggs till under spelet; en kopia av en NPC får en ny prompt i stället för den som kopierades med. Två NPC:er med samma namn använder samma tabell. Replikerna kan kopplas i vilken ordning som helst, och ett alternativ kan leda tillbaka till en tidigare replik, som "Anything else?". Ha högst fyra alternativ per replik, eftersom fönstret lägger ut dem två och två.
Repliker som beror på framsteg
För att hälsa på återvändande spelare på ett annat sätt, välj den första repliken utifrån något som servern äger. I startConversation, välj den med local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", kontrollera att repliken finns, på samma sätt som skriptet kontrollerar lines.start, och använd firstLine i stället för "start" när samtalet skapas. Sätt attributet i en handling och lägg till repliken welcomeBack i Guides tabell. Attribut lever en session; för att minnas spelaren mellan besök, spara en flagga i ett datalager, som i guiden om DataStore.
NPC som säljer
Bygg en butik med guiden om butiks-GUI, lägg sedan till en handling OpenShop som skickar en RemoteEvent till den spelaren och returnerar true, och låt butikens LocalScript öppna sitt fönster när den händelsen kommer. Köpen går fortfarande igenom butikens egna kontroller på servern. Om man bara ska kunna köpa nära NPC:n, kontrollera avståndet även i köphanteraren, eftersom klienten kan anropa butikens remote varifrån som helst.
NPC:er som går
För att Guide ska vandra omkring eller följa spelare, ta guiden om pathfinding för NPC:er och ta bort Anchored från HumanoidRootPart så att den kan röra sig. Talk-prompten sitter på den parten, så den följer med NPC:n, och avståndskontrollerna använder samma part. Pausa gåendet medan ett samtal är öppet, annars stängs fönstret så fort NPC:n går längre bort än 16 studs från spelaren.
Nycklar, uppdrag och andra belöningar
GiveItem delar ut vilket Tool som helst från DialogueItems, så en NPC kan ge en nyckel som en låst dörr kontrollerar, som i guiden om dörrar. Om föremål som gör något när de används, till exempel mat som helar, läser du i guiden om inventarier.
Ljud och kamera
För ett röstklipp eller ett kort ljud vid varje replik, lägg ett Sound i NPC:ns Head och spela det från show i DialogueClient. För att rikta kameran mot NPC:n medan den pratar visar guiden om cutscenes hur ett LocalScript tar över kamerastyrningen och lämnar tillbaka den.
Vanliga fel och lösningar
Öppna Output-fönstret (menyn Window, sedan Output) innan du trycker på Play. De flesta problem med dialogen skriver ut en varning där eller beror på ett namn som inte stämmer.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("DialogueEvent")'
DialogueClient väntar på remoten som DialogueService skapar, alltså har DialogueService inte kommit så långt. Kontrollera att det är ett Script och inte ett LocalScript, att det ligger direkt i ServerScriptService och inte är avstängt. DialogueService väntar först på DialogueData i ReplicatedStorage och mappen NPCs i Workspace, så om de saknas eller namnet är felstavat stoppas det också; då visar Output en infinite yield-varning från DialogueService med det namnet.
Ingen Talk-prompt dyker upp ovanför min NPC
DialogueService lägger bara till prompter på modeller som ligger direkt i Workspace, NPCs och som har en part med namnet HumanoidRootPart. Kontrollera båda villkoren och gå närmare än 12 studs. En rigg från Toolbox kanske saknar den parten, eller så kan det vara ett objekt av en annan typ inslaget i en mapp.
Prompten dyker upp, men ett tryck på E gör ingenting
Servern hittade inget samtal för den här NPC:n, och när spelet startar visar Output DialogueService: no conversation with a start line for Guide in DialogueData med din NPC:s namn. Tabellen i DialogueData måste heta exakt som modellen, inklusive stora bokstäver, och innehålla en replik start.
Ett alternativ stänger fönstret i stället för att gå till nästa replik
Output visar DialogueService: no line named tip for Guide in DialogueData med dina namn: alternativets next (eller failNext) anger en replik som inte finns i den NPC:ns tabell. Repliknamn är skiftlägeskänsliga, så jämför stavningen med tabellen, här tips.
Fönstret fungerar, men det finns ingen pratbubbla
Bubblan behöver en part med namnet Head direkt i NPC-modellen och att bubble chat är påslaget: i Explorer, markera BubbleChatConfiguration under TextChatService och kontrollera att Enabled är ibockat. Som standard är det påslaget.
Output skriver DialogueService: no Tool named Torch in ServerStorage.DialogueItems
Servern kunde inte hitta föremålet. Kontrollera att mappen i ServerStorage heter DialogueItems och att den innehåller ett Tool (inte en Model eller Part) med exakt samma namn som i alternativets item. Tills du rättar det svarar Guide med repliken hasTorch, eftersom handlingen misslyckades.
Output skriver DialogueService: no action named ...
Alternativets action stämmer inte med någon nyckel i tabellen ACTIONS. Namnen är skiftlägeskänsliga: heal är inte Heal.
Gör det med RoCode
Om du hellre beskriver NPC:n än bygger den för hand kan RoCode skriva de här skripten direkt i den place du har öppen. Det är en oberoende AI-agent för Roblox Studio, inte från Roblox: du skriver i webbchatten, och dess Studio-plugin skapar och redigerar skript i din Explorer.
Få modellen Guide i Workspace.NPCs att prata: en Talk-prompt, ett dialogfönster med repliker som skrivs ut och knappar med alternativ, en pratbubbla ovanför huvudet, ett alternativ med helning med en cooldown på 30 sekunder och ett alternativ som en gång delar ut verktyget Torch från ServerStorage. Spara samtalet i ett ModuleScript och dela ut alla belöningar på servern.
- Kan först granska modellen med Get Properties för att läsa viktiga värden, som Anchored på dess parts och WalkSpeed på dess Humanoid. Skriv / i chatten för att bifoga den exakta sökvägen till modellen
- Skriver ModuleScript DialogueData, Script DialogueService och LocalScript DialogueClient med Create Script
- Är instruerad att kontrollera att varje skript den skriver kompilerar med Check Script, som kompilerar det i Studio utan att köra det
- Skickar ändringarna i omgångar, och varje omgång är en ångrapunkt i Studios historik
Med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.11 eller nyare kan den styra en testfigur för att kontrollera att spelet fungerar, men den tar inga skärmbilder medan spelet körs, så gå fram till NPC:n och prata med den själv. Om något inte fungerar, berätta för RoCode vad du såg: Check Output kan läsa Server- och Client-raderna från ditt senaste speltest. En NPC som pratar är ett system av många; sidan så skapar du ett Roblox-spel med AI, ett system per prompt visar hur de passar ihop. Så ansluter RoCode till Studio.
Vanliga frågor
Hur gör man en NPC som pratar i Roblox Studio?
Lägg till en ProximityPrompt på NPC:n och visa, när spelaren utlöser den, NPC:ns replik i ett dialogfönster, i en pratbubbla eller på båda ställena. De tre skripten i den här guiden gör båda och lägger till svarsalternativ. Om du bara behöver bubblan, anropa TextChatService:DisplayBubble(npc.Head, "Hello!") från ett LocalScript när prompten utlöses, som i NPC-exemplet på Roblox sida om bubble chat.
Vad ska jag välja: Dialog-objektet eller ett eget dialog-GUI?
Dialog-objektet behöver ingen kod och visar en klickbar pratbubbla, vilket räcker för dekorativ text. Dess valhändelse utlöses bara på spelarens enhet, så det kan inte dela ut belöningar säkert, och som standard kan bara en spelare i taget prata med det. Ett eget fönster, som i den här guiden, låter servern dela ut varje belöning och ger varje spelare sitt eget samtal.
Hur ger man spelaren ett föremål från en NPC?
Spara ett Tool i ServerStorage och låt ett Script på servern klona det till spelarens Backpack när hen väljer det alternativet, som handlingen GiveItem gör. Kontrollera att spelaren inte redan har ett sådant och stäng av CanBeDropped på kopian, så att den inte kan kastas och begäras igen. Låt aldrig spelarens enhet bestämma vilket föremål som ska delas ut.
Hur gör man ett dialogfönster med skrivmaskinseffekt?
Lägg hela repliken i en TextLabel, öka dess MaxVisibleGraphemes från 0 med några tecken i taget, och sätt den till slut till -1 för att visa allt. Roblox sida om UI-animation använder samma egenskap tillsammans med utf8.graphemes. DialogueClient räknar ut hur många tecken som ska visas från den tid som gått, 45 per sekund, så hastigheten beror inte på bildfrekvensen.
Kan två spelare prata med samma NPC samtidigt?
Med skripten i den här guiden, ja: servern håller ett samtal per spelare, och varje spelare ser bara sitt eget fönster. Det inbyggda Dialog-objektet fungerar annorlunda: med standardvärdet för BehaviorType, SinglePlayer, pratar en spelare i taget, och de andra ser hens alternativ.
Måste man filtrera texten i en NPC-dialog?
Repliker som du skrivit själv behöver inte filtreras. Roblox lägger ansvaret på dig att filtrera visad text som du inte kontrollerar direkt, till exempel det som spelare skriver, ord som satts ihop av slumpmässiga tecken, eller text som hämtats från en extern webbplats. Om NPC:n upprepar något som en spelare har skrivit, filtrera den delen.
Källor och vidare läsning
- Roblox Creator Docs: Proximity prompts (på engelska). skapa prompter, MaxActivationDistance och RequiresLineOfSight
- Roblox Engine API: ProximityPrompt (på engelska). var prompten fungerar, dess text och standardtangenter, Triggered och siktkontrollen
- Roblox Creator Docs: Securing the client-server boundary (på engelska). ProximityPrompt som attackyta, kontroller av avstånd och behörighet
- Roblox Engine API: Dialog (på engelska). BehaviorType och händelsen DialogChoiceSelected som bara finns på klienten
- Roblox Engine API: TextChatService:DisplayBubble (på engelska). pratbubblor för NPC:er från klientskript
- Roblox Creator Docs: Customize bubble chat (på engelska). NPC-bubblor och BubbleChatConfiguration
- Roblox Creator Docs: Text filtering (på engelska). vilken visad text som måste filtreras
- Roblox Creator Docs: UI animation and tweens (på engelska). skrivmaskinseffekt med MaxVisibleGraphemes
- Roblox Engine API: Tool.CanBeDropped (på engelska). vad Backspace gör med ett verktyg
- Roblox Engine API: UserInputService.PreferredInput (på engelska). hur man känner igen en spelare med handkontroll
- Roblox Creator Docs: Rig Generator (på engelska). infoga en R15- eller R6-rigg
Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.