Útmutató · Játékrendszerek

Hogyan készíts NPC párbeszédet a Roblox Studióban

Az NPC párbeszéd a Robloxban három részből áll: egy jelzésből, amellyel elkezdhető a beszélgetés, egy ablakból, amely megmutatja az NPC szavait és a játékos válaszgombjait, és egy scriptből, amely eldönti, mihez vezet az egyes válasz. Ebben az útmutatóban mind a hármat összerakjuk: a beszélgetést egyszerű táblázatként írod meg, a játékosok az E megnyomásával szólalnak meg, és mindent, amit egy válasz ad (gyógyítás, tárgy), a szerver ad, nem a játékos eszköze.

Frissítve 2026. november 20.22 perc olvasásSzerző:

Röviden

Tedd az NPC modelljét egy NPCs mappába a Workspace-ben, a beszélgetését pedig írd egy ModuleScriptbe a ReplicatedStorage-ben: minden mondatnak van egy NPC szövege és egy listája a lehetőségekről, amelyek egy másik mondathoz vezetnek. Egy Script a ServerScriptService-ben minden NPC-hez hozzáad egy ProximityPromptot ("Talk"), megjegyzi, melyik mondatnál tart az egyes játékos, és egy RemoteEventen keresztül elküldi. Egy LocalScript megjeleníti a szöveget és lehetőségenként egy gombot, visszafelé pedig csak a megnyomott gomb számát küldi el.

  • A jutalmakat a szerveren add. A beépített Dialog objektum DialogChoiceSelected eseménye csak a kliensen sül el, így egy szerveroldali Script soha nem hallja meg, egy LocalScriptben adott gyógyítás vagy tárgy pedig csak az adott játékos játékmásolatát változtatja meg.
  • A mondatbuborékot a TextChatService:DisplayBubble(npc.Head, text) hívással mutasd meg egy LocalScriptből. A régi Chat szolgáltatás elavult, helyette a TextChatService használatos.
  • A saját magad által írt mondatokat nem kell szűrni. A Roblox szabálya: minden megjelenített szöveget szűrni kell, amelyet nem közvetlenül te irányítasz, például amit a játékosok írnak be.
Ezen az oldalon
  1. Hogyan működik
  2. 1. Az NPC hozzáadása
  3. 2. Beszélgetés
  4. 3. Szerverscript
  5. 4. Párbeszédablak
  6. Saját műveletek
  7. Más oktatóanyagok
  8. A védelem határai
  9. 5. Tesztelés
  10. Bővítések
  11. Common errors
  12. RoCode-dal
  13. Gyakori kérdések
  14. Források és további olvasnivaló

Hogyan működik az NPC párbeszéd

IllusztrációMinden mondat az ablakban gépelődik, miközben teljes egészében látszik a buborékban, a lehetőségek akkor jelennek meg, amikor a mondat kigépelődött, a szerver pedig akkor adja a Torchot, amikor a "Got anything for the cave?" lehetőséget választod.

Egy beszélő NPC, amely valódi játékban működik, meg van osztva a szerver és az egyes játékosok eszköze között. Az eszköz rajzolja meg az ablakot és a gombokat. A szerver, az egyetlen fél, amelyben meg lehet bízni, tudja, melyik mondatot olvassa az egyes játékos, és eldönti, mit csinál az egyes válasz. A beszélgetés egy köre így néz ki:

  1. A játékos odamegy az NPC-hez, és megnyomja az E-t a Talk jelzésén. A jelzés Triggered eseménye a szerveren sül el ezzel a játékossal.
  2. A szerverscript ellenőrzi, hogy a játékos elég közel van-e, megjegyzi, hogy a start nevű mondatnál tart, és csak ennek a játékosnak küldi el a mondat szövegét és a lehetőségek feliratait.
  3. A LocalScript kigépeli a mondatot a párbeszédablakban, megjelenít egy buborékot az NPC fölött, aztán lehetőségenként hozzáad egy gombot.
  4. A játékos rákattint, rákoppint vagy kiválaszt egy lehetőséget. A szerverre csak a száma megy vissza.
  5. A szerver megkeresi ezt a számot azon a mondaton, amelyről tudja, hogy a játékos olvassa, végrehajtja a lehetőség műveletét, ha van ilyen (gyógyítás, tárgy), és elküldi a következő mondatot, vagy bezárja az ablakot.
Miből áll egy beszélő NPC
ElemHol találhatóMit csinál
Guide rigWorkspace, egy NPCs nevű mappábanMaga az NPC. A neve választja ki a beszélgetést, és megjelenik a jelzésen.
ModuleScript DialogueDataReplicatedStorageMinden mondat, amelyet az NPC mondhat, a lehetőségek az egyes mondatok alatt, és hogy hová vezet az egyes lehetőség.
Script DialogueServiceServerScriptServiceHozzáadja a Talk jelzést, megjegyzi, melyik mondatnál tart az egyes játékos, ellenőriz minden kattintást, és végrehajtja a műveleteket.
RemoteEvent DialogueEventReplicatedStorage (a DialogueService hozza létre)Minden mondatot elvisz a játékoshoz, a kiválasztott lehetőség számát pedig vissza a szerverre.
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsMegrajzolja az ablakot, kigépeli a mondatot, megjeleníti a buborékot és a lehetőség gombokat.
Tool Torch (nem kötelező)ServerStorage, egy DialogueItems nevű mappábanA tárgy, amelyet az egyik lehetőség ad. A ServerStorage-ből semmi sem jut el a játékosokhoz.
Az Explorer, amikor az NPC kész. Amikor a játék fut, a DialogueService hozzáad egy DialogueEvent nevű RemoteEventet a ReplicatedStorage-hez, és egy TalkPrompt nevű Talk ProximityPromptot minden NPC HumanoidRootPartjához.
Workspace
  NPCs Folder new
    Guide Model new
      Humanoid Humanoid
      HumanoidRootPart Part
      Head, UpperTorso, LowerTorso ... (testrészek)
