ट्यूटोरियल · गेम सिस्टम

Roblox Studio में NPC डायलॉग कैसे बनाएं

Roblox में NPC डायलॉग के तीन हिस्से होते हैं: बातचीत शुरू करने के लिए एक prompt, एक विंडो जो NPC की बात और प्लेयर के जवाबों के बटन दिखाती है, और एक स्क्रिप्ट जो तय करती है कि हर जवाब किस ओर ले जाता है। इस गाइड में हम तीनों बनाते हैं: आप बातचीत को एक सरल टेबल के रूप में लिखते हैं, प्लेयर बात करने के लिए E दबाते हैं, और जवाब से मिलने वाली हर चीज़ (हील, आइटम) सर्वर देता है, प्लेयर का डिवाइस नहीं।

अपडेट किया गया 20 नवंबर 202624 मिनट में पढ़ेंलेखक:

संक्षेप में

NPC मॉडल को Workspace के NPCs फ़ोल्डर में रखें और उसकी बातचीत ReplicatedStorage के ModuleScript में लिखें: हर लाइन में NPC का टेक्स्ट और विकल्पों की सूची होती है, जो किसी दूसरी लाइन पर ले जाते हैं। ServerScriptService की Script हर NPC में ProximityPrompt ("Talk") जोड़ती है, याद रखती है कि हर प्लेयर किस लाइन पर है, और उसे RemoteEvent से भेजती है। LocalScript टेक्स्ट और हर विकल्प के लिए एक बटन दिखाता है, और वापस सिर्फ़ दबाए गए बटन का नंबर भेजता है।

  • इनाम सर्वर पर दें। बिल्ट-इन Dialog ऑब्जेक्ट का DialogChoiceSelected इवेंट सिर्फ़ क्लाइंट पर चलता है, इसलिए सर्वर Script उसे कभी नहीं सुनेगी, और LocalScript में दिया गया हील या आइटम सिर्फ़ उस प्लेयर की गेम कॉपी बदलता है।
  • लाइन वाला बबल LocalScript से TextChatService:DisplayBubble(npc.Head, text) के ज़रिए दिखाएँ। पुरानी Chat सर्विस deprecated है, उसकी जगह 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 डायलॉग कैसे काम करता है

चित्रणहर लाइन विंडो में टाइप होती है जबकि पूरी लाइन बबल में दिखती रहती है, लाइन टाइप होने पर विकल्प दिखते हैं, और "Got anything for the cave?" चुनने पर सर्वर Torch देता है।

असली गेम में काम करने वाला बोलने वाला NPC सर्वर और हर प्लेयर के डिवाइस के बीच बँटा होता है। डिवाइस विंडो और बटन बनाता है। सर्वर, जो अकेला भरोसे लायक पक्ष है, जानता है कि हर प्लेयर कौन सी लाइन पढ़ रहा है, और तय करता है कि हर जवाब क्या करता है। बातचीत का एक दौर ऐसा दिखता है:

  1. प्लेयर NPC के पास जाता है और उसके Talk prompt पर E दबाता है। prompt का Triggered इवेंट उसी प्लेयर के साथ सर्वर पर चलता है।
  2. सर्वर स्क्रिप्ट जाँचती है कि प्लेयर काफ़ी पास है, याद रखती है कि वह start नाम की लाइन पर है, और उस लाइन का टेक्स्ट और उसके विकल्पों के लेबल सिर्फ़ उसी प्लेयर को भेजती है।
  3. LocalScript डायलॉग विंडो में लाइन टाइप करता है, NPC के ऊपर बबल दिखाता है, फिर हर विकल्प के लिए एक बटन जोड़ता है।
  4. प्लेयर क्लिक, टैप करता है या विकल्प चुनता है। सर्वर पर सिर्फ़ उसका नंबर लौटता है।
  5. सर्वर उस लाइन पर यह नंबर ढूँढता है जिसे वह जानता है कि प्लेयर पढ़ रहा है, विकल्प का ऐक्शन (हील, आइटम) हो तो उसे चलाता है, और अगली लाइन भेजता है या विंडो बंद करता है।
