Pe scurt
Salvează pentru fiecare jucător două numere într-un DataStore: last, valoarea os.time() a ultimei revendicări, și streak. Recompensa se poate lua când au trecut 24 de ore. Dacă au trecut mai mult de 48 de ore, seria începe din nou de la ziua 1; altfel crește cu o zi și trece în cerc prin 7 zile cu recompense crescătoare. Fă verificarea în interiorul UpdateAsync, ca decizia și salvarea să se întâmple împreună.
- Folosește
os.time()pe server, nu un timp trimis de client. - În UpdateAsync returnează nil când recompensa nu se poate lua: salvarea se anulează și nu se dă nimic.
- Clientul doar cere starea și cere recompensa; răspunde serverul.
Pe această pagină
Cum funcționează recompensele zilnice și seriile
| Timp de la ultima revendicare | Rezultat |
|---|---|
| Sub 24 de ore | E încă prea devreme. Butonul arată numărătoarea inversă. |
| Între 24 și 48 de ore | Recompensa se poate lua, seria crește cu o zi. |
| Peste 48 de ore | Recompensa se poate lua, seria începe din nou de la ziua 1. |
| După ziua 7 | Următoarea revendicare e ziua 1 a unei săptămâni noi. |
os.time() pe server returnează timpul Unix curent în secunde, în UTC, așa că toate serverele sunt de acord cu el. Ceasul de pe calculatorul jucătorului nu contează, de aceea schimbarea datei pe telefon nu folosește la nimic.
Pasul 1: serverul de recompense
Activează Enable Studio Access to API Services în Game Settings, Security (place-ul trebuie să fie publicat). Apoi inserează un Script în ServerScriptService cu numele DailyRewards:
-- Script în ServerScriptService cu numele DailyRewards.
-- O recompensă la fiecare 24 de ore. Dacă o iei din nou în 48 de ore, seria continuă,
-- iar recompensele cresc în fiecare zi timp de o săptămână, apoi săptămâna începe din nou.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- monede pentru zilele 1 până la 7 ale seriei
local CLAIM_EVERY = 24 * 60 * 60 -- secunde între revendicări
local STREAK_LOST_AFTER = 48 * 60 * 60 -- a sărit o zi întreagă, iar seria începe din nou
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
-- Ziua seriei pentru următoarea revendicare, de la 1 la 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 arată meniul: secunde până la următoarea revendicare (0 = se poate acum) și ce zi e
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 citește cea mai recentă înregistrare salvată și decide în interiorul actualizării, așa că
-- un al doilea server (sau un al doilea clic) nu poate revendica aceeași zi de două ori
local ok, err = pcall(function()
store:UpdateAsync(tostring(player.UserId), function(old: any)
-- UpdateAsync poate apela asta de mai multe ori: contează doar ultimul apel
claimedDay = nil
local saved = readRecord(old)
if now - saved.last < CLAIM_EVERY then
return nil -- e încă prea devreme: returnarea lui nil anulează salvarea
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
Revendicarea se face în interiorul funcției transmise lui UpdateAsync. Roblox o apelează cu cea mai recentă înregistrare salvată. Dacă e încă prea devreme, funcția returnează nil, iar Roblox anulează scrierea. Altfel returnează înregistrarea nouă, iar scriptul ține minte ce zi a fost revendicată. Monedele se adaugă doar după ce UpdateAsync se termină fără eroare. Dacă între timp alt server a schimbat cheia, Roblox poate apela funcția din nou cu o valoare mai nouă, de aceea decizia se ia chiar în interiorul ei.
Pasul 2: butonul cu numărătoare inversă
Inserează un LocalScript în StarterPlayer > StarterPlayerScripts cu numele DailyRewardsMenu:
-- LocalScript în StarterPlayerScripts cu numele DailyRewardsMenu.
-- Un buton Daily cu numărătoare inversă. Când recompensa e gata, pe el scrie 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 -- momentul os.clock() în care recompensa va fi gata
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
Butonul întreabă serverul o dată cât are de așteptat, apoi numără singur în fiecare secundă prin os.clock(), așa că nu contactează serverul în fiecare secundă. După revendicare întreabă din nou. Numărătoarea e doar de formă: serverul verifică oricum timpul când jucătorul apasă Claim.
Verifică
- Pentru test setează
CLAIM_EVERYla30, iarSTREAK_LOST_AFTERla60. - Apasă Play. Pe buton scrie „Claim day 1!”. Apasă-l: +50 de monede.
- Butonul numără 30 de secunde. Revendică din nou în următoarele 30 de secunde: ziua 2, +75.
- Așteaptă mai mult de un minut: următoarea revendicare va fi din nou ziua 1.
- Înainte de publicare readu ambele valori la rândurile de 24 și 48 de ore.
Erori frecvente și soluții
Urmărește fereastra Output în modul Server.
Butonul arată mereu Loading...
Înregistrarea jucătorului nu s-a încărcat. În Studio activează Enable Studio Access to API Services. În Output eroarea apare după „could not load”.
La revendicare scrie „Come back later”, deși pe buton era Claim
Înregistrarea salvată era mai nouă decât știa butonul, de exemplu după o revendicare pe alt server. Răspunsul corect e cel dat de server.
Seria se resetează în fiecare zi
Jucătorii iau recompensa la un interval mai mare de 48 de ore sau STREAK_LOST_AFTER a rămas cu valoarea de test.
Monedele nu se adaugă
Jucătorul trebuie să aibă un IntValue Coins în leaderstats, creat de un script de server.
Construiește asta cu RoCode
Dacă nu vrei să configurezi asta manual, RoCode o poate construi în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii modificarea în chatul web, iar pluginul lui pentru Studio creează scripturile în Explorer-ul tău.
Adaugă recompense zilnice cu o serie de 7 zile: monede în zilele 1 până la 6 și un gem în ziua 7, un buton cu numărătoare inversă, cu salvare și verificare pe server.
- Poate insera dintr-un singur pas un ecran animat gata făcut de recompense zilnice din kiturile lui UI premium, într-una din cinci teme (candy, neon, gold, blocky, pastel), cu scripturi de server funcționale
- Sau scrie scriptul de server și butonul din acest ghid, legate de moneda ta existentă
- Are instrucțiuni să verifice compilarea fiecărui script prin Check Script și pune puncte de anulare în jurul fiecărui set de modificări
După construcție, RoCode poate porni robotul lui de test: îți joacă jocul în Studio, apasă butoane și raportează PASS sau FAIL. Verifică doar ce a ales el să testeze, iar pentru cronometrul de 24 de ore ai nevoie de propriul tău test cu valori scurte. Cum se conectează RoCode la Studio.
Întrebări frecvente
Cum faci recompense zilnice în Roblox?
Salvează momentul ultimei revendicări a fiecărui jucător prin os.time() pe server, permite revendicarea după 24 de ore și salveaz-o în interiorul UpdateAsync înainte să dai recompensa. Scriptul e la pasul 1.
Cum faci o serie de intrări zilnice?
Salvează un contor de serie împreună cu momentul revendicării. Dacă următoarea revendicare vine în 48 de ore, adaugă unu; dacă vine mai târziu, începe din nou de la 1.
Pot jucătorii păcăli recompensele zilnice schimbând ceasul?
Cu acest script, nu: folosește doar os.time()-ul serverului.
N-ar fi mai bine să resetez recompensa la miezul nopții?
Poți număra zile calendaristice în UTC în loc de 24 de ore. Cele 24 de ore glisante sunt mai simple și funcționează la fel în toate fusurile orare.
Surse și lecturi suplimentare
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (în engleză). funcția de actualizare și anularea prin nil
- Roblox Creator Docs: Data stores (în engleză). accesul din Studio și bazele data store
- Roblox Creator Docs: Remote events and functions (în engleză). RemoteFunction
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.