Kort fortalt
Lagre to tall per spiller i en DataStore: last, verdien av os.time() ved siste innløsning, og streak. Belønningen kan hentes når det har gått 24 timer. Har det gått mer enn 48 timer, starter streaken på nytt på dag 1; ellers vokser den med én dag og går i ring over 7 dager med økende belønninger. Gjør sjekken inne i UpdateAsync, så avgjørelsen og lagringen skjer samtidig.
- Bruk
os.time()på serveren, ikke en tid som klienten sender. - Returner nil inne i UpdateAsync når belønningen ikke kan hentes: lagringen avbrytes, og ingenting blir gitt.
- Klienten spør bare om status og ber om belønningen; serveren svarer.
På denne siden
Slik virker daglige belønninger og streaks
| Tid siden siste innløsning | Resultat |
|---|---|
| Under 24 timer | For tidlig. Knappen viser en nedtelling. |
| Fra 24 til 48 timer | Belønningen kan hentes, streaken vokser med én dag. |
| Over 48 timer | Belønningen kan hentes, streaken starter på nytt på dag 1. |
| Etter dag 7 | Neste innløsning er dag 1 i en ny uke. |
os.time() på serveren returnerer gjeldende Unix-tid i sekunder i UTC, så alle servere er enige om den. Klokken på spillerens datamaskin er ikke med i regnestykket, og derfor hjelper det ikke å endre datoen på telefonen.
Steg 1: belønningsserveren
Slå på Enable Studio Access to API Services under Game Settings, Security (placet må være publisert). Sett deretter inn et Script i ServerScriptService med navnet DailyRewards:
-- Script i ServerScriptService med navnet DailyRewards.
-- Én belønning hver 24. time. Hentes den igjen innen 48 timer, fortsetter streaken,
-- og belønningene vokser hver dag i en uke, deretter starter uken på nytt.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- mynter for dag 1 til 7 i streaken
local CLAIM_EVERY = 24 * 60 * 60 -- sekunder mellom innløsninger
local STREAK_LOST_AFTER = 48 * 60 * 60 -- en hel dag hoppet over, og streaken starter på nytt
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
-- Streakens dag for neste innløsning, fra 1 til 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)
-- Det menyen viser: sekunder til neste innløsning (0 = kan hentes nå) og hvilken dag det er
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 leser den nyeste lagrede posten og avgjør inne i oppdateringen, så
-- en annen server (eller et annet klikk) ikke kan hente samme dag to ganger
local ok, err = pcall(function()
store:UpdateAsync(tostring(player.UserId), function(old: any)
-- UpdateAsync kan kalle dette flere ganger: bare det siste kallet teller
claimedDay = nil
local saved = readRecord(old)
if now - saved.last < CLAIM_EVERY then
return nil -- for tidlig: å returnere nil avbryter lagringen
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
Innløsningen skjer inne i funksjonen som gis til UpdateAsync. Roblox kaller den med den nyeste lagrede posten. Er det for tidlig, returnerer funksjonen nil, og Roblox avbryter skrivingen. Ellers returnerer den den nye posten, og skriptet husker hvilken dag som ble hentet. Myntene legges til først når UpdateAsync er ferdig uten feil. Hvis en annen server har endret nøkkelen i mellomtiden, kan Roblox kalle funksjonen igjen med en nyere verdi, og derfor tas avgjørelsen nettopp inne i den.
Steg 2: knapp med nedtelling
Sett inn et LocalScript i StarterPlayer > StarterPlayerScripts med navnet DailyRewardsMenu:
-- LocalScript i StarterPlayerScripts med navnet DailyRewardsMenu.
-- En Daily-knapp med nedtelling. Når belønningen er klar, står det Claim på den.
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()-tiden da belønningen er klar
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
Knappen spør serveren én gang hvor lenge det må ventes, og teller deretter ned selv hvert sekund med os.clock(), så den ikke kontakter serveren hvert sekund. Etter innløsningen spør den igjen. Nedtellingen er bare til pynt: serveren sjekker uansett tiden når spilleren trykker på Claim.
Test det
- For testen setter du
CLAIM_EVERYtil30ogSTREAK_LOST_AFTERtil60. - Trykk på Play. Det står «Claim day 1!» på knappen. Trykk på den: +50 mynter.
- Knappen teller ned 30 sekunder. Hent igjen innen de neste 30 sekundene: dag 2, +75.
- Vent mer enn ett minutt: neste innløsning er igjen dag 1.
- Før du publiserer, må begge verdiene tilbake til linjene med 24 og 48 timer.
Vanlige feil og løsninger
Følg med på vinduet Output i Server-modus.
Knappen viser hele tiden Loading...
Spillerens post ble ikke lastet inn. Slå på Enable Studio Access to API Services i Studio. I Output står feilen etter «could not load».
Ved innløsning står det «Come back later», selv om knappen viste Claim
Den lagrede posten var nyere enn knappen visste, for eksempel etter en innløsning på en annen server. Det riktige svaret er det serveren ga.
Streaken nullstilles hver dag
Spillerne henter belønningen med mer enn 48 timers mellomrom, eller STREAK_LOST_AFTER står fortsatt på testverdien.
Myntene blir ikke lagt til
Spilleren må ha en IntValue Coins i leaderstats, opprettet av et serverskript.
Bygg det med RoCode
Hvis du ikke vil sette det opp for hånd, kan RoCode bygge det i det placet du har åpent. RoCode er en uavhengig AI-agent for Roblox Studio, ikke fra Roblox: du beskriver endringen i nettchatten, og Studio-pluginen dens oppretter skript i Explorer-en din.
Legg til daglige belønninger med en streak på 7 dager: mynter på dag 1 til 6 og en gem på dag 7, en knapp med nedtelling, med lagring og sjekk på serveren.
- Kan i ett steg sette inn en ferdig animert skjerm med daglige belønninger fra sine premium UI-sett i ett av fem temaer (candy, neon, gold, blocky, pastel), med serverskript som virker
- Eller skriver serverskriptet og knappen fra denne guiden, koblet til den eksisterende valutaen din
- Er instruert i å sjekke kompileringen av hvert skript med Check Script og setter angrepunkter rundt hver runde med endringer
Etter byggingen kan RoCode kjøre testroboten sin: den spiller spillet ditt i Studio, trykker på knapper og melder PASS eller FAIL. Den sjekker bare det den selv har valgt å teste, og 24-timers timeren krever din egen test med korte verdier. Slik kobler RoCode til Studio.
Ofte stilte spørsmål
Hvordan lager man daglige belønninger i Roblox?
Lagre tidspunktet for hver spillers siste innløsning med os.time() på serveren, tillat innløsning etter 24 timer, og lagre den inne i UpdateAsync før belønningen gis. Skriptet står i steg 1.
Hvordan lager man en daglig innloggingsstreak?
Lagre en streak-teller sammen med innløsningstiden. Kommer neste innløsning innen 48 timer, legger du til én; kommer den senere, starter du på nytt på 1.
Kan spillere jukse med de daglige belønningene ved å stille klokken?
Ikke med dette skriptet: det bruker bare serverens os.time().
Er det bedre å nullstille belønningen ved midnatt?
Du kan telle kalenderdager i UTC i stedet for 24 timer. Glidende 24 timer er enklere og virker likt i alle tidssoner.
Kilder og videre lesing
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (på engelsk). oppdateringsfunksjonen og avbrytelse via nil
- Roblox Creator Docs: Data stores (på engelsk). tilgang fra Studio og det grunnleggende om data stores
- Roblox Creator Docs: Remote events and functions (på engelsk). RemoteFunction
Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.