बोलने वाला NPC किन चीज़ों से बनता है
हिस्साकहाँ होता हैक्या करता है
रिग GuideWorkspace, NPCs नाम के फ़ोल्डर मेंख़ुद NPC। उसका नाम बातचीत चुनता है और prompt पर दिखता है।
ModuleScript DialogueDataReplicatedStorageNPC की कही जा सकने वाली सारी लाइनें, हर लाइन के नीचे के विकल्प, और हर विकल्प कहाँ ले जाता है।
Script DialogueServiceServerScriptServiceTalk prompt जोड़ती है, याद रखती है कि हर प्लेयर किस लाइन पर है, हर क्लिक जाँचती है और ऐक्शन चलाती है।
RemoteEvent DialogueEventReplicatedStorage (इसे DialogueService बनाती है)हर लाइन प्लेयर तक, और चुने गए विकल्प का नंबर वापस सर्वर तक ले जाता है।
LocalScript DialogueClientStarterPlayer, StarterPlayerScriptsविंडो बनाता है, लाइन टाइप करता है, बबल और विकल्पों के बटन दिखाता है।
Tool Torch (ज़रूरी नहीं)ServerStorage, DialogueItems नाम के फ़ोल्डर मेंवह आइटम जो एक विकल्प देता है। ServerStorage की कोई चीज़ प्लेयर को नहीं भेजी जाती।
NPC तैयार होने पर Explorer। गेम चलने पर DialogueService, ReplicatedStorage में DialogueEvent नाम का RemoteEvent और हर NPC के HumanoidRootPart में TalkPrompt नाम का Talk ProximityPrompt जोड़ती है।
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 टैब पर Rig Generator खोलने के लिए Character दबाएँ। R15, शरीर का आकार और स्टाइल चुनें। Workspace में Rig नाम का रिग आ जाएगा। R6 रिग भी इन्हीं स्क्रिप्ट के साथ काम करता है।
  2. उसका नाम Guide रखें। नाम ज़रूरी है: DialogueService मॉडल के नाम से बातचीत ढूँढती है, और prompt यही नाम प्लेयर को दिखाता है।
  3. रिग को खोलें, उसका HumanoidRootPart चुनें और Properties विंडो में Anchored पर टिक करें। Anchored पार्ट फ़िज़िक्स से कभी नहीं हिलता, इसलिए NPC वहीं खड़ा रहता है जहाँ आपने उसे रखा, और प्लेयर उसे धक्का नहीं दे सकते।
  4. Explorer में Workspace पर कर्सर ले जाएँ, + बटन दबाएँ और NPCs नाम का Folder डालें। Guide को उसमें खींचें और रिग को वहाँ रखें जहाँ प्लेयर पहुँच सकें।
  5. ज़रूरी नहीं, आइटम वाले विकल्प के लिए: ServerStorage पर कर्सर ले जाएँ और DialogueItems नाम का Folder डालें। उसमें Torch नाम का Tool रखें, जिसमें Handle नाम का एक बिना Anchored वाला Part हो, यह वह पार्ट है जिसे कैरेक्टर हाथ में पकड़ता है। Handle के अंदर PointLight उसे चमकाएगी।

नाम केस-सेंसिटिव हैं, इसलिए NPCs, Guide, DialogueItems और Torch ठीक वैसे ही लिखें जैसे दिखाया गया है। NPC कोई भी मॉडल हो सकता है जिसमें Humanoid और HumanoidRootPart हों, Toolbox वाला भी, अगर वह सीधे NPCs फ़ोल्डर में रखा हो।

स्टेप 2: बातचीत लिखें

ReplicatedStorage पर कर्सर ले जाएँ, DialogueData नाम का ModuleScript डालें और उसमें यह कोड पेस्ट करें। इसमें कोई लॉजिक नहीं, सिर्फ़ शब्द और उनके बीच के जोड़, इसलिए आप सबसे ज़्यादा यही फ़ाइल बदलेंगे।

ModuleScript स्थान: ReplicatedStorage नाम: DialogueData
-- ReplicatedStorage में DialogueData नाम का ModuleScript।
-- सारी बातचीत, Workspace.NPCs में NPC के नाम से। हर लाइन में
-- NPC का टेक्स्ट और प्लेयर के जवाब के विकल्प होते हैं। विकल्प दूसरी लाइन पर ले जा सकता है (next),
-- बातचीत ख़त्म कर सकता है (बिना next) और सर्वर से कुछ करने को कह सकता है (action)। अगर सर्वर
-- ऐक्शन पूरा नहीं कर पाता, तो वह next की जगह failNext लाइन दिखाता है।

export type Choice = {
	text: string,
	next: string?, -- इस विकल्प के बाद दिखाने वाली लाइन; nil बातचीत ख़त्म करता है
	action: string?, -- DialogueService की ACTIONS टेबल से सर्वर ऐक्शन
	item: string?, -- GiveItem ऐक्शन के लिए: ServerStorage.DialogueItems में Tool का नाम
	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 लाइनें बताती हैं कि लाइन और विकल्प कैसे दिखते हैं। गेम के दौरान ये कुछ नहीं बदलतीं; ये आपके डेटा का वर्णन करती हैं, ताकि type checking उसे जाँच सके।

हिस्से आपस में कैसे जुड़े हैं:

  • हर NPC की एक टेबल है, जिसका नाम NPCs फ़ोल्डर में उसके मॉडल जैसा है, यहाँ Guide। हर बातचीत start लाइन से शुरू होती है।
  • text वह है जो NPC कहता है। choices प्लेयर के बटन हैं, क्रम से। विंडो में चार के लिए जगह है।
  • next उस लाइन का नाम है जो इस विकल्प के बाद दिखानी है। next के बिना विकल्प, जैसे "Bye!", बातचीत ख़त्म करता है। ऐसा next या failNext जो टेबल में मौजूद न होने वाली लाइन का नाम ले, वह भी बातचीत ख़त्म करता है, Output में चेतावनी के साथ।
  • action वह काम बताता है जो सर्वर करता है, DialogueService की ACTIONS टेबल से: यहाँ Heal या GiveItem।
  • item GiveItem के लिए है: ServerStorage, DialogueItems में Tool का नाम।
  • 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 में ले जाएँ। फिर DialogueService में require वाली लाइन में ReplicatedStorage को ServerStorage से बदलें, ताकि पूरी लाइन ऐसी दिखे: local DialogueData = require(ServerStorage:WaitForChild("DialogueData")) :: { [string]: { [string]: Line } }।

स्टेप 3: सर्वर स्क्रिप्ट जोड़ें

ServerScriptService पर कर्सर ले जाएँ, DialogueService नाम की Script डालें और उसमें नीचे का कोड पेस्ट करें। यही अकेली जगह है जहाँ बातचीत आगे बढ़ती है, और अकेली जगह जहाँ इनाम दिया जाता है।

Script स्थान: ServerScriptService नाम: DialogueService
-- ServerScriptService में DialogueService नाम की Script।
-- Workspace.NPCs के हर NPC में Talk prompt जोड़ती है और हर बातचीत चलाती है।
-- प्लेयर का डिवाइस सिर्फ़ टेक्स्ट दिखाता है और उस विकल्प का नंबर वापस भेजता है
-- जिस पर उसने क्लिक किया। सर्वर जानता है कि हर प्लेयर किस लाइन पर है, विकल्प
-- और दूरी जाँचता है, और सिर्फ़ वही हील करता है या आइटम देता है।

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

-- DialogueData जैसे ही आकार, ताकि Studio की type checking उन्हें यहाँ भी जाने
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 -- स्टड: prompt का दायरा और प्लेयर को कितना पास रहना है
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)