ReplicatedStorage
  DialogueData ModuleScript new
ServerScriptService
  DialogueService Script new
ServerStorage
  DialogueItems Folder new
    Torch Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    DialogueClient LocalScript new

1. lépés: Add hozzá az NPC-t

  1. Az Avatar vagy a Home fülön kattints a Character gombra a Rig Generator megnyitásához. Válaszd az R15-öt, egy testalkatot és egy stílust. A Workspace-ben megjelenik egy Rig nevű rig. Egy R6 rig ugyanezekkel a scriptekkel működik.
  2. Nevezd át Guide-ra. A név számít: a DialogueService a modell neve alapján keresi a beszélgetést, és a jelzés megmutatja a játékosoknak.
  3. Nyisd ki a riget, jelöld ki a HumanoidRootPart partját, és a Properties ablakban jelöld be az Anchored opciót. A rögzített part soha nem mozdul el a fizika miatt, így az NPC ott áll, ahová tetted, és a játékosok nem tudják eltolni.
  4. Vidd az egeret a Workspace fölé az Explorerben, kattints a + gombra, és szúrj be egy NPCs nevű Foldert. Húzd bele Guide-ot, és állítsd a riget oda, ahová a játékosok oda tudnak menni.
  5. Nem kötelező, a tárgyas lehetőséghez: vidd az egeret a ServerStorage fölé, és szúrj be egy DialogueItems nevű Foldert. Tegyél bele egy Torch nevű Toolt egyetlen nem rögzített, Handle nevű Parttal, ez az a part, amelyet a karakter a kezében tart. Egy PointLight a Handle-ben világítóvá teszi.

A nevekben számít a kis- és nagybetű, ezért a NPCs, Guide, DialogueItems és Torch neveket pontosan úgy írd be, ahogy itt látod. NPC bármilyen modell lehet Humanoid és HumanoidRootPart objektummal, a Toolboxból származók is, ha közvetlenül az NPCs mappában vannak.

2. lépés: Írd meg a beszélgetést

Vidd az egeret a ReplicatedStorage fölé, szúrj be egy DialogueData nevű ModuleScriptet, és illeszd bele ezt a kódot. Nincs benne logika, csak a szavak és a köztük lévő kapcsolatok, ezért ezt a fájlt fogod a leggyakrabban szerkeszteni.

ModuleScript helye: ReplicatedStorage neve: DialogueData
-- ModuleScript a ReplicatedStorage-ben, a neve DialogueData.
-- Minden beszélgetés, a Workspace.NPCs alatti NPC neve szerint. Minden mondatnak van
-- NPC szövege és a játékos válaszlehetőségei. Egy lehetőség vezethet egy másik mondathoz (next),
-- befejezheti a beszélgetést (next nélkül), és kérheti a szervert, hogy csináljon valamit (action). Ha a szerver
-- nem tudja végrehajtani a műveletet, a next helyett a failNext mondatot mutatja.

export type Choice = {
	text: string,
	next: string?, -- a mondat, amelyet e lehetőség után kell megmutatni; a nil befejezi a beszélgetést
	action: string?, -- szerveroldali művelet a DialogueService ACTIONS táblázatából
	item: string?, -- a GiveItem művelethez: a Tool neve a ServerStorage.DialogueItems mappában
	failNext: string?, -- a mondat, amelyet a next helyett kell megmutatni, ha a műveletet nem sikerült végrehajtani
}

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

Az elején lévő export type sorok leírják, hogyan néz ki egy mondat és egy lehetőség. Játék közben semmit sem változtatnak; az adataidat írják le, hogy a típusellenőrzés ellenőrizhesse őket.

Hogyan kapcsolódnak egymáshoz a részek:

  • Minden NPC-nek van egy táblázata, amely az NPCs mappában lévő modelljéről kapta a nevét, itt ez Guide. Minden beszélgetés a start mondattal kezdődik.
  • A text az, amit az NPC mond. A choices a játékos gombjai, sorrendben. Az ablakban négynek van hely.
  • A next megnevezi a mondatot, amelyet e lehetőség után kell megmutatni. A next nélküli lehetőség, például a "Bye!", befejezi a beszélgetést. Az a next vagy failNext, amely a táblázatban nem szereplő mondatot nevez meg, szintén befejezi, egy Output figyelmeztetéssel.
  • Az action megnevezi, mit csinál a szerver, a DialogueService ACTIONS táblázatából: itt ez Heal vagy GiveItem.
  • Az item a GiveItemhez kell: ez a Tool neve a ServerStorage, DialogueItems mappában.
  • A failNext az a mondat, amely a next helyett jelenik meg, ha a műveletet nem sikerült végrehajtani, hogy az NPC soha ne állítson olyan gyógyítást vagy ajándékot, amely nem történt meg.
Guide beszélgetése mondatról mondatra
MondatGuide mondjaLehetőségek, és hová vezetnek
start"Welcome to the village! What can I do for you?"Az "Any tips?" a tipshez vezet. Az "I'm hurt. Can you help?" gyógyít, aztán healed (vagy healTooSoon). A "Got anything for the cave?" Torchot ad, aztán torch (vagy hasTorch). A "Bye!" befejezi a beszélgetést.
tips"Stay off the red bricks, and come back if you get hurt."Az "Anything else?" visszavisz a starthoz. A "Thanks!" befejezi a beszélgetést.
healed"There you go, good as new."A "Thank you!" befejezi a beszélgetést.
torch"Take this torch. The cave is dark."A "Thanks!" befejezi a beszélgetést.
healTooSoon"I healed you a moment ago. Come back in a little while."Az "OK" befejezi a beszélgetést.
hasTorch"You already have my torch. Keep it lit!"A "Will do!" befejezi a beszélgetést.

Ezt a modult csak a szerver olvassa. A LocalScript soha nem hívja meg rá a require függvényt: a szerver minden mondatot akkor küld el, amikor a játékos odaér. A ReplicatedStorage-ben lévő modul viszont így is átmásolódik minden játékos eszközére, ezért ha a beszélgetésben spoilerek vannak (mondjuk egy rejtvény megoldása), tedd át a DialogueData modult a ServerStorage-be. Aztán a DialogueService require sorában cseréld a ReplicatedStorage-et ServerStorage-re, hogy az egész sor így nézzen ki: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.

