Poradnik · Systemy gry

Jak zrobić dialog z NPC w Roblox Studio

Dialog z NPC w Roblox składa się z trzech części: podpowiedzi, żeby zacząć rozmowę, okna, które pokazuje słowa NPC i przyciski z odpowiedziami gracza, i skryptu, który decyduje, do czego prowadzi każda odpowiedź. W tym poradniku budujemy wszystkie trzy: piszesz rozmowę jako prostą tabelę, gracze naciskają E, żeby zagadać, a wszystko, co daje odpowiedź (leczenie, przedmiot), wydaje serwer, a nie urządzenie gracza.

Zaktualizowano 20 listopada 202620 min czytaniaAutor:

W skrócie

Włóż model NPC do folderu NPCs w Workspace i zapisz jego rozmowę w ModuleScript w ReplicatedStorage: każda kwestia ma tekst NPC i listę opcji, które prowadzą do innej kwestii. Script w ServerScriptService dodaje każdemu NPC ProximityPrompt ("Talk"), pamięta, na której kwestii jest każdy gracz, i wysyła ją przez RemoteEvent. LocalScript pokazuje tekst i po przycisku na każdą opcję, a z powrotem wysyła tylko numer klikniętego przycisku.

  • Dawaj nagrody na serwerze. Event DialogChoiceSelected wbudowanego obiektu Dialog odpala się tylko na kliencie, więc serwerowy Script nigdy go nie usłyszy, a leczenie albo przedmiot dane w LocalScript zmieniają tylko kopię gry tego gracza.
  • Pokazuj dymek z kwestią przez TextChatService:DisplayBubble(npc.Head, text) z LocalScript. Stary serwis Chat jest przestarzały, zamiast niego używa się TextChatService.
  • Kwestii, które napisałeś sam, nie trzeba filtrować. Zasada Roblox: filtruj każdy pokazywany tekst, którego nie kontrolujesz bezpośrednio, na przykład to, co wpisują gracze.
Na tej stronie
  1. Jak to działa
  2. 1. Dodajemy NPC
  3. 2. Rozmowa
  4. 3. Skrypt serwerowy
  5. 4. Okno dialogowe
  6. Własne akcje
  7. Inne tutoriale
  8. Granice ochrony
  9. 5. Sprawdzenie
  10. Rozbudowa
  11. Common errors
  12. Z RoCode
  13. Najczęstsze pytania
  14. Źródła i dalsza lektura

Jak działa dialog z NPC

IlustracjaKażda kwestia pisze się w oknie, gdy cała jest widoczna w dymku, opcje pojawiają się, gdy kwestia jest napisana, a serwer daje Torch, gdy wybierasz "Got anything for the cave?".

Mówiący NPC, który działa w prawdziwej grze, jest podzielony między serwer a urządzenie każdego gracza. Urządzenie rysuje okno i przyciski. Serwer, jedyna strona, której można ufać, wie, którą kwestię czyta każdy gracz, i decyduje, co robi każda odpowiedź. Jedna tura rozmowy wygląda tak:

  1. Gracz podchodzi do NPC i naciska E na jego podpowiedzi Talk. Event Triggered podpowiedzi odpala się na serwerze z tym graczem.
  2. Serwerowy skrypt sprawdza, czy gracz jest dość blisko, zapamiętuje, że jest na kwestii o nazwie start, i wysyła tekst tej kwestii i podpisy jej opcji tylko temu graczowi.
  3. LocalScript pisze kwestię w oknie dialogowym, pokazuje dymek nad NPC, potem dodaje po przycisku na każdą opcję.
  4. Gracz klika, dotyka albo wybiera opcję. Do serwera wraca tylko jej numer.
  5. Serwer znajduje ten numer na kwestii, którą według jego wiedzy czyta gracz, wykonuje akcję opcji, jeśli ma (leczenie, przedmiot), i wysyła następną kwestię albo zamyka okno.
Z czego składa się mówiący NPC
ElementGdzie jestCo robi
Rig GuideWorkspace, w folderze o nazwie NPCsSam NPC. Jego nazwa wybiera rozmowę i pokazuje się na podpowiedzi.
ModuleScript DialogueDataReplicatedStorageWszystkie kwestie, które może powiedzieć NPC, opcje pod każdą kwestią i to, dokąd prowadzi każda opcja.
Script DialogueServiceServerScriptServiceDodaje podpowiedź Talk, pamięta, na której kwestii jest każdy gracz, sprawdza każde kliknięcie i wykonuje akcje.
RemoteEvent DialogueEventReplicatedStorage (tworzy go DialogueService)Niesie każdą kwestię do gracza, a numer wybranej opcji z powrotem do serwera.
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsRysuje okno, pisze kwestię, pokazuje dymek i przyciski opcji.
Tool Torch (opcjonalnie)ServerStorage, w folderze o nazwie DialogueItemsPrzedmiot, który daje jedna z opcji. Nic z ServerStorage nie jest wysyłane graczom.
Explorer, gdy NPC jest gotowy. Gdy gra działa, DialogueService dodaje RemoteEvent o nazwie DialogueEvent do ReplicatedStorage i ProximityPrompt Talk o nazwie TalkPrompt do HumanoidRootPart każdego NPC.
Workspace
  NPCs Folder new
    Guide Model new
      Humanoid Humanoid
      HumanoidRootPart Part
      Head, UpperTorso, LowerTorso ... (części ciała)
