ट्यूटोरियल · प्लेयर डेटा

Roblox Studio में लीडरबोर्ड कैसे बनाएं

Roblox गेम के ऊपर दाएँ कोने की प्लेयर लिस्ट एक ही फ़ोल्डर से चलती है, जिसका नाम leaderstats है। यह गाइड उसे शुरू से बनाती है: सर्वर स्क्रिप्ट, पॉइंट देने का सुरक्षित तरीका, सेशन के बीच सेविंग और ग्लोबल टॉप-10।

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

संक्षेप में

ServerScriptService में एक Script बनाएँ, जो Players.PlayerAdded सुने, ठीक leaderstats नाम का (सब छोटे अक्षरों में) एक Folder बनाए और उसे प्लेयर का चाइल्ड बना दे। इस फ़ोल्डर के अंदर हर IntValue, NumberValue या StringValue प्लेयर लिस्ट में एक कॉलम बन जाता है।

  • आँकड़े सिर्फ़ सर्वर पर बनाएँ और बदलें। LocalScript से किया गया बदलाव सिर्फ़ वही प्लेयर देखता है, और कोई नहीं।
  • leaderstats सेव नहीं होता। अगर मान अगले सेशन तक बचने चाहिए, तो उन्हें data store से लोड और सेव करें।
  • सभी प्लेयर की रैंकिंग के लिए हर स्कोर ordered data store में लिखें और उसे अपनी दुनिया के बोर्ड पर या प्लेयर लिस्ट के Global मोड में दिखाएँ।
इस पेज पर
  1. leaderstats कैसे काम करता है
  2. 1. leaderstats बनाएँ
  3. 2. पॉइंट देना
  4. 3. सेविंग
  5. 4. ग्लोबल टॉप-10
  6. Common errors
  7. RoCode के साथ
  8. अक्सर पूछे जाने वाले सवाल
  9. स्रोत और आगे पढ़ें

leaderstats कैसे काम करता है

चित्रणचलते गेम में तैयार leaderstats और कॉइन पैड स्क्रिप्ट।

Roblox हर गेम में प्लेयर लिस्ट दिखाता है। जब किसी प्लेयर के पास leaderstats नाम का चाइल्ड Folder होता है, तो लिस्ट उसके अंदर हर वैल्यू ऑब्जेक्ट के लिए एक कॉलम जोड़ती है और उस प्लेयर की लाइन में उसका मान दिखाती है। कॉलम का हेडर वैल्यू ऑब्जेक्ट का Name होता है।

leaderstats में रखे जा सकने वाले वैल्यू ऑब्जेक्ट
ऑब्जेक्टक्या रखता हैकिसके लिए ठीक
IntValueपूर्ण संख्याएँकॉइन, किल, जीत, लेवल
NumberValueदशमलव संख्याएँसबसे अच्छा लैप टाइम, दूरी
StringValueटेक्स्टरैंक या टीम का टाइटल

दो नियम लगभग हर न चलने वाले लीडरबोर्ड को तोड़ते हैं। फ़ोल्डर का नाम ठीक leaderstats होना चाहिए: Leaderstats या leaderStats को अनदेखा किया जाता है। और फ़ोल्डर सर्वर Script को बनाना चाहिए, क्योंकि सिर्फ़ सर्वर के बदलाव सभी प्लेयर तक रेप्लिकेट होते हैं। अगर पक्का नहीं कि कोड कहाँ चलता है, तो पहले Script vs LocalScript vs ModuleScript (अंग्रेज़ी में) पढ़ें।

स्टेप 1: leaderstats स्क्रिप्ट बनाएँ

  1. Explorer में ServerScriptService पर कर्सर ले जाएँ, + बटन दबाएँ और एक Script डालें।
  2. उसका नाम Leaderstats रखें, ताकि बाद में आसानी से मिल जाए।
  3. उसकी सामग्री को नीचे के कोड से बदलें और Play दबाएँ। आपका नाम प्लेयर लिस्ट में Coins और Wins के साथ दिखेगा, दोनों 0 पर।
