ट्यूटोरियल · रिवॉर्ड

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

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

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

संक्षेप में

हर प्लेयर के लिए DataStore में दो नंबर सेव करें: last, यानी आख़िरी क्लेम का os.time() मान, और streak। 24 घंटे बीतने पर इनाम लिया जा सकता है। अगर 48 घंटे से ज़्यादा बीत गए, तो स्ट्रीक दिन 1 से फिर शुरू होती है; वरना वह एक दिन बढ़ती है और बढ़ते इनाम वाले 7 दिनों के चक्र में घूमती है। जाँच UpdateAsync के अंदर करें, ताकि फ़ैसला और सेव एक साथ हों।

  • सर्वर पर os.time() इस्तेमाल करें, क्लाइंट का भेजा हुआ समय नहीं।
  • UpdateAsync के अंदर nil लौटाएँ जब इनाम नहीं लिया जा सकता: सेव रद्द हो जाता है और कुछ नहीं मिलता।
  • क्लाइंट सिर्फ़ स्टेटस पूछता है और इनाम माँगता है; जवाब सर्वर देता है।
इस पेज पर
  1. यह कैसे काम करता है
  2. 1. सर्वर
  3. 2. बटन
  4. Common errors
  5. With RoCode
  6. अक्सर पूछे जाने वाले सवाल
  7. स्रोत और आगे पढ़ें

डेली रिवॉर्ड और स्ट्रीक कैसे काम करते हैं

पिछली बार से बीते समय के हिसाब से क्लेम पर क्या होता है
पिछले क्लेम से बीता समयनतीजा
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 डालें:

Script स्थान: ServerScriptService नाम: DailyRewards
-- 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 डालें:

LocalScript स्थान: StarterPlayerScripts नाम: DailyRewardsMenu
-- 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 दबाता है, सर्वर समय की जाँच तब भी करता है।

जाँचें

  1. टेस्ट के लिए CLAIM_EVERY को 30 और STREAK_LOST_AFTER को 60 पर सेट करें।
  2. Play दबाएँ। बटन पर «Claim day 1!» लिखा है। उसे दबाएँ: +50 कॉइन।
  3. बटन 30 सेकंड गिनता है। अगले 30 सेकंड के अंदर फिर क्लेम करें: दिन 2, +75।
  4. एक मिनट से ज़्यादा इंतज़ार करें: अगला क्लेम फिर दिन 1 होगा।
  5. पब्लिश करने से पहले दोनों मान 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 पर एक जेम, उलटी गिनती वाला बटन, सेव और सर्वर पर जाँच के साथ।

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

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

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