ReplicatedStorage
  DialogueData ModuleScript new
ServerScriptService
  DialogueService Script new
ServerStorage
  DialogueItems Folder new
    Torch Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    DialogueClient LocalScript new

Krok 1: dodaj NPC

  1. Na karcie Avatar albo Home kliknij Character, żeby otworzyć Rig Generator. Wybierz R15, kształt ciała i styl. W Workspace pojawi się rig o nazwie Rig. Rig R6 działa z tymi samymi skryptami.
  2. Zmień jego nazwę na Guide. Nazwa jest ważna: DialogueService szuka rozmowy według nazwy modelu, a podpowiedź pokazuje ją graczom.
  3. Rozwiń rig, zaznacz jego HumanoidRootPart i zaznacz Anchored w oknie Properties. Zakotwiczony part nigdy nie rusza się przez fizykę, więc NPC stoi tam, gdzie go postawiłeś, a gracze nie mogą go popychać.
  4. Najedź kursorem na Workspace w Explorerze, kliknij przycisk + i wstaw Folder o nazwie NPCs. Przeciągnij do niego Guide i postaw rig tam, gdzie gracze mogą podejść.
  5. Opcjonalnie, dla opcji z przedmiotem: najedź kursorem na ServerStorage i wstaw Folder o nazwie DialogueItems. Włóż do niego Tool o nazwie Torch z jednym niezakotwiczonym Part o nazwie Handle, to part, który postać trzyma w ręce. PointLight w Handle sprawi, że będzie świecić.

Nazwy rozróżniają wielkość liter, więc wpisuj NPCs, Guide, DialogueItems i Torch dokładnie tak, jak pokazano. NPC może być dowolny model z Humanoid i HumanoidRootPart, także z Toolboxa, jeśli leży bezpośrednio w folderze NPCs.

Krok 2: napisz rozmowę

Najedź kursorem na ReplicatedStorage, wstaw ModuleScript o nazwie DialogueData i wklej do niego ten kod. Nie ma w nim logiki, tylko słowa i powiązania między nimi, więc ten plik będziesz edytować najczęściej.

ModuleScript w ReplicatedStorage o nazwie DialogueData
-- ModuleScript w ReplicatedStorage o nazwie DialogueData.
-- Wszystkie rozmowy, według nazwy NPC w Workspace.NPCs. Każda kwestia ma
-- tekst NPC i opcje odpowiedzi gracza. Opcja może prowadzić do innej kwestii (next),
-- kończyć rozmowę (bez next) i prosić serwer, żeby coś zrobił (action). Jeśli serwer
-- nie może wykonać akcji, pokazuje kwestię failNext zamiast next.

export type Choice = {
	text: string,
	next: string?, -- kwestia do pokazania po tej opcji; nil kończy rozmowę
	action: string?, -- akcja serwerowa z tabeli ACTIONS w DialogueService
	item: string?, -- dla akcji GiveItem: nazwa Toola w ServerStorage.DialogueItems
	failNext: string?, -- kwestia do pokazania zamiast next, gdy akcji nie udało się wykonać
}

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

Linie export type na początku opisują, jak wygląda kwestia i opcja. W trakcie gry niczego nie zmieniają; opisują twoje dane, żeby mogło je sprawdzić sprawdzanie typów.

Jak części są ze sobą powiązane:

  • Każdy NPC ma tabelę nazwaną według jego modelu w folderze NPCs, tutaj to Guide. Każda rozmowa zaczyna się od kwestii start.
  • text to to, co mówi NPC. choices to przyciski gracza, po kolei. W oknie jest miejsce na cztery.
  • next wskazuje kwestię, którą trzeba pokazać po tej opcji. Opcja bez next, na przykład "Bye!", kończy rozmowę. next albo failNext, który wskazuje kwestię nieobecną w tabeli, też ją kończy, z ostrzeżeniem w Output.
  • action wskazuje to, co robi serwer, z tabeli ACTIONS w DialogueService: tutaj to Heal albo GiveItem.
  • item jest potrzebny dla GiveItem: to nazwa Toola w ServerStorage, DialogueItems.
  • failNext to kwestia, która pokazuje się zamiast next, gdy akcji nie udało się wykonać, żeby NPC nigdy nie ogłaszał leczenia albo prezentu, których nie było.
Rozmowa Guide, kwestia po kwestii
KwestiaGuide mówiOpcje i dokąd prowadzą
start"Welcome to the village! What can I do for you?""Any tips?" prowadzi do tips. "I'm hurt. Can you help?" leczy, potem healed (albo healTooSoon). "Got anything for the cave?" daje Torch, potem torch (albo hasTorch). "Bye!" kończy rozmowę.
tips"Stay off the red bricks, and come back if you get hurt.""Anything else?" wraca do start. "Thanks!" kończy rozmowę.
healed"There you go, good as new.""Thank you!" kończy rozmowę.
torch"Take this torch. The cave is dark.""Thanks!" kończy rozmowę.
healTooSoon"I healed you a moment ago. Come back in a little while.""OK" kończy rozmowę.
hasTorch"You already have my torch. Keep it lit!""Will do!" kończy rozmowę.

Ten moduł czyta tylko serwer. LocalScript nigdy nie robi mu require: serwer wysyła każdą kwestię, gdy gracz do niej dochodzi. Ale moduł w ReplicatedStorage i tak kopiuje się na urządzenie każdego gracza, więc jeśli w rozmowie są spoilery (powiedzmy, odpowiedź na zagadkę), przenieś DialogueData do ServerStorage. Potem w linii z require w DialogueService zastąp ReplicatedStorage przez ServerStorage, żeby cała linia wyglądała tak: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.