Script स्थान: ServerScriptService नाम: Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- नाम ठीक यही होना चाहिए, सब छोटे अक्षरों में

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = 0
	coins.Parent = leaderstats

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player -- पैरेंट आख़िर में सेट करते हैं, जब मान अंदर आ चुके हों
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Studio में इस स्क्रिप्ट के चलने से पहले जॉइन हो सकता है, इसलिए जो पहले से यहाँ हैं उन्हें सेट करते हैं
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

आख़िर का लूप Studio में टेस्ट करते समय ज़रूरी है: पहला प्लेयर कभी-कभी PlayerAdded जुड़ने से पहले आ जाता है, और लूप के बिना उसके आँकड़े नहीं बनते।

स्टेप 2: पॉइंट सुरक्षित तरीके से दें

किसी आँकड़े को बदलने के लिए सर्वर स्क्रिप्ट से उसका Value सेट करें। यह कॉइन पैड प्लेयर के छूने पर 10 कॉइन देता है। जब तक कैरेक्टर पार्ट पर खड़ा रहता है, Touched एक सेकंड में कई बार चलता है, इसलिए स्क्रिप्ट हर प्लेयर के लिए छोटा कूलडाउन रखती है।

Script स्थान: Workspace के पार्ट में नाम: CoinPad
local Players = game:GetService("Players")

local part = script.Parent :: BasePart
local REWARD = 10
local COOLDOWN_SECONDS = 1

local lastReward: { [Player]: number } = {}

