מדריך · מערכות משחק

איך ליצור דיאלוג עם NPC ב-Roblox Studio

דיאלוג עם NPC ב-Roblox מורכב משלושה חלקים: הנחיה כדי להתחיל את השיחה, חלון שמציג את המילים של ה-NPC ואת כפתורי התשובה של השחקן, וסקריפט שמחליט לאן מובילה כל תשובה. במדריך הזה נבנה את שלושתם: אתם כותבים את השיחה כטבלה פשוטה, שחקנים לוחצים על E כדי לדבר, וכל מה שתשובה נותנת (ריפוי, פריט) נותן השרת, לא המכשיר של השחקן.

עודכן 20 בנובמבר 202618 דק׳ קריאהמאת:

בקצרה

שימו את מודל ה-NPC בתיקייה NPCs ב-Workspace וכתבו את השיחה שלו ב-ModuleScript ב-ReplicatedStorage: לכל שורה יש טקסט של ה-NPC ורשימת אפשרויות שמובילות לשורה אחרת. Script ב-ServerScriptService מוסיף לכל NPC ProximityPrompt ("Talk"), זוכר באיזו שורה כל שחקן נמצא ושולח אותה דרך RemoteEvent. LocalScript מציג את הטקסט וכפתור לכל אפשרות, ושולח בחזרה רק את המספר של הכפתור שנלחץ.

  • תנו פרסים בשרת. האירוע DialogChoiceSelected של האובייקט המובנה Dialog נורה רק בלקוח, ולכן Script של שרת אף פעם לא ישמע אותו, וריפוי או פריט שניתנו ב-LocalScript משנים רק את העותק של המשחק אצל השחקן הזה.
  • הציגו בועה עם השורה דרך TextChatService:DisplayBubble(npc.Head, text) מתוך LocalScript. השירות הישן Chat מיושן, ובמקומו משתמשים ב-TextChatService.
  • שורות שכתבתם בעצמכם לא צריך לסנן. הכלל של Roblox: לסנן כל טקסט מוצג שאתם לא שולטים בו ישירות, למשל את מה ששחקנים מקלידים.
בעמוד הזה
  1. איך זה עובד
  2. 1. מוסיפים NPC
  3. 2. השיחה
  4. 3. סקריפט השרת
  5. 4. חלון הדיאלוג
  6. פעולות משלכם
  7. מדריכים אחרים
  8. גבולות ההגנה
  9. 5. בדיקה
  10. הרחבות
  11. Common errors
  12. עם RoCode
  13. שאלות נפוצות
  14. מקורות וקריאה נוספת

איך דיאלוג עם NPC עובד

איורכל שורה מוקלדת בחלון בזמן שהיא גלויה במלואה בבועה, האפשרויות מופיעות כשהשורה הוקלדה, והשרת נותן Torch כשאתם בוחרים "Got anything for the cave?".

NPC מדבר שעובד במשחק אמיתי מחולק בין השרת למכשיר של כל שחקן. המכשיר מצייר את החלון והכפתורים. השרת, הצד היחיד שאפשר לסמוך עליו, יודע איזו שורה כל שחקן קורא ומחליט מה כל תשובה עושה. תור אחד בשיחה נראה כך:

  1. השחקן מתקרב ל-NPC ולוחץ על E בהנחיה Talk שלו. האירוע Triggered של ההנחיה נורה בשרת עם השחקן הזה.
  2. סקריפט השרת בודק שהשחקן קרוב מספיק, זוכר שהוא בשורה בשם start, ושולח את הטקסט של השורה הזו ואת הכיתובים של האפשרויות שלה רק לשחקן הזה.
  3. ה-LocalScript מקליד את השורה בחלון הדיאלוג, מציג בועה מעל ה-NPC, ואז מוסיף כפתור לכל אפשרות.
  4. השחקן לוחץ, מקיש או בוחר אפשרות. לשרת חוזר רק המספר שלה.
  5. השרת מוצא את המספר הזה בשורה שהוא יודע שהשחקן קורא, מבצע את הפעולה של האפשרות אם יש כזו (ריפוי, פריט), ושולח את השורה הבאה או סוגר את החלון.
ממה מורכב NPC מדבר
רכיבאיפה הוא נמצאמה הוא עושה
ה-Rig בשם GuideWorkspace, בתיקייה בשם NPCsה-NPC עצמו. השם שלו בוחר את השיחה ומוצג על ההנחיה.
ModuleScript DialogueDataReplicatedStorageכל השורות שה-NPC יכול להגיד, האפשרויות מתחת לכל שורה ולאן מובילה כל אפשרות.
Script DialogueServiceServerScriptServiceמוסיף את ההנחיה Talk, זוכר באיזו שורה כל שחקן, בודק כל לחיצה ומבצע פעולות.
RemoteEvent DialogueEventReplicatedStorage (נוצר על ידי DialogueService)נושא כל שורה לשחקן, ואת המספר של האפשרות שנבחרה בחזרה לשרת.
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsמצייר את החלון, מקליד את השורה, מציג את הבועה ואת כפתורי האפשרויות.
Tool בשם Torch (לא חובה)ServerStorage, בתיקייה בשם DialogueItemsהפריט שאחת האפשרויות נותנת. שום דבר מ-ServerStorage לא נשלח לשחקנים.
ה-Explorer כשה-NPC מוכן. כשהמשחק רץ, DialogueService מוסיף RemoteEvent בשם DialogueEvent ל-ReplicatedStorage, ו-ProximityPrompt בשם TalkPrompt עם הכיתוב Talk ל-HumanoidRootPart של כל NPC.
Workspace
  NPCs Folder new
    Guide Model new
      Humanoid Humanoid
      HumanoidRootPart Part
      Head, UpperTorso, LowerTorso ... (חלקי גוף)
ReplicatedStorage
  DialogueData ModuleScript new
ServerScriptService
  DialogueService Script new