3. lépés: Add hozzá a szerverscriptet

Vidd az egeret a ServerScriptService fölé, szúrj be egy DialogueService nevű Scriptet, és illeszd bele az alábbi kódot. Ez az egyetlen hely, ahol a beszélgetés előrehalad, és az egyetlen hely, ahol jutalom jár.

Script helye: ServerScriptService neve: DialogueService
-- Script a ServerScriptService-ben, a neve DialogueService.
-- Talk jelzést ad minden NPC-hez a Workspace.NPCs alatt, és vezeti az összes beszélgetést.
-- A játékos eszköze csak megjeleníti a szöveget, és visszaküldi annak a lehetőségnek a számát,
-- amelyre kattintott. A szerver tudja, melyik mondatnál tart az egyes játékos, ellenőrzi a lehetőséget
-- és a távolságot, és csak ő gyógyít vagy ad tárgyakat.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Ugyanazok a formák, mint a DialogueData-ban, hogy a Studio típusellenőrzése itt is ismerje őket
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 -- studok: a jelzés hatótávja, és hogy milyen közel kell maradnia a játékosnak
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30

local npcFolder = workspace:WaitForChild("NPCs")
local itemFolder = ServerStorage:FindFirstChild("DialogueItems")

-- Ez a script maga hozza létre a DialogueEventet, ezért ne add hozzá kézzel
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 -- nincs karakter, halott, vagy az NPC eltűnt
	end
	-- kis ráhagyás, mert a játékos pozíciója kis késéssel ér el a szerverhez
	return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end

-- Mit csinál a szerver, ha a lehetőségnek van művelete. Mindegyik true-t ad vissza, ha sikerült.
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 -- túl nemrég gyógyult
		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 -- még nincs hátizsák, vagy a tárgy már nála van
		end
		local item = template:Clone() :: Tool
		item.CanBeDropped = false -- hogy senki se tudja eldobni, és újat kérni
		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 -- már beszélget, ennek az NPC-nek nincs "start" mondata, halott, vagy túl messze van
	end
	local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
	conversations[player] = conversation
	showLine(player, conversation)
end

-- A játékos a choiceIndex számú lehetőségre kattintott (a 0 azt jelenti, hogy bezárta az ablakot)
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
		-- Túl gyors. Újra elküldjük ugyanazt a mondatot, mert az ablak a kattintás után már letiltotta
		-- a gombokat, és különben örökké várna a válaszra.
		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 -- azon a mondaton, amelyet ez a játékos olvas, nincs ilyen lehetőség
	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 -- például "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 jelzés minden NPC-n
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() -- egy NPC másolat magával hozza a régi jelzést, amelyet senki sem figyel
	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)

-- Bezárjuk az ablakot mindenkinek, aki elment vagy meghalt a beszélgetés közben
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)

A DialogueService a játék indulásakor maga hozza létre a DialogueEvent RemoteEventet, ezért a ReplicatedStorage-be kézzel semmit sem kell beszúrnod. Ha már létrehoztál ilyen nevű RemoteEventet, töröld: a LocalScript a tiédet is megtalálhatná, azt pedig a szerveren senki sem figyeli.

Beállítások a DialogueService elején
BeállításÉrték ittMit változtat meg
TALK_DISTANCE12Milyen közel, studban, kell lennie a játékosnak, hogy megjelenjen a Talk jelzés. A szerver még 4 studnyi eltávolodást enged, mielőtt bezárja az ablakot, mert a játékos pozíciója kis késéssel ér el a szerverhez.
MIN_SECONDS_BETWEEN_CHOICES0.3A legrövidebb idő két kattintás között, amelyet a szerver elfogad. Egy gyorsabb kattintásra válasz helyett újra ugyanaz a mondat érkezik.
HEAL_COOLDOWN_SECONDS30Mennyit vár minden játékos két Heal gyógyítás között.

A szerver a conversations táblázatban játékosonként egy bejegyzést tárol: melyik NPC-vel beszél, melyik mondatot olvassa, és mikor fogadta el az utolsó kattintását. Amikor a Talk jelzés elsül, a startConversation csak akkor hozza létre ezt a bejegyzést, ha a játékos még nem beszélget, az NPC-nek van start mondata, a játékos pedig él, és hatótávon belül van. Ezután minden kattintás ezeken az ellenőrzéseken megy át:

Mit ellenőriz a DialogueService minden kattintásnál
EllenőrzésKódHa nem megy át
A játékos beszélgetésben vanconversations[player]A kattintás figyelmen kívül marad.
A lehetőség egész számtypeof és math.floorFigyelmen kívül marad. A stringek, táblázatok, törtek és a NaN itt elakadnak.
A 0 azt jelenti, hogy a játékos megnyomta az X-etchoiceIndex == 0A beszélgetés véget ér.
Él, és még mindig legfeljebb 16 studnyira van (12 plusz 4)isCloseA beszélgetés véget ér, és az ablak bezárul.
Legalább 0,3 másodperc telt el az utolsó elfogadott kattintás ótaconversation.lastChoiceUgyanaz a mondat érkezik újra, így az ablak friss gombokat kap, és nem vár örökké.
A lehetőség létezik azon a mondaton, amelyet ez a játékos olvasline.choices[choiceIndex]Figyelmen kívül marad.
A művelet sikerültminden művelet true vagy false értéket ad visszaA next helyett a failNext mondat jelenik meg.