-- हर NPC पर Talk prompt
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 की कॉपी पुराना prompt साथ लाती है, जिसे कोई नहीं सुनता
	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 ख़ुद DialogueEvent RemoteEvent बनाती है, इसलिए ReplicatedStorage में हाथ से कुछ डालने की ज़रूरत नहीं। अगर आपने इस नाम का RemoteEvent पहले से बना लिया है, तो उसे हटा दें: LocalScript आपका वाला ढूँढ सकता है, जिसे सर्वर पर कोई नहीं सुनता।

DialogueService की शुरुआत की सेटिंग
सेटिंगयहाँ मानक्या बदलती है
TALK_DISTANCE12Talk prompt दिखने के लिए प्लेयर को कितना पास, स्टड में, होना चाहिए। विंडो बंद करने से पहले सर्वर उसे 4 स्टड और दूर जाने देता है, क्योंकि प्लेयर की पोज़िशन सर्वर तक थोड़ी देर से पहुँचती है।
MIN_SECONDS_BETWEEN_CHOICES0.3दो क्लिक के बीच का सबसे छोटा समय जिसे सर्वर स्वीकार करता है। इससे तेज़ क्लिक पर जवाब की जगह वही लाइन फिर से भेजी जाती है।
HEAL_COOLDOWN_SECONDS30Heal ऐक्शन से दो हील के बीच हर प्लेयर कितना इंतज़ार करता है।

सर्वर conversations में हर प्लेयर की एक एंट्री रखता है: वह किस NPC से बात कर रहा है, कौन सी लाइन पढ़ रहा है, और उसका आख़िरी क्लिक कब स्वीकार हुआ। जब Talk prompt चलता है, तो startConversation यह एंट्री तभी बनाता है जब प्लेयर पहले से बात न कर रहा हो, NPC के पास start लाइन हो, और प्लेयर ज़िंदा और दायरे में हो। इसके बाद हर क्लिक इन जाँचों से गुज़रता है:

DialogueService हर क्लिक पर क्या जाँचती है
जाँचकोडअगर पास न हो
प्लेयर बातचीत में हैconversations[player]क्लिक अनदेखा होता है।
विकल्प पूर्ण संख्या हैtypeof और math.floorअनदेखा। स्ट्रिंग, टेबल, दशमलव और NaN यहीं रुक जाते हैं।
0 का मतलब प्लेयर ने X दबायाchoiceIndex == 0बातचीत ख़त्म होती है।
ज़िंदा है और अब भी 16 स्टड (12 और 4) से ज़्यादा दूर नहींisCloseबातचीत ख़त्म होती है, और विंडो बंद होती है।
पिछले स्वीकार किए क्लिक से कम से कम 0.3 सेकंडconversation.lastChoiceवही लाइन फिर से भेजी जाती है, ताकि विंडो को नए बटन मिलें और वह हमेशा इंतज़ार न करे।
विकल्प उस लाइन पर मौजूद है जिसे यह प्लेयर पढ़ रहा हैline.choices[choiceIndex]अनदेखा।
ऐक्शन सफल हुआहर ऐक्शन true या false लौटाता हैnext की जगह failNext लाइन दिखती है।

prompt NPC के HumanoidRootPart पर लगाया जाता है, क्योंकि ProximityPrompt तब काम करता है जब वह Workspace में किसी पार्ट (या Attachment, या PrimaryPart वाले मॉडल) के अंदर हो। उसका RequiresLineOfSight डिफ़ॉल्ट रूप से चालू होता है और जब भी कैमरे से उस पार्ट तक का नज़ारा किसी चीज़ से रुकता है, prompt छिपा देता है। Roblox prompt के अपने पार्ट को इस जाँच से बाहर रखता है, लेकिन बाकी शरीर को नहीं, और HumanoidRootPart धड़ के अंदर होता है, इसलिए स्क्रिप्ट line of sight जाँच बंद कर देती है। prompt का नाम TalkPrompt है, और अपना prompt जोड़ने से पहले स्क्रिप्ट पार्ट पर पहले से मौजूद हर TalkPrompt हटा देती है: गेम के दौरान बनी NPC की कॉपी असली वाले का prompt साथ लाती है, और कॉपी हुए prompt को कोई नहीं सुनता। अगर DialogueData में NPC के नाम के लिए start लाइन वाली बातचीत नहीं है, तो Output में उस NPC के नाम के साथ चेतावनी दिखती है।