Krok 3: dodaj skrypt serwerowy

Najedź kursorem na ServerScriptService, wstaw Script o nazwie DialogueService i wklej do niego kod poniżej. To jedyne miejsce, gdzie rozmowa idzie do przodu, i jedyne miejsce, gdzie dawana jest nagroda.

Script w ServerScriptService o nazwie DialogueService
-- Script w ServerScriptService o nazwie DialogueService.
-- Dodaje podpowiedź Talk każdemu NPC w Workspace.NPCs i prowadzi każdą rozmowę.
-- Urządzenie gracza tylko pokazuje tekst i odsyła numer opcji,
-- którą kliknął. Serwer wie, na której kwestii jest każdy gracz, sprawdza opcję
-- i odległość i tylko on leczy albo daje przedmioty.

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

-- Te same kształty co w DialogueData, żeby sprawdzanie typów Studio znało je i tutaj
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 -- study: promień podpowiedzi i to, jak blisko gracz musi zostać
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30

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

-- Ten skrypt sam tworzy DialogueEvent, więc nie dodawaj go ręcznie
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 -- nie ma postaci, jest martwy albo NPC zniknął
	end
	-- mały zapas, bo pozycja gracza dociera do serwera z małym opóźnieniem
	return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end

-- Co robi serwer, gdy opcja ma akcję. Każda zwraca true, jeśli wykonana.
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 -- leczony zbyt niedawno
		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 -- plecaka jeszcze nie ma albo przedmiot już w nim jest
		end
		local item = template:Clone() :: Tool
		item.CanBeDropped = false -- żeby nikt nie mógł go wyrzucić i poprosić o kolejny
		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 -- już rozmawia, ten NPC nie ma kwestii "start", martwy albo za daleko
	end
	local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
	conversations[player] = conversation
	showLine(player, conversation)
end

-- Gracz kliknął opcję o numerze choiceIndex (0 znaczy, że zamknął okno)
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
		-- Za szybko. Wysyłamy tę samą kwestię znowu, bo okno już zablokowało
		-- przyciski po kliknięciu i inaczej czekałoby na odpowiedź w nieskończoność.
		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 -- na kwestii, którą czyta ten gracz, nie ma takiej opcji
	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 -- na przykład "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)

-- Podpowiedź Talk na każdym 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() -- kopia NPC przynosi starą podpowiedź, której nikt nie nasłuchuje
	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)

-- Zamykamy okno wszystkim, którzy odeszli albo zginęli w środku rozmowy
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 sam tworzy RemoteEvent DialogueEvent przy starcie gry, więc ręcznie niczego nie trzeba wstawiać do ReplicatedStorage. Jeśli już utworzyłeś RemoteEvent o tej nazwie, usuń go: LocalScript mógłby znaleźć twój, a jego na serwerze nikt nie nasłuchuje.

Ustawienia na początku DialogueService
UstawienieWartość tutajCo zmienia
TALK_DISTANCE12Jak blisko, w studach, musi być gracz, żeby pojawiła się podpowiedź Talk. Serwer pozwala mu odejść jeszcze o 4 study, zanim zamknie okno, bo pozycja gracza dociera do serwera z małym opóźnieniem.
MIN_SECONDS_BETWEEN_CHOICES0.3Najkrótszy czas między dwoma kliknięciami, który przyjmuje serwer. Przy szybszym kliknięciu zamiast odpowiedzi wysyłana jest znowu ta sama kwestia.
HEAL_COOLDOWN_SECONDS30Ile każdy gracz czeka między leczeniami od akcji Heal.

Serwer trzyma w conversations po jednym wpisie na gracza: z którym NPC rozmawia, którą kwestię czyta i kiedy przyjęto jego ostatnie kliknięcie. Gdy odpala się podpowiedź Talk, startConversation tworzy ten wpis tylko wtedy, gdy gracz jeszcze nie rozmawia, NPC ma kwestię start, a gracz żyje i jest w zasięgu. Potem każde kliknięcie przechodzi przez takie sprawdzenia:

Co DialogueService sprawdza przy każdym kliknięciu
SprawdzenieKodJeśli nie przeszło
Gracz jest w rozmowieconversations[player]Kliknięcie jest ignorowane.
Opcja to liczba całkowitatypeof i math.floorIgnorowane. Stringi, tabele, ułamki i NaN zatrzymują się tutaj.
0 oznacza, że gracz kliknął XchoiceIndex == 0Rozmowa się kończy.
Żyje i nadal jest nie dalej niż 16 studów (12 plus 4)isCloseRozmowa się kończy, a okno się zamyka.
Co najmniej 0.3 sekundy od ostatniego przyjętego kliknięciaconversation.lastChoiceTa sama kwestia jest wysyłana znowu, więc okno dostaje świeże przyciski, zamiast czekać w nieskończoność.
Opcja istnieje na kwestii, którą czyta ten graczline.choices[choiceIndex]Ignorowane.
Akcja się udałakażda akcja zwraca true albo falseZamiast next pokazuje się kwestia failNext.