A jelzés az NPC HumanoidRootPartjára kerül, mert a ProximityPrompt akkor működik, ha egy partban (vagy Attachmentben, vagy PrimaryParttal rendelkező modellben) van a Workspace-ben. A RequiresLineOfSight opciója alapból be van kapcsolva, és elrejti a jelzést, valahányszor valami eltakarja a kamerától ehhez a parthoz vezető kilátást. A Roblox a jelzés saját partját kiveszi ebből az ellenőrzésből, a test többi részét viszont nem, a HumanoidRootPart pedig a törzsön belül van, ezért a script kikapcsolja a rálátás ellenőrzését. A jelzés neve TalkPrompt, és a script a sajátja hozzáadása előtt töröl minden TalkPromptot, amely már a parton van: egy játék közben készült NPC másolat az eredeti jelzésével érkezik, a lemásoltat pedig senki sem figyeli. Ha a DialogueData-ban nincs start mondatos beszélgetés az NPC nevéhez, az Outputban figyelmeztetés jelenik meg az NPC nevével.

Egy ciklus másodpercenként kétszer ellenőriz minden nyitott beszélgetést, és bezárja, ha a játékos 16 studnál messzebb került, vagy a karaktere meghalt, hogy a beszélgetés közben meghalt játékos ne nyitott ablakkal éledjen újra. A PlayerRemoving mindkét táblázatot kiüríti, amikor valaki kilép.

4. lépés: Add hozzá a párbeszédablakot

Nyisd meg a StarterPlayer mappát, vidd az egeret a StarterPlayerScripts fölé, szúrj be egy DialogueClient nevű LocalScriptet, és illeszd bele ezt a kódot. Kódban rakja össze a párbeszédablakot, így a GUI-t nem kell kézzel megrajzolnod.

LocalScript helye: StarterPlayer > StarterPlayerScripts neve: DialogueClient
-- LocalScript a StarterPlayer > StarterPlayerScripts mappában, a neve DialogueClient.
-- Megrajzolja a szervertől érkező beszélgetést: az NPC nevét, a betűről betűre
-- kigépelődő mondatát, a buborékot a feje fölött és lehetőségenként egy gombot. Egy lehetőségre
-- kattintva csak a száma megy el; hogy mi következik, azt a szerver dönti el.

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)

-- Kódban összerakott párbeszédablak
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 pixellel feljebb, hogy a Roblox eszköztára ne takarja el a lehetőségeket
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 -- egy hosszú mondat összemegy, hogy elférjen egy kis telefonképernyőn
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- és nagy képernyőn soha nem lesz 20 pixelnél nagyobb
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 -- minden új mondattal nő, hogy a régi gépelési ciklus leálljon

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 -- csak ezen az eszközön változik
	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()

	-- Buborék az NPC fölött (a DisplayBubble csak LocalScriptben működik)
	local head = npc:FindFirstChild("Head")
	if head then
		TextChatService:DisplayBubble(head, text)
	end

	-- Betűről betűre kigépeljük a mondatot. A darabszámot az eltelt időből számoljuk,
	-- így a sebesség bármilyen képkockasebesség mellett ugyanaz.
	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 -- ezt a mondatot egy újabb vagy a bezárás váltotta fel
		end
		shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
		lineLabel.MaxVisibleGraphemes = shown
	end
	lineLabel.MaxVisibleGraphemes = -1

	-- Lehetőségenként egy gomb; a szerver csak a gomb számát kapja meg
	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 -- mondatonként egy kattintás
				dialogueEvent:FireServer(index)
			end
		end)
		if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
			GuiService.SelectedObject = button -- hogy a lehetőséget kontrollerrel is ki lehessen választani
		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)

A színeket, a méreteket és a LETTERS_PER_SECOND értéket tetszés szerint módosíthatod. Az utolsó két kezelőt hagyd úgy, ahogy van: ez az egyetlen mód, ahogyan az ablak a szerverrel kommunikál.

Mit csinál a DialogueClient egyes része:

  • Az ablak. Egy ScreenGui egy Frame-mel, amely a képernyő alján középen van rögzítve, a szélessége 60%-ával és a magassága 34%-ával, egy UISizeConstraint-tel 720 x 300 pixelre korlátozva, hogy ne nyúljon szét az egész széles monitoron. Az NPC mondata TextScaled beállítást használ, amely kis telefonképernyőn lekicsinyíti a szöveget, hogy elférjen a címkéjében, az UITextSizeConstraint pedig nem engedi, hogy nagy képernyőn 20 pixelnél nagyobbra nőjön. Az UIGridLayout kettő x kettő elrendezésben teszi ki a lehetőségeket. A ResetOnSpawn értéke false, mert ez a LocalScript játékmenetenként egyszer fut le: egy respawnkor törölt ablak soha többé nem térne vissza.
  • Írógép effektus. Az egész mondat egyszerre kerül a TextLabelbe, a MaxVisibleGraphemes pedig eldönti, hány karakter látszik; ez ugyanaz a tulajdonság, amelyet a Roblox saját írógép példája használ az utf8.graphemes mellett. A Roblox úgy rendezi el a szöveget, mintha minden karakter látszana, így a szavak nem ugranak új sorba, és nem változik a méretük, ahogy megjelennek. A script az eltelt időből számolja ki, hány karaktert mutasson, másodpercenként 45-öt, így a sebesség bármilyen képkockasebesség mellett ugyanaz, végül pedig -1-re állítja a tulajdonságot, ami mindent megmutat.
  • Gombok. Akkor jelennek meg, amikor a mondat kigépelődött. Mindegyik csak a saját számát küldi el, és csak egyszer: a lineNumber ellenőrzés megakadályozza, hogy egy dupla kattintás kétszer küldjön, utána pedig az ablak a szervertől várja a következő mondatot.
  • Mondatbuborék. A TextChatService:DisplayBubble(head, text) a mondatot egy chatbuborékba teszi az NPC Head partja fölött. A Roblox ezt csak kliensscriptekben engedi, a bubble chat pedig alapból be van kapcsolva. A buborékot ennek a játékosnak az eszköze rajzolja meg, ezért csak ő látja.
  • Jelzés. Amíg a játékos beszélget, a Talk jelzés saját példánya (a TalkPrompt név alapján találja meg) ki van kapcsolva, hogy ne lógjon a beszélgetés fölött. A többi játékos továbbra is látja a sajátját.
  • Bármilyen eszköz. Az Activated egérkattintásra, telefonos koppintásra és a kontroller A gombjára sül el. A kontroller csak a kiválasztott gombot tudja megnyomni, ezért amikor a PreferredInput szerint a játékos kontrollert használ, a script a GuiService.SelectedObject segítségével kiválasztja az első lehetőséget.
  • Az X gomb. 0-t küld, amit a szerver úgy ért, hogy „fejezd be a beszélgetést”, és azonnal bezárja az ablakot.

