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

Roblox Studio में DataStore से प्लेयर का डेटा कैसे सेव करें

जब तक कोई सर्वर स्क्रिप्ट उसे सेव न करे, Roblox सेशन के बीच प्लेयर के बारे में कुछ भी याद नहीं रखता। इस गाइड में आप एक PlayerData मॉड्यूल बनाएँगे, जो DataStoreService के ज़रिए हर प्लेयर का डेटा लोड करता है, मेमोरी में रखता है और सेव करता है, और फिर जाँच, लिमिट और सेव किया हुआ डेटा कैसे खोता है, यह समझेंगे।

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

संक्षेप में

सर्वर Script से DataStoreService इस्तेमाल करें: प्लेयर के आने पर GetAsync से उसका डेटा लोड करें, खेलते समय उसे एक टेबल में रखें, और टाइमर पर, निकलने पर (PlayerRemoving) और सर्वर बंद होने पर (game:BindToClose) UpdateAsync से सेव करें। हर कॉल को pcall में लपेटें और नाकाम कॉल को कुछ बार दोहराएँ।

  • Studio में जाँचने के लिए place पब्लिश करें और एक अलग टेस्ट गेम में File > Experience Settings > Security > Enable Studio Access to API Services चालू करें: Studio वही डेटा इस्तेमाल करता है जो लाइव सर्वर करते हैं।
  • अगर प्लेयर का डेटा लोड नहीं हुआ, तो उस प्लेयर को कभी सेव न करें। डिफ़ॉल्ट वैल्यू सेव करने से उसकी असली प्रोग्रेस मिट जाएगी।
  • हर प्लेयर की एक टेबल एक key में रखें, जैसे User_12345, और हर बदलाव पर नहीं, टाइमर पर सेव करें।
  • आइटम ट्रेडिंग या पेड आइटम के लिए session locking जोड़ें, ताकि दो सर्वर एक ही प्लेयर को सेव न कर सकें।
इस पेज पर
  1. Studio एक्सेस
  2. DataStore कैसे काम करता है
  3. GetAsync और UpdateAsync
  4. 1. PlayerData मॉड्यूल
  5. मॉड्यूल कैसे बना है
  6. 2. डेटा के साथ काम
  7. 3. चेतावनी
  8. 4. Studio में जाँच
  9. डेटा क्यों खोता है
  10. Session locking
  11. लिमिट
  12. वर्ज़न और बैकअप
  13. Common errors
  14. With RoCode
  15. अक्सर पूछे जाने वाले सवाल
  16. स्रोत और आगे पढ़ें

शुरू करने से पहले: टेस्ट कॉपी में Studio एक्सेस चालू करें

Studio में चल रहा गेम तब तक data store तक नहीं पहुँच सकता, जब तक आप इसकी अनुमति न दें। इस अनुमति में एक पेच है, जिसके बारे में Roblox का डॉक्यूमेंटेशन चेतावनी देता है: तब Studio लाइव गेम वाले ही data store पढ़ता और लिखता है, इसलिए जो टेस्ट Studio में आपके कॉइन शून्य करता है, वह लाइव गेम में भी उन्हें शून्य कर देता है, और टेस्ट कोड की गलती असली प्लेयर्स की key बिगाड़ सकती है।

  1. एक टेस्ट कॉपी बनाएँ। place को फ़ाइल में सेव करें, कॉपी खोलें, File > Publish to Roblox As चुनें और Create new game दबाएँ। इसे लाइव गेम के अंदर place की तरह न जोड़ें: एक गेम के सारे place एक ही data store साझा करते हैं।
  2. टेस्ट कॉपी में File > Experience Settings खोलें और Security पर जाएँ।
  3. Enable Studio Access to API Services चालू करें और Save दबाएँ।

Data store कॉल सिर्फ़ सर्वर Script में काम करती हैं; कोशिश करने वाला LocalScript एरर पाता है, इसलिए क्लाइंट सेव किया डेटा नहीं लिख सकते। जब किसी बटन को इसे बदलना हो, तो क्लाइंट RemoteEvent से सर्वर से कहता है, और फ़ैसला सर्वर करता है (देखें RemoteEvents गाइड, अंग्रेज़ी में)।

Data store प्लेयर का डेटा कैसे रखते हैं

चित्रणगाइड के स्टेप 4 की जाँच तेज़ रफ़्तार में: Play, Stop सेशन को data store में सेव करता है, दोबारा Play उसे लोड करता है, इसलिए Output में 200 दिखता है।

Data store, Roblox के सर्वर पर key और value का एक नाम वाला सेट है, जो आपके गेम के सभी सर्वर और सभी place के लिए साझा है। DataStoreService:GetDataStore("PlayerData") ऐसा एक store लौटाता है।

Roblox की सलाह एक नियम पर आती है: प्लेयर डेटा के लिए एक store, हर प्लेयर की एक key, हर key में एक टेबल। key प्लेयर के UserId से बनाएँ, जैसे User_12345, कभी उस नाम से नहीं जिसे वह बदल सकता है। स्थायी पैटर्न User_{UserId} से, अगर आप इसे सेट करें, तो Roblox की right to be forgotten वाली ऑटोमैटिक प्रोसेसिंग भी प्लेयर का डेटा ढूँढ पाती है।

Data store में क्या सेव हो सकता है
टाइपसेव होता है?नोट
नंबर, स्ट्रिंग, बूलियन, बफ़रहाँस्ट्रिंग सही UTF-8 होनी चाहिए। inf या nan न रखें।
टेबलहाँअगर अंदर का सब कुछ भी सेव हो सकता है। जिस टेबल की नंबर वाली key 1 से शुरू नहीं होतीं (इसलिए उसकी लंबाई 0 है), वह इन key को स्ट्रिंग बनाकर लौटती है।
Instance, Vector3, CFrame, Color3नहींसेव करने पर एरर आता है या nil लिखा जाता है। आइटम का नाम या पोज़िशन तीन नंबरों के रूप में सेव करें।