ServerStorage
  DialogueItems Folder new
    Torch Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    DialogueClient LocalScript new

שלב 1: הוסיפו NPC

  1. בלשונית Avatar או Home לחצו על Character כדי לפתוח את Rig Generator. בחרו R15, צורת גוף וסגנון. ב-Workspace יופיע Rig בשם Rig. Rig מסוג R6 עובד עם אותם סקריפטים.
  2. שנו את השם שלו ל-Guide. השם חשוב: DialogueService מחפש את השיחה לפי שם המודל, וההנחיה מציגה אותו לשחקנים.
  3. פתחו את ה-Rig, סמנו את ה-HumanoidRootPart שלו וסמנו Anchored בחלון Properties. Part מעוגן אף פעם לא זז בגלל פיזיקה, ולכן ה-NPC עומד איפה ששמתם אותו, ושחקנים לא יכולים לדחוף אותו.
  4. רחפו מעל Workspace ב-Explorer, לחצו על כפתור ה-+ והכניסו Folder בשם NPCs. גררו לתוכה את Guide והציבו את ה-Rig במקום ששחקנים יכולים להגיע אליו.
  5. לא חובה, לאפשרות עם הפריט: רחפו מעל ServerStorage והכניסו Folder בשם DialogueItems. שימו בה Tool בשם Torch עם Part אחד לא מעוגן בשם Handle, זה ה-Part שהדמות מחזיקה ביד. PointLight בתוך ה-Handle יגרום לו לזהור.

השמות רגישים לאותיות גדולות וקטנות, ולכן הקלידו NPCs, Guide, DialogueItems ו-Torch בדיוק כמו שמוצג. NPC יכול להיות כל מודל עם Humanoid ו-HumanoidRootPart, כולל מה-Toolbox, אם הוא נמצא ישירות בתיקייה NPCs.

שלב 2: כתבו את השיחה

רחפו מעל ReplicatedStorage, הכניסו ModuleScript בשם DialogueData והדביקו בו את הקוד הזה. אין בו לוגיקה, רק מילים והקשרים ביניהן, ולכן את הקובץ הזה תערכו הכי הרבה.

ModuleScript בתוך ReplicatedStorage בשם DialogueData
-- ModuleScript ב-ReplicatedStorage בשם DialogueData.
-- כל השיחות, לפי שם ה-NPC ב-Workspace.NPCs. לכל שורה יש
-- טקסט של ה-NPC ואפשרויות תשובה של השחקן. אפשרות יכולה להוביל לשורה אחרת (next),
-- לסיים את השיחה (בלי next) ולבקש מהשרת לעשות משהו (action). אם השרת
-- לא יכול לבצע את הפעולה, הוא מציג את השורה failNext במקום next.

export type Choice = {
	text: string,
	next: string?, -- השורה שמוצגת אחרי האפשרות הזו; nil מסיים את השיחה
	action: string?, -- פעולת שרת מהטבלה ACTIONS ב-DialogueService
	item: string?, -- לפעולה GiveItem: שם ה-Tool ב-ServerStorage.DialogueItems
	failNext: string?, -- השורה שמוצגת במקום next כשלא הצליחו לבצע את הפעולה
}

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

שורות ה-export type בהתחלה מתארות איך נראות שורה ואפשרות. בזמן המשחק הן לא משנות כלום; הן מתארות את הנתונים שלכם כדי שבדיקת הטיפוסים תוכל לבדוק אותם.

איך החלקים קשורים זה לזה:

  • לכל NPC יש טבלה שנקראת לפי המודל שלו בתיקייה NPCs, כאן זה Guide. כל שיחה מתחילה מהשורה start.
  • text הוא מה שה-NPC אומר. choices הם הכפתורים של השחקן, לפי הסדר. בחלון יש מקום לארבעה.
  • next מציין את השורה שצריך להציג אחרי האפשרות הזו. אפשרות בלי next, למשל "Bye!", מסיימת את השיחה. next או failNext שמציינים שורה שלא קיימת בטבלה גם מסיימים אותה, עם אזהרה ב-Output.
  • action מציין את מה שהשרת עושה, מהטבלה ACTIONS ב-DialogueService: כאן זה Heal או GiveItem.
  • item נחוץ ל-GiveItem: זה שם ה-Tool ב-ServerStorage, DialogueItems.
  • failNext היא השורה שמוצגת במקום next כשלא הצליחו לבצע את הפעולה, כדי שה-NPC אף פעם לא יטען לריפוי או למתנה שלא היו.
השיחה של Guide, שורה אחר שורה
שורהGuide אומראפשרויות ולאן הן מובילות
start"Welcome to the village! What can I do for you?""Any tips?" מוביל ל-tips. "I'm hurt. Can you help?" מרפא, ואז healed (או healTooSoon). "Got anything for the cave?" נותן Torch, ואז torch (או hasTorch). "Bye!" מסיים את השיחה.
tips"Stay off the red bricks, and come back if you get hurt.""Anything else?" מחזיר ל-start. "Thanks!" מסיים את השיחה.
healed"There you go, good as new.""Thank you!" מסיים את השיחה.
torch"Take this torch. The cave is dark.""Thanks!" מסיים את השיחה.
healTooSoon"I healed you a moment ago. Come back in a little while.""OK" מסיים את השיחה.
hasTorch"You already have my torch. Keep it lit!""Will do!" מסיים את השיחה.

את המודול הזה קורא רק השרת. LocalScript אף פעם לא עושה לו require: השרת שולח כל שורה כשהשחקן מגיע אליה. אבל מודול ב-ReplicatedStorage עדיין מועתק למכשיר של כל שחקן, ולכן אם יש בשיחה ספוילרים (נגיד, הפתרון לחידה), העבירו את DialogueData ל-ServerStorage. אז בשורה עם require ב-DialogueService החליפו את ReplicatedStorage ב-ServerStorage, כך שכל השורה תיראה כך: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }.