एक लूप सेकंड में दो बार हर खुली बातचीत जाँचता है और प्लेयर के 16 स्टड से ज़्यादा दूर जाने या उसके कैरेक्टर के मरने पर उसे बंद कर देता है, ताकि बातचीत के बीच मरा प्लेयर खुली विंडो के साथ दोबारा स्पॉन न हो। किसी के जाने पर PlayerRemoving दोनों टेबल साफ़ करता है।

स्टेप 4: डायलॉग विंडो जोड़ें

StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ, DialogueClient नाम का LocalScript डालें और उसमें यह कोड पेस्ट करें। यह डायलॉग विंडो कोड में बनाता है, इसलिए GUI हाथ से बनाने की ज़रूरत नहीं।

LocalScript स्थान: StarterPlayer > StarterPlayerScripts नाम: DialogueClient
-- StarterPlayer > StarterPlayerScripts में DialogueClient नाम का LocalScript।
-- सर्वर की भेजी बातचीत दिखाता है: 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 जैसे चाहें बदलें। आख़िरी दो हैंडलर वैसे ही छोड़ें: विंडो सिर्फ़ इन्हीं के ज़रिए सर्वर से बात करती है।

DialogueClient का हर हिस्सा क्या करता है:

  • विंडो। एक ScreenGui जिसमें स्क्रीन के नीचे बीच में टिका Frame है, स्क्रीन की चौड़ाई का 60% और ऊँचाई का 34%, UISizeConstraint से 720 x 300 पिक्सेल की सीमा के साथ, ताकि वह चौड़े मॉनिटर पर पूरी चौड़ाई में न फैले। NPC की लाइन TextScaled इस्तेमाल करती है, जो फ़ोन की छोटी स्क्रीन पर टेक्स्ट को उसके लेबल में फ़िट करने के लिए छोटा करता है, और UITextSizeConstraint बड़ी स्क्रीन पर उसे 20 पिक्सेल से बड़ा नहीं होने देता। UIGridLayout विकल्पों को दो-दो करके रखता है। ResetOnSpawn false है, क्योंकि यह LocalScript हर सेशन में एक बार चलता है: रीस्पॉन पर हटाई गई विंडो फिर कभी नहीं लौटती।
  • टाइपराइटर इफ़ेक्ट। पूरी लाइन एक साथ TextLabel में जाती है, और MaxVisibleGraphemes तय करता है कि कितने अक्षर दिखें; यह वही प्रॉपर्टी है जिसे Roblox का अपना टाइपराइटर उदाहरण utf8.graphemes के साथ इस्तेमाल करता है। Roblox टेक्स्ट को ऐसे रखता है जैसे सारे अक्षर दिख रहे हों, इसलिए शब्द दिखते समय नई लाइन पर नहीं कूदते और साइज़ नहीं बदलते। स्क्रिप्ट बीते समय से गिनती है कि कितने अक्षर दिखाने हैं, सेकंड में 45, इसलिए हर फ़्रेम रेट पर रफ़्तार एक जैसी रहती है, और फिर प्रॉपर्टी को -1 करती है, जो सब कुछ दिखाता है।
  • बटन। लाइन टाइप होने पर दिखते हैं। हर बटन सिर्फ़ अपना नंबर भेजता है, और एक ही बार: lineNumber जाँच डबल क्लिक को दो बार भेजने नहीं देती, और फिर विंडो सर्वर से अगली लाइन का इंतज़ार करती है।
  • लाइन वाला बबल। TextChatService:DisplayBubble(head, text) लाइन को NPC के Head के ऊपर चैट बबल में रखता है। Roblox यह सिर्फ़ क्लाइंट स्क्रिप्ट में करने देता है, और bubble chat डिफ़ॉल्ट रूप से चालू है। बबल इस प्लेयर का डिवाइस बनाता है, इसलिए सिर्फ़ वही उसे देखता है।
  • prompt। जब तक प्लेयर बात कर रहा है, Talk prompt की उसकी कॉपी (TalkPrompt नाम से ढूँढी जाती है) बंद रहती है, ताकि वह बातचीत के ऊपर न लटके। दूसरे प्लेयर अपनी कॉपी अब भी देखते हैं।
  • कोई भी डिवाइस। Activated माउस क्लिक, फ़ोन पर टैप और गेमपैड के A बटन पर चलता है। गेमपैड सिर्फ़ चुना हुआ बटन दबा सकता है, इसलिए जब PreferredInput बताता है कि प्लेयर गेमपैड इस्तेमाल कर रहा है, तो स्क्रिप्ट GuiService.SelectedObject से पहला विकल्प चुन देती है।
  • X बटन। यह 0 भेजता है, जिसे सर्वर "बातचीत ख़त्म करो" समझता है, और तुरंत विंडो बंद कर देता है।

अपने ऐक्शन जोड़ें

ऐक्शन DialogueService की शुरुआत में ACTIONS टेबल का एक फ़ंक्शन है। यह प्लेयर और विकल्प लेता है और अपना काम हो जाने पर 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 की key से मेल नहीं खाता (केस मायने रखता है), तो Output में DialogueService: no action named StartQuest दिखेगा, और बातचीत failNext लाइन पर जाएगी।

