Tutorial · Recompense

Cum faci recompense zilnice în Roblox Studio

O recompensă zilnică le dă jucătorilor un motiv să-ți deschidă jocul mâine, iar o serie le dă un motiv să nu sară nicio zi. Toată logica se sprijină pe un moment de timp salvat: când a luat jucătorul ultima oară recompensa și câte zile la rând. Ghidul acesta păstrează sigur ambele valori, ca jucătorul să nu poată lua recompensa de două ori reintrând în joc sau deschizând două servere, și adaugă un buton cu numărătoare inversă până la următoarea recompensă.

Actualizat 20 noiembrie 20264 min de cititAutor:

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ă
  1. Cum funcționează
  2. 1. Server
  3. 2. Buton
  4. Common errors
  5. With RoCode
  6. Întrebări frecvente
  7. Surse și lecturi suplimentare

Cum funcționează recompensele zilnice și seriile

Ce se întâmplă la revendicare în funcție de timpul de la ultima dată
Timp de la ultima revendicareRezultat
Sub 24 de oreE încă prea devreme. Butonul arată numărătoarea inversă.
Între 24 și 48 de oreRecompensa se poate lua, seria crește cu o zi.
Peste 48 de oreRecompensa se poate lua, seria începe din nou de la ziua 1.
După ziua 7Urmă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
-- 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
-- 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ă

  1. Pentru test setează CLAIM_EVERY la 30, iar STREAK_LOST_AFTER la 60.
  2. Apasă Play. Pe buton scrie „Claim day 1!”. Apasă-l: +50 de monede.
  3. Butonul numără 30 de secunde. Revendică din nou în următoarele 30 de secunde: ziua 2, +75.
  4. Așteaptă mai mult de un minut: următoarea revendicare va fi din nou ziua 1.
  5. Î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.

Tu scrii

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.

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

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.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.