שלב 3: הוסיפו את סקריפט השרת

רחפו מעל ServerScriptService, הכניסו Script בשם DialogueService והדביקו בו את הקוד שלמטה. זה המקום היחיד שבו השיחה מתקדמת, והמקום היחיד שבו ניתן פרס.

Script בתוך ServerScriptService בשם DialogueService
-- Script ב-ServerScriptService בשם DialogueService.
-- מוסיף את ההנחיה Talk לכל NPC ב-Workspace.NPCs ומנהל כל שיחה.
-- המכשיר של השחקן רק מציג טקסט ושולח בחזרה את מספר האפשרות
-- שהוא לחץ עליה. השרת יודע באיזו שורה כל שחקן, בודק את האפשרות
-- ואת המרחק, ורק הוא מרפא או נותן פריטים.

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

-- אותן צורות כמו ב-DialogueData, כדי שבדיקת הטיפוסים של Studio תכיר אותן גם כאן
type Choice = { text: string, next: string?, action: string?, item: string?, failNext: string? }
type Line = { text: string, choices: { Choice } }
local DialogueData = require(ReplicatedStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }

local TALK_DISTANCE = 12 -- studs: רדיוס ההנחיה וכמה קרוב השחקן צריך להישאר
local MIN_SECONDS_BETWEEN_CHOICES = 0.3
local HEAL_COOLDOWN_SECONDS = 30

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

-- הסקריפט הזה יוצר את DialogueEvent בעצמו, אז אל תוסיפו אותו ביד
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 -- אין דמות, היא מתה או שה-NPC נעלם
	end
	-- מרווח קטן, כי המיקום של השחקן מגיע לשרת באיחור קטן
	return (playerRoot.Position - npcRoot.Position).Magnitude <= TALK_DISTANCE + 4
end

-- מה השרת עושה כשלאפשרות יש פעולה. כל אחת מחזירה true אם בוצעה.
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 -- ריפאו לפני זמן קצר מדי
		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 -- עוד אין תרמיל, או שהפריט כבר אצלו
		end
		local item = template:Clone() :: Tool
		item.CanBeDropped = false -- כדי שאף אחד לא יוכל לזרוק אותו ולבקש עוד אחד
		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 -- כבר מדבר, ל-NPC הזה אין שורה "start", מת או רחוק מדי
	end
	local conversation = { npc = npc, npcName = npcName, lineId = "start", lastChoice = 0 }
	conversations[player] = conversation
	showLine(player, conversation)
end

-- השחקן לחץ על האפשרות עם המספר choiceIndex (0 אומר שהוא סגר את החלון)
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
		-- מהר מדי. שולחים שוב את אותה שורה, כי החלון כבר נעל
		-- את הכפתורים אחרי הלחיצה, ואחרת היה מחכה לתשובה לנצח.
		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 -- בשורה שהשחקן הזה קורא אין אפשרות כזו
	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 -- למשל "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 על כל 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() -- עותק של NPC מביא הנחיה ישנה שאף אחד לא מאזין לה
	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)

-- סוגרים את החלון לכל מי שהלך או מת באמצע שיחה
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 יוצר בעצמו את ה-RemoteEvent בשם DialogueEvent כשהמשחק עולה, ולכן לא צריך להכניס כלום ביד ל-ReplicatedStorage. אם כבר יצרתם RemoteEvent בשם הזה, מחקו אותו: ה-LocalScript עלול למצוא את שלכם, ואף אחד בשרת לא מאזין לו.

ההגדרות בראש DialogueService
הגדרההערך כאןמה היא משנה
TALK_DISTANCE12כמה קרוב, ב-studs, השחקן צריך להיות כדי שההנחיה Talk תופיע. השרת מאפשר לו להתרחק עוד 4 studs לפני שהוא סוגר את החלון, כי המיקום של השחקן מגיע לשרת באיחור קטן.
MIN_SECONDS_BETWEEN_CHOICES0.3הזמן הקצר ביותר בין שתי לחיצות שהשרת מקבל. על לחיצה מהירה יותר נשלחת שוב אותה שורה במקום תשובה.
HEAL_COOLDOWN_SECONDS30כמה זמן כל שחקן מחכה בין ריפויים מהפעולה Heal.

השרת שומר ב-conversations רשומה אחת לכל שחקן: עם איזה NPC הוא מדבר, איזו שורה הוא קורא ומתי התקבלה הלחיצה האחרונה שלו. כשההנחיה Talk נורית, startConversation יוצר את הרשומה הזו רק אם השחקן עוד לא מדבר, ל-NPC יש שורה start, והשחקן חי ונמצא בטווח. אחרי זה כל לחיצה עוברת דרך הבדיקות האלה:

מה DialogueService בודק בכל לחיצה
בדיקהקודאם נכשלה
השחקן נמצא בשיחהconversations[player]מתעלמים מהלחיצה.
האפשרות היא מספר שלםtypeof ו-math.floorמתעלמים. מחרוזות, טבלאות, שברים ו-NaN נעצרים כאן.
0 אומר שהשחקן לחץ על XchoiceIndex == 0השיחה מסתיימת.
חי ועדיין לא רחוק יותר מ-16 studs (12 ועוד 4)isCloseהשיחה מסתיימת, והחלון נסגר.
לפחות 0.3 שנייה מאז הלחיצה האחרונה שהתקבלהconversation.lastChoiceאותה שורה נשלחת שוב, ולכן החלון מקבל כפתורים חדשים, ולא מחכה לנצח.
האפשרות קיימת בשורה שהשחקן הזה קוראline.choices[choiceIndex]מתעלמים.
הפעולה הצליחהכל פעולה מחזירה true או falseבמקום next מוצגת השורה failNext.

