Tutoriel · Récompenses

Comment faire des récompenses quotidiennes sur Roblox Studio

Une récompense quotidienne donne aux joueurs une raison d'ouvrir ton jeu demain, et une série leur donne une raison de ne pas rater un jour. La logique repose sur un horodatage sauvegardé : quand ce joueur a-t-il réclamé pour la dernière fois, et combien de jours d'affilée. Ce guide sauvegarde les deux de façon sûre, pour qu'un joueur ne puisse pas réclamer deux fois en revenant dans le jeu ou en ayant deux serveurs ouverts, et ajoute un bouton qui affiche le compte à rebours jusqu'à la prochaine récompense.

Mis à jour le 12 novembre 20265 min de lectureÉcrit par

En bref

Sauvegarde deux nombres par joueur dans un DataStore : last, le os.time() de la dernière réclamation, et streak, la série. Une réclamation est permise quand 24 heures sont passées. Si plus de 48 heures sont passées, la série repart au jour 1 ; sinon elle augmente de un, en parcourant 7 jours de récompenses croissantes. Fais la vérification dans UpdateAsync, pour que la décision et la sauvegarde se fassent ensemble.

  • Utilise os.time() sur le serveur, jamais une heure envoyée par le client.
  • Dans UpdateAsync, renvoie nil quand la réclamation n'est pas permise : la sauvegarde est annulée et rien n'est payé.
  • Le client ne fait que demander l'état et réclamer ; c'est le serveur qui répond.
Sur cette page
  1. Fonctionnement
  2. 1. Serveur
  3. 2. Bouton
  4. Problèmes courants
  5. Avec RoCode
  6. Questions fréquentes
  7. Sources et lectures

Comment marchent les récompenses quotidiennes et les séries

Ce que fait une réclamation, selon le temps écoulé depuis la dernière
Temps depuis la dernière réclamationRésultat
Moins de 24 heuresPas prêt. Le bouton affiche le compte à rebours.
De 24 à 48 heuresRéclamation permise, la série gagne un jour.
Plus de 48 heuresRéclamation permise, la série repart au jour 1.
Après le jour 7La réclamation suivante est le jour 1 d'une nouvelle semaine.

Sur le serveur, os.time() renvoie l'heure Unix actuelle, en secondes et en UTC, donc tous les serveurs sont d'accord dessus. L'horloge de l'ordinateur du joueur ne joue aucun rôle, c'est pourquoi changer la date sur un téléphone ne sert à rien.

Étape 1 : le serveur des récompenses

Active Enable Studio Access to API Services dans Game Settings, Security (le jeu doit être publié). Puis insère un Script dans ServerScriptService nommé DailyRewards :

Script dans ServerScriptService nommé DailyRewards
-- Script dans ServerScriptService nommé DailyRewards.
-- Une récompense toutes les 24 heures. Réclamer à nouveau dans les 48 heures garde la série
-- et les récompenses grandissent chaque jour pendant une semaine, puis la semaine recommence.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- pièces du jour 1 au jour 7 d'une série
local CLAIM_EVERY = 24 * 60 * 60 -- secondes entre deux réclamations
local STREAK_LOST_AFTER = 48 * 60 * 60 -- rate un jour entier et la série recommence

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

-- Le jour de série de la prochaine réclamation, de 1 à 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)