ऐक्शन लिखने के नियम:

  • जाँच और बदलाव ऐक्शन के अंदर, सर्वर पर करें। प्लेयर का डिवाइस सिर्फ़ विकल्प का नंबर भेजता है।
  • ऐक्शन को जो चाहिए वह विकल्प से (जैसे item) या सर्वर की अपनी स्थिति से पढ़ें, रिमोट से कभी नहीं।
  • हर क़ीमती चीज़ की सीमा ऐक्शन के अंदर ही रखें, जैसे Heal lastHeal में अपना 30 सेकंड का कूलडाउन रखता है। हर क्लिक पर 0.3 सेकंड की सीमा सिर्फ़ क्लिक धीमे करती है; यह प्लेयर को एक ही विकल्प बार-बार चुनने से नहीं रोकती।
  • कोई दूसरी विंडो खोलने के लिए, जैसे दुकान, ऐक्शन उस प्लेयर को RemoteEvent भेज सकता है और true लौटा सकता है। उस विंडो में होने वाली हर चीज़ को फिर भी अपनी सर्वर जाँच चाहिए, जैसा दुकानदार NPC हिस्से में है।

NPC डायलॉग के दूसरे ट्यूटोरियल कहाँ गलती करते हैं

अगर आप इस गाइड की तुलना किसी वीडियो या फ़ोरम पोस्ट से कर रहे हैं, तो ये ज़रूरी फ़र्क़ हैं, और हर तरीके से समस्या क्यों होती है।

NPC डायलॉग ट्यूटोरियल के आम तरीके और यह गाइड उनकी जगह क्या करती है
ट्यूटोरियलसमस्यायह गाइड
Dialog ऑब्जेक्ट इस्तेमाल करता है, और इनाम देने के लिए सर्वर Script DialogChoiceSelected सुनती हैRoblox के रेफ़रेंस में लिखा है कि यह इवेंट सिर्फ़ क्लाइंट की तरफ़ काम करता है और सर्वर पर नहीं चलेगा, इसलिए इनाम कभी नहीं मिलता।विकल्प सर्वर तक संख्या के रूप में पहुँचता है, और सर्वर ख़ुद इनाम देता है।
इनाम LocalScript से देता हैLocalScript का किया बदलाव उसी एक डिवाइस पर रहता है (देखें क्या रेप्लिकेट होता है), और चीटर वही कोड कभी भी चला सकता है।सारे ऐक्शन DialogueService में रहते हैं।
NPC को game:GetService("Chat"):Chat(head, text) से बुलवाता हैChat सर्विस deprecated है, उसकी जगह TextChatService इस्तेमाल होती है।LocalScript में TextChatService:DisplayBubble।
क्लाइंट से इनाम का नाम या अगली लाइन का id भेजता हैचीटर कोई भी आइटम नाम भेज सकता है या सीधे इनाम देने वाली लाइन पर कूद सकता है।क्लाइंट सिर्फ़ विकल्प का नंबर भेजता है। सर्वर उसे उस लाइन पर ढूँढता है जिसे वह जानता है कि प्लेयर पढ़ रहा है।
prompt चलने के बाद कुछ नहीं जाँचताRoblox की सुरक्षा गाइड ProximityPrompt को रिमोट के साथ उन चीज़ों में रखती है जिनका क्लाइंट गलत इस्तेमाल कर सकते हैं, और ऐक्शन से पहले यह जाँचने की सलाह देती है कि प्लेयर काफ़ी पास है।दूरी बातचीत शुरू होने पर, हर क्लिक पर और बातचीत खुली रहने तक सेकंड में दो बार जाँची जाती है।
लूप में wait() से टेक्स्ट टाइप करता हैग्लोबल wait deprecated है, उसकी जगह task.wait इस्तेमाल होता है।os.clock() से दिखने वाले अक्षरों की संख्या गिनता है और task.wait() से इंतज़ार करता है।

प्लेयर क्या नकली बना सकता है और क्या नहीं

मान लें कि चीटर अपने डिवाइस पर सब कुछ नियंत्रित करता है। वह आपके LocalScript और ReplicatedStorage की हर चीज़ पढ़ सकता है, DialogueEvent को किसी भी आर्ग्युमेंट के साथ कितनी भी बार कॉल कर सकता है, और Talk prompt को कोड से चला सकता है, जिसकी चेतावनी Roblox की सुरक्षा गाइड देती है। DialogueService उसी तरह की सर्वर जाँचों से जवाब देती है जो RemoteEvent आर्ग्युमेंट की जाँच हिस्से में समझाई गई हैं। चीटर को इससे यह मिलता है।