हर रिक्वेस्ट एक वेब कॉल है, जो नाकाम हो सकती है, समय लेती है और प्रति मिनट का बजट खर्च करती है। इसलिए भरोसेमंद सेव सिस्टम प्लेयर के आने पर डेटा एक बार पढ़ते हैं, खेलते समय उसे सर्वर की टेबल में रखते हैं और समय-समय पर वापस लिखते हैं।

GetAsync, SetAsync या UpdateAsync: कौन सा चुनें

Data store के मुख्य मेथड
मेथडक्या करता हैकिसके लिए
GetAsync(key)वैल्यू पढ़ता है। नतीजा इस सर्वर पर 4 सेकंड के लिए कैश होता है।प्लेयर का डेटा लोड करना
SetAsync(key, value)वैल्यू को बिना पढ़े ओवरराइट करता है। एक write।नई key या ऐसी वैल्यू जो पुरानी पर निर्भर नहीं
UpdateAsync(key, callback)सबसे नई वैल्यू पढ़ता है, उसे आपके फ़ंक्शन को देता है और जो वह लौटाए उसे लिखता है। एक read और एक write।प्लेयर का डेटा सेव करना और कोई भी key जिसे कई सर्वर लिख सकते हैं
IncrementAsync(key, delta)सेव किए पूर्णांक में एक पूर्णांक जोड़ता है।काउंटर
RemoveAsync(key)key मिटाता है और पुरानी वैल्यू लौटाता है। पिछले वर्ज़न अब भी लिस्ट और पढ़े जा सकते हैं।प्लेयर का डेटा मिटाना

SetAsync अंधाधुंध लिखता है: अगर दो सर्वर लगभग एक साथ एक key सेव करें, तो आखिरी write जीतता है, उसमें जो भी हो। UpdateAsync पहले मौजूदा वैल्यू पढ़ता है, और अगर बीच में कोई दूसरा सर्वर लिख दे, तो Roblox आपका फ़ंक्शन नई वैल्यू के साथ फिर चलाता है। Roblox इसे हमेशा सलाह देता है जब write मौजूदा वैल्यू पर निर्भर हो या key को कई सर्वर लिख सकते हों, और प्लेयर डेटा ठीक ऐसा ही है। फ़ंक्शन के तीन नियम हैं:

  • यह yield नहीं करना चाहिए: अंदर कोई task.wait() या दूसरी data store कॉल नहीं।
  • यह एक से ज़्यादा बार चल सकता है, इसलिए इसे सिर्फ़ नई वैल्यू निकालनी चाहिए, कभी आइटम नहीं देने चाहिए और इवेंट नहीं चलाने चाहिए।
  • nil लौटाने से write रद्द हो जाता है। मॉड्यूल इसका इस्तेमाल करता है, ताकि गेम के नए वर्ज़न का सेव किया डेटा ओवरराइट न हो।

स्टेप 1: PlayerData मॉड्यूल बनाएँ

यह ModuleScript अकेला कोड है जो data store से बात करता है। यह प्लेयर के आने पर उसका डेटा लोड करता है, उसे मेमोरी में रखता है, हर 180 सेकंड पर, निकलने पर और सर्वर बंद होने पर सेव करता है, और जिनका डेटा लोड नहीं हुआ उन्हें सेव करने से इनकार करता है।

  1. Explorer में ServerScriptService पर कर्सर ले जाएँ, + दबाएँ और ModuleScript डालें। उसका नाम PlayerData रखें और उसकी सामग्री नीचे वाले कोड से बदल दें।
  2. ModuleScript तभी चलता है जब कोई स्क्रिप्ट उसे require करे। ServerScriptService में Main नाम की Script डालें, जिसमें यह लाइन हो: local PlayerData = require(game:GetService("ServerScriptService").PlayerData)। दूसरी सर्वर स्क्रिप्ट भी इसे इसी तरह require करती हैं।
  3. DEFAULTS और Data टाइप को अपने गेम के हिसाब से बदलें, हर फ़ील्ड को नंबर, स्ट्रिंग, बूलियन या टेबल ही रखें।
स्टेप 1-3 के बाद Explorer
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript स्थान: ServerScriptService नाम: PlayerData
-- PlayerData: प्लेयर के आने पर उसका डेटा लोड करता है, मेमोरी में रखता है
-- और टाइमर पर, निकलने पर और सर्वर बंद होने पर सेव करता है।
-- दूसरी सर्वर स्क्रिप्ट इसे PlayerData.Get(player) से पढ़ती और बदलती हैं।

local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- डेटा का ढाँचा बदलने पर बढ़ाएँ, और migrate() में एक स्टेप जोड़ें
local AUTOSAVE_SECONDS = 180
-- Studio में नाकाम कॉल तुरंत हार मान लेती है, इसलिए store एक्सेस के बिना टेस्ट जल्दी चलता है
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- हर नाकामी के बाद दोगुना होता है: 1, 2, 4

export type Data = {
	SchemaVersion: number,
	Coins: number,
	Level: number,
	Inventory: { string },
}

-- बिल्कुल नया प्लेयर इससे शुरू करता है
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- लोड नाकाम होने पर false: डिफ़ॉल्ट डेटा असली प्रोग्रेस की जगह नहीं लेना चाहिए
}

-- नीचे हर pcall के अंदर कॉल होता है, इसलिए अभी पब्लिश न हुआ place
-- (store एक्सेस के बिना) भी प्लेयर्स को डिफ़ॉल्ट डेटा के साथ लोड करता है
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- अभी चल रहे सेव, key के हिसाब से
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- प्लेयर का डेटा तैयार होने पर प्लेयर के साथ चलता है। टेबल PlayerData.Get(player) से लें:
-- BindableEvent से भेजी गई टेबल कॉपी बनकर आती है, और उसे बदलने से कुछ नहीं बदलेगा।
PlayerData.Loaded = loadedEvent.Event

