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
Hoe dagelijkse beloningen en reeksen werken
| Tijd sinds de vorige claim | Resultaat |
|---|---|
| Minder dan 24 uur | Nog te vroeg. De knop toont een aftelling. |
| Tussen 24 en 48 uur | De beloning kan geclaimd worden, de reeks groeit met één dag. |
| Meer dan 48 uur | De beloning kan geclaimd worden, de reeks begint opnieuw bij dag 1. |
| Na dag 7 | De 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.
-- 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.
-- 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
- Zet om te testen
CLAIM_EVERYop30enSTREAK_LOST_AFTERop60. - Druk op Play. Op de knop staat "Claim day 1!". Druk erop: +50 munten.
- De knop telt 30 seconden af. Claim opnieuw binnen de volgende 30 seconden: dag 2, +75.
- Wacht langer dan een minuut: de volgende claim is weer dag 1.
- 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.
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.
- 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
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (in het Engels). de updatefunctie en annuleren met nil
- Roblox Creator Docs: Data stores (in het Engels). toegang vanuit Studio en de basis van data stores
- Roblox Creator Docs: Remote events and functions (in het Engels). RemoteFunction
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.