संक्षेप में
हर प्लेयर के लिए DataStore में दो नंबर सेव करें: last, यानी आख़िरी क्लेम का os.time() मान, और streak। 24 घंटे बीतने पर इनाम लिया जा सकता है। अगर 48 घंटे से ज़्यादा बीत गए, तो स्ट्रीक दिन 1 से फिर शुरू होती है; वरना वह एक दिन बढ़ती है और बढ़ते इनाम वाले 7 दिनों के चक्र में घूमती है। जाँच UpdateAsync के अंदर करें, ताकि फ़ैसला और सेव एक साथ हों।
- सर्वर पर
os.time()इस्तेमाल करें, क्लाइंट का भेजा हुआ समय नहीं। - UpdateAsync के अंदर nil लौटाएँ जब इनाम नहीं लिया जा सकता: सेव रद्द हो जाता है और कुछ नहीं मिलता।
- क्लाइंट सिर्फ़ स्टेटस पूछता है और इनाम माँगता है; जवाब सर्वर देता है।
इस पेज पर
डेली रिवॉर्ड और स्ट्रीक कैसे काम करते हैं
| पिछले क्लेम से बीता समय | नतीजा |
|---|---|
| 24 घंटे से कम | अभी जल्दी है। बटन उलटी गिनती दिखाता है। |
| 24 से 48 घंटे | इनाम लिया जा सकता है, स्ट्रीक एक दिन बढ़ती है। |
| 48 घंटे से ज़्यादा | इनाम लिया जा सकता है, स्ट्रीक दिन 1 से फिर शुरू होती है। |
| दिन 7 के बाद | अगला क्लेम नए हफ़्ते का दिन 1 है। |
सर्वर पर os.time() UTC में सेकंड में मौजूदा Unix समय लौटाता है, इसलिए सभी सर्वर इस पर सहमत रहते हैं। प्लेयर के कंप्यूटर की घड़ी इसमें शामिल नहीं होती, इसलिए फ़ोन पर तारीख बदलने से कुछ नहीं मिलता।
स्टेप 1: रिवॉर्ड सर्वर
Game Settings, Security में Enable Studio Access to API Services चालू करें (place पब्लिश होना चाहिए)। फिर ServerScriptService में DailyRewards नाम की एक Script डालें:
-- ServerScriptService में DailyRewards नाम की Script।
-- हर 24 घंटे में एक इनाम। अगर 48 घंटे के अंदर फिर क्लेम करें, तो स्ट्रीक जारी रहती है,
-- और हफ़्ते भर हर दिन इनाम बढ़ता है, फिर हफ़्ता नए सिरे से शुरू होता है।
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- स्ट्रीक के दिन 1 से 7 के कॉइन
local CLAIM_EVERY = 24 * 60 * 60 -- दो क्लेम के बीच सेकंड
local STREAK_LOST_AFTER = 48 * 60 * 60 -- पूरा एक दिन छूट गया, और स्ट्रीक फिर से शुरू होती है
type Record = { last: number, streak: number }
local store = DataStoreService:GetDataStore("DailyRewards_v1")
local statusFunction = Instance.new("RemoteFunction")
statusFunction.Name = "GetDailyStatus"
statusFunction.Parent = ReplicatedStorage
local claimFunction = Instance.new("RemoteFunction")
claimFunction.Name = "ClaimDaily"
claimFunction.Parent = ReplicatedStorage
local records: { [Player]: Record } = {}
local claiming: { [Player]: boolean } = {}
local function readRecord(data: any): Record
if type(data) == "table" and type(data.last) == "number" and type(data.streak) == "number" then
return { last = data.last, streak = data.streak }
end
return { last = 0, streak = 0 }
end
-- अगले क्लेम के लिए स्ट्रीक का दिन, 1 से 7
local function nextDay(record: Record, now: number): number
if now - record.last >= STREAK_LOST_AFTER then
return 1
end
return record.streak % #REWARDS + 1
end
local function addCoins(player: Player, amount: number)
local leaderstats = player:FindFirstChild("leaderstats")
local coins = leaderstats and leaderstats:FindFirstChild("Coins")
if coins and coins:IsA("IntValue") then
coins.Value += amount
end
end
Players.PlayerAdded:Connect(function(player: Player)
local ok, data = pcall(function()
return store:GetAsync(tostring(player.UserId))
end)
if ok then
records[player] = readRecord(data)
else
warn("DailyRewards: could not load", player.Name, data)
end
end)
Players.PlayerRemoving:Connect(function(player: Player)
records[player] = nil
claiming[player] = nil
end)
-- मेनू क्या दिखाता है: अगले क्लेम तक सेकंड (0 = अभी ले सकते हैं) और यह कौन सा दिन है
statusFunction.OnServerInvoke = function(player: Player)
local record = records[player]
if not record then
return nil
end
local now = os.time()
return {
wait = math.max(0, record.last + CLAIM_EVERY - now),
day = nextDay(record, now),
rewards = REWARDS,
}
end
claimFunction.OnServerInvoke = function(player: Player): string
local record = records[player]
if not record then
return "Still loading, try again in a moment"
end
if claiming[player] then
return "One moment..."
end
claiming[player] = true
local now = os.time()
local claimedDay: number? = nil
-- UpdateAsync सबसे ताज़ा सेव रिकॉर्ड पढ़ता है और अपडेट के अंदर फ़ैसला करता है, इसलिए
-- दूसरा सर्वर (या दूसरा क्लिक) एक ही दिन दो बार नहीं ले सकता
local ok, err = pcall(function()
store:UpdateAsync(tostring(player.UserId), function(old: any)
-- UpdateAsync इसे कई बार कॉल कर सकता है: सिर्फ़ आख़िरी कॉल गिनी जाती है
claimedDay = nil
local saved = readRecord(old)
if now - saved.last < CLAIM_EVERY then
return nil -- अभी जल्दी है: nil लौटाने से सेव रद्द हो जाता है
end
local day = nextDay(saved, now)
claimedDay = day
return { last = now, streak = day }
end)
end)
claiming[player] = nil
if not ok then
warn("DailyRewards: could not save", player.Name, err)
return "Could not save, try again later"
end
local day = claimedDay
if not day then
return "Come back later for your next reward"
end
records[player] = { last = now, streak = day }
addCoins(player, REWARDS[day])
return string.format("Day %d reward: +%d coins!", day, REWARDS[day])
end
क्लेम UpdateAsync को दिए गए फ़ंक्शन के अंदर होता है। Roblox उसे सबसे ताज़ा सेव किए गए रिकॉर्ड के साथ कॉल करता है। अगर अभी जल्दी है, तो फ़ंक्शन nil लौटाता है और Roblox लिखना रद्द कर देता है। वरना वह नया रिकॉर्ड लौटाता है, और स्क्रिप्ट याद रखती है कि कौन सा दिन क्लेम हुआ। कॉइन तभी जुड़ते हैं जब UpdateAsync बिना गलती के पूरा हो जाए। अगर इस बीच किसी दूसरे सर्वर ने key बदल दी, तो Roblox नए मान के साथ फ़ंक्शन को फिर कॉल कर सकता है, इसीलिए फ़ैसला उसी के अंदर लिया जाता है।
स्टेप 2: उलटी गिनती वाला बटन
StarterPlayer > StarterPlayerScripts में DailyRewardsMenu नाम की एक LocalScript डालें:
-- StarterPlayerScripts में DailyRewardsMenu नाम की LocalScript।
-- उलटी गिनती वाला Daily बटन। जब इनाम तैयार हो, उस पर Claim लिखा होता है।
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local statusFunction = ReplicatedStorage:WaitForChild("GetDailyStatus") :: RemoteFunction
local claimFunction = ReplicatedStorage:WaitForChild("ClaimDaily") :: RemoteFunction
local gui = Instance.new("ScreenGui")
gui.Name = "DailyGui"
gui.ResetOnSpawn = false
local button = Instance.new("TextButton")
button.Size = UDim2.fromOffset(170, 48)
button.Position = UDim2.new(0, 12, 0.5, 52)
button.BackgroundColor3 = Color3.fromRGB(240, 170, 40)
button.TextColor3 = Color3.new(1, 1, 1)
button.Font = Enum.Font.GothamBold
button.TextSize = 17
button.Text = "Daily reward"
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = button
button.Parent = gui
gui.Parent = Players.LocalPlayer:WaitForChild("PlayerGui")
local readyAt: number? = nil -- os.clock() समय, जब इनाम तैयार होगा
local day = 1
local busy = false
local function refresh()
local ok, status = pcall(function()
return statusFunction:InvokeServer()
end)
if ok and type(status) == "table" and type(status.wait) == "number" then
readyAt = os.clock() + status.wait
day = if type(status.day) == "number" then status.day else 1
end
end
local function format(seconds: number): string
local h = seconds // 3600
local m = (seconds % 3600) // 60
local s = seconds % 60
return string.format("%02d:%02d:%02d", h, m, s)
end
button.Activated:Connect(function()
if busy or not readyAt or os.clock() < readyAt then
return
end
busy = true
button.Text = "Claiming..."
local ok, message = pcall(function()
return claimFunction:InvokeServer()
end)
button.Text = if ok and type(message) == "string" then message else "Try again"
task.wait(2)
refresh()
busy = false
end)
refresh()
while true do
if not busy then
if not readyAt then
button.Text = "Loading..."
refresh()
elseif os.clock() >= readyAt then
button.Text = string.format("Claim day %d!", day)
else
button.Text = "Next: " .. format(math.ceil(readyAt - os.clock()))
end
end
task.wait(1)
end
बटन एक बार सर्वर से पूछता है कि कितना इंतज़ार करना है, फिर os.clock() से हर सेकंड ख़ुद गिनती करता है, इसलिए हर सेकंड सर्वर से नहीं पूछता। क्लेम के बाद वह फिर पूछता है। उलटी गिनती सिर्फ़ दिखाने के लिए है: जब प्लेयर Claim दबाता है, सर्वर समय की जाँच तब भी करता है।
जाँचें
- टेस्ट के लिए
CLAIM_EVERYको30औरSTREAK_LOST_AFTERको60पर सेट करें। - Play दबाएँ। बटन पर «Claim day 1!» लिखा है। उसे दबाएँ: +50 कॉइन।
- बटन 30 सेकंड गिनता है। अगले 30 सेकंड के अंदर फिर क्लेम करें: दिन 2, +75।
- एक मिनट से ज़्यादा इंतज़ार करें: अगला क्लेम फिर दिन 1 होगा।
- पब्लिश करने से पहले दोनों मान 24 और 48 घंटे वाली लाइनों पर वापस करें।
आम गलतियाँ और उनके हल
Server मोड में Output विंडो पर नज़र रखें।
बटन लगातार Loading... दिखाता है
प्लेयर का रिकॉर्ड लोड नहीं हुआ। Studio में Enable Studio Access to API Services चालू करें। Output में गलती «could not load» के बाद दिखती है।
क्लेम पर «Come back later» आता है, जबकि बटन पर Claim था
सेव किया गया रिकॉर्ड उससे नया था जितना बटन जानता था, जैसे किसी दूसरे सर्वर पर क्लेम के बाद। सही जवाब वही है जो सर्वर ने दिया।
स्ट्रीक हर दिन रीसेट हो जाती है
प्लेयर 48 घंटे से ज़्यादा के अंतर पर इनाम ले रहे हैं, या STREAK_LOST_AFTER टेस्ट वाले मान पर रह गया।
कॉइन नहीं जुड़ते
प्लेयर के leaderstats में Coins नाम का IntValue होना चाहिए, जो सर्वर स्क्रिप्ट ने बनाया हो।
इसे RoCode से बनाएँ
अगर आप यह सब हाथ से सेट नहीं करना चाहते, तो RoCode इसे आपके खुले place में बना सकता है। RoCode, Roblox Studio के लिए एक स्वतंत्र AI एजेंट है, Roblox का नहीं: आप वेब चैट में बदलाव बताते हैं, और उसका Studio प्लगइन आपके Explorer में स्क्रिप्ट बनाता है।
7 दिन की स्ट्रीक वाले डेली रिवॉर्ड जोड़ो: दिन 1 से 6 तक कॉइन और दिन 7 पर एक जेम, उलटी गिनती वाला बटन, सेव और सर्वर पर जाँच के साथ।
- एक ही स्टेप में अपने प्रीमियम UI किट से एक तैयार एनिमेटेड डेली रिवॉर्ड स्क्रीन डाल सकता है, पाँच थीम में से एक में (candy, neon, gold, blocky, pastel), काम करती सर्वर स्क्रिप्ट के साथ
- या इस गाइड की सर्वर स्क्रिप्ट और बटन लिखता है, जो आपकी मौजूदा करेंसी से जुड़े होते हैं
- उसे हर स्क्रिप्ट का कंपाइल Check Script से जाँचने को कहा गया है, और वह हर बदलाव के सेट के आसपास undo पॉइंट रखता है
बनाने के बाद RoCode अपना टेस्ट रोबोट चला सकता है: वह Studio में आपका गेम खेलता है, बटन दबाता है और PASS या FAIL बताता है। वह सिर्फ़ वही जाँचता है जो उसने ख़ुद टेस्ट के लिए चुना, और 24 घंटे के टाइमर के लिए छोटे मानों के साथ आपका अपना टेस्ट चाहिए। RoCode, Studio से कैसे जुड़ता है।
अक्सर पूछे जाने वाले सवाल
Roblox में डेली रिवॉर्ड कैसे बनाएं?
सर्वर पर os.time() से हर प्लेयर के आख़िरी क्लेम का समय सेव करें, 24 घंटे बाद क्लेम की इजाज़त दें, और इनाम देने से पहले उसे UpdateAsync के अंदर सेव करें। स्क्रिप्ट स्टेप 1 में है।
डेली लॉगिन स्ट्रीक कैसे बनाएं?
क्लेम के समय के साथ स्ट्रीक काउंटर भी सेव करें। अगर अगला क्लेम 48 घंटे के अंदर आया, तो एक जोड़ें; अगर बाद में, तो 1 से फिर शुरू करें।
क्या प्लेयर घड़ी बदलकर डेली रिवॉर्ड में धोखा कर सकते हैं?
इस स्क्रिप्ट के साथ नहीं: यह सिर्फ़ सर्वर का os.time() इस्तेमाल करती है।
क्या इनाम आधी रात को रीसेट करना बेहतर है?
24 घंटे की जगह UTC के हिसाब से कैलेंडर दिन गिने जा सकते हैं। खिसकते 24 घंटे आसान हैं और सभी टाइम ज़ोन के लिए एक जैसे काम करते हैं।
स्रोत और आगे पढ़ें
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (अंग्रेज़ी में). अपडेट फ़ंक्शन और nil से रद्द करना
- Roblox Creator Docs: Data stores (अंग्रेज़ी में). Studio से एक्सेस और data store की बुनियादी बातें
- Roblox Creator Docs: Remote events and functions (अंग्रेज़ी में). RemoteFunction
कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।