Podpowiedź wisi na HumanoidRootPart NPC, bo ProximityPrompt działa, gdy leży w parcie (albo Attachment, albo modelu z PrimaryPart) w Workspace. Jego RequiresLineOfSight jest domyślnie włączone i chowa podpowiedź za każdym razem, gdy coś zasłania widok od kamery do tego partu. Własny part podpowiedzi Roblox wyłącza z tego sprawdzenia, ale reszty ciała nie, a HumanoidRootPart jest w środku tułowia, więc skrypt wyłącza sprawdzanie bezpośredniej widoczności. Podpowiedź nazywa się TalkPrompt, a skrypt usuwa każdy TalkPrompt, który już leży na parcie, zanim doda swój: kopia NPC zrobiona w trakcie gry przychodzi z podpowiedzią oryginału, a skopiowanej nikt nie nasłuchuje. Jeśli w DialogueData nie ma rozmowy z kwestią start dla nazwy NPC, w Output pojawia się ostrzeżenie z nazwą tego NPC.

Pętla dwa razy na sekundę sprawdza każdą otwartą rozmowę i zamyka ją, gdy gracz odszedł dalej niż 16 studów albo jego postać zginęła, żeby gracz, który zginął w środku rozmowy, nie odrodził się z otwartym oknem. PlayerRemoving czyści obie tabele, gdy ktoś wychodzi.

Krok 4: dodaj okno dialogowe

Otwórz StarterPlayer, najedź kursorem na StarterPlayerScripts, wstaw LocalScript o nazwie DialogueClient i wklej do niego ten kod. Buduje okno dialogowe w kodzie, więc nie trzeba rysować GUI ręcznie.

LocalScript w StarterPlayer > StarterPlayerScripts o nazwie DialogueClient
-- LocalScript w StarterPlayer > StarterPlayerScripts o nazwie DialogueClient.
-- Rysuje rozmowę, którą przysyła serwer: imię NPC, jego kwestię pisaną litera
-- po literze, dymek nad głową i po przycisku na każdą opcję. Kliknięcie
-- opcji wysyła tylko jej numer; co będzie dalej, decyduje serwer.

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)

-- Okno dialogowe zbudowane w kodzie
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 piksele wyżej, żeby pasek narzędzi Roblox nie zasłaniał opcji
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 -- długa kwestia się zmniejsza, żeby zmieścić się na małym ekranie telefonu
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- i nigdy nie robi się większa niż 20 pikseli na dużym
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 -- rośnie z każdą nową kwestią, żeby stara pętla pisania się zatrzymała

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 -- zmienia się tylko na tym urządzeniu
	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()

	-- Dymek nad NPC (DisplayBubble działa tylko w LocalScript)
	local head = npc:FindFirstChild("Head")
	if head then
		TextChatService:DisplayBubble(head, text)
	end

	-- Piszemy kwestię litera po literze. Liczba jest liczona z upływu czasu,
	-- więc prędkość jest taka sama przy każdej liczbie klatek.
	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 -- tę kwestię zastąpiła nowsza albo zamknięcie
		end
		shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
		lineLabel.MaxVisibleGraphemes = shown
	end
	lineLabel.MaxVisibleGraphemes = -1

	-- Po przycisku na opcję; serwer dostaje tylko numer przycisku
	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 -- jedno kliknięcie na kwestię
				dialogueEvent:FireServer(index)
			end
		end)
		if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
			GuiService.SelectedObject = button -- żeby opcję można było wybrać padem
		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)

Kolory, rozmiary i LETTERS_PER_SECOND możesz zmieniać, jak chcesz. Dwa ostatnie handlery zostaw bez zmian: to jedyny sposób, w jaki okno rozmawia z serwerem.

Co robi każda część DialogueClient:

  • Okno. ScreenGui z Frame przypiętym na dole na środku ekranu, 60% jego szerokości i 34% wysokości, z ograniczeniem 720 na 300 pikseli przez UISizeConstraint, żeby nie rozciągał się na cały szeroki monitor. Kwestia NPC używa TextScaled, który zmniejsza tekst, żeby zmieścił się w swoim labelu na małym ekranie telefonu, a UITextSizeConstraint nie pozwala mu urosnąć ponad 20 pikseli na dużym. UIGridLayout układa opcje dwa na dwa. ResetOnSpawn jest false, bo ten LocalScript uruchamia się raz na sesję: okno usunięte przy respawnie by już nie wróciło.
  • Efekt maszyny do pisania. Cała kwestia trafia do TextLabel od razu, a MaxVisibleGraphemes decyduje, ile znaków widać; to ta sama właściwość, której używa własny przykład maszyny do pisania od Roblox razem z utf8.graphemes. Roblox układa tekst tak, jakby widać było wszystkie znaki, więc słowa nie przeskakują do nowej linii i nie zmieniają rozmiaru w miarę pojawiania się. Skrypt liczy, ile znaków pokazać, z upływu czasu, 45 na sekundę, więc prędkość jest taka sama przy każdej liczbie klatek, a potem ustawia właściwość na -1, co pokazuje wszystko.
  • Przyciski. Pojawiają się, gdy kwestia jest napisana. Każdy wysyła tylko swój numer i tylko raz: sprawdzenie lineNumber nie pozwala podwójnemu kliknięciu wysłać dwa razy, a dalej okno czeka na następną kwestię od serwera.
  • Dymek z kwestią. TextChatService:DisplayBubble(head, text) umieszcza kwestię w dymku czatu nad Head NPC. Roblox pozwala na to tylko w skryptach klienckich, a bubble chat jest domyślnie włączony. Dymek rysuje urządzenie tego gracza, więc widzi go tylko on.
  • Podpowiedź. Gdy gracz rozmawia, jego kopia podpowiedzi Talk (znajdowana po nazwie TalkPrompt) jest wyłączona, żeby nie wisiała nad rozmową. Inni gracze nadal widzą swoje.
  • Każde urządzenie. Activated odpala się na kliknięcie myszą, dotknięcie na telefonie i przycisk A na padzie. Pad może nacisnąć tylko zaznaczony przycisk, więc gdy PreferredInput mówi, że gracz używa pada, skrypt zaznacza pierwszą opcję przez GuiService.SelectedObject.
  • Przycisk X. Wysyła 0, co serwer rozumie jako „zakończ rozmowę”, i od razu zamyka okno.