Add hozzá a saját műveleteidet

A művelet egy függvény a DialogueService elején lévő ACTIONS táblázatban. Megkapja a játékost és a lehetőséget, és true értéket ad vissza, ha elvégezte a dolgát. Ha a sajátodat szeretnéd hozzáadni, mondjuk egy küldetést, amelyet az NPC ad:

  1. Adj hozzá az ACTIONS táblázathoz egy StartQuest nevű bejegyzést. Először az ellenőrzés, aztán a módosítás: ha a player:GetAttribute("Quest") már be van állítva, adj vissza false értéket; különben hívd meg a player:SetAttribute("Quest", "Cave") függvényt, és adj vissza true értéket.
  2. A DialogueData-ban állítsd be a lehetőségnél az action = "StartQuest" értéket, egy next mondatot siker esetére és egy failNext mondatot kudarc esetére, például "You are already on a quest."
  3. Nyomd meg a Play gombot, és válaszd ki kétszer a lehetőséget. Ha a DialogueData-ban lévő név nem egyezik az ACTIONS kulcsával (a kis- és nagybetű számít), az Outputban megjelenik a DialogueService: no action named StartQuest üzenet, a beszélgetés pedig a failNext mondatra lép.

Szabályok a műveletek írásához:

  • Az ellenőrzést és a módosítást a műveleten belül végezd, a szerveren. A játékos eszköze egyedül a lehetőség számát küldi el.
  • Amire a műveletnek szüksége van, azt a lehetőségből olvasd ki (mint az item), vagy a szerver saját állapotából, de soha ne a remote-ból.
  • Mindent, ami értékes, magán a műveleten belül korlátozz, ugyanúgy, ahogy a Heal saját 30 másodperces cooldownt tart a lastHeal táblázatban. A kattintásonkénti 0,3 másodperces korlát csak lassítja a kattintásokat; nem akadályozza meg, hogy a játékos újra és újra végigmenjen ugyanazon a lehetőségen.
  • Egy másik ablak, például egy bolt megnyitásához a művelet küldhet egy RemoteEventet ennek a játékosnak, és visszaadhat true értéket. Mindenhez, ami abban az ablakban történik, továbbra is saját szerveroldali ellenőrzések kellenek, ahogy az Árus NPC részben.

Miben tévednek más NPC párbeszéd oktatóanyagok

Ha ezt az útmutatót egy videóval vagy fórumbejegyzéssel hasonlítod össze, ezek a fontos különbségek, és az ok, amiért mindegyik módszer problémát okoz.

Gyakori módszerek az NPC párbeszéd oktatóanyagokban, és mit csinál helyettük ez az útmutató
OktatóanyagProblémaEz az útmutató
A Dialog objektumot használja, egy szerveroldali Script pedig a DialogChoiceSelected eseményt figyeli a jutalom kiadásáhozA Roblox dokumentációja szerint ez az esemény csak a kliensoldalon működik, a szerveren nem sül el, ezért a jutalom soha nem érkezik meg.A lehetőség számként jut el a szerverhez, és a szerver maga adja a jutalmat.
LocalScriptből adja a jutalmatA LocalScripttel végzett módosítás azon az egy eszközön marad (lásd mi replikálódik), egy csaló pedig bármikor lefuttathatja ugyanazt a kódot.Minden művelet a DialogueService-ben él.
A game:GetService("Chat"):Chat(head, text) hívással szólaltatja meg az NPC-tA Chat szolgáltatás elavult, helyette a TextChatService használatos.TextChatService:DisplayBubble egy LocalScriptben.
A kliensről küldi el a jutalom nevét vagy a következő mondat id-játEgy csaló bármilyen tárgynevet elküldhet, vagy egyenesen a jutalmat adó mondatra ugorhat.A kliens csak a lehetőség számát küldi el. A szerver azon a mondaton keresi meg, amelyről tudja, hogy a játékos olvassa.
A jelzés elsülése után semmit sem ellenőrizA Roblox biztonsági útmutatója a ProximityPromptot a remote-ok mellé sorolja, mint amivel a kliensek visszaélhetnek, és azt tanácsolja, hogy a művelet előtt ellenőrizd, elég közel van-e a játékos.A távolságot a beszélgetés kezdetén, minden kattintásnál, és amíg nyitva van, másodpercenként kétszer ellenőrzi.
A szöveget egy ciklusban a wait() segítségével gépeliA globális wait elavult, helyette a task.wait használatos.A látható betűk számát az os.clock() alapján számolja, és a task.wait() segítségével vár.

Mit tud és mit nem tud hamisítani a játékos

Számolj azzal, hogy egy csaló mindent irányít a saját eszközén. Elolvashatja a LocalScriptjeidet és mindent a ReplicatedStorage-ben, bármilyen argumentummal annyiszor hívhatja meg a DialogueEventet, ahányszor akarja, és kódból is elsütheti a Talk jelzést, amire a Roblox biztonsági útmutatója figyelmeztet. A DialogueService ugyanolyan fajta szerveroldali ellenőrzésekkel válaszol, mint amilyeneket a RemoteEvent argumentumainak ellenőrzése rész tárgyal. Ezt nyeri vele a csaló.