local function deepCopy(value: any): any
	if type(value) ~= "table" then
		return value
	end
	local copy = {}
	for key, item in value do
		copy[key] = deepCopy(item)
	end
	return copy
end

local function defaultData(): Data
	local data = deepCopy(DEFAULTS) -- ताज़ा कॉपी, ताकि प्लेयर कभी एक Inventory टेबल साझा न करें
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- सेव किए डेटा को मौजूदा schema पर लाता है। अगर इसे सुरक्षित रूप से इस्तेमाल न किया जा सके तो nil लौटाता है।
local function migrate(saved: any): Data?
	if type(saved) ~= "table" then
		return nil
	end
	local version = tonumber(saved.SchemaVersion) or 1
	if version > SCHEMA_VERSION then
		return nil -- गेम के नए वर्ज़न ने सेव किया: यहाँ न लोड करें, न ओवरराइट करें
	end

	-- हर schema बदलाव पर एक स्टेप, पुराने से नए की ओर
	if version < 2 then
		-- उदाहरण: वर्ज़न 1 में करेंसी का नाम Gold था। इसे सिर्फ़ तब कॉपी करें जब Coins न हो,
		-- ताकि जिस पुराने डेटा में Coins पहले से है पर SchemaVersion नहीं, उसकी वैल्यू बची रहे।
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- प्लेयर के आखिरी सेव के बाद आए फ़ील्ड जोड़ें, और गलत टाइप वाली वैल्यू बदलें
	for field, default in DEFAULTS do
		if type(saved[field]) ~= type(default) then
			saved[field] = deepCopy(default)
		end
	end
	saved.SchemaVersion = SCHEMA_VERSION
	return saved
end

-- Store कॉल को pcall में चलाता है। नाकामी पर रुककर फिर कोशिश करता है, हर बार इंतज़ार
-- दोगुना करके और थोड़ी रैंडमनेस जोड़कर, ताकि सर्वर सब एक साथ retry न करें।
local function withRetries(label: string, call: () -> any): (boolean, any)
	for attempt = 1, MAX_ATTEMPTS do
		local ok, result = pcall(call)
		if ok then
			return true, result
		end
		warn(`{label} failed (attempt {attempt} of {MAX_ATTEMPTS}): {result}`)
		if attempt < MAX_ATTEMPTS then
			local waitTime = FIRST_RETRY_SECONDS * 2 ^ (attempt - 1)
			task.wait(waitTime + math.random() * waitTime / 2)
		end
	end
	return false, nil
end

local function save(session: Session): boolean
	if not session.canSave then
		return false
	end
	local key = session.key
	pendingSaves[key] = (pendingSaves[key] or 0) + 1

	local newerSchema = false
	local ok = withRetries(`Save {key}`, function()
		return store():UpdateAsync(key, function(current: any)
			if type(current) == "table" and (tonumber(current.SchemaVersion) or 1) > SCHEMA_VERSION then
				newerSchema = true
				return nil -- nil लौटाने से write रद्द होता है
			end
			-- पूरी मौजूदा टेबल प्लेयर के UserId के टैग के साथ लिखें
			return session.data, { session.userId }
		end)
	end)

	local left = (pendingSaves[key] or 1) - 1
	if left > 0 then
		pendingSaves[key] = left
	else
		pendingSaves[key] = nil
	end
	if newerSchema then
		session.canSave = false
		warn(`{key} was saved by a newer version of the game, so this server stopped saving it`)
	end
	return ok and not newerSchema
end

local function startAutosave(player: Player, session: Session)
	task.spawn(function()
		-- अंतराल के किसी रैंडम पल पर शुरू करें, ताकि सर्वर सब एक साथ सेव न करें
		task.wait(math.random() * AUTOSAVE_SECONDS)
		while sessions[player] == session do
			save(session)
			task.wait(AUTOSAVE_SECONDS)
		end
	end)
end

local function load(player: Player)
	local key = "User_" .. player.UserId

	-- अगर प्लेयर अभी इस सर्वर से निकलकर लौटा है, तो पहले आखिरी सेव पूरा होने दें
	while pendingSaves[key] do
		task.wait()
	end

	local ok, saved = withRetries(`Load {key}`, function()
		return store():GetAsync(key)
	end)
	if player.Parent ~= Players then
		return -- लोड के दौरान निकल गया: कुछ नहीं बदला, सेव करने को कुछ नहीं
	end

	local data: Data? = nil
	if ok then
		data = if saved == nil then defaultData() else migrate(saved)
	end

	local session: Session = {
		key = key,
		userId = player.UserId,
		data = data or defaultData(),
		canSave = data ~= nil,
	}
	if not session.canSave then
		warn(`Could not load {key}. {player.Name} is playing on default data that will not be saved.`)
	end

	sessions[player] = session
	player:SetAttribute("DataLoaded", session.canSave) -- GUI इसे पढ़कर प्लेयर को चेतावनी दे सकता है
	startAutosave(player, session)
	loadedEvent:Fire(player)
end

local function endSession(player: Player)
	local session = sessions[player]
	if not session then
		return
	end
	sessions[player] = nil -- ऑटोसेव लूप रोकता है, और दोबारा कॉल करने से कुछ नहीं होता
	save(session)
end