चीटर क्या आज़मा सकता है और DialogueService उसके साथ क्या करती है
चीटर कोशिश करता हैनतीजाक्यों
मैप के दूसरे छोर से Talk prompt चलानाकुछ नहीं होताstartConversation जाँचता है कि वह 16 स्टड (12 और 4) से ज़्यादा दूर नहीं।
विकल्प 99, स्ट्रिंग, दशमलव या NaN भेजनाअनदेखायह पूर्ण संख्या नहीं, या जिस लाइन को वह पढ़ रहा है उस पर ऐसा विकल्प नहीं।
इनाम का नाम या लाइन का id भेजनाकभी पढ़ा नहीं जातासर्वर सिर्फ़ विकल्प का नंबर पढ़ता है। इनाम लाइन की सर्वर कॉपी के item और action फ़ील्ड से आते हैं।
जितनी तेज़ नेटवर्क दे उतनी तेज़ी से क्लिक करनाहर बातचीत में 0.3 सेकंड में एक क्लिकतेज़ क्लिक पर उनकी अपनी लाइन लौटती है। बातचीत ख़त्म करके फिर शुरू करने से यह इंतज़ार बच जाता है, इसलिए Heal और GiveItem अपनी सीमाएँ रखते हैं।
बिना बातचीत के टॉर्च माँगनानामुमकिनआइटम सिर्फ़ उस लाइन के विकल्प से मिलते हैं जिस पर, सर्वर के अनुसार, प्लेयर है।
ढेर सारे टॉर्च जमा करनाएक बार में एकसर्वर पहले उसके Backpack और कैरेक्टर में Torch ढूँढता है, और दिया गया टॉर्च गिराया नहीं जा सकता, इसलिए गिराकर और फिर माँगकर उसे फ़ार्म नहीं किया जा सकता।
हील वाली लाइन को स्पैम करना30 सेकंड में एक हीलकूलडाउन हर प्लेयर के लिए सर्वर पर रखा जाता है, और NPC healTooSoon लाइन से यह बताता है।
दूर चले जाना और विंडो खुली छोड़नाआधे सेकंड के अंदर बंद होती हैसर्वर हर खुली बातचीत सेकंड में दो बार जाँचता है।
पूरी बातचीत पढ़ना, उन लाइनों समेत जहाँ वह नहीं पहुँचामुमकिनDialogueData, ReplicatedStorage में है, जो हर डिवाइस पर कॉपी होता है। अगर यह ज़रूरी है तो उसे ServerStorage में ले जाएँ (देखें स्टेप 2)।

एक सीमा साफ़ कह देनी चाहिए: जो चीटर Guide के पास जाकर विकल्प चुनता है, उसे ठीक वही मिलता है जो ईमानदार प्लेयर को। सर्वर यह नियंत्रित करता है कि कितनी बार और कहाँ से, लेकिन यह नहीं कि कौन। हर दुर्लभ चीज़, जैसे ऐसा इनाम जो हर प्लेयर एक ही बार पा सके, ऐसी जाँच माँगती है जो सर्वर के पास हो, जैसे मिलने पर सेट किया गया attribute या data store में सेव किया गया flag।

स्टेप 5: जाँचें

  1. Play (F5) दबाएँ और Guide के पास जाएँ। 12 स्टड के अंदर Guide के नाम के साथ Talk prompt दिखता है। E दबाएँ।
  2. विंडो "Guide" दिखाती है, स्वागत वाली लाइन टाइप करती है और फिर चार बटन दिखाती है। वही लाइन NPC के सिर के ऊपर बबल में दिखती है।
  3. "Any tips?" चुनें, फिर "Anything else?": आप फिर पहली लाइन पर हैं। "Bye!" चुनें: विंडो बंद होती है, और Talk prompt लौट आता है।
  4. पहले ख़ुद को डैमेज दें: Server पर जाने के लिए Client/Server टॉगल दबाएँ, Workspace में अपने कैरेक्टर का Humanoid चुनें, Properties विंडो में Health को 50 करें और वापस Client पर जाएँ। प्लेयर के कैरेक्टर हर सेकंड MaxHealth का 1% वापस पाते हैं, इसलिए तुरंत Guide से बात करें और "I'm hurt. Can you help?" चुनें: हेल्थ पूरी हो जाती है। 30 सेकंड के अंदर फिर बात करें और इसे दोबारा चुनें: हील नहीं होता, और Guide कहता है कि उसने आपको अभी-अभी हील किया।
  5. "Got anything for the cave?" चुनें: हॉटबार में Torch आ जाता है। उसे equip करें और Backspace दबाएँ: वह हाथ में ही रहता है। फिर माँगें: दूसरा टॉर्च नहीं मिलता, और Guide कहता है कि वह आपके पास पहले से है।
  6. बातचीत शुरू करें और दूर चले जाएँ। लगभग तब विंडो बंद होती है जब आप Guide से 16 स्टड दूर होते हैं।
  7. टेस्ट मोड की ड्रॉपडाउन लिस्ट में Server & Clients चुनें, 2 क्लाइंट सेट करें और Play दबाएँ। दोनों प्लेयर एक साथ Guide से बात कर सकते हैं, हर कोई अपनी लाइन पर।
  8. playtest के दौरान Controller Emulator (Emulation टैब पर Controller) से गेमपैड जाँचें। एमुलेट किए गेमपैड से पास जाएँ और prompt का बटन दबाएँ (डिफ़ॉल्ट ButtonX): जब विकल्प दिखते हैं, पहला पहले से चुना होता है, और A उसे दबाता है।
  9. Studio के Device Simulator से फ़ोन स्क्रीन जाँचें (लिखते समय यह बीटा है: File, Beta Features में New Device Simulator चालू करें और Studio दोबारा शुरू करें)। कोई फ़ोन चुनें, Rotate तब तक दबाएँ जब तक वह लैंडस्केप में न आ जाए, Play दबाएँ, Guide के पास जाएँ और Talk prompt पर टैप करें। "Any tips?" चुनें: पूरी लाइन विकल्पों के बटन के ऊपर दिखती है, ज़रूरत हो तो छोटे टेक्स्ट में, और उन पर नहीं चढ़ती।

इस पूरे समय Output विंडो खुली रखें (Window मेनू, फिर Output)। जब ये स्क्रिप्ट ठीक चलती हैं, तो कुछ प्रिंट नहीं करतीं, इसलिए हर लाल गलती या DialogueService: से शुरू होने वाली चेतावनी असली समस्या है। देखें आम गलतियाँ।

इसे आगे कैसे बढ़ाएँ

ज़्यादा NPC और लंबी बातचीत