Mit próbálhat meg egy csaló, és mit kezd vele a DialogueService
A csaló megpróbáljaEredményMiért
A Talk jelzést a pálya túlsó végéről elsütniSemmi sem történikA startConversation ellenőrzi, hogy legfeljebb 16 studnyira van-e (12 plusz 4).
A 99-es lehetőséget, egy stringet, egy törtet vagy NaN-t küldeniFigyelmen kívül maradNem egész szám, vagy nincs ilyen lehetőség azon a mondaton, amelyet olvas.
Jutalom nevét vagy mondat id-ját küldeniSoha nem olvassák kiA szerver csak a lehetőség számát olvassa. A jutalmak a mondat szerveroldali példányának item és action mezőiből jönnek.
Olyan gyorsan kattintani, ahogy a hálózat engediBeszélgetésenként 0,3 másodpercenként egy kattintásA gyorsabb kattintásokra a saját mondatuk érkezik vissza. A beszélgetés befejezése és újraindítása megkerüli ezt a várakozást, ezért a Heal és a GiveItem saját korlátokat tart.
Beszélgetés nélkül fáklyát kérniLehetetlenTárgyak csak egy olyan mondat lehetőségére járnak, amelyről a szerver tudja, hogy a játékos ott tart.
Egy rakás fáklyát összegyűjteniEgyszerre csak egyetA szerver először Torchot keres a Backpackjában és a karakterében, a kapott fáklyát pedig nem lehet eldobni, így nem lehet eldobással és újrakéréssel farmolni.
A gyógyító mondattal spamelni30 másodpercenként egy gyógyításA cooldownt a szerver játékosonként tárolja, és az NPC a healTooSoon mondattal jelzi ezt.
Elmenni, és nyitva hagyni az ablakotFél másodpercen belül bezárulA szerver másodpercenként kétszer ellenőriz minden nyitott beszélgetést.
Elolvasni az egész beszélgetést, azokkal a mondatokkal együtt, ahová még nem jutott elLehetségesA DialogueData a ReplicatedStorage-ben van, amely minden eszközre átmásolódik. Ha ez fontos, tedd át a ServerStorage-be (lásd a 2. lépést).

Egy korlátot érdemes nyíltan kimondani: az a csaló, aki odamegy Guide-hoz, és lehetőségeket választ, pontosan ugyanazt kapja, mint egy becsületes játékos. A szerver azt irányítja, milyen gyakran és honnan, de azt nem, hogy ki. Mindenhez, ami ritka, például egy olyan jutalomhoz, amelyet minden játékos egyszer kaphat meg, a szerver saját ellenőrzése kell, például egy a megszerzéskor beállított attribútum vagy egy adattárba mentett jelző.

5. lépés: Teszteld

  1. Nyomd meg a Play gombot (F5), és menj oda Guide-hoz. 12 studon belül megjelenik a Talk jelzés Guide nevével. Nyomd meg az E-t.
  2. Az ablakban megjelenik a "Guide" név, kigépelődik az üdvözlő mondat, aztán négy gomb jelenik meg. Ugyanez a mondat megjelenik egy buborékban az NPC feje fölött.
  3. Válaszd az "Any tips?", majd az "Anything else?" lehetőséget: újra az első mondatnál vagy. Válaszd a "Bye!" lehetőséget: az ablak bezárul, és a Talk jelzés visszatér.
  4. Először sebezd meg magad: kattints a Client/Server kapcsolóra, hogy átválts a Serverre, jelöld ki a karaktered Humanoid objektumát a Workspace-ben, a Properties ablakban állítsd a Health értékét 50-re, és válts vissza a Clientre. A játékoskarakterek másodpercenként a MaxHealth 1%-át töltik vissza, ezért azonnal szólítsd meg Guide-ot, és válaszd az "I'm hurt. Can you help?" lehetőséget: az életerő teljesre ugrik. Szólítsd meg újra 30 másodpercen belül, és válaszd ezt még egyszer: nincs gyógyítás, Guide pedig azt mondja, hogy egy perce gyógyított meg.
  5. Válaszd a "Got anything for the cave?" lehetőséget: a Torch megjelenik a hotbarban. Vedd kézbe, és nyomd meg a Backspace-t: a kezedben marad. Kérd újra: második fáklya nincs, Guide pedig azt mondja, hogy már nálad van.
  6. Kezdj egy beszélgetést, és menj el. Az ablak nagyjából akkor zárul be, amikor 16 studnyira kerülsz Guide-tól.
  7. Válaszd a Server & Clients lehetőséget a tesztmódok legördülő listájában, állíts be 2 klienst, és nyomd meg a Play gombot. Mindkét játékos egyszerre beszélhet Guide-dal, mindegyik a saját mondatánál.
  8. Teszteld a kontrollert a Controller Emulatorral (Controller az Emulation fülön) playtest közben. Az emulált kontrollerrel menj oda, és nyomd meg a jelzés gombját (alapból ButtonX): amikor a lehetőségek megjelennek, az első már ki van választva, és az A megnyomja.
  9. Teszteld a telefon képernyőjét a Studio Device Simulatorával (az írás idején ez béta: kapcsold be a New Device Simulatort a File, Beta Features menüben, és indítsd újra a Studiót). Válassz egy telefont, nyomd a Rotate gombot, amíg fekvő tájolásba nem kerül, nyomd meg a Play gombot, menj oda Guide-hoz, és koppints a Talk jelzésre. Válaszd az "Any tips?" lehetőséget: az egész mondat látszik a lehetőség gombok fölött, szükség esetén kisebb szöveggel, és nem csúszik rájuk.

Mindeközben tartsd nyitva az Output ablakot (Window menü, majd Output). Amikor ezek a scriptek működnek, semmit sem írnak ki, ezért minden piros hiba vagy DialogueService: kezdetű figyelmeztetés valódi probléma. Lásd Gyakori hibák.

Hogyan bővítsd

Több NPC és hosszabb beszélgetések

