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
Jak działają codzienne nagrody i serie
| Czas od poprzedniego odbioru | Wynik |
|---|---|
| Mniej niż 24 godziny | Jeszcze za wcześnie. Przycisk pokazuje odliczanie. |
| Od 24 do 48 godzin | Nagrodę można odebrać, seria rośnie o jeden dzień. |
| Więcej niż 48 godzin | Nagrodę można odebrać, seria zaczyna się od nowa od dnia 1. |
| Po dniu 7 | Nastę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.
-- 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.
-- 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ź
- Do testu ustaw
CLAIM_EVERYna30, aSTREAK_LOST_AFTERna60. - Kliknij Play. Na przycisku jest napis „Claim day 1!”. Kliknij go: +50 monet.
- Przycisk odlicza 30 sekund. Odbierz ponownie w ciągu kolejnych 30 sekund: dzień 2, +75.
- Poczekaj ponad minutę: następny odbiór znowu będzie dniem 1.
- 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.
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.
- 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
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (po angielsku). funkcja aktualizacji i anulowanie przez nil
- Roblox Creator Docs: Data stores (po angielsku). dostęp ze Studio i podstawy data store
- Roblox Creator Docs: Remote events and functions (po angielsku). RemoteFunction
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ą.