part.Touched:Connect(function(hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return
	end

	local now = os.clock()
	local last = lastReward[player]
	if last and now - last < COOLDOWN_SECONDS then
		return -- Touched एक कदम में कई बार चलता है; इससे एक बार छूने पर दस बार भुगतान नहीं होता
	end
	lastReward[player] = now

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if coins and coins:IsA("IntValue") then
		coins.Value += REWARD
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastReward[player] = nil
end)

FindFirstAncestorOfClass("Model") कैरेक्टर को तब भी ढूँढ लेता है जब छूने वाला पार्ट किसी ऐक्सेसरी के अंदर हो, जबकि सीधी hit.Parent जाँच इसे छोड़ देती है।

अगर पॉइंट उस काम के लिए मिलते हैं जो प्लेयर अपनी स्क्रीन पर करता है, जैसे बटन दबाना, तो LocalScript को RemoteEvent से सर्वर से पूछना चाहिए, और सर्वर तय करे कि देना है या नहीं। क्लाइंट को कभी रकम भेजने न दें। RemoteEvents गाइड जाँच के साथ यह पैटर्न दिखाती है।

चार तैयार उदाहरण: पहले गेम की गाइड ट्रैक पर हर छुए गए कॉइन के लिए 1 Coin और 3 कॉइन के बाद फ़िनिश पैड पर एक Win देती है, क्लिकर सिम्युलेटर गाइड सर्वर पर क्लिक की सीमा के साथ बटन दबाने पर Coins देती है, तलवार गाइड प्लेयर के मरने से पहले आख़िरी वार करने वाले के Kills में 1 जोड़ती है, और गन गाइड दिखाती है कि जब गोली लक्ष्य का Health 0 कर दे तो किल कैसे गिनें।

स्टेप 3: आँकड़े सेशन के बीच सेव करें

leaderstats तभी तक रहता है जब तक सर्वर चलता है। कॉइन और जीत सेव करने के लिए उन्हें प्लेयर के आने पर data store से लोड करें और जाने पर सेव करें। यह वर्शन स्टेप 1 की स्क्रिप्ट की जगह लेता है। यह कभी उस प्लेयर को सेव नहीं करता जिसका डेटा लोड नहीं हुआ: ज़्यादातर कॉपी की गई सेव स्क्रिप्ट में यही गलती प्रोग्रेस मिटा देती है।

Script स्थान: ServerScriptService नाम: Leaderstats
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- नीचे हर pcall के अंदर कॉल होता है, इसलिए अभी तक पब्लिश न हुआ place
-- (data store एक्सेस के बिना) भी लीडरबोर्ड पाता है
local function statsStore(): DataStore
	return DataStoreService:GetDataStore("PlayerStats_v1")
end

-- वे प्लेयर जिनके सेव किए आँकड़े लोड हो गए। जो यहाँ नहीं हैं उन्हें कभी सेव नहीं करते,
-- इसलिए असफल लोड असली प्रोग्रेस को शून्य से नहीं बदलेगा।
local loaded: { [Player]: boolean } = {}

local function keyFor(player: Player): string
	return "player_" .. player.UserId
end

local function onPlayerAdded(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Parent = leaderstats

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Parent = leaderstats

	local ok, data = pcall(function()
		return statsStore():GetAsync(keyFor(player))
	end)
	if ok then
		if type(data) == "table" then
			coins.Value = tonumber(data.Coins) or 0
			wins.Value = tonumber(data.Wins) or 0
		end
		loaded[player] = true
	else
		warn(`Could not load stats for {player.Name}: {data}`)
	end

	leaderstats.Parent = player
end

local function save(player: Player)
	if not loaded[player] then
		return
	end
	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if not (coins and coins:IsA("IntValue") and wins and wins:IsA("IntValue")) then
		return
	end
	local ok, err = pcall(function()
		statsStore():SetAsync(keyFor(player), { Coins = coins.Value, Wins = wins.Value })
	end)
	if not ok then
		warn(`Could not save stats for {player.Name}: {err}`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	save(player)
	loaded[player] = nil
end)

-- सर्वर बंद होने पर, बंद होने से पहले सबको सेव करते हैं
game:BindToClose(function()
	local pending = 0
	for _, player in Players:GetPlayers() do
		pending += 1
		task.spawn(function()
			save(player)
			pending -= 1
		end)
	end
	while pending > 0 do
		task.wait()
	end
end)

छोटे गेम के लिए इतना काफ़ी है। दोबारा कोशिश, UpdateAsync, रिक्वेस्ट की सीमाएँ और एक ही प्लेयर को दो सर्वर के लिखने से बचाव के बारे में आगे DataStore ट्यूटोरियल में पढ़ें।

स्टेप 4: ग्लोबल टॉप-10

leaderstats सिर्फ़ एक ही सर्वर के प्लेयर की तुलना करता है। ग्लोबल रैंकिंग के लिए ordered data store चाहिए: ऐसा data store जो हर key पर एक संख्या रखता है और keys को मान के हिसाब से क्रम में लौटा सकता है। सर्वर से हर प्लेयर का स्कोर उसमें लिखें, फिर सबसे ऊपर की एंट्री वापस पढ़ें।

इसे दिखाने के दो तरीके हैं। Roblox की प्लेयर लिस्ट में Friends और Global मोड हैं, जो Creator Hub में रजिस्टर किया गया ordered data store पढ़ते हैं (लिखते समय यह बीटा फ़ीचर है, हर गेम में एक सक्रिय लीडरबोर्ड)। या आप रैंकिंग ख़ुद अपनी दुनिया के बोर्ड पर बना सकते हैं: यह किसी भी गेम में काम करता है और आप उसे जैसा चाहें सजा सकते हैं। नीचे की स्क्रिप्ट दूसरा तरीका अपनाती है, और स्कोर प्लेयर के user ID को key बनाकर लिखती है, जो वही फ़ॉर्मेट है जिसकी Creator Hub का लीडरबोर्ड उम्मीद करता है।

  1. Workspace में एक Anchored Part जोड़ें, उसका नाम WinsBoard रखें और उसे साइनबोर्ड जितना बड़ा बनाएँ (जैसे 12 x 8 x 1 स्टड), आगे वाला हिस्सा स्पॉन की ओर।
  2. ServerScriptService में GlobalWinsBoard नाम की Script डालें और उसमें नीचे का कोड रखें।
  3. Play दबाएँ। पहले अपडेट के बाद बोर्ड भर जाएगा और हर मिनट अपडेट होगा।
Script स्थान: ServerScriptService नाम: GlobalWinsBoard
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

local winsBoard = DataStoreService:GetOrderedDataStore("GlobalWins_v1")

local TOP_N = 10
local REFRESH_SECONDS = 60

-- बोर्ड: Workspace में WinsBoard नाम का Anchored Part। स्क्रिप्ट ख़ुद
-- SurfaceGui और लाइनें जोड़ती है, इसलिए सिर्फ़ Part बनाना है।
local boardPart = workspace:WaitForChild("WinsBoard") :: BasePart

local gui = Instance.new("SurfaceGui")
gui.Face = Enum.NormalId.Front
gui.SizingMode = Enum.SurfaceGuiSizingMode.PixelsPerStud
gui.PixelsPerStud = 50
gui.Parent = boardPart

local list = Instance.new("Frame")
list.Size = UDim2.fromScale(1, 1)
list.BackgroundColor3 = Color3.fromRGB(18, 11, 31)
list.Parent = gui

local layout = Instance.new("UIListLayout")
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = list

local nameCache: { [number]: string } = {}

local function nameFor(userId: number): string
	local cached = nameCache[userId]
	if cached then
		return cached
	end
	local ok, name = pcall(function()
		return Players:GetNameFromUserIdAsync(userId)
	end)
	local result = if ok then name else "Unknown player"
	nameCache[userId] = result
	return result
end

local function recordWins(player: Player)
	local leaderstats = player:FindFirstChild("leaderstats")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if wins and wins:IsA("IntValue") then
		local ok, err = pcall(function()
			winsBoard:SetAsync(tostring(player.UserId), wins.Value)
		end)
		if not ok then
			warn(`Could not record wins for {player.Name}: {err}`)
		end
	end
end

local function refresh()
	local ok, pages = pcall(function()
		return winsBoard:GetSortedAsync(false, TOP_N)
	end)
	if not ok then
		warn(`Could not read the wins board: {pages}`)
		return
	end

	for _, child in list:GetChildren() do
		if child:IsA("TextLabel") then
			child:Destroy()
		end
	end

	for rank, entry in pages:GetCurrentPage() do
		local label = Instance.new("TextLabel")
		label.Size = UDim2.new(1, 0, 1 / TOP_N, 0)
		label.BackgroundTransparency = 1
		label.TextColor3 = Color3.new(1, 1, 1)
		label.TextScaled = true
		label.Text = `{rank}. {nameFor(tonumber(entry.key) or 0)}   {entry.value}`
		label.LayoutOrder = rank
		label.Parent = list
	end
end

while true do
	for _, player in Players:GetPlayers() do
		recordWins(player)
	end
	refresh()
	task.wait(REFRESH_SECONDS)
end

GetSortedAsync(false, 10) सबसे बड़े 10 मान पहले लौटाता है। Ordered data store सिर्फ़ पूर्ण संख्याएँ रखता है, इसलिए स्कोर पूर्ण संख्या में रखें। स्क्रिप्ट हर प्लेयर को मिनट में एक बार लिखती है और टॉप-10 मिनट में एक बार पढ़ती है, जो प्रति सर्वर की डिफ़ॉल्ट सीमाओं से काफ़ी नीचे है (ordered data store में लिखने के लिए हर मिनट 30 + हर प्लेयर पर 5, और क्रम वाले पढ़ने के लिए 5 + हर प्लेयर पर 2, 30 सितंबर 2026 के डॉक्यूमेंटेशन के अनुसार)।

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

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

लीडरबोर्ड बिल्कुल नहीं दिखता

जाँचें कि फ़ोल्डर का नाम छोटे अक्षरों में leaderstats है, उसका पैरेंट Player है (कैरेक्टर नहीं), और कोड ServerScriptService में Script है, LocalScript नहीं।

दूसरे प्लेयर मेरे आँकड़े का बदलाव नहीं देखते

मान क्लाइंट पर बदला गया। बदलाव को सर्वर Script में ले जाएँ, और अगर उसे कोई बटन या की चलाती है, तो RemoteEvent भेजें और मान सर्वर को बदलने दें।

attempt to index nil with 'Coins'

कोड ने फ़ोल्डर बनने से पहले player.leaderstats.Coins पढ़ने की कोशिश की, या नाम अलग लिखा है। सर्वर पर FindFirstChild इस्तेमाल करें और नतीजा जाँचें; LocalScript में player:WaitForChild("leaderstats") इस्तेमाल करें। स्क्रिप्ट गलतियों की गाइड इस गलती को विस्तार से समझाती है।

एक बार छूने पर कॉइन 10, 20 या 50 बढ़ जाते हैं

जब तक पार्ट एक-दूसरे को काटते हैं, Touched बार-बार चलता है। स्टेप 2 की तरह हर प्लेयर के लिए कूलडाउन जोड़ें, या उठाने के बाद आइटम हटा दें।

हर बार दोबारा आने पर आँकड़े रीसेट हो जाते हैं

Roblox leaderstats सेव नहीं करता। स्टेप 3 की स्क्रिप्ट जोड़ें। Studio में सेविंग जाँचने के लिए place पब्लिश करें और Experience Settings में Studio Access to API Services चालू करें।

RoCode से बनाएँ

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

आप लिखते हैं

Coins और Wins वाला लीडरबोर्ड जोड़ो जो सेशन के बीच सेव हो, और स्पॉन के पास एक पार्ट पर जीत के हिसाब से टॉप-10 बोर्ड।

RoCode करता है
  • पहले place में मौजूद leaderstats या DataStore कोड ढूँढ सकता है, ताकि दूसरा लीडरबोर्ड जोड़ने के बजाय जो है उसी को आगे बढ़ाए
  • ServerScriptService में सर्वर स्क्रिप्ट और Workspace में बोर्ड का पार्ट बनाता है
  • काम ख़त्म करने से पहले लिखी गई स्क्रिप्ट का कंपाइल होना Studio के अंदर जाँचता है
  • बदलाव हिस्सों में भेजता है, और हर हिस्सा Studio की हिस्ट्री में undo पॉइंट के रूप में दर्ज होता है

नतीजा फिर भी आप जाँचते हैं और गेम में आँकड़े और सेविंग ख़ुद टेस्ट करते हैं: प्लगइन 3.9 या नए के साथ RoCode छोटा playtest चलाकर गलतियाँ पढ़ सकता है, और प्लगइन 3.9.11 या नए के साथ टेस्ट कैरेक्टर चला सकता है और Coins और Wins जैसे मान जाँच सकता है, लेकिन वह सिर्फ़ वही जाँचता है जो उसने टेस्ट के लिए ख़ुद चुना। Leaderstats आम तौर पर गेम के कई सिस्टम में से पहला होता है: इसी तरीके से बाकी गेम एक प्रॉम्प्ट में एक सिस्टम करके बनाएँ। RoCode, Studio से कैसे जुड़ता है।

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

Roblox में leaderstats क्या है?

Player के अंदर ठीक leaderstats नाम का Folder, सब छोटे अक्षरों में। Roblox उसमें हर IntValue, NumberValue या StringValue को प्लेयर लिस्ट में कॉलम के रूप में दिखाता है। इसे सर्वर Script से बनाएँ, जैसा स्टेप 1 में है।

Roblox में ग्लोबल लीडरबोर्ड कैसे बनाएं?

सर्वर से हर प्लेयर का स्कोर ordered data store में लिखें, फिर सबसे ऊपर की एंट्री वापस पढ़ें और उन्हें अपनी दुनिया के बोर्ड पर दिखाएँ। स्टेप 4 में टॉप-10 की पूरी स्क्रिप्ट है।

क्या Roblox leaderstats अपने आप सेव करता है?

नहीं। leaderstats तभी तक रहता है जब तक प्लेयर सर्वर पर है। प्लेयर के जाने पर मान data store से सेव करें और आने पर लोड करें, जैसा स्टेप 3 में है।

क्या लीडरबोर्ड से कोई मान छिपाया जा सकता है?

हाँ। सिर्फ़ leaderstats फ़ोल्डर के अंदर के मान दिखते हैं। निजी डेटा प्लेयर के किसी दूसरे फ़ोल्डर में या सर्वर स्क्रिप्ट की टेबल में रखें।

पूरी प्लेयर लिस्ट कैसे छिपाएँ?

LocalScript से StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false) कॉल करें। उसे फिर से दिखाने के लिए true दें।

क्या कॉइन के लिए NumberValue इस्तेमाल कर सकते हैं?

कर सकते हैं, लेकिन पूर्ण संख्या वाली करेंसी के लिए IntValue बेहतर है, और अगर बाद में आप उस पर रैंकिंग बनाना चाहें तो ordered data store सिर्फ़ पूर्ण संख्याएँ लेता है।

स्रोत और आगे पढ़ें

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

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

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