In breve
Salva per ogni giocatore due numeri in un DataStore: last, il valore di os.time() dell'ultimo riscatto, e streak. La ricompensa si può riscattare quando sono passate 24 ore. Se ne sono passate più di 48, la serie ricomincia dal giorno 1; altrimenti cresce di un giorno e gira in un ciclo di 7 giorni con premi crescenti. Fai il controllo dentro UpdateAsync, così la decisione e il salvataggio avvengono insieme.
- Usa
os.time()sul server, non un orario inviato dal client. - Dentro UpdateAsync restituisci nil quando non si può riscattare: il salvataggio viene annullato e non viene dato nulla.
- Il client chiede solo lo stato e richiede la ricompensa; risponde il server.
In questa pagina
Come funzionano ricompense giornaliere e serie
| Tempo dall'ultimo riscatto | Risultato |
|---|---|
| Meno di 24 ore | È ancora presto. Il pulsante mostra il conto alla rovescia. |
| Da 24 a 48 ore | Si può riscattare, la serie cresce di un giorno. |
| Più di 48 ore | Si può riscattare, la serie ricomincia dal giorno 1. |
| Dopo il giorno 7 | Il riscatto successivo è il giorno 1 di una nuova settimana. |
os.time() sul server restituisce l'ora Unix attuale in secondi in UTC, quindi tutti i server sono d'accordo. L'orologio del computer del giocatore non entra in gioco, ed è per questo che cambiare la data sul telefono non serve a niente.
Passo 1: il server delle ricompense
Attiva Enable Studio Access to API Services in Game Settings, Security (il place deve essere pubblicato). Poi inserisci uno Script in ServerScriptService chiamato DailyRewards:
-- Script in ServerScriptService chiamato DailyRewards.
-- Una ricompensa ogni 24 ore. Se riscatti di nuovo entro 48 ore, la serie continua,
-- e le ricompense crescono ogni giorno per una settimana, poi la settimana ricomincia.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- monete per i giorni da 1 a 7 della serie
local CLAIM_EVERY = 24 * 60 * 60 -- secondi tra un riscatto e l'altro
local STREAK_LOST_AFTER = 48 * 60 * 60 -- saltato un giorno intero, e la serie ricomincia
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
-- Giorno della serie per il prossimo riscatto, da 1 a 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)
-- Cosa mostra il menu: secondi al prossimo riscatto (0 = si può adesso) e che giorno è
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 legge il record salvato più recente e decide dentro l'aggiornamento, quindi
-- un secondo server (o un secondo clic) non può riscattare lo stesso giorno due volte
local ok, err = pcall(function()
store:UpdateAsync(tostring(player.UserId), function(old: any)
-- UpdateAsync può chiamarla più volte: conta solo l'ultima chiamata
claimedDay = nil
local saved = readRecord(old)
if now - saved.last < CLAIM_EVERY then
return nil -- ancora presto: restituire nil annulla il salvataggio
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
Il riscatto avviene dentro la funzione passata a UpdateAsync. Roblox la chiama con il record salvato più recente. Se è ancora presto, la funzione restituisce nil e Roblox annulla la scrittura. Altrimenti restituisce il nuovo record, e lo script ricorda quale giorno è stato riscattato. Le monete vengono aggiunte solo dopo che UpdateAsync è finito senza errori. Se nel frattempo un altro server ha cambiato la chiave, Roblox può chiamare di nuovo la funzione con il valore più nuovo, ed è per questo che la decisione si prende lì dentro.
Passo 2: il pulsante con il conto alla rovescia
Inserisci un LocalScript in StarterPlayer > StarterPlayerScripts chiamato DailyRewardsMenu:
-- LocalScript in StarterPlayerScripts chiamato DailyRewardsMenu.
-- Pulsante Daily con conto alla rovescia. Quando la ricompensa è pronta, c'è scritto 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 -- valore di os.clock() quando la ricompensa sarà pronta
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
Il pulsante chiede una volta al server quanto aspettare, poi conta da solo ogni secondo con os.clock(), quindi non interroga il server ogni secondo. Dopo un riscatto chiede di nuovo. Il conto alla rovescia serve solo all'aspetto: il server controlla comunque l'orario quando il giocatore preme Claim.
Prova
- Per il test imposta
CLAIM_EVERYa30eSTREAK_LOST_AFTERa60. - Premi Play. Sul pulsante c'è scritto «Claim day 1!». Premilo: +50 monete.
- Il pulsante conta 30 secondi. Riscatta di nuovo entro i 30 secondi successivi: giorno 2, +75.
- Aspetta più di un minuto: il riscatto successivo sarà di nuovo il giorno 1.
- Prima di pubblicare riporta entrambi i valori alle righe da 24 e 48 ore.
Errori comuni e soluzioni
Tieni d'occhio la finestra Output in modalità Server.
Il pulsante mostra sempre Loading...
Il record del giocatore non si è caricato. In Studio attiva Enable Studio Access to API Services. Nell'Output l'errore appare dopo «could not load».
Al riscatto dice «Come back later», anche se sul pulsante c'era Claim
Il record salvato era più nuovo di quello che sapeva il pulsante, per esempio dopo un riscatto su un altro server. La risposta giusta è quella del server.
La serie si azzera ogni giorno
I giocatori riscattano a più di 48 ore di distanza, oppure STREAK_LOST_AFTER è rimasto al valore di prova.
Le monete non vengono aggiunte
Il giocatore deve avere un IntValue Coins in leaderstats, creato da uno script lato server.
Costruiscilo con RoCode
Se non vuoi configurarlo a mano, RoCode può costruirlo nel place che hai aperto. RoCode è un agente IA indipendente per Roblox Studio, non di Roblox: descrivi la modifica nella chat web e il suo plugin per Studio crea gli script nel tuo Explorer.
Aggiungi ricompense giornaliere con una serie di 7 giorni: monete nei giorni da 1 a 6 e una gemma il giorno 7, un pulsante con conto alla rovescia, con salvataggio e controllo sul server.
- Può inserire in un solo passo una schermata animata di ricompense giornaliere già pronta dai suoi kit UI premium, in uno dei cinque temi (candy, neon, gold, blocky, pastel), con script lato server funzionanti
- Oppure scrive lo script lato server e il pulsante di questa guida, collegati alla tua valuta esistente
- Ha l'istruzione di verificare la compilazione di ogni script con Check Script, e mette punti di annullamento attorno a ogni gruppo di modifiche
Dopo la build RoCode può avviare il suo robot di test: gioca al tuo gioco in Studio, preme i pulsanti e riporta PASS o FAIL. Controlla solo ciò che ha scelto di testare, e per il timer di 24 ore serve un tuo test con valori brevi. Come RoCode si collega a Studio.
Domande frequenti
Come si fanno le ricompense giornaliere su Roblox?
Salva l'orario dell'ultimo riscatto di ogni giocatore con os.time() sul server, permetti il riscatto dopo 24 ore e salvalo dentro UpdateAsync prima di dare la ricompensa. Lo script è nel passo 1.
Come si fa una serie di accessi giornalieri?
Salva un contatore della serie insieme all'orario del riscatto. Se il riscatto successivo arriva entro 48 ore, aggiungi uno; se arriva dopo, ricomincia da 1.
I giocatori possono imbrogliare le ricompense giornaliere cambiando l'orologio?
Con questo script no: usa solo os.time() del server.
È meglio azzerare la ricompensa a mezzanotte?
Puoi contare i giorni di calendario in UTC invece delle 24 ore. Le 24 ore mobili sono più semplici e funzionano allo stesso modo in tutti i fusi orari.
Fonti e letture
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (in inglese). la funzione di aggiornamento e l'annullamento con nil
- Roblox Creator Docs: Data stores (in inglese). accesso da Studio e basi dei data store
- Roblox Creator Docs: Remote events and functions (in inglese). RemoteFunction
Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.