Dodaj własne akcje

Akcja to funkcja w tabeli ACTIONS na początku DialogueService. Dostaje gracza i opcję i zwraca true, gdy zrobiła swoje. Żeby dodać własną, powiedzmy questa, którego daje NPC:

  1. Dodaj do ACTIONS wpis o nazwie StartQuest. Najpierw sprawdzenie, potem zmiana: jeśli player:GetAttribute("Quest") jest już ustawione, zwróć false; w przeciwnym razie wywołaj player:SetAttribute("Quest", "Cave") i zwróć true.
  2. W DialogueData ustaw opcji action = "StartQuest", kwestię next na wypadek sukcesu i kwestię failNext na wypadek porażki, na przykład "You are already on a quest."
  3. Kliknij Play i wybierz opcję dwa razy. Jeśli nazwa w DialogueData nie zgadza się z kluczem w ACTIONS (wielkość liter ma znaczenie), w Output pojawi się DialogueService: no action named StartQuest, a rozmowa przejdzie do kwestii failNext.

Zasady pisania akcji:

  • Rób sprawdzenie i zmianę w akcji, na serwerze. Jedyne, co wysyła urządzenie gracza, to numer opcji.
  • To, czego potrzebuje akcja, czytaj z opcji (jak item) albo z własnego stanu serwera, ale nigdy z remote’a.
  • Ograniczaj wszystko cenne w samej akcji, tak jak Heal trzyma własny cooldown 30 sekund w lastHeal. Limit 0.3 sekundy na kliknięcie tylko spowalnia kliknięcia; nie przeszkadza graczowi przechodzić przez tę samą opcję raz za razem.
  • Żeby otworzyć inne okno, na przykład sklep, akcja może wysłać RemoteEvent temu graczowi i zwrócić true. Wszystko, co dzieje się w tamtym oknie, i tak wymaga własnych serwerowych sprawdzeń, jak w sekcji NPC-sprzedawca.

W czym mylą się inne tutoriale o dialogach z NPC

Jeśli porównujesz ten poradnik z filmem albo postem na forum, oto ważne różnice i powód, dla którego każdy sposób tworzy problem.

Częste sposoby w tutorialach o dialogach z NPC i co ten poradnik robi zamiast nich
TutorialProblemTen poradnik
Używa obiektu Dialog, a serwerowy Script nasłuchuje DialogChoiceSelected, żeby dać nagrodęW dokumentacji Roblox napisano, że ten event działa tylko po stronie klienta i na serwerze się nie odpali, więc nagroda nigdy nie przychodzi.Opcja dociera do serwera jako liczba, a serwer sam daje nagrodę.
Daje nagrodę z LocalScriptZmiana zrobiona przez LocalScript zostaje na tym jednym urządzeniu (zobacz co się replikuje), a oszust może uruchomić ten sam kod, kiedy chce.Wszystkie akcje żyją w DialogueService.
Każe NPC mówić przez game:GetService("Chat"):Chat(head, text)Serwis Chat jest przestarzały, zamiast niego używa się TextChatService.TextChatService:DisplayBubble w LocalScript.
Wysyła z klienta nazwę nagrody albo id następnej kwestiiOszust może wysłać dowolną nazwę przedmiotu albo przeskoczyć prosto do kwestii, która daje nagrodę.Klient wysyła tylko numer opcji. Serwer znajduje go na kwestii, którą według jego wiedzy czyta gracz.
Niczego nie sprawdza po odpaleniu podpowiedziPoradnik Roblox o bezpieczeństwie stawia ProximityPrompt obok remote’ów jako coś, czego klienci mogą nadużywać, i radzi przed działaniem sprawdzać, czy gracz jest dość blisko.Odległość jest sprawdzana na początku rozmowy, przy każdym kliknięciu i dwa razy na sekundę, gdy jest otwarta.
Pisze tekst przez wait() w pętliGlobalne wait jest przestarzałe, zamiast niego używa się task.wait.Liczy liczbę widocznych liter z os.clock() i czeka przez task.wait().

Co gracz może, a czego nie może podrobić

Zakładaj, że oszust kontroluje wszystko na swoim urządzeniu. Może czytać twoje LocalScripty i wszystko w ReplicatedStorage, wywoływać DialogueEvent z dowolnymi argumentami dowolnie wiele razy i uruchamiać podpowiedź Talk z kodu, przed czym ostrzega poradnik Roblox o bezpieczeństwie. DialogueService odpowiada serwerowymi sprawdzeniami tego samego rodzaju, które omawia sekcja sprawdzanie argumentów RemoteEvent. Oto co oszust z tego ma.