-- Ce que montre le menu : les secondes avant la prochaine réclamation (0 = prêt) et le jour
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 lit la dernière sauvegarde et décide pendant la mise à jour, donc un
	-- deuxième serveur (ou un deuxième clic) ne peut pas réclamer le même jour deux fois
	local ok, err = pcall(function()
		store:UpdateAsync(tostring(player.UserId), function(old: any)
			-- UpdateAsync peut exécuter ceci plusieurs fois : seule la dernière exécution compte
			claimedDay = nil
			local saved = readRecord(old)
			if now - saved.last < CLAIM_EVERY then
				return nil -- pas prêt : renvoyer nil annule la sauvegarde
			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

La réclamation se fait dans la fonction passée à UpdateAsync. Roblox l'appelle avec la sauvegarde la plus récente. Si c'est trop tôt, la fonction renvoie nil et Roblox annule l'écriture. Sinon, elle renvoie la nouvelle sauvegarde, et le script retient quel jour a été réclamé. Les pièces ne sont ajoutées qu'une fois qu'UpdateAsync a fini sans erreur. Si un autre serveur a modifié la clé entre-temps, Roblox peut rappeler la fonction avec la valeur plus récente, c'est pourquoi la décision est prise à l'intérieur.

Étape 2 : le bouton avec compte à rebours

Insère un LocalScript dans StarterPlayer > StarterPlayerScripts nommé DailyRewardsMenu :

LocalScript dans StarterPlayerScripts nommé DailyRewardsMenu
-- LocalScript dans StarterPlayerScripts nommé DailyRewardsMenu.
-- Un bouton Daily avec un compte à rebours. Quand la récompense est prête, il affiche 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 -- moment os.clock() où la récompense est prête
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

Le bouton demande une fois au serveur combien de temps attendre, puis fait le compte à rebours tout seul chaque seconde avec os.clock(), pour ne pas appeler le serveur chaque seconde. Après une réclamation, il redemande. Le compte à rebours n'est qu'un affichage : le serveur vérifie quand même l'heure quand le joueur appuie sur Claim.

Le tester

  1. Règle CLAIM_EVERY sur 30 et STREAK_LOST_AFTER sur 60 pour tester.
  2. Appuie sur Play. Le bouton affiche « Claim day 1! ». Appuie dessus : +50 pièces.
  3. Le bouton compte 30 secondes. Réclame à nouveau dans les 30 secondes suivantes : jour 2, +75.
  4. Attends plus d'une minute : la réclamation suivante est de nouveau le jour 1.
  5. Remets les deux valeurs aux lignes de 24 et 48 heures avant de publier.

Problèmes courants

Surveille la fenêtre Output dans la vue Server.

Le bouton reste sur Loading...

La sauvegarde du joueur ne s'est pas chargée. Dans Studio, active Enable Studio Access to API Services. L'Output montre l'erreur après « could not load ».

La réclamation dit de revenir plus tard alors que le bouton affichait Claim

La sauvegarde était plus récente que ce que le bouton savait, par exemple après une réclamation sur un autre serveur. C'est la réponse du serveur qui est la bonne.

La série repart à zéro tous les jours

Les joueurs réclament à plus de 48 heures d'intervalle, ou STREAK_LOST_AFTER est resté à une valeur de test.

Les pièces ne sont pas ajoutées

Le joueur doit avoir une IntValue Coins dans leaderstats, créée par un script serveur.

Le faire avec RoCode

Si tu préfères ne pas tout configurer à la main, RoCode peut le construire dans le jeu que tu as ouvert. RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox : tu décris le changement dans un chat web, et son plugin pour Studio crée les scripts dans ton Explorer.

Tu écris

Ajoute des récompenses quotidiennes avec une série de 7 jours : des pièces du jour 1 au jour 6 et une gemme le jour 7, un bouton avec compte à rebours, sauvegardées et vérifiées sur le serveur.

RoCode fait
  • Peut insérer en une étape un écran de récompenses quotidiennes animé et prêt à l'emploi tiré de ses kits d'interface premium, dans l'un des cinq thèmes (candy, neon, gold, blocky, pastel), avec des scripts serveur qui marchent
  • Ou écrit le script serveur et le bouton de ce guide, reliés à ta monnaie existante
  • A pour consigne de vérifier la compilation de chaque script avec Check Script, et place des points d'annulation autour de chaque lot de changements

Après une construction, RoCode peut lancer son robot de test : il joue à ton jeu dans Studio, clique sur les boutons et rapporte PASS ou FAIL. Il ne vérifie que ce qu'il a choisi de tester, et un minuteur de 24 heures demande ton propre test avec des valeurs courtes. Comment RoCode se connecte à Studio.

Questions fréquentes

Comment faire des récompenses quotidiennes sur Roblox ?

Sauvegarde l'heure de la dernière réclamation de chaque joueur avec os.time() sur le serveur, autorise une réclamation après 24 heures, et sauvegarde la réclamation dans UpdateAsync avant de payer. L'étape 1 contient le script.

Comment faire une série de connexions quotidiennes ?

Sauvegarde un compteur de série avec l'heure de réclamation. Si la réclamation suivante arrive dans les 48 heures, ajoute un ; si elle arrive plus tard, repars à 1.

Les joueurs peuvent-ils tricher en changeant leur horloge ?

Pas avec ce script : il n'utilise que le os.time() du serveur.

La récompense devrait-elle plutôt repartir à minuit ?

Tu peux compter des jours du calendrier en UTC au lieu de 24 heures. Une période glissante de 24 heures est plus simple et traite tous les fuseaux horaires de la même façon.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 12 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.