ההנחיה נתלית על ה-HumanoidRootPart של ה-NPC, כי ProximityPrompt עובד כשהוא נמצא בתוך Part (או Attachment, או מודל עם PrimaryPart) ב-Workspace. ה-RequiresLineOfSight שלו מופעל כברירת מחדל ומסתיר את ההנחיה בכל פעם שמשהו חוסם את הראייה מהמצלמה ל-Part הזה. את ה-Part של ההנחיה עצמה Roblox מוציאה מהבדיקה הזו, אבל לא את שאר הגוף, וה-HumanoidRootPart נמצא בתוך הגו, ולכן הסקריפט מכבה את בדיקת קו הראייה. ההנחיה נקראת TalkPrompt, והסקריפט מוחק כל TalkPrompt שכבר נמצא על ה-Part לפני שהוא מוסיף את שלו: עותק של NPC שנוצר בזמן המשחק מגיע עם ההנחיה של המקור, ואף אחד לא מאזין להנחיה שהועתקה. אם ב-DialogueData אין שיחה עם שורה start לשם של ה-NPC, ב-Output מופיעה אזהרה עם השם של ה-NPC הזה.

לולאה בודקת פעמיים בשנייה כל שיחה פתוחה וסוגרת אותה כשהשחקן התרחק יותר מ-16 studs או שהדמות שלו מתה, כדי ששחקן שמת באמצע שיחה לא ייוולד מחדש עם חלון פתוח. PlayerRemoving מנקה את שתי הטבלאות כשמישהו יוצא.

שלב 4: הוסיפו את חלון הדיאלוג

פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts, הכניסו LocalScript בשם DialogueClient והדביקו בו את הקוד הזה. הוא בונה את חלון הדיאלוג בקוד, ולכן לא צריך לצייר GUI ביד.

LocalScript בתוך StarterPlayer > StarterPlayerScripts בשם DialogueClient
-- LocalScript ב-StarterPlayer > StarterPlayerScripts בשם DialogueClient.
-- מצייר את השיחה שהשרת שולח: את שם ה-NPC, את השורה שלו שמוקלדת אות
-- אחר אות, בועה מעל הראש וכפתור לכל אפשרות. לחיצה על
-- אפשרות שולחת רק את המספר שלה; מה יקרה הלאה, השרת מחליט.

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)

-- חלון הדיאלוג, שנבנה בקוד
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 פיקסלים גבוה יותר, כדי שסרגל הכלים של Roblox לא יסתיר את האפשרויות
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 -- שורה ארוכה מוקטנת כדי להיכנס למסך קטן של טלפון
lineLabel.TextWrapped = true
lineLabel.TextYAlignment = Enum.TextYAlignment.Top
lineLabel.FontFace = REGULAR
lineLabel.Parent = box
local lineTextLimit = Instance.new("UITextSizeConstraint")
lineTextLimit.MaxTextSize = 20 -- ואף פעם לא נעשית גדולה מ-20 פיקסלים במסך גדול
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 -- גדל עם כל שורה חדשה, כדי שלולאת ההקלדה הישנה תיעצר

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 -- משתנה רק במכשיר הזה
	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()

	-- הבועה מעל ה-NPC (DisplayBubble עובד רק ב-LocalScript)
	local head = npc:FindFirstChild("Head")
	if head then
		TextChatService:DisplayBubble(head, text)
	end

	-- מקלידים את השורה אות אחר אות. הכמות מחושבת מהזמן שעבר,
	-- ולכן המהירות זהה בכל קצב פריימים.
	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 -- את השורה הזו החליפה שורה חדשה יותר או סגירה
		end
		shown = math.min(letters, math.floor((os.clock() - startTime) * LETTERS_PER_SECOND))
		lineLabel.MaxVisibleGraphemes = shown
	end
	lineLabel.MaxVisibleGraphemes = -1

	-- כפתור לכל אפשרות; השרת מקבל רק את מספר הכפתור
	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 -- לחיצה אחת לכל שורה
				dialogueEvent:FireServer(index)
			end
		end)
		if index == 1 and UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
			GuiService.SelectedObject = button -- כדי שאפשר יהיה לבחור אפשרות עם ג׳ויפד
		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)

את הצבעים, הגדלים ו-LETTERS_PER_SECOND אפשר לשנות איך שרוצים. את שני ה-handlers האחרונים השאירו כמו שהם: זו הדרך היחידה שבה החלון מדבר עם השרת.

מה עושה כל חלק ב-DialogueClient:

  • החלון. ScreenGui עם Frame שמעוגן בתחתית המסך במרכז, 60% מהרוחב שלו ו-34% מהגובה, עם הגבלה של 720 על 300 פיקסלים דרך UISizeConstraint, כדי שלא יימתח על כל מסך רחב. השורה של ה-NPC משתמשת ב-TextScaled, שמקטין את הטקסט כדי שייכנס לתווית שלו במסך קטן של טלפון, ו-UITextSizeConstraint לא נותן לו לגדול מעבר ל-20 פיקסלים במסך גדול. UIGridLayout מסדר את האפשרויות שתיים על שתיים. ResetOnSpawn שווה false, כי ה-LocalScript הזה רץ פעם אחת לסשן: חלון שנמחק בלידה מחדש לא היה חוזר יותר.
  • אפקט מכונת כתיבה. כל השורה נכנסת ל-TextLabel מיד, ו-MaxVisibleGraphemes קובע כמה תווים גלויים; זה אותו מאפיין שהדוגמה של Roblox עצמה למכונת כתיבה משתמשת בו יחד עם utf8.graphemes. Roblox פורסת את הטקסט כאילו כל התווים גלויים, ולכן מילים לא קופצות לשורה חדשה ולא משנות גודל תוך כדי ההופעה. הסקריפט מחשב כמה תווים להציג מהזמן שעבר, 45 בשנייה, ולכן המהירות זהה בכל קצב פריימים, ואז קובע את המאפיין ל-1-, מה שמציג הכול.
  • הכפתורים. הם מופיעים כשהשורה הוקלדה. כל אחד שולח רק את המספר שלו, ופעם אחת: הבדיקה של lineNumber לא נותנת ללחיצה כפולה לשלוח פעמיים, ומשם החלון מחכה לשורה הבאה מהשרת.
  • בועה עם השורה. TextChatService:DisplayBubble(head, text) שם את השורה בבועת צ׳אט מעל ה-Head של ה-NPC. Roblox מתירה את זה רק בסקריפטים של לקוח, ו-bubble chat מופעל כברירת מחדל. את הבועה מצייר המכשיר של השחקן הזה, ולכן רק הוא רואה אותה.
  • ההנחיה. בזמן שהשחקן מדבר, העותק שלו של ההנחיה Talk (מוצאים אותה לפי השם TalkPrompt) כבוי, כדי שלא תתלה מעל השיחה. שחקנים אחרים עדיין רואים את שלהם.
  • כל מכשיר. Activated נורה בלחיצת עכבר, בהקשה בטלפון ובכפתור A בג׳ויפד. ג׳ויפד יכול ללחוץ רק על כפתור נבחר, ולכן כש-PreferredInput אומר שהשחקן משתמש בג׳ויפד, הסקריפט בוחר את האפשרות הראשונה דרך GuiService.SelectedObject.
  • כפתור ה-X. הוא שולח 0, שהשרת מבין כ"לסיים את השיחה", וסוגר מיד את החלון.