Czego może spróbować oszust i co z tym robi DialogueService
Oszust próbujeWynikDlaczego
Uruchomić podpowiedź Talk z drugiego końca mapyNic się nie dziejestartConversation sprawdza, czy jest nie dalej niż 16 studów (12 plus 4).
Wysłać opcję 99, string, ułamek albo NaNIgnorowaneTo nie jest liczba całkowita albo takiej opcji nie ma na kwestii, którą czyta.
Wysłać nazwę nagrody albo id kwestiiNigdy nie jest czytaneSerwer czyta tylko numer opcji. Nagrody pochodzą z pól item i action serwerowej kopii kwestii.
Klikać tak szybko, jak pozwala siećJedno kliknięcie co 0.3 sekundy na rozmowęPrzy szybszych kliknięciach wraca ich własna kwestia. Zakończenie i ponowne rozpoczęcie rozmowy omija to czekanie, dlatego Heal i GiveItem trzymają własne limity.
Poprosić o pochodnię bez rozmowyNiemożliwePrzedmioty są dawane tylko przez opcję na kwestii, na której według wiedzy serwera jest gracz.
Nazbierać mnóstwo pochodniPo jednej narazSerwer najpierw szuka Torch w jego Backpack i postaci, a danej pochodni nie da się wyrzucić, więc nie da się ich farmić, wyrzucając i prosząc znowu.
Spamować kwestią z leczeniemJedno leczenie co 30 sekundCooldown jest trzymany na serwerze dla każdego gracza, a NPC informuje o tym kwestią healTooSoon.
Odejść i zostawić otwarte oknoZamyka się w ciągu pół sekundySerwer sprawdza każdą otwartą rozmowę dwa razy na sekundę.
Przeczytać całą rozmowę, łącznie z kwestiami, do których nie doszedłMożliweDialogueData leży w ReplicatedStorage, który kopiuje się na każde urządzenie. Przenieś go do ServerStorage, jeśli to ważne (zobacz krok 2).

O jednym ograniczeniu warto powiedzieć wprost: oszust, który podchodzi do Guide i wybiera opcje, dostaje dokładnie to samo co uczciwy gracz. Serwer kontroluje, jak często i skąd, ale nie kto. Wszystko rzadkie, na przykład nagroda, którą każdy gracz może dostać raz, wymaga sprawdzenia, którym zarządza serwer, w rodzaju atrybutu ustawionego przy odbiorze albo flagi zapisanej w magazynie danych.

Krok 5: sprawdź

  1. Kliknij Play (F5) i podejdź do Guide. W promieniu 12 studów pojawia się podpowiedź Talk z imieniem Guide. Naciśnij E.
  2. Okno pokazuje "Guide", pisze powitalną kwestię, a potem pokazuje cztery przyciski. Ta sama kwestia pojawia się w dymku nad głową NPC.
  3. Wybierz "Any tips?", potem "Anything else?": jesteś znowu na pierwszej kwestii. Wybierz "Bye!": okno się zamyka, a podpowiedź Talk wraca.
  4. Najpierw zadaj sobie obrażenia: kliknij przełącznik Client/Server, żeby przejść na Server, zaznacz Humanoid swojej postaci w Workspace, ustaw Health na 50 w oknie Properties i przełącz z powrotem na Client. Postacie graczy odzyskują 1% MaxHealth co sekundę, więc od razu zagadaj do Guide i wybierz "I'm hurt. Can you help?": zdrowie skacze do pełna. Zagadaj znowu w ciągu 30 sekund i wybierz to jeszcze raz: leczenia nie ma, a Guide mówi, że leczył cię przed chwilą.
  5. Wybierz "Got anything for the cave?": Torch pojawia się na hotbarze. Załóż go i naciśnij Backspace: zostaje w ręce. Poproś znowu: drugiej pochodni nie ma, a Guide mówi, że już ją masz.
  6. Zacznij rozmowę i odejdź. Okno zamyka się mniej więcej wtedy, gdy jesteś 16 studów od Guide.
  7. Wybierz Server & Clients na liście trybów testu, ustaw 2 klientów i kliknij Play. Obaj gracze mogą rozmawiać z Guide jednocześnie, każdy na swojej kwestii.
  8. Sprawdź pad przez Controller Emulator (Controller na karcie Emulation) w trakcie playtestu. Emulowanym padem podejdź i naciśnij przycisk podpowiedzi (domyślnie ButtonX): gdy pojawiają się opcje, pierwsza jest już zaznaczona, a A ją naciska.
  9. Sprawdź ekran telefonu przez Device Simulator w Studio (w chwili pisania to beta: włącz New Device Simulator w File, Beta Features i uruchom Studio ponownie). Wybierz telefon, klikaj Rotate, aż będzie w orientacji poziomej, kliknij Play, podejdź do Guide i dotknij podpowiedzi Talk. Wybierz "Any tips?": cała kwestia jest widoczna nad przyciskami opcji, w razie potrzeby mniejszym tekstem, i nie nachodzi na nie.

Przez cały ten czas trzymaj okno Output otwarte (menu Window, potem Output). Gdy te skrypty działają, nic nie wypisują, więc każdy czerwony błąd albo ostrzeżenie zaczynające się od DialogueService: to prawdziwy problem. Zobacz Częste błędy.

Jak rozbudować

Więcej NPC i dłuższe rozmowy

