Poradnik · Nagrody

Jak zrobić codzienne nagrody w Roblox Studio

Codzienna nagroda daje graczom powód, żeby jutro znowu otworzyć twoją grę, a seria daje powód, żeby nie opuścić ani jednego dnia. Cała logika opiera się na zapisanym znaczniku czasu: kiedy gracz ostatnio odebrał nagrodę i ile dni z rzędu. Ten poradnik bezpiecznie przechowuje obie wartości, żeby gracz nie mógł odebrać nagrody dwa razy, wchodząc ponownie do gry albo otwierając dwa serwery, i dodaje przycisk z odliczaniem do następnej nagrody.

Zaktualizowano 20 listopada 20264 min czytaniaAutor:

W skrócie

Zapisuj dla każdego gracza dwie liczby w DataStore: last, wartość os.time() ostatniego odbioru, oraz streak. Nagrodę można odebrać, gdy minęły 24 godziny. Jeśli minęło więcej niż 48 godzin, seria zaczyna się od nowa od dnia 1; w przeciwnym razie rośnie o jeden dzień i krąży po 7 dniach z rosnącymi nagrodami. Rób sprawdzenie wewnątrz UpdateAsync, żeby decyzja i zapis działy się razem.

  • Używaj os.time() na serwerze, a nie czasu przysłanego przez klienta.
  • Wewnątrz UpdateAsync zwracaj nil, gdy nagrody nie można odebrać: zapis zostaje anulowany i nic nie jest wydawane.
  • Klient tylko pyta o status i prosi o nagrodę; odpowiada serwer.
Na tej stronie
  1. Jak to działa
  2. 1. Serwer
  3. 2. Przycisk
  4. Common errors
  5. With RoCode
  6. Najczęstsze pytania
  7. Źródła i dalsza lektura

Jak działają codzienne nagrody i serie

Co się dzieje przy odbiorze w zależności od czasu od poprzedniego razu
Czas od poprzedniego odbioruWynik
Mniej niż 24 godzinyJeszcze za wcześnie. Przycisk pokazuje odliczanie.
Od 24 do 48 godzinNagrodę można odebrać, seria rośnie o jeden dzień.
Więcej niż 48 godzinNagrodę można odebrać, seria zaczyna się od nowa od dnia 1.
Po dniu 7Następny odbiór to dzień 1 nowego tygodnia.

os.time() na serwerze zwraca obecny czas Unix w sekundach w UTC, więc wszystkie serwery się z nim zgadzają. Zegar na komputerze gracza nie bierze w tym udziału i dlatego zmiana daty w telefonie nic nie daje.

Krok 1: serwer nagród

Włącz Enable Studio Access to API Services w Game Settings, Security (gra musi być opublikowana). Potem wstaw Script do ServerScriptService o nazwie DailyRewards:

Script w ServerScriptService o nazwie DailyRewards
-- Script w ServerScriptService o nazwie DailyRewards.
-- Jedna nagroda co 24 godziny. Jeśli odbierzesz znowu w ciągu 48 godzin, seria trwa dalej,
-- a nagrody rosną każdego dnia przez tydzień, potem tydzień zaczyna się od nowa.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- monety za dni od 1 do 7 serii
local CLAIM_EVERY = 24 * 60 * 60 -- sekundy między odbiorami
local STREAK_LOST_AFTER = 48 * 60 * 60 -- opuszczony cały dzień i seria zaczyna się od nowa

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

-- Dzień serii dla następnego odbioru, od 1 do 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)

