Tutorial · Recompensas

Como fazer recompensa diária no Roblox Studio

Uma recompensa diária dá aos jogadores um motivo para abrir o seu jogo amanhã, e uma sequência (streak) dá um motivo para não faltar nenhum dia. A lógica é um horário salvo: quando este jogador pegou a última recompensa, e quantos dias seguidos. Este guia guarda os dois com segurança, para que um jogador não consiga pegar duas vezes saindo e entrando de novo ou com dois servidores abertos, e adiciona um botão com a contagem regressiva até a próxima recompensa.

Atualizado em 12 de novembro de 20264 min de leituraEscrito por

Resumo

Salve dois números por jogador em um DataStore: last, o os.time() da última coleta, e streak. A coleta é liberada quando 24 horas passaram. Se passaram mais de 48 horas, a sequência recomeça no dia 1; senão, ela sobe um, passando por 7 dias de recompensas crescentes. Faça a checagem dentro do UpdateAsync, para que a decisão e o salvamento aconteçam juntos.

  • Use o os.time() no servidor, nunca um horário enviado pelo cliente.
  • Dentro do UpdateAsync, retorne nil quando a coleta não é permitida: o salvamento é cancelado e nada é pago.
  • O cliente só pede o status e pede para coletar; quem responde é o servidor.
Nesta página
  1. Como funciona
  2. 1. Servidor
  3. 2. Botão
  4. Erros comuns
  5. Com o RoCode
  6. Perguntas frequentes
  7. Fontes e leitura extra

Como funcionam a recompensa diária e a sequência

O que uma coleta faz, pelo tempo desde a última coleta
Tempo desde a última coletaResultado
Menos de 24 horasAinda não. O botão faz a contagem regressiva.
De 24 a 48 horasColeta liberada, a sequência sobe um dia.
Mais de 48 horasColeta liberada, a sequência recomeça no dia 1.
Depois do dia 7A próxima coleta é o dia 1 de uma nova semana.

O os.time() no servidor devolve o horário Unix atual, em segundos e em UTC, então todos os servidores concordam com ele. O relógio do computador do jogador não entra na conta, e por isso mudar a data no celular não faz nada.

Passo 1: O servidor das recompensas

Ative Enable Studio Access to API Services em Game Settings, Security (o jogo precisa estar publicado). Depois insira um Script no ServerScriptService chamado DailyRewards:

Script em ServerScriptService chamado DailyRewards
-- Script no ServerScriptService chamado DailyRewards.
-- Uma recompensa a cada 24 horas. Coletar de novo em até 48 horas mantém a sequência
-- e as recompensas crescem todo dia por uma semana, depois a semana recomeça.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- moedas do dia 1 ao dia 7 de uma sequência
local CLAIM_EVERY = 24 * 60 * 60 -- segundos entre coletas
local STREAK_LOST_AFTER = 48 * 60 * 60 -- perca um dia inteiro e a sequência recomeça

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

-- O dia da sequência que a próxima coleta vai ser, de 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)

