Tutorial · Belohnungen

Tägliche Belohnungen in Roblox Studio erstellen

Eine tägliche Belohnung gibt Spielern einen Grund, dein Spiel morgen wieder zu öffnen, und ein Streak gibt ihnen einen Grund, keinen Tag auszulassen. Die Logik ist ein gespeicherter Zeitstempel: Wann hat dieser Spieler zuletzt abgeholt, und wie viele Tage hintereinander? Dieser Guide speichert beides sicher, sodass ein Spieler weder durch erneutes Beitreten noch mit zwei offenen Servern doppelt abholen kann, und fügt einen Button hinzu, der bis zur nächsten Belohnung herunterzählt.

Aktualisiert am 12. November 20264 Min. LesezeitGeschrieben von

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
  1. So funktioniert es
  2. 1. Server
  3. 2. Button
  4. Häufige Fehler
  5. Mit RoCode
  6. Häufige Fragen
  7. Quellen und weiterführende Links

So funktionieren tägliche Belohnungen und Streaks

Was eine Abholung macht, je nach Zeit seit der letzten
Zeit seit der letzten AbholungErgebnis
Weniger als 24 StundenNoch nicht bereit. Der Button zählt herunter.
24 bis 48 StundenAbholen erlaubt, der Streak steigt um einen Tag.
Mehr als 48 StundenAbholen erlaubt, der Streak beginnt wieder bei Tag 1.
Nach Tag 7Die 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
-- 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
-- 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

  1. Setz zum Testen CLAIM_EVERY auf 30 und STREAK_LOST_AFTER auf 60.
  2. Drück auf Play. Auf dem Button steht „Claim day 1!“. Drück ihn: +50 Coins.
  3. Der Button zählt 30 Sekunden herunter. Hol innerhalb der nächsten 30 Sekunden wieder ab: Tag 2, +75.
  4. Warte mehr als eine Minute: Die nächste Abholung ist wieder Tag 1.
  5. 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.

Du schreibst

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.

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

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.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.