Tutorial · Ricompense

Come fare le ricompense giornaliere in Roblox Studio

Una ricompensa giornaliera dà ai giocatori un motivo per aprire il tuo gioco domani, e una serie dà un motivo per non saltare nemmeno un giorno. Tutta la logica si regge su un orario salvato: quando il giocatore ha riscattato l'ultima volta e per quanti giorni di fila. Questa guida salva entrambi i valori in modo sicuro, così un giocatore non può riscattare due volte rientrando nel gioco o aprendo due server, e aggiunge un pulsante con il conto alla rovescia fino alla prossima ricompensa.

Aggiornato il 20 novembre 20264 min di letturaScritto da

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
  1. Come funziona
  2. 1. Server
  3. 2. Pulsante
  4. Common errors
  5. With RoCode
  6. Domande frequenti
  7. Fonti e letture

Come funzionano ricompense giornaliere e serie

Cosa succede al riscatto in base al tempo trascorso dall'ultima volta
Tempo dall'ultimo riscattoRisultato
Meno di 24 oreÈ ancora presto. Il pulsante mostra il conto alla rovescia.
Da 24 a 48 oreSi può riscattare, la serie cresce di un giorno.
Più di 48 oreSi può riscattare, la serie ricomincia dal giorno 1.
Dopo il giorno 7Il 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
-- 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
-- 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

  1. Per il test imposta CLAIM_EVERY a 30 e STREAK_LOST_AFTER a 60.
  2. Premi Play. Sul pulsante c'è scritto «Claim day 1!». Premilo: +50 monete.
  3. Il pulsante conta 30 secondi. Riscatta di nuovo entro i 30 secondi successivi: giorno 2, +75.
  4. Aspetta più di un minuto: il riscatto successivo sarà di nuovo il giorno 1.
  5. 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.

Tu scrivi

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.

RoCode fa
  • 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

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.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.