Guide · Spelsystem

Så gör du en NPC-dialog i Roblox Studio

En NPC-dialog i Roblox består av tre delar: en prompt för att starta samtalet, ett fönster som visar NPC:ns ord och knappar med spelarens svar, och ett skript som bestämmer vad varje svar leder till. I den här guiden bygger vi alla tre: du skriver samtalet som en enkel tabell, spelarna trycker på E för att prata, och allt som ett svar ger (helning, ett föremål) delas ut av servern, inte av spelarens enhet.

Uppdaterad 20 november 202622 min läsningSkriven av

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 DialogChoiceSelected på 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änsten Chat ä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
  1. Så fungerar det
  2. 1. Lägg till NPC:n
  3. 2. Samtalet
  4. 3. Serverskriptet
  5. 4. Dialogfönstret
  6. Egna handlingar
  7. Andra guider
  8. Skyddets gränser
  9. 5. Test
  10. Utbyggnader
  11. Common errors
  12. Med RoCode
  13. Vanliga frågor
  14. Källor och vidare läsning

Så fungerar en NPC-dialog

IllustrationVarje replik skrivs ut i fönstret medan hela repliken syns i pratbubblan, alternativen dyker upp när repliken är utskriven, och servern delar ut Torch när du väljer "Got anything for the cave?".

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:

  1. Spelaren går fram till NPC:n och trycker på E på dess Talk-prompt. Promptens händelse Triggered utlöses på servern med den spelaren.
  2. Serverskriptet kontrollerar att spelaren är tillräckligt nära, minns att hen är på repliken med namnet start och skickar den replikens text och etiketterna för dess alternativ bara till den spelaren.
  3. 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.
  4. Spelaren klickar, trycker eller väljer ett alternativ. Bara dess nummer skickas tillbaka till servern.
  5. 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.
Vad en NPC som pratar består av
DelVar den finnsVad den gör
Riggen GuideWorkspace, i en mapp med namnet NPCsSjälva NPC:n. Dess namn väljer samtalet och visas på prompten.
ModuleScript DialogueDataReplicatedStorageAlla repliker som NPC:n kan säga, alternativen under varje replik och vart varje alternativ leder.
Script DialogueServiceServerScriptServiceLägger till Talk-prompten, minns vilken replik varje spelare är på, kontrollerar varje klick och utför handlingarna.
RemoteEvent DialogueEventReplicatedStorage (skapas av DialogueService)Bär varje replik till spelaren, och numret på det valda alternativet tillbaka till servern.
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsRitar fönstret, skriver ut repliken, visar pratbubblan och knapparna med alternativ.
Tool Torch (valfritt)ServerStorage, i en mapp med namnet DialogueItemsFöremålet som ett av alternativen ger. Inget från ServerStorage skickas till spelarna.
Explorer när NPC:n är klar. När spelet körs lägger DialogueService till en RemoteEvent med namnet DialogueEvent i ReplicatedStorage och en ProximityPrompt Talk med namnet TalkPrompt i varje NPC:s HumanoidRootPart.
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

  1. 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 Rig dyker upp i Workspace. En R6-rigg fungerar med samma skript.
  2. Döp om den till Guide. Namnet är viktigt: DialogueService letar upp samtalet efter modellens namn, och prompten visar det för spelarna.
  3. 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.
  4. 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.
  5. 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 namnet Torch i den, med en enda Part som inte är förankrad och heter Handle, 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
-- 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 repliken start.
  • text är det som NPC:n säger. choices är spelarens knappar, i ordning. Fönstret har plats för fyra.
  • next anger repliken som ska visas efter det här alternativet. Ett alternativ utan next, till exempel "Bye!", avslutar samtalet. En next eller failNext som anger en replik som saknas i tabellen avslutar det också, med en varning i Output.
  • action anger vad servern gör, från tabellen ACTIONS i DialogueService: här Heal eller GiveItem.
  • item behövs för GiveItem: det är namnet på ett Tool i ServerStorage, DialogueItems.
  • failNext är repliken som visas i stället för next när handlingen inte kunde utföras, så att NPC:n aldrig påstår en helning eller en gåva som inte blev av.
