בקצרה
שימו את מודל ה-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: לסנן כל טקסט מוצג שאתם לא שולטים בו ישירות, למשל את מה ששחקנים מקלידים.
בעמוד הזה
איך דיאלוג עם NPC עובד
NPC מדבר שעובד במשחק אמיתי מחולק בין השרת למכשיר של כל שחקן. המכשיר מצייר את החלון והכפתורים. השרת, הצד היחיד שאפשר לסמוך עליו, יודע איזו שורה כל שחקן קורא ומחליט מה כל תשובה עושה. תור אחד בשיחה נראה כך:
- השחקן מתקרב ל-NPC ולוחץ על E בהנחיה Talk שלו. האירוע
Triggeredשל ההנחיה נורה בשרת עם השחקן הזה. - סקריפט השרת בודק שהשחקן קרוב מספיק, זוכר שהוא בשורה בשם
start, ושולח את הטקסט של השורה הזו ואת הכיתובים של האפשרויות שלה רק לשחקן הזה. - ה-LocalScript מקליד את השורה בחלון הדיאלוג, מציג בועה מעל ה-NPC, ואז מוסיף כפתור לכל אפשרות.
- השחקן לוחץ, מקיש או בוחר אפשרות. לשרת חוזר רק המספר שלה.
- השרת מוצא את המספר הזה בשורה שהוא יודע שהשחקן קורא, מבצע את הפעולה של האפשרות אם יש כזו (ריפוי, פריט), ושולח את השורה הבאה או סוגר את החלון.
| רכיב | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
ה-Rig בשם Guide | Workspace, בתיקייה בשם NPCs | ה-NPC עצמו. השם שלו בוחר את השיחה ומוצג על ההנחיה. |
ModuleScript DialogueData | ReplicatedStorage | כל השורות שה-NPC יכול להגיד, האפשרויות מתחת לכל שורה ולאן מובילה כל אפשרות. |
Script DialogueService | ServerScriptService | מוסיף את ההנחיה Talk, זוכר באיזו שורה כל שחקן, בודק כל לחיצה ומבצע פעולות. |
RemoteEvent DialogueEvent | ReplicatedStorage (נוצר על ידי DialogueService) | נושא כל שורה לשחקן, ואת המספר של האפשרות שנבחרה בחזרה לשרת. |
LocalScript DialogueClient | StarterPlayer, StarterPlayerScripts | מצייר את החלון, מקליד את השורה, מציג את הבועה ואת כפתורי האפשרויות. |
Tool בשם Torch (לא חובה) | ServerStorage, בתיקייה בשם DialogueItems | הפריט שאחת האפשרויות נותנת. שום דבר מ-ServerStorage לא נשלח לשחקנים. |
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
- בלשונית Avatar או Home לחצו על Character כדי לפתוח את Rig Generator. בחרו R15, צורת גוף וסגנון. ב-Workspace יופיע Rig בשם
Rig. Rig מסוג R6 עובד עם אותם סקריפטים. - שנו את השם שלו ל-
Guide. השם חשוב: DialogueService מחפש את השיחה לפי שם המודל, וההנחיה מציגה אותו לשחקנים. - פתחו את ה-Rig, סמנו את ה-HumanoidRootPart שלו וסמנו Anchored בחלון Properties. Part מעוגן אף פעם לא זז בגלל פיזיקה, ולכן ה-NPC עומד איפה ששמתם אותו, ושחקנים לא יכולים לדחוף אותו.
- רחפו מעל Workspace ב-Explorer, לחצו על כפתור ה-+ והכניסו Folder בשם
NPCs. גררו לתוכה את Guide והציבו את ה-Rig במקום ששחקנים יכולים להגיע אליו. - לא חובה, לאפשרות עם הפריט: רחפו מעל 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.
-- כל השיחות, לפי שם ה-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 אומר | אפשרויות ולאן הן מובילות |
|---|---|---|
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.
-- מוסיף את ההנחיה 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 עלול למצוא את שלכם, ואף אחד בשרת לא מאזין לו.
| הגדרה | הערך כאן | מה היא משנה |
|---|---|---|
TALK_DISTANCE | 12 | כמה קרוב, ב-studs, השחקן צריך להיות כדי שההנחיה Talk תופיע. השרת מאפשר לו להתרחק עוד 4 studs לפני שהוא סוגר את החלון, כי המיקום של השחקן מגיע לשרת באיחור קטן. |
MIN_SECONDS_BETWEEN_CHOICES | 0.3 | הזמן הקצר ביותר בין שתי לחיצות שהשרת מקבל. על לחיצה מהירה יותר נשלחת שוב אותה שורה במקום תשובה. |
HEAL_COOLDOWN_SECONDS | 30 | כמה זמן כל שחקן מחכה בין ריפויים מהפעולה Heal. |
השרת שומר ב-conversations רשומה אחת לכל שחקן: עם איזה NPC הוא מדבר, איזו שורה הוא קורא ומתי התקבלה הלחיצה האחרונה שלו. כשההנחיה Talk נורית, startConversation יוצר את הרשומה הזו רק אם השחקן עוד לא מדבר, ל-NPC יש שורה start, והשחקן חי ונמצא בטווח. אחרי זה כל לחיצה עוברת דרך הבדיקות האלה:
| בדיקה | קוד | אם נכשלה |
|---|---|---|
| השחקן נמצא בשיחה | conversations[player] | מתעלמים מהלחיצה. |
| האפשרות היא מספר שלם | typeof ו-math.floor | מתעלמים. מחרוזות, טבלאות, שברים ו-NaN נעצרים כאן. |
| 0 אומר שהשחקן לחץ על X | choiceIndex == 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.
-- מצייר את השיחה שהשרת שולח: את שם ה-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 נותן:
- הוסיפו ל-
ACTIONSרשומה בשםStartQuest. קודם בדיקה, אחר כך שינוי: אםplayer:GetAttribute("Quest")כבר קבוע, החזירוfalse; אחרת קראו ל-player:SetAttribute("Quest", "Cave")והחזירוtrue. - ב-DialogueData תנו לאפשרות
action = "StartQuest", שורתnextלמקרה של הצלחה ושורתfailNextלמקרה של כישלון, למשל "You are already on a quest." - לחצו על Play ובחרו את האפשרות פעמיים. אם השם ב-DialogueData לא תואם למפתח ב-
ACTIONS(אותיות גדולות וקטנות חשובות), ב-Output יופיעDialogueService: no action named StartQuest, והשיחה תעבור לשורהfailNext.
כללים לכתיבת פעולות:
- עשו את הבדיקה ואת השינוי בתוך הפעולה, בשרת. הדבר היחיד שהמכשיר של השחקן שולח הוא מספר האפשרות.
- את מה שהפעולה צריכה קראו מהאפשרות (כמו
item) או מהמצב של השרת עצמו, אבל אף פעם לא מ-remote. - הגבילו כל דבר בעל ערך בתוך הפעולה עצמה, בדיוק כמו ש-Heal מחזיק זמן המתנה משלו של 30 שניות ב-
lastHeal. המגבלה של 0.3 שנייה ללחיצה רק מאטה לחיצות; היא לא מונעת משחקן לעבור שוב ושוב באותה אפשרות. - כדי לפתוח חלון אחר, למשל חנות, פעולה יכולה לשלוח RemoteEvent לשחקן הזה ולהחזיר
true. כל מה שקורה בחלון ההוא עדיין צריך בדיקות שרת משלו, כמו בפרק 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. זה מה שרמאי מרוויח מזה.
| רמאי מנסה | תוצאה | למה |
|---|---|---|
| להפעיל את ההנחיה 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: בדקו
- לחצו על Play (F5) וגשו ל-Guide. בטווח של 12 studs מופיעה ההנחיה Talk עם השם Guide. לחצו על E.
- החלון מציג "Guide", מקליד את שורת הברכה ואז מציג ארבעה כפתורים. אותה שורה מופיעה בבועה מעל הראש של ה-NPC.
- בחרו "Any tips?", ואז "Anything else?": אתם שוב בשורה הראשונה. בחרו "Bye!": החלון נסגר, וההנחיה Talk חוזרת.
- קודם פגעו בעצמכם: לחצו על המתג Client/Server כדי לעבור ל-Server, סמנו את ה-Humanoid של הדמות שלכם ב-Workspace, קבעו Health ל-50 בחלון Properties וחזרו ל-Client. דמויות של שחקנים משחזרות 1% מה-MaxHealth בכל שנייה, אז דברו מיד עם Guide ובחרו "I'm hurt. Can you help?": החיים קופצים למלא. דברו שוב בתוך 30 שניות ובחרו את זה שוב: אין ריפוי, ו-Guide אומר שהוא ריפא אתכם לפני רגע.
- בחרו "Got anything for the cave?": Torch מופיע בסרגל הכלים. הצטיידו בו ולחצו על Backspace: הוא נשאר ביד. בקשו שוב: אין לפיד שני, ו-Guide אומר שכבר יש לכם אחד.
- התחילו שיחה והתרחקו. החלון נסגר בערך כשאתם נמצאים 16 studs מ-Guide.
- בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. שני השחקנים יכולים לדבר עם Guide בו-זמנית, כל אחד בשורה שלו.
- בדקו ג׳ויפד דרך Controller Emulator (Controller בלשונית Emulation) בזמן בדיקת משחק. עם הג׳ויפד המדומה גשו ולחצו על כפתור ההנחיה (כברירת מחדל ButtonX): כשהאפשרויות מופיעות, הראשונה כבר נבחרה, ו-A לוחץ עליה.
- בדקו את מסך הטלפון דרך 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 ותיתן את כל הפרסים בשרת.
- יכול קודם לבחון את המודל עם 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 חוזר על משהו ששחקן הקליד, סננו את החלק הזה.
מקורות וקריאה נוספת
- Roblox Creator Docs: Proximity prompts (באנגלית). יצירת הנחיות, MaxActivationDistance ו-RequiresLineOfSight
- Roblox Engine API: ProximityPrompt (באנגלית). איפה הנחיה עובדת, הטקסט והמקשים שלה כברירת מחדל, Triggered ובדיקת קו הראייה
- Roblox Creator Docs: Securing the client-server boundary (באנגלית). ProximityPrompt כמשטח תקיפה, בדיקות מרחק והרשאות
- Roblox Engine API: Dialog (באנגלית). BehaviorType והאירוע DialogChoiceSelected רק בלקוח
- Roblox Engine API: TextChatService:DisplayBubble (באנגלית). בועות עם שורות ל-NPCs מסקריפטים של לקוח
- Roblox Creator Docs: Customize bubble chat (באנגלית). בועות NPC ו-BubbleChatConfiguration
- Roblox Creator Docs: Text filtering (באנגלית). איזה טקסט מוצג צריך לסנן
- Roblox Creator Docs: UI animation and tweens (באנגלית). אפקט מכונת כתיבה דרך MaxVisibleGraphemes
- Roblox Engine API: Tool.CanBeDropped (באנגלית). מה Backspace עושה לכלי
- Roblox Engine API: UserInputService.PreferredInput (באנגלית). איך מזהים שחקן עם ג׳ויפד
- Roblox Creator Docs: Rig Generator (באנגלית). הכנסת Rig מסוג R15 או R6
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.