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
Comment marchent les récompenses quotidiennes et les séries
| Temps depuis la dernière réclamation | Résultat |
|---|---|
| Moins de 24 heures | Pas prêt. Le bouton affiche le compte à rebours. |
| De 24 à 48 heures | Réclamation permise, la série gagne un jour. |
| Plus de 48 heures | Réclamation permise, la série repart au jour 1. |
| Après le jour 7 | La 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.
-- 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.
-- 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
- Règle
CLAIM_EVERYsur30etSTREAK_LOST_AFTERsur60pour tester. - Appuie sur Play. Le bouton affiche « Claim day 1! ». Appuie dessus : +50 pièces.
- Le bouton compte 30 secondes. Réclame à nouveau dans les 30 secondes suivantes : jour 2, +75.
- Attends plus d'une minute : la réclamation suivante est de nouveau le jour 1.
- 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.
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.
- 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
- Roblox Creator Docs : GlobalDataStore:UpdateAsync (en anglais). la fonction de mise à jour et l'annulation avec nil
- Roblox Creator Docs : Data stores (en anglais). l'accès depuis Studio et les bases des data stores
- Roblox Creator Docs : Remote events and functions (en anglais). RemoteFunction
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.