Kurz gesagt
Speichere pro Spieler zwei Zahlen in einem DataStore: last, die os.time() der letzten Abholung, und streak. Abholen ist erlaubt, wenn 24 Stunden vergangen sind. Sind mehr als 48 Stunden vergangen, beginnt der Streak wieder bei Tag 1; sonst steigt er um eins und läuft durch 7 Tage mit wachsenden Belohnungen. Mach die Prüfung in UpdateAsync, damit Entscheidung und Speichern zusammen passieren.
- Nutze
os.time()auf dem Server, nie eine Zeit, die der Client schickt. - Gib in UpdateAsync nil zurück, wenn das Abholen nicht erlaubt ist: Das Speichern wird abgebrochen, und nichts wird ausgezahlt.
- Der Client fragt nur nach dem Status und nach einer Abholung; der Server antwortet.
Auf dieser Seite
So funktionieren tägliche Belohnungen und Streaks
| Zeit seit der letzten Abholung | Ergebnis |
|---|---|
| Weniger als 24 Stunden | Noch nicht bereit. Der Button zählt herunter. |
| 24 bis 48 Stunden | Abholen erlaubt, der Streak steigt um einen Tag. |
| Mehr als 48 Stunden | Abholen erlaubt, der Streak beginnt wieder bei Tag 1. |
| Nach Tag 7 | Die nächste Abholung ist Tag 1 einer neuen Woche. |
os.time() auf dem Server gibt die aktuelle Unix-Zeit zurück, in Sekunden und in UTC, also sind sich alle Server einig. Die Uhr auf dem Computer des Spielers spielt keine Rolle, deshalb bringt es nichts, das Datum auf dem Handy zu ändern.
Schritt 1: Der Belohnungs-Server
Schalte in Game Settings, Security Enable Studio Access to API Services ein (das Spiel muss veröffentlicht sein). Füge dann in ServerScriptService ein Script namens DailyRewards ein:
-- Script in ServerScriptService namens DailyRewards.
-- Eine Belohnung alle 24 Stunden. Wer innerhalb von 48 Stunden wieder abholt, hält den Streak,
-- und die Belohnungen wachsen eine Woche lang jeden Tag, dann beginnt die Woche von vorn.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- Coins für Tag 1 bis Tag 7 eines Streaks
local CLAIM_EVERY = 24 * 60 * 60 -- Sekunden zwischen zwei Abholungen
local STREAK_LOST_AFTER = 48 * 60 * 60 -- wer einen ganzen Tag verpasst, beginnt den Streak neu
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
-- Der Streak-Tag der nächsten Abholung, von 1 bis 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)
-- Was das Menü zeigt: Sekunden bis zur nächsten Abholung (0 = jetzt bereit) und welcher Tag es ist
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 liest den neuesten gespeicherten Eintrag und entscheidet im Update selbst, also kann
-- ein zweiter Server (oder ein zweiter Klick) denselben Tag nicht zweimal abholen
local ok, err = pcall(function()
store:UpdateAsync(tostring(player.UserId), function(old: any)
-- UpdateAsync kann das mehr als einmal ausführen: Nur der letzte Durchlauf zählt
claimedDay = nil
local saved = readRecord(old)
if now - saved.last < CLAIM_EVERY then
return nil -- noch nicht bereit: nil zurückgeben bricht das Speichern ab
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
Die Abholung passiert in der Funktion, die an UpdateAsync übergeben wird. Roblox ruft sie mit dem neuesten gespeicherten Eintrag auf. Ist es zu früh, gibt die Funktion nil zurück, und Roblox bricht das Schreiben ab. Sonst gibt sie den neuen Eintrag zurück, und das Skript merkt sich, welcher Tag abgeholt wurde. Erst wenn UpdateAsync ohne Fehler fertig ist, werden Coins hinzugefügt. Hat ein anderer Server den Schlüssel inzwischen geändert, kann Roblox die Funktion mit dem neueren Wert noch einmal aufrufen, deshalb fällt die Entscheidung in ihr.
Schritt 2: Der Countdown-Button
Füge in StarterPlayer > StarterPlayerScripts ein LocalScript namens DailyRewardsMenu ein:
-- LocalScript in StarterPlayerScripts namens DailyRewardsMenu.
-- Ein Daily-Button mit Countdown. Ist die Belohnung bereit, steht Claim darauf.
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 -- os.clock()-Zeit, zu der die Belohnung bereit ist
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
Der Button fragt den Server einmal, wie lange er warten muss, und zählt dann jede Sekunde selbst mit os.clock() herunter, also ruft er den Server nicht jede Sekunde auf. Nach einer Abholung fragt er erneut. Der Countdown ist nur Anzeige: Der Server prüft die Zeit trotzdem, wenn der Spieler auf Claim drückt.
Testen
- Setz zum Testen
CLAIM_EVERYauf30undSTREAK_LOST_AFTERauf60. - Drück auf Play. Auf dem Button steht „Claim day 1!“. Drück ihn: +50 Coins.
- Der Button zählt 30 Sekunden herunter. Hol innerhalb der nächsten 30 Sekunden wieder ab: Tag 2, +75.
- Warte mehr als eine Minute: Die nächste Abholung ist wieder Tag 1.
- Setz beide Werte vor dem Veröffentlichen zurück auf die Zeilen mit 24 und 48 Stunden.
Häufige Fehler und Lösungen
Behalte das Output-Fenster in der Server-Ansicht im Blick.
Der Button bleibt auf Loading...
Der Eintrag des Spielers wurde nicht geladen. Schalte in Studio Enable Studio Access to API Services ein. Der Output zeigt den Fehler nach „could not load“.
Beim Abholen kommt „come back later“, obwohl der Button Claim zeigte
Der gespeicherte Eintrag war neuer, als der Button wusste, zum Beispiel nach einer Abholung auf einem anderen Server. Die Antwort des Servers ist die richtige.
Der Streak wird jeden Tag zurückgesetzt
Die Spieler holen mit mehr als 48 Stunden Abstand ab, oder STREAK_LOST_AFTER steht noch auf einem Testwert.
Es werden keine Coins hinzugefügt
Der Spieler braucht einen IntValue Coins in leaderstats, erstellt von einem Server-Skript.
Mit RoCode bauen
Wenn du das nicht von Hand einrichten willst, kann RoCode es in dem Spiel bauen, das du offen hast. RoCode ist ein unabhängiger KI-Agent für Roblox Studio und stammt nicht von Roblox: Du beschreibst die Änderung in einem Webchat, und sein Studio-Plugin erstellt die Skripte in deinem Explorer. Prompts kannst du auf Deutsch schreiben.
Füge tägliche Belohnungen mit einem 7-Tage-Streak hinzu: Coins an Tag 1 bis 6 und ein Gem an Tag 7, ein Countdown-Button, gespeichert und auf dem Server geprüft.
- Kann in einem Schritt einen fertigen, animierten Bildschirm für tägliche Belohnungen aus seinen Premium-UI-Kits einfügen, in einem von fünf Themes (candy, neon, gold, blocky, pastel), mit funktionierenden Server-Skripten
- Oder schreibt das Server-Skript und den Button aus diesem Guide, verbunden mit deiner vorhandenen Währung
- Ist angewiesen, jedes Skript mit Check Script auf Kompilierfehler zu prüfen, und setzt um jede Änderungsrunde Undo-Punkte
Nach einem Build kann RoCode seinen Testroboter starten: Er spielt dein Spiel in Studio, klickt Buttons und meldet PASS oder FAIL. Er prüft nur, was er selbst zum Testen ausgewählt hat, und einen 24-Stunden-Timer musst du selbst mit kurzen Werten testen. Wie sich RoCode mit Studio verbindet.
Häufige Fragen
Wie mache ich tägliche Belohnungen in Roblox?
Speichere die letzte Abholzeit jedes Spielers mit os.time() auf dem Server, erlaube eine Abholung nach 24 Stunden und speichere die Abholung in UpdateAsync, bevor du auszahlst. Schritt 1 hat das Skript.
Wie mache ich einen täglichen Login-Streak?
Speichere mit der Abholzeit einen Streak-Zähler. Kommt die nächste Abholung innerhalb von 48 Stunden, zähl eins dazu; kommt sie später, fang wieder bei 1 an.
Können Spieler bei täglichen Belohnungen schummeln, indem sie ihre Uhr ändern?
Nicht mit diesem Skript: Es nutzt nur das os.time() des Servers.
Sollte die Belohnung stattdessen um Mitternacht zurückgesetzt werden?
Du kannst statt 24 Stunden Kalendertage in UTC zählen. Rollende 24 Stunden sind einfacher und behandeln jede Zeitzone gleich.
Quellen und weiterführende Links
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (auf Englisch). die Update-Funktion und Abbrechen mit nil
- Roblox Creator Docs: Data stores (auf Englisch). Studio-Zugriff und DataStore-Grundlagen
- Roblox Creator Docs: Remote events and functions (auf Englisch). RemoteFunction
So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 12. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.