-- Co pokazuje menu: sekundy do następnego odbioru (0 = można teraz) i który to dzień
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 czyta najświeższy zapisany rekord i decyduje wewnątrz aktualizacji, więc
	-- drugi serwer (albo drugie kliknięcie) nie może odebrać tego samego dnia dwa razy
	local ok, err = pcall(function()
		store:UpdateAsync(tostring(player.UserId), function(old: any)
			-- UpdateAsync może wywołać to kilka razy: liczy się tylko ostatnie wywołanie
			claimedDay = nil
			local saved = readRecord(old)
			if now - saved.last < CLAIM_EVERY then
				return nil -- jeszcze za wcześnie: zwrócenie nil anuluje zapis
			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

Odbiór odbywa się wewnątrz funkcji przekazanej do UpdateAsync. Roblox wywołuje ją z najświeższym zapisanym rekordem. Jeśli jest za wcześnie, funkcja zwraca nil i Roblox anuluje zapis. W przeciwnym razie zwraca nowy rekord, a skrypt zapamiętuje, który dzień został odebrany. Monety są dodawane dopiero, gdy UpdateAsync zakończy się bez błędu. Jeśli inny serwer w tym czasie zmienił klucz, Roblox może wywołać funkcję ponownie z nowszą wartością, dlatego decyzja zapada właśnie w jej środku.

Krok 2: przycisk z odliczaniem

Wstaw LocalScript do StarterPlayer > StarterPlayerScripts o nazwie DailyRewardsMenu:

LocalScript w StarterPlayerScripts o nazwie DailyRewardsMenu
-- LocalScript w StarterPlayerScripts o nazwie DailyRewardsMenu.
-- Przycisk Daily z odliczaniem. Gdy nagroda jest gotowa, jest na nim napis 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 -- czas os.clock(), kiedy nagroda będzie gotowa
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

Przycisk raz pyta serwer, ile czekać, a potem sam odlicza co sekundę przez os.clock(), więc nie pyta serwera co sekundę. Po odbiorze pyta ponownie. Odliczanie jest tylko dla wyglądu: serwer i tak sprawdza czas, gdy gracz klika Claim.

Sprawdź

  1. Do testu ustaw CLAIM_EVERY na 30, a STREAK_LOST_AFTER na 60.
  2. Kliknij Play. Na przycisku jest napis „Claim day 1!”. Kliknij go: +50 monet.
  3. Przycisk odlicza 30 sekund. Odbierz ponownie w ciągu kolejnych 30 sekund: dzień 2, +75.
  4. Poczekaj ponad minutę: następny odbiór znowu będzie dniem 1.
  5. Przed publikacją przywróć obie wartości do linii z 24 i 48 godzinami.

Częste błędy i rozwiązania

Obserwuj okno Output w trybie Server.

Przycisk cały czas pokazuje Loading...

Rekord gracza się nie wczytał. W Studio włącz Enable Studio Access to API Services. W Output błąd widać po „could not load”.

Przy odbiorze pisze „Come back later”, choć na przycisku było Claim

Zapisany rekord był nowszy, niż wiedział przycisk, na przykład po odbiorze na innym serwerze. Prawidłowa odpowiedź to ta, którą dał serwer.

Seria resetuje się każdego dnia

Gracze odbierają nagrodę z przerwą dłuższą niż 48 godzin albo STREAK_LOST_AFTER został z wartością testową.

Monety się nie dodają

Gracz musi mieć IntValue Coins w leaderstats, utworzony przez serwerowy skrypt.

Zbuduj to z RoCode

Jeśli nie chcesz ustawiać tego ręcznie, RoCode może to zbudować w grze, którą masz otwartą. RoCode to niezależny agent AI do Roblox Studio, nie robi go Roblox: opisujesz zmianę na czacie w przeglądarce, a jego plugin do Studio tworzy skrypty w twoim Explorerze.

Ty piszesz

Dodaj codzienne nagrody z serią na 7 dni: monety w dniach od 1 do 6 i gem w dniu 7, przycisk z odliczaniem, z zapisem i sprawdzaniem na serwerze.

RoCode robi
  • Może w jednym kroku wstawić gotowy animowany ekran codziennych nagród ze swoich zestawów premium UI w jednym z pięciu motywów (candy, neon, gold, blocky, pastel), z działającymi skryptami serwerowymi
  • Albo pisze serwerowy skrypt i przycisk z tego poradnika, podłączone do twojej istniejącej waluty
  • Ma polecone sprawdzać kompilację każdego skryptu przez Check Script i stawia punkty cofania wokół każdego zestawu zmian

Po zbudowaniu RoCode może uruchomić swojego robota testowego: gra w twoją grę w Studio, klika przyciski i zgłasza PASS albo FAIL. Sprawdza tylko to, co sam wybrał do testu, a do 24-godzinnego licznika potrzebny jest twój własny test z krótkimi wartościami. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Jak zrobić codzienne nagrody w Roblox?

Zapisuj czas ostatniego odbioru każdego gracza przez os.time() na serwerze, pozwalaj na odbiór po 24 godzinach i zapisuj go wewnątrz UpdateAsync przed wydaniem nagrody. Skrypt jest w kroku 1.

Jak zrobić serię codziennych logowań?

Zapisuj licznik serii razem z czasem odbioru. Jeśli następny odbiór przyszedł w ciągu 48 godzin, dodawaj jeden; jeśli później, zaczynaj od nowa od 1.

Czy gracze mogą oszukać codzienne nagrody, przestawiając zegar?

Z tym skryptem nie: używa tylko os.time() serwera.

Może lepiej resetować nagrodę o północy?

Możesz liczyć dni kalendarzowe w UTC zamiast 24 godzin. Ruchome 24 godziny są prostsze i działają tak samo we wszystkich strefach czasowych.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.