הוסיפו פעולות משלכם

פעולה היא פונקציה בטבלה ACTIONS בראש DialogueService. היא מקבלת את השחקן ואת האפשרות ומחזירה true כשהיא עשתה את שלה. כדי להוסיף אחת משלכם, נגיד משימה שה-NPC נותן:

  1. הוסיפו ל-ACTIONS רשומה בשם StartQuest. קודם בדיקה, אחר כך שינוי: אם player:GetAttribute("Quest") כבר קבוע, החזירו false; אחרת קראו ל-player:SetAttribute("Quest", "Cave") והחזירו true.
  2. ב-DialogueData תנו לאפשרות action = "StartQuest", שורת next למקרה של הצלחה ושורת failNext למקרה של כישלון, למשל "You are already on a quest."
  3. לחצו על Play ובחרו את האפשרות פעמיים. אם השם ב-DialogueData לא תואם למפתח ב-ACTIONS (אותיות גדולות וקטנות חשובות), ב-Output יופיע DialogueService: no action named StartQuest, והשיחה תעבור לשורה failNext.

כללים לכתיבת פעולות:

  • עשו את הבדיקה ואת השינוי בתוך הפעולה, בשרת. הדבר היחיד שהמכשיר של השחקן שולח הוא מספר האפשרות.
  • את מה שהפעולה צריכה קראו מהאפשרות (כמו item) או מהמצב של השרת עצמו, אבל אף פעם לא מ-remote.
  • הגבילו כל דבר בעל ערך בתוך הפעולה עצמה, בדיוק כמו ש-Heal מחזיק זמן המתנה משלו של 30 שניות ב-lastHeal. המגבלה של 0.3 שנייה ללחיצה רק מאטה לחיצות; היא לא מונעת משחקן לעבור שוב ושוב באותה אפשרות.
  • כדי לפתוח חלון אחר, למשל חנות, פעולה יכולה לשלוח RemoteEvent לשחקן הזה ולהחזיר true. כל מה שקורה בחלון ההוא עדיין צריך בדיקות שרת משלו, כמו בפרק NPC מוכר.

במה מדריכים אחרים לדיאלוג עם NPC טועים

אם אתם משווים את המדריך הזה לסרטון או לפוסט בפורום, אלה ההבדלים החשובים, והסיבה שבגללה כל טריק יוצר בעיה.

טריקים נפוצים במדריכים לדיאלוג עם NPC ומה המדריך הזה עושה במקומם
מדריךבעיההמדריך הזה
משתמש באובייקט Dialog, ו-Script של שרת מאזין ל-DialogChoiceSelected כדי לתת פרסבתיעוד של Roblox כתוב שהאירוע הזה עובד רק בצד הלקוח ולא יירה בשרת, ולכן הפרס אף פעם לא מגיע.האפשרות מגיעה לשרת כמספר, והשרת בעצמו נותן את הפרס.
נותן פרס מ-LocalScriptשינוי ש-LocalScript עשה נשאר במכשיר האחד הזה (ראו מה משוכפל), ורמאי יכול להריץ את אותו קוד מתי שירצה.כל הפעולות חיות ב-DialogueService.
גורם ל-NPC לדבר דרך game:GetService("Chat"):Chat(head, text)השירות Chat מיושן, ובמקומו משתמשים ב-TextChatService.TextChatService:DisplayBubble ב-LocalScript.
שולח מהלקוח את שם הפרס או את ה-id של השורה הבאהרמאי יכול לשלוח כל שם פריט או לקפוץ ישר לשורה שנותנת את הפרס.הלקוח שולח רק את מספר האפשרות. השרת מוצא אותו בשורה שהוא יודע שהשחקן קורא.
לא בודק כלום אחרי שההנחיה נוריתמדריך האבטחה של Roblox שם את ProximityPrompt לצד remotes כמשהו שלקוחות יכולים לנצל לרעה, וממליץ לבדוק לפני פעולה אם השחקן קרוב מספיק.המרחק נבדק בתחילת השיחה, בכל לחיצה ופעמיים בשנייה כל עוד היא פתוחה.
מקליד טקסט דרך wait() בלולאהה-wait הגלובלי מיושן, ובמקומו משתמשים ב-task.wait.מחשב את מספר האותיות הגלויות מ-os.clock() ומחכה דרך task.wait().

מה שחקן יכול ומה הוא לא יכול לזייף