-- O que o menu mostra: segundos até a próxima coleta (0 = pronta agora) e qual é o dia
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
	-- O UpdateAsync lê o registro salvo mais novo e decide dentro da atualização, então um
	-- segundo servidor (ou um segundo clique) não consegue coletar o mesmo dia duas vezes
	local ok, err = pcall(function()
		store:UpdateAsync(tostring(player.UserId), function(old: any)
			-- O UpdateAsync pode rodar isto mais de uma vez: só a última execução conta
			claimedDay = nil
			local saved = readRecord(old)
			if now - saved.last < CLAIM_EVERY then
				return nil -- ainda não: retornar nil cancela o salvamento
			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

A coleta acontece dentro da função passada ao UpdateAsync. O Roblox a chama com o registro salvo mais novo. Se for cedo demais, a função retorna nil e o Roblox cancela a gravação. Senão, ela retorna o registro novo, e o script lembra qual dia foi coletado. As moedas só são adicionadas depois que o UpdateAsync termina sem erro. Se outro servidor mudou a chave nesse meio tempo, o Roblox pode chamar a função de novo com o valor mais novo, e é por isso que a decisão é tomada dentro dela.

Passo 2: O botão com contagem regressiva

Insira um LocalScript em StarterPlayer > StarterPlayerScripts chamado DailyRewardsMenu:

LocalScript em StarterPlayerScripts chamado DailyRewardsMenu
-- LocalScript em StarterPlayerScripts chamado DailyRewardsMenu.
-- Um botão Daily com contagem regressiva. Quando a recompensa está pronta, ele diz 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 -- o horário do os.clock() em que a recompensa fica 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

O botão pergunta ao servidor uma vez quanto tempo esperar, depois faz a contagem sozinho a cada segundo com os.clock(), então não chama o servidor a cada segundo. Depois de uma coleta, ele pergunta de novo. A contagem é só visual: o servidor ainda confere o horário quando o jogador aperta Claim.

Teste

  1. Mude CLAIM_EVERY para 30 e STREAK_LOST_AFTER para 60 para testar.
  2. Aperte Play. O botão diz "Claim day 1!". Aperte: +50 moedas.
  3. O botão conta 30 segundos. Colete de novo dentro dos 30 segundos seguintes: dia 2, +75.
  4. Espere mais de um minuto: a próxima coleta volta a ser o dia 1.
  5. Volte os dois valores para as linhas de 24 e 48 horas antes de publicar.

Erros comuns e como resolver

Acompanhe a janela Output na visão do Server.

O botão fica parado em Loading...

O registro do jogador não carregou. No Studio, ative Enable Studio Access to API Services. O Output mostra o erro depois de "could not load".

Ao coletar aparece para voltar mais tarde, mesmo com o botão dizendo Claim

O registro salvo era mais novo do que o botão sabia, por exemplo depois de uma coleta em outro servidor. A resposta do servidor é a correta.

A sequência zera todo dia

Os jogadores estão coletando com mais de 48 horas de intervalo, ou o STREAK_LOST_AFTER ficou com um valor de teste.

As moedas não são adicionadas

O jogador precisa de um IntValue Coins em leaderstats criado por um script de servidor.

Crie com o RoCode

Se você prefere não montar isso à mão, o RoCode pode construir no jogo que você tem aberto. O RoCode é um agente de IA independente para Roblox Studio, não feito pela Roblox: você descreve a mudança em um chat na web, e o plugin dele para o Studio cria os scripts no seu Explorer.

Você digita

Adicione recompensas diárias com uma sequência de 7 dias: moedas nos dias 1 a 6 e uma gema no dia 7, um botão com contagem regressiva, salvo e conferido no servidor.

O RoCode faz
  • Pode inserir de uma vez uma tela de recompensa diária pronta e animada dos kits de UI premium dele, em um de cinco temas (candy, neon, gold, blocky, pastel), com scripts de servidor funcionando
  • Ou escreve o script de servidor e o botão deste guia, ligados à moeda que você já tem
  • É instruído a compilar cada script com Check Script, e cria pontos de desfazer em volta de cada lote

Depois de uma construção, o RoCode pode rodar o robô de teste dele: ele joga o seu jogo no Studio, clica nos botões e informa PASS ou FAIL. Ele confere só o que escolheu testar, e um timer de 24 horas precisa do seu próprio teste com valores curtos. Como o RoCode se conecta ao Studio.

Perguntas frequentes

Como fazer recompensa diária no Roblox?

Salve o horário da última coleta de cada jogador com os.time() no servidor, libere a coleta depois de 24 horas e salve a coleta dentro do UpdateAsync antes de pagar. O Passo 1 tem o script.

Como fazer uma sequência de login diário?

Salve um contador de sequência junto com o horário da coleta. Se a próxima coleta vier em até 48 horas, some um; se vier depois, recomece no 1.

Os jogadores conseguem trapacear mudando o relógio?

Não com este script: ele só usa o os.time() do servidor.

A recompensa deveria zerar à meia-noite?

Você pode contar dias do calendário em UTC no lugar de 24 horas. Um período móvel de 24 horas é mais simples e trata todos os fusos horários do mesmo jeito.

Fontes e leitura extra

Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 12 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.