NPCs फ़ोल्डर में अपने नाम वाला एक और रिग जोड़ें, और DialogueData में उसी नाम की टेबल, start लाइन के साथ। DialogueService फ़ोल्डर के हर उस मॉडल में Talk prompt जोड़ती है जिसमें HumanoidRootPart हो, गेम के दौरान जोड़े गए मॉडल समेत; NPC की कॉपी को कॉपी किए prompt की जगह नया prompt मिलता है। एक ही नाम वाले दो NPC एक ही टेबल इस्तेमाल करते हैं। लाइनें किसी भी क्रम में जुड़ सकती हैं, और कोई विकल्प पहले की लाइन पर वापस ले जा सकता है, जैसे "Anything else?"। हर लाइन पर चार से ज़्यादा विकल्प न रखें, क्योंकि विंडो उन्हें दो-दो करके रखती है।

प्रोग्रेस पर निर्भर लाइनें

लौटकर आए प्लेयर का अलग स्वागत करने के लिए, पहली लाइन उस चीज़ से चुनें जो सर्वर के पास है। startConversation में उसे local firstLine = if player:GetAttribute("MetGuide") then "welcomeBack" else "start" से चुनें, जाँचें कि लाइन मौजूद है, जैसे स्क्रिप्ट lines.start जाँचती है, और बातचीत बनाते समय "start" की जगह firstLine इस्तेमाल करें। attribute किसी ऐक्शन में सेट करें, और Guide की टेबल में welcomeBack लाइन जोड़ें। Attribute एक सेशन तक रहते हैं; प्लेयर को अगली बार तक याद रखने के लिए flag को data store में सेव करें, जैसा DataStore ट्यूटोरियल में है।

दुकानदार NPC

दुकान GUI गाइड से दुकान बनाएँ, फिर OpenShop ऐक्शन जोड़ें जो उस प्लेयर को RemoteEvent भेजे और true लौटाए, और दुकान का LocalScript यह इवेंट आने पर अपनी विंडो खोले। ख़रीदारी पहले की तरह दुकान की अपनी सर्वर जाँचों से होती है। अगर ख़रीदारी सिर्फ़ NPC के पास हो सकती है, तो ख़रीदारी हैंडलर के अंदर भी दूरी जाँचें, क्योंकि क्लाइंट दुकान का रिमोट कहीं से भी कॉल कर सकता है।

चलने वाले NPC

Guide को घुमाने या प्लेयर के पीछे चलाने के लिए NPC पाथफ़ाइंडिंग गाइड लें और HumanoidRootPart से Anchored हटाएँ, ताकि वह हिल सके। Talk prompt इसी पार्ट पर है, इसलिए NPC के साथ चलता है, और दूरी की जाँच भी यही पार्ट इस्तेमाल करती है। बातचीत खुली रहने तक चलना रोक दें, वरना NPC के प्लेयर से 16 स्टड से ज़्यादा दूर जाते ही विंडो बंद हो जाएगी।

चाबियाँ, क्वेस्ट और दूसरे इनाम

GiveItem, DialogueItems का कोई भी Tool देता है, इसलिए NPC ऐसी चाबी दे सकता है जिसे बंद दरवाज़ा जाँचता है, जैसा दरवाज़ा गाइड में है। इस्तेमाल पर कुछ करने वाले आइटम, जैसे हील करने वाला खाना, के बारे में इन्वेंटरी गाइड में पढ़ें।

साउंड और कैमरा

हर लाइन पर आवाज़ की क्लिप या छोटी साउंड के लिए NPC के Head में Sound रखें और उसे DialogueClient के show से चलाएँ। NPC के बोलते समय कैमरा उस पर ले जाने के लिए, कटसीन गाइड दिखाती है कि LocalScript कैमरे का नियंत्रण कैसे लेता है और कैसे लौटाता है।

आम गलतियाँ और उनके हल

Play दबाने से पहले Output विंडो खोलें (Window मेनू, फिर Output)। डायलॉग की ज़्यादातर समस्याएँ वहाँ चेतावनी प्रिंट करती हैं या किसी ऐसे नाम से आती हैं जो मेल नहीं खाता।

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

DialogueClient उस रिमोट का इंतज़ार कर रहा है जिसे DialogueService बनाती है, यानी DialogueService यहाँ तक नहीं पहुँची। जाँचें कि यह Script है, LocalScript नहीं, सीधे ServerScriptService में है और बंद (disabled) नहीं है। DialogueService पहले ReplicatedStorage में DialogueData और Workspace में NPCs फ़ोल्डर का इंतज़ार करती है, इसलिए इनका न होना या नाम की टाइपो भी उसे रोक देती है; तब Output, DialogueService से उस नाम के साथ infinite yield चेतावनी दिखाता है।

मेरे NPC के ऊपर Talk prompt नहीं दिखता

DialogueService सिर्फ़ उन मॉडल में prompt जोड़ती है जो सीधे Workspace, NPCs में हों और जिनमें HumanoidRootPart नाम का पार्ट हो। दोनों शर्तें जाँचें और 12 स्टड से ज़्यादा पास जाएँ। Toolbox के रिग में यह पार्ट नहीं हो सकता, या वह किसी फ़ोल्डर में लिपटा दूसरे टाइप का ऑब्जेक्ट हो सकता है।

prompt दिखता है, लेकिन E दबाने से कुछ नहीं होता