הניחו שרמאי שולט בכל דבר במכשיר שלו. הוא יכול לקרוא את ה-LocalScripts שלכם ואת כל מה שב-ReplicatedStorage, להפעיל את DialogueEvent עם כל ארגומנט כמה פעמים שירצה, ולהפעיל את ההנחיה Talk מקוד, כמו שמדריך האבטחה של Roblox מזהיר. DialogueService עונה בבדיקות שרת מאותו סוג שמפורטות בפרק בדיקת ארגומנטים של RemoteEvent. זה מה שרמאי מרוויח מזה.

מה רמאי יכול לנסות ומה DialogueService עושה עם זה
רמאי מנסהתוצאהלמה
להפעיל את ההנחיה Talk מהצד השני של המפהשום דבר לא קורהstartConversation בודק שהוא לא רחוק יותר מ-16 studs (12 ועוד 4).
לשלוח את אפשרות 99, מחרוזת, שבר או NaNמתעלמיםזה לא מספר שלם, או שאין אפשרות כזו בשורה שהוא קורא.
לשלוח שם של פרס או id של שורהאף פעם לא נקראהשרת קורא רק את מספר האפשרות. פרסים לקוחים מהשדות item ו-action של העותק של השורה בשרת.
ללחוץ הכי מהר שהרשת מאפשרתלחיצה אחת כל 0.3 שנייה לשיחהעל לחיצות מהירות יותר חוזרת אותה שורה שלהן. סיום והתחלה מחדש של שיחה עוקפים את ההמתנה הזו, ולכן Heal ו-GiveItem מחזיקים מגבלות משלהם.
לבקש לפיד בלי שיחהבלתי אפשריפריטים ניתנים רק לפי אפשרות בשורה שהשרת יודע שהשחקן נמצא בה.
לאסוף ערימה של לפידיםאחד בכל פעםהשרת קודם מחפש Torch ב-Backpack ובדמות שלו, ואת הלפיד שניתן אי אפשר לזרוק, ולכן אי אפשר לחוות אותו על ידי זריקה ובקשה חוזרת.
להציף את שורת הריפויריפוי אחד כל 30 שניותזמן ההמתנה נשמר בשרת לכל שחקן, וה-NPC מודיע על זה בשורה healTooSoon.
ללכת ולהשאיר את החלון פתוחנסגר תוך חצי שנייההשרת בודק כל שיחה פתוחה פעמיים בשנייה.
לקרוא את כל השיחה, כולל שורות שהוא לא הגיע אליהןאפשריDialogueData נמצא ב-ReplicatedStorage, שמועתק לכל מכשיר. העבירו אותו ל-ServerStorage אם זה חשוב (ראו שלב 2).

על מגבלה אחת כדאי לדבר ישר: רמאי שניגש ל-Guide ובוחר אפשרויות מקבל בדיוק מה ששחקן הגון מקבל. השרת שולט בכמה פעמים ומאיפה, אבל לא במי. כל דבר נדיר, למשל פרס שכל שחקן יכול לקבל פעם אחת, צריך בדיקה שהשרת הוא הבעלים שלה, כמו Attribute שנקבע בקבלה, או דגל שנשמר במאגר הנתונים.

שלב 5: בדקו

  1. לחצו על Play (F5) וגשו ל-Guide. בטווח של 12 studs מופיעה ההנחיה Talk עם השם Guide. לחצו על E.
  2. החלון מציג "Guide", מקליד את שורת הברכה ואז מציג ארבעה כפתורים. אותה שורה מופיעה בבועה מעל הראש של ה-NPC.
  3. בחרו "Any tips?", ואז "Anything else?": אתם שוב בשורה הראשונה. בחרו "Bye!": החלון נסגר, וההנחיה Talk חוזרת.
  4. קודם פגעו בעצמכם: לחצו על המתג Client/Server כדי לעבור ל-Server, סמנו את ה-Humanoid של הדמות שלכם ב-Workspace, קבעו Health ל-50 בחלון Properties וחזרו ל-Client. דמויות של שחקנים משחזרות 1% מה-MaxHealth בכל שנייה, אז דברו מיד עם Guide ובחרו "I'm hurt. Can you help?": החיים קופצים למלא. דברו שוב בתוך 30 שניות ובחרו את זה שוב: אין ריפוי, ו-Guide אומר שהוא ריפא אתכם לפני רגע.
  5. בחרו "Got anything for the cave?": Torch מופיע בסרגל הכלים. הצטיידו בו ולחצו על Backspace: הוא נשאר ביד. בקשו שוב: אין לפיד שני, ו-Guide אומר שכבר יש לכם אחד.
  6. התחילו שיחה והתרחקו. החלון נסגר בערך כשאתם נמצאים 16 studs מ-Guide.
  7. בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. שני השחקנים יכולים לדבר עם Guide בו-זמנית, כל אחד בשורה שלו.
  8. בדקו ג׳ויפד דרך Controller Emulator (Controller בלשונית Emulation) בזמן בדיקת משחק. עם הג׳ויפד המדומה גשו ולחצו על כפתור ההנחיה (כברירת מחדל ButtonX): כשהאפשרויות מופיעות, הראשונה כבר נבחרה, ו-A לוחץ עליה.
  9. בדקו את מסך הטלפון דרך Device Simulator ב-Studio (נכון לזמן הכתיבה זו בטא: הפעילו את New Device Simulator ב-File, Beta Features והפעילו מחדש את Studio). בחרו טלפון, לחצו על Rotate עד שיהיה במצב לרוחב, לחצו על Play, גשו ל-Guide והקישו על ההנחיה Talk. בחרו "Any tips?": כל השורה גלויה מעל כפתורי האפשרויות, אם צריך בטקסט קטן יותר, ולא עולה עליהם.

כל הזמן הזה השאירו את חלון ה-Output פתוח (תפריט Window, ואז Output). כשהסקריפטים האלה עובדים, הם לא מדפיסים כלום, ולכן כל שגיאה אדומה או אזהרה שמתחילה ב-DialogueService: היא בעיה אמיתית. ראו שגיאות נפוצות.

איך להרחיב

