Tutorial · Belønninger

Slik lager du daglige belønninger i Roblox Studio

En daglig belønning gir spillerne en grunn til å åpne spillet ditt i morgen, og en streak gir dem en grunn til ikke å hoppe over en dag. Hele logikken hviler på et lagret tidsstempel: når spilleren sist hentet belønningen, og hvor mange dager på rad. Denne guiden lagrer begge verdiene trygt, så en spiller ikke kan hente belønningen to ganger ved å starte spillet på nytt eller åpne to servere, og legger til en knapp med nedtelling til neste belønning.

Oppdatert 20. november 20264 min lesingSkrevet av

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
  1. Slik virker det
  2. 1. Server
  3. 2. Knappen
  4. Common errors
  5. With RoCode
  6. Ofte stilte spørsmål
  7. Kilder og videre lesing

Slik virker daglige belønninger og streaks

Hva som skjer ved innløsning, avhengig av tiden siden sist
Tid siden siste innløsningResultat
Under 24 timerFor tidlig. Knappen viser en nedtelling.
Fra 24 til 48 timerBelønningen kan hentes, streaken vokser med én dag.
Over 48 timerBelønningen kan hentes, streaken starter på nytt på dag 1.
Etter dag 7Neste 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
-- 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
-- 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

  1. For testen setter du CLAIM_EVERY til 30 og STREAK_LOST_AFTER til 60.
  2. Trykk på Play. Det står «Claim day 1!» på knappen. Trykk på den: +50 mynter.
  3. Knappen teller ned 30 sekunder. Hent igjen innen de neste 30 sekundene: dag 2, +75.
  4. Vent mer enn ett minutt: neste innløsning er igjen dag 1.
  5. 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.

Du skriver

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.

RoCode gjør
  • 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

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.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.