सर्वर को इस NPC की बातचीत नहीं मिली, और गेम शुरू होने पर Output आपके NPC के नाम के साथ DialogueService: no conversation with a start line for Guide in DialogueData दिखाता है। DialogueData की टेबल का नाम बड़े अक्षरों समेत ठीक मॉडल जैसा होना चाहिए, और उसमें start लाइन होनी चाहिए।

विकल्प अगली लाइन पर जाने की जगह विंडो बंद कर देता है

Output आपके नामों के साथ DialogueService: no line named tip for Guide in DialogueData दिखाता है: विकल्प का next (या failNext) ऐसी लाइन का नाम लेता है जो इस NPC की टेबल में नहीं है। लाइनों के नाम केस-सेंसिटिव हैं, इसलिए स्पेलिंग टेबल से मिलाएँ, यहाँ tips।

विंडो काम करती है, लेकिन लाइन वाला बबल नहीं दिखता

बबल को NPC मॉडल के ठीक अंदर Head नाम का पार्ट और चालू bubble chat चाहिए: Explorer में TextChatService के नीचे BubbleChatConfiguration चुनें और जाँचें कि Enabled पर टिक है। डिफ़ॉल्ट रूप से यह चालू होता है।

Output में लिखा है DialogueService: no Tool named Torch in ServerStorage.DialogueItems

सर्वर आइटम नहीं ढूँढ पाया। जाँचें कि ServerStorage के फ़ोल्डर का नाम DialogueItems है और उसमें विकल्प के item जैसे ठीक नाम वाला Tool (Model या Part नहीं) है। जब तक आप इसे ठीक नहीं करते, Guide hasTorch लाइन से जवाब देता है, क्योंकि ऐक्शन असफल रहा।

Output में लिखा है DialogueService: no action named ...

विकल्प का action, ACTIONS टेबल की किसी key से मेल नहीं खाता। नाम केस-सेंसिटिव हैं: heal, Heal नहीं है।

RoCode से बनाएँ

अगर NPC को हाथ से बनाने के बजाय उसका वर्णन करना आपके लिए आसान है, तो RoCode ये स्क्रिप्ट सीधे आपके खुले place में लिख सकता है। यह Roblox Studio के लिए एक स्वतंत्र AI एजेंट है, Roblox का नहीं: आप वेब चैट में लिखते हैं, और उसका Studio प्लगइन आपके Explorer में स्क्रिप्ट बनाता और बदलता है।

आप लिखते हैं

Workspace.NPCs के Guide मॉडल को बोलने वाला बनाओ: Talk prompt, टाइप होती लाइनों और विकल्पों के बटन वाली डायलॉग विंडो, सिर के ऊपर बबल, 30 सेकंड कूलडाउन वाला हील विकल्प, और ServerStorage से एक बार Torch टूल देने वाला विकल्प। बातचीत ModuleScript में रखो और सारे इनाम सर्वर पर दो।

RoCode करता है
  • पहले Get Properties से मॉडल देख सकता है, ताकि उसके पार्ट का Anchored और उसके Humanoid का WalkSpeed जैसे मुख्य मान पढ़ सके। मॉडल का सटीक पाथ जोड़ने के लिए चैट में / लिखें
  • Create Script से DialogueData ModuleScript, DialogueService Script और DialogueClient LocalScript लिखता है
  • उसे हर लिखी स्क्रिप्ट का कंपाइल होना Check Script से जाँचने को कहा गया है, जो उसे बिना चलाए Studio में कंपाइल करता है
  • बदलाव हिस्सों में भेजता है, और हर हिस्सा Studio की हिस्ट्री में एक undo पॉइंट है

प्लगइन 3.9 या नए के साथ RoCode छोटा playtest चलाकर गलतियाँ पढ़ सकता है, और प्लगइन 3.9.11 या नए के साथ गेम काम करता है यह जाँचने के लिए टेस्ट कैरेक्टर चला सकता है, लेकिन गेम के दौरान वह स्क्रीनशॉट नहीं लेता, इसलिए NPC के पास जाकर उससे ख़ुद बात करें। अगर कुछ ठीक से काम नहीं करता, तो RoCode को बताएँ कि आपने क्या देखा: Check Output आपके आख़िरी playtest की Server और Client लाइनें पढ़ सकता है। बोलने वाला NPC कई सिस्टम में से एक है; पेज AI से Roblox गेम कैसे बनाएं, एक प्रॉम्प्ट में एक सिस्टम दिखाता है कि वे आपस में कैसे जुड़ते हैं। RoCode, Studio से कैसे जुड़ता है।

अक्सर पूछे जाने वाले सवाल

Roblox Studio में बोलने वाला NPC कैसे बनाएं?

NPC में ProximityPrompt जोड़ें, और जब प्लेयर उसे चलाए, तो NPC की लाइन डायलॉग विंडो में, बबल में या दोनों में दिखाएँ। इस गाइड की तीन स्क्रिप्ट दोनों करती हैं और जवाब के विकल्प भी जोड़ती हैं। अगर सिर्फ़ बबल चाहिए, तो prompt चलने पर LocalScript से TextChatService:DisplayBubble(npc.Head, "Hello!") कॉल करें, जैसा Roblox के bubble chat पेज के NPC उदाहरण में है।

क्या चुनें: 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 API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।

अपने गेम में RoCode आज़माएँ।

हर दिन मुफ़्त क्रेडिट, कार्ड की ज़रूरत नहीं। प्लगइन इंस्टॉल करें, फ़ीचर बताएँ और देखें कि Studio में क्या बना।