עוד NPCs ושיחות ארוכות יותר

הוסיפו לתיקייה NPCs עוד Rig עם שם משלו, וב-DialogueData טבלה עם אותו שם ושורה start. DialogueService מוסיף הנחיית Talk לכל מודל בתיקייה שיש לו HumanoidRootPart, כולל כאלה שנוספו בזמן המשחק; עותק של NPC מקבל הנחיה טרייה במקום זו שאיתה הועתק. שני NPCs עם אותו שם משתמשים בטבלה אחת. שורות יכולות להתקשר בכל סדר, ואפשרות יכולה להוביל חזרה לשורה מוקדמת יותר, כמו "Anything else?". אל תשימו בשורה יותר מארבע אפשרויות, כי החלון מסדר אותן שתיים על שתיים.

שורות שתלויות בהתקדמות

כדי לברך אחרת שחקנים שחוזרים, בחרו את השורה הראשונה לפי מה שהשרת הוא הבעלים שלו. ב-startConversation בחרו אותה דרך local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start", בדקו שהשורה קיימת, בדיוק כמו שהסקריפט בודק את lines.start, והשתמשו ב-firstLine במקום "start" כשיוצרים את השיחה. קבעו את ה-Attribute בפעולה, והוסיפו שורה welcomeBack לטבלה של Guide. Attributes חיים סשן אחד; כדי לזכור שחקן בין ביקורים, שמרו דגל במאגר הנתונים, כמו במדריך ל-DataStore.

NPC מוכר

בנו חנות לפי המדריך ל-GUI של חנות, ואז הוסיפו פעולה OpenShop ששולחת RemoteEvent לשחקן הזה ומחזירה true, ותנו ל-LocalScript של החנות לפתוח את החלון שלו כשהאירוע הזה מגיע. הקניות עדיין עוברות דרך בדיקות השרת של החנות עצמה. אם אפשר לקנות רק ליד ה-NPC, בדקו את המרחק גם בתוך ה-handler של הקנייה, כי הלקוח יכול להפעיל את ה-remote של החנות מכל מקום.

NPCs שהולכים

כדי ש-Guide יסתובב או ילך אחרי שחקנים, קחו את המדריך למציאת דרך ל-NPC והסירו את Anchored מה-HumanoidRootPart, כדי שיוכל לזוז. ההנחיה Talk תלויה על ה-Part הזה, ולכן זזה יחד עם ה-NPC, ובדיקות המרחק משתמשות באותו Part. עצרו את ההליכה כל עוד שיחה פתוחה, אחרת החלון ייסגר ברגע שה-NPC יתרחק מהשחקן יותר מ-16 studs.

מפתחות, משימות ופרסים אחרים

GiveItem נותן כל Tool מ-DialogueItems, ולכן NPC יכול לתת מפתח שדלת נעולה בודקת, כמו במדריך לדלתות. על פריטים שעושים משהו כשמשתמשים בהם, למשל אוכל שמרפא, קראו במדריך למלאי.

סאונד ומצלמה

לקטע קולי או לצליל קצר בכל שורה, שימו Sound ב-Head של ה-NPC והפעילו אותו מ-show ב-DialogueClient. כדי לכוון את המצלמה ל-NPC בזמן שהוא מדבר, המדריך לסצנות קולנועיות מראה איך LocalScript לוקח שליטה על המצלמה ומחזיר אותה.

שגיאות נפוצות ופתרונות

פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. רוב הבעיות עם דיאלוג מדפיסות שם אזהרה או נובעות משם שלא תואם.

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

DialogueClient מחכה ל-remote ש-DialogueService יוצר, כלומר DialogueService לא הגיע לנקודה הזו. בדקו שזה Script, לא LocalScript, שהוא נמצא ישירות ב-ServerScriptService ולא מושבת. DialogueService מחכה קודם ל-DialogueData ב-ReplicatedStorage ולתיקייה NPCs ב-Workspace, ולכן אם הם חסרים או שיש שגיאת הקלדה בשם, גם זה עוצר אותו; אז ה-Output מציג אזהרת infinite yield מ-DialogueService עם השם הזה.

ההנחיה Talk לא מופיעה מעל ה-NPC שלי

DialogueService מוסיף הנחיות רק למודלים שנמצאים ישירות ב-Workspace, NPCs ושיש להם Part בשם HumanoidRootPart. בדקו את שני התנאים והתקרבו לפחות מ-12 studs. ל-Rig מה-Toolbox עלול לא להיות ה-Part הזה, או שזה יכול להיות אובייקט מסוג אחר עטוף בתיקייה.

ההנחיה מופיעה, אבל לחיצה על E לא עושה כלום

השרת לא מצא שיחה ל-NPC הזה, וכשהמשחק עולה ה-Output מציג DialogueService: no conversation with a start line for Guide in DialogueData עם השם של ה-NPC שלכם. הטבלה ב-DialogueData חייבת להיקרא בדיוק כמו המודל, כולל אותיות גדולות, ולהכיל שורה start.

אפשרות סוגרת את החלון במקום לעבור לשורה הבאה

ה-Output מציג DialogueService: no line named tip for Guide in DialogueData עם השמות שלכם: ה-next (או ה-failNext) של האפשרות מציין שורה שלא קיימת בטבלה של ה-NPC הזה. שמות של שורות רגישים לאותיות גדולות וקטנות, ולכן השוו את האיות לטבלה, כאן זה tips.

החלון עובד, אבל אין בועה עם השורה

הבועה צריכה Part בשם Head ישירות בתוך מודל ה-NPC ו-bubble chat מופעל: ב-Explorer סמנו את BubbleChatConfiguration מתחת ל-TextChatService ובדקו ש-Enabled מסומן. כברירת מחדל הוא מופעל.

ב-Output כתוב DialogueService: no Tool named Torch in ServerStorage.DialogueItems

