Tutorial · Beloningen

Dagelijkse beloningen maken in Roblox Studio

Een dagelijkse beloning geeft spelers een reden om je game morgen weer te openen, en een reeks geeft ze een reden om geen dag over te slaan. Alle logica draait om een opgeslagen tijdstempel: wanneer de speler de beloning voor het laatst claimde en hoeveel dagen op rij. Deze handleiding bewaart beide waarden betrouwbaar, zodat een speler de beloning niet twee keer kan claimen door opnieuw te joinen of twee servers te openen, en voegt een knop toe met een aftelling tot de volgende beloning.

Bijgewerkt 20 november 20265 min lezenAuteur:

In het kort

Sla voor elke speler twee getallen op in een DataStore: last, de waarde van os.time() bij de laatste claim, en streak. De beloning kan geclaimd worden als er 24 uur voorbij zijn. Zijn er meer dan 48 uur voorbij, dan begint de reeks opnieuw bij dag 1; anders groeit hij met één dag en loopt hij rond in een cyclus van 7 dagen met stijgende beloningen. Doe de controle binnen UpdateAsync, zodat de beslissing en het opslaan samen gebeuren.

  • Gebruik os.time() op de server, niet een tijd die de client stuurt.
  • Geef binnen UpdateAsync nil terug als de beloning niet geclaimd mag worden: het opslaan wordt geannuleerd en er wordt niets uitgedeeld.
  • De client vraagt alleen de status op en vraagt om de beloning; de server beslist.
Op deze pagina
  1. Hoe het werkt
  2. 1. Server
  3. 2. Knop
  4. Common errors
  5. With RoCode
  6. Veelgestelde vragen
  7. Bronnen en verder lezen

Hoe dagelijkse beloningen en reeksen werken

Wat er bij een claim gebeurt, afhankelijk van de tijd sinds de vorige keer
Tijd sinds de vorige claimResultaat
Minder dan 24 uurNog te vroeg. De knop toont een aftelling.
Tussen 24 en 48 uurDe beloning kan geclaimd worden, de reeks groeit met één dag.
Meer dan 48 uurDe beloning kan geclaimd worden, de reeks begint opnieuw bij dag 1.
Na dag 7De volgende claim is dag 1 van een nieuwe week.

os.time() op de server geeft de huidige Unix-tijd in seconden in UTC terug, dus alle servers zijn het erover eens. De klok op de computer van de speler doet niet mee, en daarom heeft het geen zin om de datum op je telefoon te veranderen.

Stap 1: de beloningsserver

Zet Enable Studio Access to API Services aan in Game Settings, Security (de place moet gepubliceerd zijn). Zet daarna een Script in ServerScriptService met de naam DailyRewards:

Script in ServerScriptService met de naam DailyRewards
-- Script in ServerScriptService met de naam DailyRewards.
-- Eén beloning per 24 uur. Claim je opnieuw binnen 48 uur, dan gaat de reeks door,
-- en de beloningen stijgen elke dag gedurende een week, daarna begint de week opnieuw.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- munten voor dag 1 tot en met 7 van de reeks
local CLAIM_EVERY = 24 * 60 * 60 -- seconden tussen claims
local STREAK_LOST_AFTER = 48 * 60 * 60 -- een hele dag overgeslagen, en de reeks begint opnieuw

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

-- Dag van de reeks voor de volgende claim, van 1 tot 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)