Dodaj do folderu NPCs kolejny rig z własną nazwą, a do DialogueData tabelę o tej samej nazwie z kwestią start. DialogueService dodaje podpowiedź Talk każdemu modelowi w folderze, który ma HumanoidRootPart, łącznie z dodanymi w trakcie gry; kopia NPC dostaje świeżą podpowiedź zamiast tej, z którą została skopiowana. Dwa NPC o tej samej nazwie używają jednej tabeli. Kwestie mogą łączyć się w dowolnej kolejności, a opcja może prowadzić z powrotem do wcześniejszej kwestii, jak "Anything else?". Trzymaj na kwestii nie więcej niż cztery opcje, bo okno układa je dwa na dwa.

Kwestie, które zależą od postępu

Żeby inaczej witać powracających graczy, wybieraj pierwszą kwestię według tego, czym zarządza serwer. W startConversation wybierz ją przez local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", sprawdź, czy kwestia istnieje, tak jak skrypt sprawdza lines.start, i użyj firstLine zamiast "start" przy tworzeniu rozmowy. Ustawiaj atrybut w akcji i dodaj kwestię welcomeBack do tabeli Guide. Atrybuty żyją jedną sesję; żeby pamiętać gracza między wizytami, zapisuj flagę w magazynie danych, jak w poradniku o DataStore.

NPC-sprzedawca

Zbuduj sklep według poradnika o GUI sklepu, potem dodaj akcję OpenShop, która wysyła RemoteEvent temu graczowi i zwraca true, i niech LocalScript sklepu otwiera swoje okno, gdy przychodzi ten event. Zakupy dalej idą przez własne serwerowe sprawdzenia sklepu. Jeśli kupować można tylko przy NPC, sprawdzaj odległość też w handlerze zakupu, bo klient może wywołać remote sklepu skądkolwiek.

NPC, którzy chodzą

Żeby Guide się przechadzał albo chodził za graczami, weź poradnik o pathfindingu NPC i zdejmij Anchored z HumanoidRootPart, żeby mógł się ruszać. Podpowiedź Talk wisi na tym parcie, więc rusza się razem z NPC, a sprawdzenia odległości używają tego samego partu. Pauzuj chodzenie, gdy rozmowa jest otwarta, inaczej okno się zamknie, gdy tylko NPC odejdzie od gracza dalej niż 16 studów.

Klucze, questy i inne nagrody

GiveItem daje dowolny Tool z DialogueItems, więc NPC może dać klucz, który sprawdzają zamknięte drzwi, jak w poradniku o drzwiach. O przedmiotach, które coś robią przy użyciu, na przykład jedzeniu, które leczy, przeczytaj w poradniku o ekwipunku.

Dźwięki i kamera

Dla klipu głosowego albo krótkiego dźwięku przy każdej kwestii włóż Sound do Head NPC i odtwarzaj go z show w DialogueClient. Żeby skierować kamerę na NPC, gdy mówi, poradnik o cutscenkach pokazuje, jak LocalScript przejmuje sterowanie kamerą i je oddaje.

Częste błędy i rozwiązania

Otwórz okno Output (menu Window, potem Output) przed kliknięciem Play. Większość problemów z dialogiem wypisuje tam ostrzeżenie albo bierze się z nazwy, która się nie zgadza.

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

DialogueClient czeka na remote, który tworzy DialogueService, więc DialogueService nie doszedł do tego miejsca. Sprawdź, czy to Script, a nie LocalScript, czy leży bezpośrednio w ServerScriptService i czy nie jest wyłączony. DialogueService najpierw czeka na DialogueData w ReplicatedStorage i folder NPCs w Workspace, więc ich brak albo literówka w nazwie też go zatrzymuje; wtedy Output pokazuje ostrzeżenie infinite yield od DialogueService z tą nazwą.

Nad moim NPC nie pojawia się podpowiedź Talk

DialogueService dodaje podpowiedzi tylko modelom, które leżą bezpośrednio w Workspace, NPCs i mają part o nazwie HumanoidRootPart. Sprawdź oba warunki i podejdź bliżej niż 12 studów. Rig z Toolboxa może nie mieć tego partu albo może to być obiekt innego typu zawinięty w folder.

Podpowiedź się pojawia, ale naciśnięcie E nic nie robi

Serwer nie znalazł rozmowy dla tego NPC, a przy starcie gry Output pokazuje DialogueService: no conversation with a start line for Guide in DialogueData z nazwą twojego NPC. Tabela w DialogueData musi nazywać się dokładnie jak model, łącznie z wielkimi literami, i zawierać kwestię start.

Opcja zamyka okno, zamiast przejść do następnej kwestii

Output pokazuje DialogueService: no line named tip for Guide in DialogueData z twoimi nazwami: next (albo failNext) opcji wskazuje kwestię, której nie ma w tabeli tego NPC. Nazwy kwestii rozróżniają wielkość liter, więc porównaj pisownię z tabelą, tutaj to tips.

Okno działa, ale nie ma dymka z kwestią

Dymek potrzebuje partu o nazwie Head bezpośrednio w modelu NPC i włączonego bubble chat: w Explorerze zaznacz BubbleChatConfiguration pod TextChatService i sprawdź, czy zaznaczone jest Enabled. Domyślnie jest włączony.

W Output jest napisane DialogueService: no Tool named Torch in ServerStorage.DialogueItems