-- प्लेयर के डेटा की लाइव टेबल, या लोड होने तक nil। इसे सिर्फ़ सर्वर स्क्रिप्ट से बदलें।
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True जब प्लेयर का डेटा लोड हो गया और सेव होगा। किसी भी बिक्री से पहले जाँचें।
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- टाइमर का इंतज़ार किए बिना अभी सेव करता है, खरीदारी जैसे ज़रूरी पलों के लिए।
-- Yield करता है और सेव होने पर true लौटाता है।
function PlayerData.SaveNow(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and save(session)
end

Players.PlayerAdded:Connect(load)
Players.PlayerRemoving:Connect(endSession)
for _, player in Players:GetPlayers() do
	task.spawn(load, player) -- वे प्लेयर जो इस मॉड्यूल के पहली बार require होने से पहले आ गए
end

game:BindToClose(function()
	-- सर्वर इन फ़ंक्शन को 30 सेकंड देता है, इसलिए सबको एक साथ सेव करें
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- फिर सभी चल रहे सेव का इंतज़ार करें, PlayerRemoving में शुरू हुए सेव भी
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

गेम रिलीज़ होने के बाद STORE_NAME और key का पैटर्न User_ न बदलें। इनमें से किसी को भी बदलने से मॉड्यूल खाली key पर पहुँचेगा, और हर प्लेयर डिफ़ॉल्ट वैल्यू से दोबारा शुरू करेगा।

मॉड्यूल डेटा को कैसे सुरक्षित रखता है

डिफ़ॉल्ट वैल्यू और schema वर्ज़न

नए प्लेयर को DEFAULTS की ताज़ा कॉपी मिलती है। यह कॉपी ही होनी चाहिए: अगर सभी प्लेयर एक ही Inventory टेबल साझा करते, तो एक को दिया गया आइटम सबके पास दिखता।

हर सेव की गई टेबल में SchemaVersion होता है। फ़ील्ड जोड़ने के लिए नया वर्ज़न नहीं चाहिए, क्योंकि migrate गायब फ़ील्ड डिफ़ॉल्ट वैल्यू से भर देता है। नाम बदलने या ढाँचा बदलने के लिए चाहिए: SCHEMA_VERSION बढ़ाएँ और एक स्टेप जोड़ें, जैसे उदाहरण में जो Gold का नाम Coins करता है (नए गेम में उसे हटा दें और 1 से शुरू करें)। जिस डेटा का वर्ज़न सर्वर से ऊँचा है, वह नई रिलीज़ से आया है जो अभी रोल आउट हो रही है, इसलिए पुराने सर्वर उसे नहीं छूते।

नाकाम लोड कभी सेव नहीं होता

यह नियम पूरा डेटा मिटने से बचाता है। अगर लोड की सारी कोशिशें नाकाम हों, तो प्लेयर डिफ़ॉल्ट डेटा पर खेलता है, लेकिन canSave false होता है, इसलिए ये वैल्यू कभी उसकी असली प्रोग्रेस को ओवरराइट नहीं करेंगी। मॉड्यूल DataLoaded एट्रिब्यूट को भी false करता है, और स्टेप 3 प्लेयर को बताने के लिए इसका इस्तेमाल करता है। Roblox का रेफ़रेंस उदाहरण नाकाम लोड को इसी तरह संभालता है और किक करने की जगह यही सुझाता है; अगर आप किक करना पसंद करें, तो जहाँ मॉड्यूल चेतावनी छापता है वहाँ मैसेज के साथ player:Kick() कॉल करें।

बढ़ते अंतराल के साथ retry

withRetries हर कॉल को pcall में लपेटता है। नाकामी के बाद यह 1, फिर 2, फिर 4 सेकंड रुकता है, हर बार उस समय के आधे तक का रैंडम हिस्सा जोड़कर, और चार कोशिशों के बाद रुक जाता है (Studio में एक के बाद, ताकि store एक्सेस के बिना place तुरंत चले)। रैंडमनेस किसी गड़बड़ी के बाद बहुत से सर्वरों के retry को फैला देती है, और सीमा इंतज़ार को लगभग 10 सेकंड के अंदर रखती है, उन 30 सेकंड के भीतर जो सर्वर को बंद होने के लिए मिलते हैं। क्योंकि हर सेव पूरी लाइव टेबल UpdateAsync से लिखता है, देर से पूरा हुआ retry पुराना डेटा वापस नहीं ला सकता।

मॉड्यूल कब सेव करता है

कबक्यों
हर 180 सेकंड, जब तक प्लेयर सर्वर पर हैक्रैश होने पर नुकसान सीमित रखता है। पहला सेव अंतराल के किसी रैंडम पल पर होता है, ताकि सर्वर सब एक साथ सेव न करें। Roblox का रेफ़रेंस उदाहरण भी 180 सेकंड इस्तेमाल करता है।
जब प्लेयर निकलता है (PlayerRemoving)सामान्य आखिरी सेव। सेशन पहले हटाया जाता है, इसलिए ऑटोसेव रुक जाता है।
जब सर्वर बंद होता है (game:BindToClose)जो अभी सर्वर पर हैं, वे सब एक साथ सेव होते हैं, और फ़ंक्शन हर चल रहे सेव का इंतज़ार करता है। Roblox इसे 30 सेकंड देता है।
माँग पर, PlayerData.SaveNow(player) सेकिसी ऐसी चीज़ के बाद जो खोनी नहीं चाहिए, जैसे खरीदारी।

अगर प्लेयर उसी सर्वर पर दोबारा आता है जब उसका आखिरी सेव अभी चल रहा है, तो नया लोड उस सेव के खत्म होने का इंतज़ार करता है, इसलिए पुरानी वैल्यू नहीं पढ़ सकता।

स्टेप 2: दूसरी स्क्रिप्ट से डेटा पढ़ें और बदलें

मॉड्यूल को require करने वाली सभी सर्वर स्क्रिप्ट एक ही टेबल के साथ काम करती हैं:

कॉलक्या करता है
PlayerData.Get(player)प्लेयर के डेटा की लाइव टेबल, या लोड होने तक nil। फ़ील्ड सीधे बदलें, जैसे data.Coins += 10, और अगला सेव इसे उठा लेगा।
PlayerData.Loadedप्लेयर का डेटा तैयार होने पर प्लेयर के साथ चलता है, नाकाम लोड के बाद भी। सिर्फ़ प्लेयर भेजता है, क्योंकि BindableEvent से भेजी गई टेबल कॉपी बनकर पहुँचती है।
PlayerData.CanSave(player)लोड नाकाम हुआ तो false। किसी भी बिक्री से पहले जाँचें: जो खरीदारी सेव नहीं हो सकती, वह प्लेयर के निकलने पर गायब हो जाएगी।
PlayerData.SaveNow(player)तुरंत सेव करता है और सफल होने पर true लौटाता है। Yield करता है।

सेव किया डेटा सिर्फ़ मॉड्यूल में रहता है, और leaderstats बस दिखाने के लिए है: इसे लीडरबोर्ड गाइड की तरह बनाएँ, Loaded हैंडलर में PlayerData.Get(player) से भरें और वैल्यू बदलने पर दोनों अपडेट करें। सेव की गई वैल्यू कभी leaderstats से वापस न पढ़ें, और किसी दूसरी स्क्रिप्ट को कभी वही key सेव न करने दें।

जो स्क्रिप्ट प्लेयर्स के आने के बाद मॉड्यूल require करती है, उसे उनके लिए Loaded नहीं मिलता। हैंडलर जोड़ें, फिर Players:GetPlayers() पर लूप चलाकर उन सबको संभालें जिनके लिए PlayerData.Get(player) पहले से टेबल लौटाता है।

कोई पुरानी सेव स्क्रिप्ट बदल रहे हैं, जैसे लीडरबोर्ड गाइड वाली? उसकी वैल्यू उसके अपने store और key में रहती हैं, इसलिए यह मॉड्यूल सबको डिफ़ॉल्ट वैल्यू से शुरू करेगा। लॉन्च से पहले या तो STORE_NAME और User_ प्रीफ़िक्स को पुराने पर सेट करें (migrate बिना SchemaVersion वाले डेटा को वर्ज़न 1 मानता है और गायब फ़ील्ड भरता है), या पुरानी वैल्यू ट्रांसफ़र करें और फिर पुरानी स्क्रिप्ट हटा दें।

क्लाइंट इस डेटा को कभी सीधे नहीं बदलते। शॉप का बटन RemoteEvent चलाता है; सर्वर CanSave जाँचता है, कीमत की तुलना प्लेयर के Coins से करता है, टेबल बदलता है और SaveNow कॉल करता है। शॉप GUI गाइड ऐसी खरीदारी सर्वर साइड पर बनाती है।

फ़ील्ड जोड़ने का तैयार उदाहरण क्लिकर सिम्युलेटर गाइड में है: वह PowerLevel और Rebirths को DEFAULTS और Data टाइप में जोड़ती है, और फिर उन्हें PlayerData.Get से लौटी टेबल में बदलती है। migrate पुराने सेव वाले प्लेयर्स को नए फ़ील्ड दे देता है।

स्टेप 3: प्लेयर को बताएँ कि उसका डेटा लोड नहीं हुआ

जिस प्लेयर का डेटा लोड नहीं हुआ, उसे पता होना चाहिए कि यह सेशन सेव नहीं होगा, ताकि वह बेकार खेलने की जगह दोबारा जॉइन करे। यह LocalScript DataLoaded एट्रिब्यूट पर नज़र रखता है और जब वह false हो तो बैनर दिखाता है।

LocalScript स्थान: StarterPlayerScripts नाम: DataWarning
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local shown = false

local function showWarning()
	if shown or player:GetAttribute("DataLoaded") ~= false then
		return
	end
	shown = true

	local gui = Instance.new("ScreenGui")
	gui.Name = "DataWarning"
	gui.ResetOnSpawn = false

	local label = Instance.new("TextLabel")
	label.AnchorPoint = Vector2.new(0.5, 0)
	label.Position = UDim2.new(0.5, 0, 0, 12)
	label.Size = UDim2.new(0.8, 0, 0, 48)
	label.BackgroundColor3 = Color3.fromRGB(110, 28, 28)
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextScaled = true
	label.Text = "Your saved progress could not be loaded. Nothing you do in this server will be saved, so rejoin later."
	label.Parent = gui

	gui.Parent = player:WaitForChild("PlayerGui")
end

-- सर्वर इस प्लेयर का डेटा लोड करने की कोशिश के बाद DataLoaded एक बार सेट करता है
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

स्टेप 4: Studio में सेविंग जाँचें

यह टेस्ट कॉपी में करें, जिसमें Studio एक्सेस चालू हो।

  1. खुद को सेव करने के लिए कुछ दें। Main में require वाली लाइन के नीचे जोड़ें: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Play दबाएँ। Output विंडो (Window मेनू में या Script टैब पर) आपका नाम और 100 दिखाएगी (पहली बार चलाने पर), बिना Could not load चेतावनी के।
  3. Stop दबाएँ। टेस्ट खत्म करने से सर्वर बंद होता है, और मॉड्यूल बंद होने से पहले आपको सेव कर देता है।
  4. फिर से Play दबाएँ। Output में 200 दिखना चाहिए, पिछली बार से 100 ज़्यादा। अगर फिर वही नंबर दिखे, तो सेव नहीं हुआ: उसके ऊपर की चेतावनियाँ पढ़ें।
  5. एरर वाला रास्ता जाँचें। Studio एक्सेस बंद करें और Play दबाएँ। कुछ सेकंड के retry के बाद Output में Could not load User_... और 100 दिखेगा, और स्टेप 3 वाला बैनर आएगा। टेस्ट रोकें, एक्सेस फिर चालू करें और Play दबाएँ: Output में 300 दिखेगा, आपके सेव किए 200 और 100, क्योंकि नाकाम सेशन ने आपका डेटा कभी ओवरराइट नहीं किया।
  6. Main से टेस्ट लाइन हटा दें।

प्लेयर का डेटा क्यों खोता है

ये आम तरीके हैं जिनसे सेव सिस्टम प्रोग्रेस खो देता है। मॉड्यूल कोड में पहली चार लाइनें और schema वाली लाइन संभाल लेता है; बाकी इस पर निर्भर हैं कि आप क्या और कैसे रखते हैं, और आखिरी के लिए session locking चाहिए।

क्या होता हैनतीजाकैसे रोकें
लोड नाकाम हुआ, फिर भी स्क्रिप्ट सेव करती हैडिफ़ॉल्ट वैल्यू असली प्रोग्रेस मिटा देती हैं: पूरा डेटा साफ़जिस प्लेयर का लोड नाकाम हुआ, उसे कभी सेव न करें
सिर्फ़ PlayerRemoving में सेवक्रैश या सर्वर बंद होने पर सेव छूट जाता हैऑटोसेव और BindToClose, जो अपने सेव का इंतज़ार करे
pcall नहीं या retry नहींएक नाकाम रिक्वेस्ट स्क्रिप्ट रोक देती है या सेव खो देती हैसमय में फैले कुछ retry के साथ pcall
हर बदलाव पर सेवरिक्वेस्ट कतार में लगती हैं; कतार में 30 होने पर नई छोड़ दी जाती हैंडेटा मेमोरी में रखें और टाइमर पर सेव करें
ऐसी चीज़ सेव करना जो store नहीं रख सकतासेव पर एरर आता है, या वैल्यू nil लौटती हैनंबर, स्ट्रिंग, बूलियन और उनकी टेबल सेव करें
बिना migration के डेटा का ढाँचा बदलनापुराने सेव गलत फ़ील्ड में लोड होते हैंSchema वर्ज़न और migration स्टेप
दो स्क्रिप्ट एक key सेव करती हैंहर सेव दूसरी के फ़ील्ड मिटा देता हैkey का मालिक एक ही मॉड्यूल हो
दो सर्वर एक प्लेयर को रखते हैंपुराने डेटा वाला सर्वर आखिर में सेव करके नई प्रोग्रेस मिटा देता हैSession locking

Session locking, "lock lost" और ProfileStore

प्लेयर एक समय में एक सर्वर से जुड़ा होता है, लेकिन जब वह नए सर्वर पर आता है तब पुराने सर्वर का आखिरी सेव अभी चल रहा हो सकता है: धीमा retry, टेलीपोर्ट या जल्दी दोबारा जॉइन करना। अगर नया सर्वर पहले डेटा लोड कर ले, तो उसके पास पुराना डेटा होगा, और जो सर्वर आखिर में सेव करेगा वही जीतेगा। Roblox का डॉक्यूमेंटेशन बताता है कि ट्रेडिंग वाले गेम में यही अंतराल आइटम डुप्लिकेट होने की आम वजह है।

Session locking यह अंतराल बंद करती है। जब सर्वर प्लेयर की key लोड करता है, तो उसी UpdateAsync कॉल में वह key के metadata में अपना lock ID लिख देता है। कोई भी दूसरा सर्वर, जिसे ऐसा बिना expire हुआ lock मिले जो उसने नहीं लगाया, वह key न लोड करेगा न सेव करेगा। मालिक हर ऑटोसेव पर lock नया करता है और आखिरी सेव में उसे हटा देता है; अगर वह उसे नया करना बंद कर दे, तो lock expire हो जाता है और दूसरा सर्वर उसे ले सकता है।

"lock lost" का मतलब क्या है

Session locking वाले सिस्टम में सर्वर का lock खो गया (lock lost) तब होता है जब प्लेयर की key का मालिक अब कोई दूसरा सर्वर है, क्योंकि lock expire हो गया या छीन लिया गया। उसकी कॉपी पुरानी हो सकती है, इसलिए उसे उस प्लेयर को सेव करना बंद करना चाहिए; आम तरीका: उसे एक मैसेज के साथ किक करना, ताकि वह दोबारा जुड़े। अगर आपने प्लेयर के रूप में "lock lost" देखा, तो यह उस गेम के अपने सेव सिस्टम का मैसेज है, और इसे सिर्फ़ उसके डेवलपर समझा सकते हैं।

क्या आपको इसकी ज़रूरत है?

इस गाइड का मॉड्यूल सेशन lock नहीं करता। बिना lock के असली सबसे बुरा मामला यह है: किसी दुर्लभ race में प्लेयर वह खो देता है जो उसने पुराने सर्वर पर उसके आखिरी सफल सेव के बाद कमाया। Lock तब जोड़ें जब डुप्लिकेशन या नुकसान से प्लेयर्स का कुछ असली जाता हो: ट्रेडिंग, developer products, दुर्लभ आइटम या बार-बार टेलीपोर्ट।

विकल्पयह क्या हैक्या जानना चाहिए
इस गाइड का मॉड्यूललोड, मेमोरी कैश, retry, ऑटोसेव, बंद होने पर सेव और schema वर्ज़न, बिना lock केइतना छोटा कि पूरा पढ़ा और बदला जा सके
प्लेयर डेटा और खरीदारी के लिए Roblox का उदाहरणRoblox का रेफ़रेंस कोड, session locking, हर key के लिए क्रम से retry और खरीदारी की रसीदों को संभालने के साथRoblox कहता है कि यह किसी लोकप्रिय गेम में समय की कसौटी पर परखा नहीं गया और बिना व्यापक टेस्टिंग के जैसा है वैसा इस्तेमाल नहीं होना चाहिए
ProfileStoreकम्युनिटी का मुफ़्त ओपन सोर्स मॉड्यूल, ProfileService का उत्तराधिकारी, session locking और ऑटोसेव के इर्द-गिर्द बनाRoblox का नहीं। मौजूदा गेम को इस पर ले जाने के लिए पहले से सेव डेटा का migration चाहिए

किसी भी थर्ड पार्टी मॉड्यूल के लिए Roblox सलाह देता है कि जाँचें उसका मालिक कौन है, क्या वह मेंटेन होता है और उसके बिना आप अपने डेटा तक कैसे पहुँचेंगे। वही डॉक्यूमेंटेशन DataStore2 को पुरानी लाइब्रेरी कहता है जिसे नए गेम को इस्तेमाल नहीं करना चाहिए।

Data store की लिमिट

ये 30 सितंबर 2026 तक Roblox डॉक्यूमेंटेशन की लिमिट हैं। Roblox इन्हें बदलता रहता है, इसलिए किसी सटीक नंबर पर भरोसा करने से पहले एरर कोड और लिमिट वाला पेज (अंग्रेज़ी में) देखें।

हर सर्वर के लिए प्रति मिनट डिफ़ॉल्ट रिक्वेस्ट लिमिट
रिक्वेस्ट टाइपसामान्य storeOrdered store
Read: GetAsync, UpdateAsync में read60 + 40 × प्लेयर60 + 40 × प्लेयर
Write: SetAsync, IncrementAsync, UpdateAsync में write60 + 40 × प्लेयर30 + 5 × प्लेयर
List: ListKeysAsync या ordered store के लिए GetSortedAsync5 + 2 × प्लेयर5 + 2 × प्लेयर
Remove: RemoveAsync60 + 40 × प्लेयर30 + 5 × प्लेयर

20 प्लेयर पर सर्वर प्रति मिनट 860 सामान्य write कर सकता है; इस मॉड्यूल का ऑटोसेव उनमें से लगभग 7 खर्च करता है, और हर निकलने वाले प्लेयर पर एक। बजट तब खत्म होता है जब हर उठाए गए कॉइन पर सेव हो। दूसरा बजट पूरे गेम पर लागू होता है और Open Cloud के साथ साझा है: प्रति मिनट 300 read और हर ऑनलाइन प्लेयर पर 40, और 300 write और हर प्लेयर पर 20।

साइज़ और throughput की लिमिट
लिमिटवैल्यू
Store का नाम, key का नाम, scopeहर एक 50 कैरेक्टर
एक key में वैल्यूJSON के रूप में 4,194,304 कैरेक्टर
सभी सर्वरों से एक key पढ़ना25 MB प्रति मिनट
सभी सर्वरों से एक key में लिखना4 MB प्रति मिनट, हर रिक्वेस्ट अगले KB तक ऊपर राउंड होती है
इंतज़ार कर रही रिक्वेस्टहर कतार में 30; इससे ज़्यादा पर रिक्वेस्ट 301-306 एरर के साथ नाकाम होती हैं
पूरे गेम का स्टोरेज500 MB और हर समय के हर यूज़र पर 1 MB

प्लेयर के डेटा का साइज़ #HttpService:JSONEncode(data) से नापें, और लाइव सर्वर का बचा बजट DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite) से देखें। जिन GetAsync कॉल का जवाब 4 सेकंड वाले कैश ने दिया, वे गिनी नहीं जातीं। Studio के Run मोड की अपनी, शायद कम लिमिट हैं, इसलिए रिक्वेस्ट लिमिट जाँचने के लिए Roblox Team Create की सलाह देता है।

वर्ज़न और बैकअप

सामान्य data store आपके लिए इतिहास रखते हैं। UTC के हर घंटे में key में पहला write एक वर्ज़न के रूप में सेव होता है, और उस घंटे के बाद के write एक-दूसरे को ओवरराइट करते हैं। पुराना वर्ज़न तब से 30 दिन बाद expire होता है जब किसी नए write ने उसकी जगह ली; सबसे नया कभी expire नहीं होता। Ordered store वर्ज़न नहीं रखते।

किसी एक प्लेयर को रोलबैक करने के लिए Data Stores Manager खोलें (Creations, आपका गेम, Configure > Data Stores Manager), उसकी key चुनें, पहले का वर्ज़न चुनें और Revert दबाएँ; इसके लिए Edit अधिकार चाहिए। यह तब करें जब प्लेयर ऑफ़लाइन हो, वरना उसके सेशन वाला सर्वर रोलबैक के ऊपर अपनी कॉपी सेव कर देगा। सर्वर स्क्रिप्ट से ListVersionsAsync और GetVersionAsync पुराना वर्ज़न ढूँढते और पढ़ते हैं, जिसे आप फिर मौजूदा वैल्यू के रूप में वापस लिखते हैं।

ऐसा अपडेट पब्लिश करने से पहले जो डेटा सेव करने का तरीका बदलता है, Roblox Open Cloud Snapshot Data Stores API से snapshot लेने की सलाह देता है (हर गेम के लिए दिन में एक)। इसके बिना 3:30 UTC पर गलत सेव उस key में 3:00 से लिखी हर चीज़ मिटा देगा, क्योंकि वह उसी घंटे वाले वर्ज़न में जाता है।

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

Data store के एरर Studio की Output विंडो में दिखते हैं, और मॉड्यूल हर नाकाम कोशिश पर Roblox के एरर टेक्स्ट के साथ चेतावनी छापता है। स्क्रिप्ट एरर गाइड बताती है कि Output को आम तौर पर कैसे पढ़ें।

StudioAccessToApisNotAllowed (एरर 403)

"Can't write to DataStore from Studio because API access is not enabled." place पब्लिश करें, फिर टेस्ट कॉपी में File > Experience Settings > Security में Enable Studio Access to API Services चालू करें।

DataStore request was added to queue

सर्वर बजट से तेज़ रिक्वेस्ट भेज रहा है, या एक key को बहुत बार लिख रहा है, आम तौर पर हर बदलाव पर या लूप में सेव करने से। कतार में 30 रिक्वेस्ट होने पर नई 301-306 एरर के साथ नाकाम होती हैं। डेटा मेमोरी में रखें और टाइमर पर सेव करें।

CantStoreValue (एरर 104), या फ़ील्ड nil लौटता है

टेबल में ऐसा कुछ है जिसे store सेव नहीं कर सकता, जैसे Instance, Vector3 या Color3। उसकी जगह नाम, ID या सादे नंबर सेव करें और लोड पर ऑब्जेक्ट फिर से बनाएँ।

ValueTooLarge (एरर 105)

एक key में 4,194,304 से ज़्यादा JSON कैरेक्टर हैं। #HttpService:JSONEncode(data) से नापें, जो फिर से बनाया जा सकता है उसे हटाएँ, या डेटा को कई स्थायी key में बाँटें।

एरर नहीं है, पर डेटा सेव नहीं होता

मॉड्यूल की Could not load चेतावनी ढूँढें: नाकाम लोड के बाद यह जानबूझकर सेव करने से इनकार करता है। वरना वैल्यू शायद LocalScript में बदली गई, जो कभी सर्वर तक नहीं पहुँचती, या वही key कोई दूसरी स्क्रिप्ट सेव करती है।

हर बार दोबारा जॉइन करने पर डेटा रीसेट हो जाता है

key सेशन के बीच बदल रही है (player.Name से बनी है, या आपने STORE_NAME बदला), लोड नाकाम होता है और आप डिफ़ॉल्ट वैल्यू देखते हैं, या मॉड्यूल को कोई require नहीं करता और वह चलता ही नहीं। Output देखें और जाँचें कि Main, PlayerData को require करता है।

इसे RoCode से बनाएँ

अगर आप यह हाथ से नहीं बनाना चाहते, तो RoCode इसे सीधे आपके खुले place में कर सकता है। यह एक स्वतंत्र AI एजेंट है, Roblox का नहीं, जो Roblox Studio के प्लगइन के ज़रिए काम करता है: यह ऐसा Luau लिखता है जो किसी भी स्क्रिप्ट की तरह DataStoreService इस्तेमाल करता है, और आपके Explorer में स्क्रिप्ट बनाता है। यह खुद कभी आपके data store तक नहीं जाता, लेकिन प्लगइन 3.9 या नए के साथ छोटे प्लेटेस्ट के लिए Play दबा सकता है, जहाँ आपकी स्क्रिप्ट किसी भी टेस्ट की तरह चलती हैं।

आप लिखते हैं

मेरे गेम में सेविंग जोड़ो: Coins, Level और Inventory को ऑटोसेव और सर्वर बंद होने पर सेव वाले PlayerData मॉड्यूल में रखो, और Coins को मेरे मौजूदा leaderstats में दिखाओ।

RoCode करता है
  • Search Scripts और Read Script से मौजूदा leaderstats और DataStore कोड ढूँढ सकता है, ताकि दूसरी सेव स्क्रिप्ट जोड़ने की जगह जो आपके पास है उसे बढ़ाए। बड़े place में मैसेज में स्क्रिप्ट या फ़ोल्डर का नाम बताएँ।
  • Create Script से ModuleScript और उसे require करने वाली Script बनाता है, या Edit Script से मौजूदा को बदलता है
  • हर लिखी स्क्रिप्ट के लिए Check Script चलाता है: Studio के अंदर कंपाइल जाँच, चेतावनियों की छोटी सूची के साथ, type checking या टेस्ट रन नहीं
  • बदलाव समूहों में भेजता है, और हर समूह Studio में एक undo पॉइंट है

टेस्ट कॉपी में Studio Access to API Services आपको खुद ही चालू करना होगा: RoCode यह सेटिंग नहीं बदल सकता। प्लगइन 3.9 या नए के साथ इसका छोटा प्लेटेस्ट एरर पढ़ता है, और प्लगइन 3.9.11 या नए के साथ यह गेम चलता है या नहीं, यह जाँचने के लिए टेस्ट कैरेक्टर चला सकता है, लेकिन यह सिर्फ़ वही जाँचता है जो इसने खुद जाँचना तय किया, इसलिए खुद खेलकर देखें कि Coins, Level और Inventory सेव और लोड होते हैं। अगर आपके टेस्ट में सेव नहीं हुआ, तो Check Output आपके चलाए प्लेटेस्ट की Server लाइनें पढ़ सकता है। सेविंग आम तौर पर तब जोड़ी जाती है जब मुख्य गेम लूप पहले से चलता हो; AI से Roblox गेम एक-एक सिस्टम करके बनाना यही क्रम दिखाता है। RoCode, Studio से कैसे जुड़ता है।

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

Roblox Studio में DataStore कैसे चालू करें?

place पब्लिश करें, File > Experience Settings > Security खोलें, Enable Studio Access to API Services चालू करें और Save दबाएँ। यह एक अलग टेस्ट गेम में करें, क्योंकि तब Studio उस गेम के लाइव सर्वर वाले ही data store इस्तेमाल करता है।

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

नहीं। सेशन के बाद प्लेयर के बारे में कुछ भी सेव नहीं रहता, जब तक कोई सर्वर स्क्रिप्ट उसे DataStoreService से सेव न करे, leaderstats भी नहीं।

क्या चुनें: ProfileStore या सीधे DataStoreService?

ProfileStore भी data store पर ही बना है, इसलिए सवाल यह है कि क्या आप चाहते हैं कि session locking आपके लिए कोई और लिखे और मेंटेन करे। ट्रेडिंग, पेड आइटम या बार-बार टेलीपोर्ट के लिए lock फ़ायदेमंद है, लाइब्रेरी से या Roblox के रेफ़रेंस उदाहरण से। छोटे गेम के लिए इस जैसा मॉड्यूल पढ़ना और बदलना आसान है।

प्लेयर का डेटा रीसेट या डिलीट कैसे करें?

Data Stores Manager में key ढूँढें और Mark for Deletion चुनें, जिसे इंतज़ार की अवधि में रद्द किया जा सकता है, या सर्वर स्क्रिप्ट से key के लिए RemoveAsync कॉल करें। यह तब करें जब प्लेयर ऑफ़लाइन हो, वरना उसके सर्वर का अगला सेव डेटा वापस लिख देगा। टेस्ट कॉपी में STORE_NAME बदलने से सब शून्य से शुरू करते हैं; लाइव गेम में यह कभी न करें।

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

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

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

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