-- Wat het menu toont: seconden tot de volgende claim (0 = nu mogelijk) en welke dag het is
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 leest de nieuwste opgeslagen record en beslist binnen de update, daardoor
	-- kan een tweede server (of een tweede klik) niet twee keer dezelfde dag claimen
	local ok, err = pcall(function()
		store:UpdateAsync(tostring(player.UserId), function(old: any)
			-- UpdateAsync kan dit meerdere keren aanroepen: alleen de laatste aanroep telt
			claimedDay = nil
			local saved = readRecord(old)
			if now - saved.last < CLAIM_EVERY then
				return nil -- nog te vroeg: nil teruggeven annuleert het opslaan
			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

De claim gebeurt binnen de functie die aan UpdateAsync wordt doorgegeven. Roblox roept die aan met de nieuwste opgeslagen record. Is het nog te vroeg, dan geeft de functie nil terug en annuleert Roblox het schrijven. Anders geeft ze de nieuwe record terug en onthoudt het script welke dag geclaimd is. De munten worden pas toegevoegd nadat UpdateAsync zonder fout klaar is. Als een andere server de key in de tussentijd heeft gewijzigd, kan Roblox de functie opnieuw aanroepen met een nieuwere waarde, en daarom wordt de beslissing juist daarbinnen genomen.

Stap 2: de knop met aftelling

Zet een LocalScript in StarterPlayer > StarterPlayerScripts met de naam DailyRewardsMenu:

LocalScript in StarterPlayerScripts met de naam DailyRewardsMenu
-- LocalScript in StarterPlayerScripts met de naam DailyRewardsMenu.
-- Een Daily-knop met aftelling. Als de beloning klaar is, staat er Claim op.
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()-tijd waarop de beloning klaar is
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

De knop vraagt de server één keer hoe lang er gewacht moet worden en telt daarna zelf elke seconde af met os.clock(), dus hij spreekt de server niet elke seconde aan. Na een claim vraagt hij het opnieuw. De aftelling is alleen voor het zicht: de server controleert de tijd hoe dan ook als de speler op Claim drukt.

Testen

  1. Zet om te testen CLAIM_EVERY op 30 en STREAK_LOST_AFTER op 60.
  2. Druk op Play. Op de knop staat "Claim day 1!". Druk erop: +50 munten.
  3. De knop telt 30 seconden af. Claim opnieuw binnen de volgende 30 seconden: dag 2, +75.
  4. Wacht langer dan een minuut: de volgende claim is weer dag 1.
  5. Zet beide waarden voor het publiceren terug naar de regels met 24 en 48 uur.

Veelvoorkomende fouten en oplossingen

Houd het Output-venster in de Server-modus in de gaten.

De knop toont steeds Loading...

De record van de speler is niet geladen. Zet in Studio Enable Studio Access to API Services aan. In Output zie je de fout na "could not load".

Bij het claimen staat er "Come back later", terwijl er Claim op de knop stond

De opgeslagen record was nieuwer dan de knop wist, bijvoorbeeld na een claim op een andere server. Het juiste antwoord is dat van de server.

De reeks wordt elke dag gereset

Spelers claimen met meer dan 48 uur ertussen, of STREAK_LOST_AFTER staat nog op de testwaarde.

Er worden geen munten toegevoegd

De speler moet een IntValue Coins in leaderstats hebben, gemaakt door een serverscript.

Bouw dit met RoCode

Heb je geen zin om dit met de hand in te stellen, dan kan RoCode het bouwen in de place die je open hebt. RoCode is een onafhankelijke AI-agent voor Roblox Studio, niet van Roblox: je beschrijft de wijziging in een webchat en de plugin voor Studio maakt de scripts in je Explorer.

Jij typt

Voeg dagelijkse beloningen toe met een reeks van 7 dagen: munten op dag 1 tot en met 6 en een gem op dag 7, een knop met aftelling, met opslaan en controle op de server.

RoCode doet
  • Kan in één stap een kant-en-klaar geanimeerd scherm voor dagelijkse beloningen uit zijn premium UI-sets invoegen, in een van vijf thema's (candy, neon, gold, blocky, pastel), met werkende serverscripts
  • Of schrijft het serverscript en de knop uit deze handleiding, gekoppeld aan je bestaande valuta
  • Hij is opgedragen elk script met Check Script op compileren te controleren, en hij zet undo-punten rond elke reeks wijzigingen

Na het bouwen kan RoCode zijn testrobot starten: die speelt je game in Studio, drukt op knoppen en meldt PASS of FAIL. Hij controleert alleen wat hij zelf heeft gekozen om te testen, en voor de timer van 24 uur heb je je eigen test met korte waarden nodig. Hoe RoCode verbinding maakt met Studio.

Veelgestelde vragen

Hoe maak je dagelijkse beloningen in Roblox?

Sla de tijd van de laatste claim van elke speler op met os.time() op de server, sta een claim toe na 24 uur en sla die op binnen UpdateAsync voordat je de beloning uitdeelt. Het script staat in stap 1.

Hoe maak je een reeks voor dagelijks inloggen?

Sla een teller voor de reeks op samen met de claimtijd. Komt de volgende claim binnen 48 uur, tel er dan één bij op; komt hij later, begin dan opnieuw bij 1.

Kunnen spelers dagelijkse beloningen omzeilen door hun klok te verzetten?

Met dit script niet: het gebruikt alleen os.time() van de server.

Is het niet beter om de beloning om middernacht te resetten?

Je kunt kalenderdagen in UTC tellen in plaats van 24 uur. Een glijdende 24 uur is eenvoudiger en werkt hetzelfde voor alle tijdzones.

Bronnen en verder lezen

Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.