संक्षेप में
सर्वर 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 जोड़ें, ताकि दो सर्वर एक ही प्लेयर को सेव न कर सकें।
इस पेज पर
शुरू करने से पहले: टेस्ट कॉपी में Studio एक्सेस चालू करें
Studio में चल रहा गेम तब तक data store तक नहीं पहुँच सकता, जब तक आप इसकी अनुमति न दें। इस अनुमति में एक पेच है, जिसके बारे में Roblox का डॉक्यूमेंटेशन चेतावनी देता है: तब Studio लाइव गेम वाले ही data store पढ़ता और लिखता है, इसलिए जो टेस्ट Studio में आपके कॉइन शून्य करता है, वह लाइव गेम में भी उन्हें शून्य कर देता है, और टेस्ट कोड की गलती असली प्लेयर्स की key बिगाड़ सकती है।
- एक टेस्ट कॉपी बनाएँ। place को फ़ाइल में सेव करें, कॉपी खोलें, File > Publish to Roblox As चुनें और Create new game दबाएँ। इसे लाइव गेम के अंदर place की तरह न जोड़ें: एक गेम के सारे place एक ही data store साझा करते हैं।
- टेस्ट कॉपी में File > Experience Settings खोलें और Security पर जाएँ।
- Enable Studio Access to API Services चालू करें और Save दबाएँ।
Data store कॉल सिर्फ़ सर्वर Script में काम करती हैं; कोशिश करने वाला LocalScript एरर पाता है, इसलिए क्लाइंट सेव किया डेटा नहीं लिख सकते। जब किसी बटन को इसे बदलना हो, तो क्लाइंट RemoteEvent से सर्वर से कहता है, और फ़ैसला सर्वर करता है (देखें RemoteEvents गाइड, अंग्रेज़ी में)।
Data store प्लेयर का डेटा कैसे रखते हैं
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 वाली ऑटोमैटिक प्रोसेसिंग भी प्लेयर का डेटा ढूँढ पाती है।
| टाइप | सेव होता है? | नोट |
|---|---|---|
| नंबर, स्ट्रिंग, बूलियन, बफ़र | हाँ | स्ट्रिंग सही UTF-8 होनी चाहिए। inf या nan न रखें। |
| टेबल | हाँ | अगर अंदर का सब कुछ भी सेव हो सकता है। जिस टेबल की नंबर वाली key 1 से शुरू नहीं होतीं (इसलिए उसकी लंबाई 0 है), वह इन key को स्ट्रिंग बनाकर लौटती है। |
Instance, Vector3, CFrame, Color3 | नहीं | सेव करने पर एरर आता है या nil लिखा जाता है। आइटम का नाम या पोज़िशन तीन नंबरों के रूप में सेव करें। |
हर रिक्वेस्ट एक वेब कॉल है, जो नाकाम हो सकती है, समय लेती है और प्रति मिनट का बजट खर्च करती है। इसलिए भरोसेमंद सेव सिस्टम प्लेयर के आने पर डेटा एक बार पढ़ते हैं, खेलते समय उसे सर्वर की टेबल में रखते हैं और समय-समय पर वापस लिखते हैं।
GetAsync, SetAsync या UpdateAsync: कौन सा चुनें
| मेथड | क्या करता है | किसके लिए |
|---|---|---|
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 सेकंड पर, निकलने पर और सर्वर बंद होने पर सेव करता है, और जिनका डेटा लोड नहीं हुआ उन्हें सेव करने से इनकार करता है।
- Explorer में ServerScriptService पर कर्सर ले जाएँ, + दबाएँ और ModuleScript डालें। उसका नाम
PlayerDataरखें और उसकी सामग्री नीचे वाले कोड से बदल दें। - ModuleScript तभी चलता है जब कोई स्क्रिप्ट उसे require करे। ServerScriptService में
Mainनाम की Script डालें, जिसमें यह लाइन हो:local PlayerData = require(game:GetService("ServerScriptService").PlayerData)। दूसरी सर्वर स्क्रिप्ट भी इसे इसी तरह require करती हैं। DEFAULTSऔरDataटाइप को अपने गेम के हिसाब से बदलें, हर फ़ील्ड को नंबर, स्ट्रिंग, बूलियन या टेबल ही रखें।
ServerScriptService
PlayerData ModuleScript new
Main Script new
StarterPlayer
StarterPlayerScripts
DataWarning LocalScript new
-- 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 हो तो बैनर दिखाता है।
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 एक्सेस चालू हो।
- खुद को सेव करने के लिए कुछ दें।
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) - Play दबाएँ। Output विंडो (Window मेनू में या Script टैब पर) आपका नाम और 100 दिखाएगी (पहली बार चलाने पर), बिना
Could not loadचेतावनी के। - Stop दबाएँ। टेस्ट खत्म करने से सर्वर बंद होता है, और मॉड्यूल बंद होने से पहले आपको सेव कर देता है।
- फिर से Play दबाएँ। Output में 200 दिखना चाहिए, पिछली बार से 100 ज़्यादा। अगर फिर वही नंबर दिखे, तो सेव नहीं हुआ: उसके ऊपर की चेतावनियाँ पढ़ें।
- एरर वाला रास्ता जाँचें। Studio एक्सेस बंद करें और Play दबाएँ। कुछ सेकंड के retry के बाद Output में
Could not load User_...और 100 दिखेगा, और स्टेप 3 वाला बैनर आएगा। टेस्ट रोकें, एक्सेस फिर चालू करें और Play दबाएँ: Output में 300 दिखेगा, आपके सेव किए 200 और 100, क्योंकि नाकाम सेशन ने आपका डेटा कभी ओवरराइट नहीं किया। 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 इन्हें बदलता रहता है, इसलिए किसी सटीक नंबर पर भरोसा करने से पहले एरर कोड और लिमिट वाला पेज (अंग्रेज़ी में) देखें।
| रिक्वेस्ट टाइप | सामान्य store | Ordered store |
|---|---|---|
Read: GetAsync, UpdateAsync में read | 60 + 40 × प्लेयर | 60 + 40 × प्लेयर |
Write: SetAsync, IncrementAsync, UpdateAsync में write | 60 + 40 × प्लेयर | 30 + 5 × प्लेयर |
List: ListKeysAsync या ordered store के लिए GetSortedAsync | 5 + 2 × प्लेयर | 5 + 2 × प्लेयर |
Remove: RemoveAsync | 60 + 40 × प्लेयर | 30 + 5 × प्लेयर |
20 प्लेयर पर सर्वर प्रति मिनट 860 सामान्य write कर सकता है; इस मॉड्यूल का ऑटोसेव उनमें से लगभग 7 खर्च करता है, और हर निकलने वाले प्लेयर पर एक। बजट तब खत्म होता है जब हर उठाए गए कॉइन पर सेव हो। दूसरा बजट पूरे गेम पर लागू होता है और Open Cloud के साथ साझा है: प्रति मिनट 300 read और हर ऑनलाइन प्लेयर पर 40, और 300 write और हर प्लेयर पर 20।
| लिमिट | वैल्यू |
|---|---|
| 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 में दिखाओ।
- 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 Creator Docs: Data stores (अंग्रेज़ी में). Studio एक्सेस, GetAsync, SetAsync, UpdateAsync, set और update
- Roblox Creator Docs: Best practices for data stores (अंग्रेज़ी में). हर प्लेयर की एक key, मेमोरी में डेटा, बढ़ते अंतराल के साथ retry, थर्ड पार्टी मॉड्यूल
- Roblox Creator Docs: Data store error codes and limits (अंग्रेज़ी में). एरर कोड, सर्वर और गेम की रिक्वेस्ट लिमिट, साइज़, throughput और स्टोरेज लिमिट
- Roblox Creator Docs: Versioning, listing and caching (अंग्रेज़ी में). घंटे वाले वर्ज़न, snapshot, 4 सेकंड का कैश, क्या सेव हो सकता है
- Roblox Creator Docs: Implement player data and purchasing systems (अंग्रेज़ी में). रेफ़रेंस उदाहरण, session locking, नाकाम लोड, हर 180 सेकंड पर ऑटोसेव
- Roblox Creator Docs: Data Stores Manager (अंग्रेज़ी में). key देखना, वर्ज़न रोलबैक, डेटा डिलीट करना
- Roblox Engine API: DataModel:BindToClose (अंग्रेज़ी में). बंद होने के लिए 30 सेकंड
कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।