Guides samtal, replik för replik
ReplikGuide sägerAlternativ 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
-- 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ällningar i början av DialogueService
InställningVärde härVad den ändrar
TALK_DISTANCE12Hur 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_CHOICES0.3Den 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_SECONDS30Hur 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:

Vad DialogueService kontrollerar vid varje klick
KontrollKodOm den inte går igenom
Spelaren är i ett samtalconversations[player]Klicket ignoreras.
Alternativet är ett heltaltypeof och math.floorIgnoreras. Strängar, tabeller, decimaltal och NaN stoppas här.
0 betyder att spelaren tryckte på XchoiceIndex == 0Samtalet avslutas.
Lever och är fortfarande inte längre bort än 16 studs (12 plus 4)isCloseSamtalet avslutas, och fönstret stängs.
Minst 0.3 sekunder sedan senaste godtagna klickconversation.lastChoiceSamma 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äserline.choices[choiceIndex]Ignoreras.
Handlingen lyckadesvarje handling returnerar true eller falseRepliken 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
-- 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 UISizeConstraint så att den inte sträcks ut över en hel bred skärm. NPC:ns replik använder TextScaled, som krymper texten så att den får plats i sin etikett på en liten mobilskärm, och UITextSizeConstraint hindrar den från att bli större än 20 pixlar på en stor. UIGridLayout lä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 MaxVisibleGraphemes bestämmer hur många tecken som syns; det är samma egenskap som Roblox eget skrivmaskinsexempel använder tillsammans med utf8.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 lineNumber hindrar 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. Activated utlö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är PreferredInput säger att spelaren använder handkontroll väljer skriptet det första alternativet med GuiService.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:

  1. Lägg till en post med namnet StartQuest i ACTIONS. Först kontrollen, sedan ändringen: om player:GetAttribute("Quest") redan är satt, returnera false; annars anropa player:SetAttribute("Quest", "Cave") och returnera true.
  2. I DialogueData, ge alternativet action = "StartQuest", en replik next för när det lyckas och en replik failNext för när det misslyckas, till exempel "You are already on a quest."
  3. 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) visas DialogueService: no action named StartQuest i Output, och samtalet går till repliken failNext.

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.

Vanliga knep i guider om NPC-dialog och vad den här guiden gör i stället
GuidenProblemetDen här guiden
Använder Dialog-objektet, och ett Script på servern lyssnar på DialogChoiceSelected för att dela ut belöningenRoblox 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 LocalScriptEn ä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 klientenEn 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östsRoblox 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 loopDen 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.

Vad en fuskare kan försöka med och vad DialogueService gör åt det
Fuskaren försökerResultatVarför
Utlösa Talk-prompten från andra sidan kartanIngenting händerstartConversation kontrollerar att hen inte är längre bort än 16 studs (12 plus 4).
Skicka alternativ 99, en sträng, ett decimaltal eller NaNIgnorerasDet är inget heltal, eller så finns inget sådant alternativ på repliken hen läser.
Skicka en belönings namn eller en repliks idLäses aldrigServern 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återEtt klick var 0.3:e sekund per samtalSnabbare 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 prataOmöjligtFöremål delas bara ut via ett alternativ på repliken som servern vet att spelaren är på.
Samla en hög med facklorEn i tagetServern 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 helningenEn helning var 30:e sekundCooldownen sparas på servern för varje spelare, och NPC:n säger det med repliken healTooSoon.
Gå iväg och lämna fönstret öppetStängs inom en halv sekundServern kontrollerar varje öppet samtal två gånger per sekund.
Läsa hela samtalet, även repliker hen inte har kommit tillMöjligtDialogueData 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

  1. Tryck på Play (F5) och gå fram till Guide. Inom 12 studs dyker en Talk-prompt med namnet Guide upp. Tryck på E.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. Starta ett samtal och gå iväg. Fönstret stängs ungefär när du är 16 studs från Guide.
  7. 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.
  8. 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.
  9. 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.

Du skriver

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.

RoCode gör
  • 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

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.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.