Serwer nie mógł znaleźć przedmiotu. Sprawdź, czy folder w ServerStorage nazywa się DialogueItems i czy leży w nim Tool (nie Model ani Part) o nazwie dokładnie jak w item opcji. Dopóki tego nie naprawisz, Guide odpowiada kwestią hasTorch, bo akcja się nie udała.

W Output jest napisane DialogueService: no action named ...

action opcji nie zgadza się z żadnym kluczem w tabeli ACTIONS. Nazwy rozróżniają wielkość liter: heal to nie Heal.

Zrób to z RoCode

Jeśli łatwiej ci opisać NPC, niż budować go ręcznie, RoCode może napisać te skrypty prosto w grze, którą masz otwartą. To niezależny agent AI do Roblox Studio, nie robi go Roblox: piszesz na czacie w przeglądarce, a jego plugin do Studio tworzy i edytuje skrypty w twoim Explorerze.

Ty piszesz

Spraw, żeby model Guide w Workspace.NPCs rozmawiał: podpowiedź Talk, okno dialogowe z pisanymi kwestiami i przyciskami opcji, dymek nad głową, opcja z leczeniem z cooldownem 30 sekund i opcja, która raz daje narzędzie Torch z ServerStorage. Trzymaj rozmowę w ModuleScript i dawaj wszystkie nagrody na serwerze.

RoCode robi
  • Może najpierw obejrzeć model przez Get Properties, żeby przeczytać kluczowe wartości, takie jak Anchored na jego partach i WalkSpeed w jego Humanoid. Wpisz / na czacie, żeby dołączyć dokładną ścieżkę do modelu
  • Pisze ModuleScript DialogueData, Script DialogueService i LocalScript DialogueClient przez Create Script
  • Ma polecone sprawdzać kompilację każdego napisanego skryptu przez Check Script, który kompiluje go w Studio bez uruchamiania
  • Wysyła zmiany paczkami, a każda paczka to punkt cofania w historii Studio

Z pluginem 3.9 lub nowszym RoCode może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.11 lub nowszym może sterować testową postacią, żeby sprawdzić, czy gra działa, ale w trakcie gry nie robi zrzutów ekranu, więc podejdź do NPC i porozmawiaj z nim sam. Jeśli coś działa nie tak, powiedz RoCode, co zobaczyłeś: Check Output może przeczytać linie Server i Client z twojego ostatniego playtestu. Mówiący NPC to jeden system z wielu; strona jak stworzyć grę Roblox z AI, po jednym systemie na prompt pokazuje, jak się składają razem. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Jak zrobić mówiącego NPC w Roblox Studio?

Dodaj NPC ProximityPrompt i, gdy gracz go uruchamia, pokazuj kwestię NPC w oknie dialogowym, w dymku albo w obu miejscach. Trzy skrypty z tego poradnika robią jedno i drugie i dodają opcje odpowiedzi. Jeśli potrzebujesz tylko dymka, wywołaj TextChatService:DisplayBubble(npc.Head, "Hello!") z LocalScript przy odpaleniu podpowiedzi, jak w przykładzie z NPC na stronie Roblox o bubble chat.

Co wybrać: obiekt Dialog czy własne GUI dialogu?

Obiekt Dialog nie potrzebuje kodu i pokazuje klikalny dymek, co wystarcza do dekoracyjnego tekstu. Jego event wyboru odpala się tylko na urządzeniu gracza, więc nie może bezpiecznie dawać nagród, a domyślnie może z nim rozmawiać tylko jeden gracz naraz. Własne okno, jak w tym poradniku, pozwala serwerowi dawać każdą nagrodę i daje każdemu graczowi własną rozmowę.

Jak dać graczowi przedmiot od NPC?

Trzymaj Tool w ServerStorage i niech serwerowy Script klonuje go do Backpack gracza, gdy ten wybiera tę opcję, jak robi akcja GiveItem. Sprawdzaj, czy gracz jeszcze tego nie ma, i wyłączaj w kopii CanBeDropped, żeby nie dało się jej wyrzucić i poprosić znowu. Nigdy nie pozwalaj urządzeniu gracza mówić, jaki przedmiot dać.

Jak zrobić okno dialogowe z efektem maszyny do pisania?

Włóż całą kwestię do TextLabel, zwiększaj jego MaxVisibleGraphemes od 0 po kilka znaków naraz, a na końcu ustaw -1, żeby pokazać wszystko. Strona Roblox o animacji UI używa tej samej właściwości razem z utf8.graphemes. DialogueClient liczy, ile znaków pokazać, z upływu czasu, 45 na sekundę, więc prędkość nie zależy od liczby klatek.

Czy dwóch graczy może rozmawiać z jednym NPC jednocześnie?

Ze skryptami z tego poradnika tak: serwer prowadzi po jednej rozmowie na gracza, a każdy gracz widzi tylko swoje okno. Wbudowany obiekt Dialog działa inaczej: z jego domyślnym BehaviorType, SinglePlayer, mówi jeden gracz naraz, a pozostali widzą jego opcje.

Czy trzeba filtrować tekst dialogu NPC?

Kwestii, które napisałeś sam, nie trzeba. Roblox kładzie na ciebie odpowiedzialność za filtrowanie pokazywanego tekstu, którego nie kontrolujesz bezpośrednio, na przykład tego, co wpisują gracze, słów złożonych z losowych znaków albo tekstu wczytanego z zewnętrznej strony. Jeśli NPC powtarza coś wpisanego przez gracza, filtruj tę część.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.