Adj hozzá az NPCs mappához egy újabb riget saját névvel, a DialogueData-hoz pedig egy ugyanilyen nevű táblázatot start mondattal. A DialogueService a mappa minden HumanoidRootParttal rendelkező modelljéhez hozzáad egy Talk jelzést, a játék közben hozzáadottakhoz is; egy NPC másolat friss jelzést kap ahelyett, amellyel lemásolták. Két azonos nevű NPC ugyanazt a táblázatot használja. A mondatok bármilyen sorrendben kapcsolódhatnak, és egy lehetőség visszavezethet egy korábbi mondathoz, mint az "Anything else?". Egy mondaton legfeljebb négy lehetőség legyen, mert az ablak kettő x kettő elrendezésben teszi ki őket.

Mondatok, amelyek a haladástól függnek

Ha a visszatérő játékosokat másképp szeretnéd üdvözölni, az első mondatot aszerint válaszd ki, ami a szerver birtokában van. A startConversation függvényben válaszd ki így: local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", ellenőrizd, hogy a mondat létezik, ugyanúgy, ahogy a script a lines.start értéket ellenőrzi, és a beszélgetés létrehozásakor a "start" helyett a firstLine értéket használd. Az attribútumot egy műveletben állítsd be, és adj hozzá egy welcomeBack mondatot Guide táblázatához. Az attribútumok egy játékmenetig élnek; ha látogatások között is emlékezni akarsz a játékosra, ments egy jelzőt egy adattárba, ahogy a DataStore útmutatóban.

Árus NPC

Rakd össze a boltot a bolt GUI útmutató alapján, aztán adj hozzá egy OpenShop műveletet, amely RemoteEventet küld ennek a játékosnak, és true értéket ad vissza, a bolt LocalScriptje pedig nyissa meg a saját ablakát, amikor ez az esemény megérkezik. A vásárlások továbbra is a bolt saját szerveroldali ellenőrzésein mennek át. Ha csak az NPC közelében lehet vásárolni, a távolságot a vásárlás kezelőjében is ellenőrizd, mert a kliens bárhonnan meghívhatja a bolt remote-ját.

Járkáló NPC-k

Ha azt szeretnéd, hogy Guide kóboroljon vagy kövesse a játékosokat, használd az NPC útkeresési útmutatót, és vedd le az Anchored opciót a HumanoidRootPartról, hogy mozoghasson. A Talk jelzés ezen a parton van, így együtt mozog az NPC-vel, és a távolságellenőrzések is ugyanezt a partot használják. Szüneteltesd a járkálást, amíg egy beszélgetés nyitva van, különben az ablak bezárul, amint az NPC 16 studnál messzebb kerül a játékostól.

Kulcsok, küldetések és más jutalmak

A GiveItem bármilyen Toolt kiad a DialogueItems mappából, így az NPC adhat egy kulcsot, amelyet egy zárt ajtó ellenőriz, ahogy az ajtó útmutatóban. Az olyan tárgyakról, amelyek használatkor csinálnak valamit, például gyógyító ételről, az inventory útmutatóban olvashatsz.

Hangok és kamera

Egy hangfelvételhez vagy egy rövid hanghoz minden mondatnál tegyél egy Soundot az NPC Head partjába, és játszd le a DialogueClient show függvényéből. Ha az NPC-re szeretnéd irányítani a kamerát, amíg beszél, az átvezető jelenet útmutató megmutatja, hogyan veszi át egy LocalScript a kamera irányítását, és hogyan adja vissza.

Gyakori hibák és megoldásaik

Nyisd meg az Output ablakot (Window menü, majd Output), mielőtt megnyomod a Play gombot. A párbeszéd problémáinak többsége figyelmeztetést ír ki ott, vagy egy nem egyező névből adódik.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("DialogueEvent")'

A DialogueClient arra a remote-ra vár, amelyet a DialogueService hoz létre, vagyis a DialogueService nem jutott el eddig a pontig. Ellenőrizd, hogy Script-e, nem LocalScript, hogy közvetlenül a ServerScriptService-ben van-e, és nincs-e kikapcsolva. A DialogueService először a ReplicatedStorage-ben lévő DialogueData modulra és a Workspace-ben lévő NPCs mappára vár, ezért ha ezek hiányoznak, vagy elírtad a nevüket, az is megállítja; ilyenkor az Output a DialogueService infinite yield figyelmeztetését mutatja ezzel a névvel.

Az NPC-m fölött nem jelenik meg a Talk jelzés

A DialogueService csak olyan modellekhez ad jelzést, amelyek közvetlenül a Workspace, NPCs mappában vannak, és van HumanoidRootPart nevű partjuk. Ellenőrizd mindkét feltételt, és menj 12 studnál közelebb. Egy Toolboxból származó rignek lehet, hogy nincs ilyen partja, vagy más típusú, mappába csomagolt objektum lehet.

A jelzés megjelenik, de az E megnyomása semmit sem csinál

A szerver nem talált beszélgetést ehhez az NPC-hez, és a játék indulásakor az Output a DialogueService: no conversation with a start line for Guide in DialogueData üzenetet mutatja az NPC-d nevével. A DialogueData táblázatának pontosan úgy kell hívnia, mint a modellnek, a nagybetűkkel együtt, és tartalmaznia kell egy start mondatot.

Egy lehetőség bezárja az ablakot, ahelyett hogy a következő mondatra lépne

Az Output a DialogueService: no line named tip for Guide in DialogueData üzenetet mutatja a te neveiddel: a lehetőség next (vagy failNext) értéke olyan mondatot nevez meg, amely nincs ennek az NPC-nek a táblázatában. A mondatnevekben számít a kis- és nagybetű, ezért vesd össze az írásmódot a táblázattal, itt ez tips.

Az ablak működik, de nincs mondatbuborék

A buborékhoz egy Head nevű part kell közvetlenül az NPC modelljében, és bekapcsolt bubble chat: az Explorerben jelöld ki a TextChatService alatti BubbleChatConfiguration objektumot, és ellenőrizd, hogy be van-e jelölve az Enabled. Alapból be van kapcsolva.

Az Outputban ez áll: DialogueService: no Tool named Torch in ServerStorage.DialogueItems