השרת לא הצליח למצוא את הפריט. בדקו שהתיקייה ב-ServerStorage נקראת DialogueItems ושיש בה Tool (לא Model ולא Part) עם השם בדיוק כמו ב-item של האפשרות. עד שתתקנו את זה, Guide עונה בשורה hasTorch, כי הפעולה נכשלה.

ב-Output כתוב DialogueService: no action named ...

ה-action של האפשרות לא תואם אף מפתח בטבלה ACTIONS. השמות רגישים לאותיות גדולות וקטנות: heal זה לא Heal.

לעשות עם RoCode

אם קל לכם יותר לתאר NPC מאשר לבנות אותו ביד, RoCode יכול לכתוב את הסקריפטים האלה ישירות בפלייס שפתוח אצלכם. זה סוכן AI עצמאי ל-Roblox Studio, לא של Roblox: אתם כותבים בצ׳אט באתר, והפלאגין שלו ל-Studio יוצר ועורך סקריפטים ב-Explorer שלכם.

אתם כותבים

תגרום למודל Guide ב-Workspace.NPCs לדבר: הנחיה Talk, חלון דיאלוג עם שורות שמוקלדות וכפתורי אפשרויות, בועה מעל הראש, אפשרות ריפוי עם זמן המתנה של 30 שניות, ואפשרות שנותנת פעם אחת את הכלי Torch מ-ServerStorage. תשמור את השיחה ב-ModuleScript ותיתן את כל הפרסים בשרת.

RoCode עושה
  • יכול קודם לבחון את המודל עם Get Properties, כדי לקרוא ערכי מפתח כמו Anchored של ה-Parts שלו ו-WalkSpeed של ה-Humanoid שלו. הקלידו / בצ׳אט כדי לצרף את הנתיב המדויק למודל
  • כותב את ה-ModuleScript בשם DialogueData, את ה-Script בשם DialogueService ואת ה-LocalScript בשם DialogueClient עם Create Script
  • הוא מונחה לבדוק את הקומפילציה של כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ
  • שולח את השינויים בקבוצות, וכל קבוצה היא נקודת ביטול בהיסטוריה של Studio

עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.11 ומעלה יכול לשלוט בדמות בדיקה כדי לבדוק שהמשחק עובד, אבל בזמן המשחק הוא לא מצלם מסך, אז גשו ל-NPC ודברו איתו בעצמכם. אם משהו לא עובד כמו שצריך, ספרו ל-RoCode מה ראיתם: Check Output יכול לקרוא את שורות ה-Server וה-Client מבדיקת המשחק האחרונה שלכם. NPC מדבר הוא מערכת אחת מתוך הרבה; העמוד איך ליצור משחק Roblox עם AI, מערכת אחת לכל פרומפט מראה איך הן מתחברות יחד. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איך יוצרים NPC מדבר ב-Roblox Studio?

הוסיפו ל-NPC ProximityPrompt, וכששחקן מפעיל אותו, הציגו את השורה של ה-NPC בחלון דיאלוג, בבועה או בשניהם. שלושת הסקריפטים מהמדריך הזה עושים את שניהם ומוסיפים אפשרויות תשובה. אם צריך רק בועה, קראו ל-TextChatService:DisplayBubble(npc.Head, "Hello!") מ-LocalScript כשההנחיה נורית, כמו בדוגמה עם NPC בעמוד של Roblox על bubble chat.

מה לבחור: האובייקט Dialog או GUI דיאלוג משלכם?

האובייקט Dialog לא צריך קוד ומציג בועה שאפשר ללחוץ עליה, וזה מספיק לטקסט דקורטיבי. אירוע הבחירה שלו נורה רק במכשיר של השחקן, ולכן הוא לא יכול לתת פרסים בבטחה, וכברירת מחדל רק שחקן אחד יכול לדבר איתו בכל פעם. חלון משלכם, כמו במדריך הזה, מאפשר לשרת לתת כל פרס ונותן לכל שחקן שיחה משלו.

איך נותנים לשחקן פריט מ-NPC?

שמרו את ה-Tool ב-ServerStorage, ותנו ל-Script של שרת לשכפל אותו ל-Backpack של השחקן כשהוא בוחר את האפשרות הזו, כמו שהפעולה GiveItem עושה. בדקו שאין לשחקן כבר כזה, וכבו בעותק את CanBeDropped, כדי שאי אפשר יהיה לזרוק אותו ולבקש שוב. אף פעם אל תתנו למכשיר של השחקן להגיד איזה פריט לתת.

איך יוצרים חלון דיאלוג עם אפקט מכונת כתיבה?

שימו את כל השורה ב-TextLabel, הגדילו את ה-MaxVisibleGraphemes שלו מ-0 בכמה תווים בכל פעם, ובסוף קבעו 1- כדי להציג הכול. העמוד של Roblox על אנימציית UI משתמש באותו מאפיין יחד עם utf8.graphemes. DialogueClient מחשב כמה תווים להציג מהזמן שעבר, 45 בשנייה, ולכן המהירות לא תלויה בקצב הפריימים.

שני שחקנים יכולים לדבר עם אותו NPC בו-זמנית?

עם הסקריפטים מהמדריך הזה כן: השרת מנהל שיחה אחת לכל שחקן, וכל שחקן רואה רק את החלון שלו. האובייקט המובנה Dialog בנוי אחרת: עם ה-BehaviorType שלו כברירת מחדל, SinglePlayer, מדבר שחקן אחד בכל פעם, והשאר רואים את האפשרויות שלו.

צריך לסנן את הטקסט של דיאלוג NPC?

שורות שכתבתם בעצמכם לא צריך. Roblox מטילה עליכם את האחריות לסנן טקסט מוצג שאתם לא שולטים בו ישירות, למשל את מה ששחקנים מקלידים, מילים שהורכבו מתווים אקראיים, או טקסט שנטען מאתר חיצוני. אם ה-NPC חוזר על משהו ששחקן הקליד, סננו את החלק הזה.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.