A szerver nem találta a tárgyat. Ellenőrizd, hogy a ServerStorage-ben lévő mappa neve DialogueItems-e, és hogy egy Tool van-e benne (nem Model és nem Part), pontosan olyan névvel, mint a lehetőség item értéke. Amíg ezt ki nem javítod, Guide a hasTorch mondattal válaszol, mert a művelet nem sikerült.

Az Outputban ez áll: DialogueService: no action named ...

A lehetőség action értéke egyetlen kulccsal sem egyezik az ACTIONS táblázatban. A nevekben számít a kis- és nagybetű: a heal nem ugyanaz, mint a Heal.

Elkészítés a RoCode-dal

Ha egyszerűbb leírnod az NPC-t, mint kézzel összerakni, a RoCode közvetlenül a nálad nyitott place-be megírhatja ezeket a scripteket. Ez egy független AI-ügynök a Roblox Studióhoz, nem a Robloxtól: a webes chatben írsz, a Studio pluginja pedig létrehozza és szerkeszti a scripteket az Explorerben.

Te írod

Szólaltasd meg a Workspace.NPCs alatti Guide modellt: Talk jelzés, párbeszédablak kigépelődő mondatokkal és lehetőség gombokkal, buborék a fej fölött, egy gyógyító lehetőség 30 másodperces cooldownnal, és egy lehetőség, amely egyszer kiadja a Torch eszközt a ServerStorage-ből. A beszélgetést egy ModuleScriptben tárold, és minden jutalmat a szerveren adj ki.

A RoCode elvégzi
  • Először megvizsgálhatja a modellt a Get Properties segítségével, hogy kiolvassa a kulcsértékeket, például a partjai Anchored értékét és a Humanoidja WalkSpeed értékét. Írj / jelet a chatbe, hogy csatold a modell pontos útvonalát
  • A Create Script segítségével megírja a DialogueData ModuleScriptet, a DialogueService Scriptet és a DialogueClient LocalScriptet
  • Utasítása szerint minden megírt script lefordulását ellenőrzi a Check Scripttel, amely futtatás nélkül lefordítja a Studióban
  • A módosításokat csomagokban küldi, és minden csomag egy visszavonási pont a Studio előzményeiben

3.9-es vagy újabb pluginnal a RoCode rövid playtestet indíthat, és elolvashatja a hibákat, 3.9.11-es vagy újabb pluginnal pedig egy tesztkaraktert is irányíthat, hogy ellenőrizze, működik-e a játék, de játék közben nem készít képernyőképeket, ezért menj oda az NPC-hez, és beszélj vele magad. Ha valami nem úgy működik, mondd el a RoCode-nak, mit láttál: a Check Output el tudja olvasni a legutóbbi playtested Server és Client sorait. A beszélő NPC egy rendszer a sok közül; a hogyan készíts Roblox játékot AI-val, promptonként egy rendszerrel oldal megmutatja, hogyan állnak össze. Hogyan csatlakozik a RoCode a Studióhoz.

Gyakori kérdések

Hogyan készíthetek beszélő NPC-t a Roblox Studióban?

Adj az NPC-hez egy ProximityPromptot, és amikor a játékos elsüti, mutasd meg az NPC mondatát egy párbeszédablakban, egy buborékban vagy mindkettőben. Az útmutató három scriptje mindkettőt megcsinálja, és válaszlehetőségeket is hozzáad. Ha csak buborék kell, hívd meg a TextChatService:DisplayBubble(npc.Head, "Hello!") függvényt egy LocalScriptből, amikor a jelzés elsül, ahogy a Roblox bubble chatről szóló oldalának NPC példájában.

Melyiket válasszam: a Dialog objektumot vagy saját párbeszéd GUI-t?

A Dialog objektumhoz nem kell kód, és kattintható buborékot mutat, ami díszítő szöveghez elég. A választási eseménye csak a játékos eszközén sül el, ezért biztonságosan nem tud jutalmat adni, és alapból egyszerre csak egy játékos beszélhet vele. Egy saját ablak, mint ebben az útmutatóban, lehetővé teszi, hogy minden jutalmat a szerver adjon, és minden játékosnak saját beszélgetést ad.

Hogyan adhatok tárgyat a játékosnak egy NPC-től?

Tárold a Toolt a ServerStorage-ben, és egy szerveroldali Script klónozza a játékos Backpackjába, amikor az kiválasztja ezt a lehetőséget, ahogy a GiveItem művelet teszi. Ellenőrizd, hogy a játékosnak nincs-e még ilyen, és kapcsold ki a másolat CanBeDropped opcióját, hogy ne lehessen eldobni és újra kérni. Soha ne engedd, hogy a játékos eszköze mondja meg, melyik tárgyat kell kiadni.

Hogyan készíthetek párbeszédablakot írógép effektussal?

Tedd az egész mondatot egy TextLabelbe, növeld a MaxVisibleGraphemes értékét 0-tól néhány karakterenként, a végén pedig állítsd -1-re, hogy minden látsszon. A Roblox UI animációról szóló oldala ugyanezt a tulajdonságot használja az utf8.graphemes mellett. A DialogueClient az eltelt időből számolja ki, hány karaktert mutasson, másodpercenként 45-öt, így a sebesség nem függ a képkockasebességtől.

Beszélhet két játékos egyszerre ugyanazzal az NPC-vel?

Ennek az útmutatónak a scriptjeivel igen: a szerver játékosonként egy beszélgetést vezet, és minden játékos csak a saját ablakát látja. A beépített Dialog objektum másképp működik: az alapértelmezett BehaviorType értékével, a SinglePlayerrel egyszerre egy játékos beszél, a többiek pedig az ő lehetőségeit látják.

Kell szűrni az NPC párbeszéd szövegét?

A saját magad által írt mondatokat nem kell. A Roblox rád bízza azoknak a megjelenített szövegeknek a szűrését, amelyeket nem közvetlenül te irányítasz, például amit a játékosok írnak be, a véletlen karakterekből összerakott szavakat, vagy egy külső oldalról betöltött szöveget. Ha az NPC megismétel valamit, amit egy játékos írt be, azt a részt szűrd.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.