Tutorial · Spielerdaten

Spielerdaten in Roblox Studio mit DataStores speichern

Roblox behält zwischen zwei Sitzungen nichts über einen Spieler, außer ein Server-Skript speichert es. Dieser Guide baut ein Modul PlayerData, das die Daten jedes Spielers mit DataStoreService lädt, zwischenspeichert und speichert, und behandelt dann Testen, Limits und wie gespeicherte Daten verloren gehen.

Aktualisiert am 12. November 202618 Min. LesezeitGeschrieben von

Kurz gesagt

Nutze DataStoreService aus einem Server-Script: Lade die Daten jedes Spielers mit GetAsync, wenn er beitritt, halte sie während des Spielens in einer Tabelle und speichere sie mit UpdateAsync per Timer, wenn er geht (PlayerRemoving) und wenn der Server herunterfährt (game:BindToClose). Pack jeden Aufruf in pcall und wiederhole Fehlschläge ein paar Mal.

  • Um in Studio zu testen, veröffentliche das Spiel und schalte File > Experience Settings > Security > Enable Studio Access to API Services ein, und zwar in einem separaten Testspiel: Studio nutzt dieselben Daten wie die Live-Server.
  • Konnten die Daten eines Spielers nicht geladen werden, speichere diesen Spieler nie. Die Standardwerte zu speichern würde seinen echten Fortschritt überschreiben.
  • Speichere pro Spieler eine Tabelle unter einem Schlüssel wie User_12345, per Timer statt bei jeder Änderung.
  • Für Handel oder bezahlte Items füge Session Locking hinzu, damit nicht zwei Server denselben Spieler speichern können.
Auf dieser Seite
  1. Studio-Zugriff einschalten
  2. So funktionieren DataStores
  3. GetAsync vs UpdateAsync
  4. 1. Modul PlayerData
  5. So funktioniert das Modul
  6. 2. Daten nutzen
  7. 3. Spieler warnen
  8. 4. In Studio testen
  9. Warum Daten verloren gehen
  10. Session Locking
  11. Limits
  12. Versionen und Backups
  13. Häufige Fehler
  14. Mit RoCode
  15. Häufige Fragen
  16. Quellen und weiterführende Links

Bevor du anfängst: Studio-Zugriff in einer Testkopie einschalten

Ein Spiel, das in Studio läuft, erreicht DataStores erst, wenn du es erlaubst. Das Erlauben hat einen Haken, auf den die Dokumentation von Roblox hinweist: Studio liest und schreibt dann dieselben DataStores wie das Live-Spiel, also setzt ein Test, der in Studio deine Coins zurücksetzt, sie auch im Live-Spiel zurück, und ein Fehler in Testcode kann die Schlüssel echter Spieler beschädigen.

  1. Mach eine Testkopie. Speichere dein Spiel als Datei, öffne die Kopie, wähl File > Publish to Roblox As und klick auf Create new game. Füge sie nicht als Place in dein Live-Spiel ein: Alle Places eines Spiels teilen sich dieselben DataStores.
  2. Öffne in der Testkopie File > Experience Settings und geh zu Security.
  3. Schalte Enable Studio Access to API Services ein und klick auf Save.

DataStore-Aufrufe funktionieren nur in Server-Scripts; ein LocalScript, das es versucht, bekommt einen Fehler, also können Clients keine gespeicherten Daten schreiben. Soll ein Button sie ändern, fragt der Client den Server mit einem RemoteEvent, und der Server entscheidet (siehe den RemoteEvents-Guide (auf Englisch)).

Wie DataStores Spielerdaten halten

IllustrationDer Test aus Schritt 4 des Guides, beschleunigt: Play, Stop speichert die Sitzung im DataStore, und erneutes Play lädt sie, also zeigt der Output 200.

Ein DataStore ist eine benannte Menge von Schlüsseln und Werten auf den Servern von Roblox, die sich jeder Server und jeder Place deines Spiels teilen. DataStoreService:GetDataStore("PlayerData") gibt einen zurück.

Die Best Practices von Roblox laufen auf einen DataStore für Spielerdaten, einen Schlüssel pro Spieler, eine Tabelle in jedem Schlüssel hinaus. Bilde den Schlüssel aus der UserId des Spielers, etwa User_12345, nie aus seinem Namen, den er ändern kann. Ein festes Muster User_{UserId} erlaubt außerdem der automatischen Verarbeitung von Löschanfragen (Recht auf Vergessenwerden) durch Roblox, die Daten eines Spielers zu finden, wenn du sie einrichtest.

Was ein DataStore speichern kann
TypSpeicherbar?Hinweise
Zahlen, Strings, Booleans, BufferJaStrings müssen gültiges UTF-8 sein. Speichere kein inf oder nan.
TabellenJaWenn alles darin auch speicherbar ist. Eine Tabelle, deren Zahlenschlüssel nicht bei 1 beginnen (deren Länge also 0 ist), kommt mit diesen Schlüsseln als Strings zurück.
Instances, Vector3, CFrame, Color3NeinDas Speichern bricht mit einem Fehler ab oder speichert nil. Speichere den Namen eines Items oder eine Position als drei Zahlen.

Jede Anfrage ist ein Webaufruf, der fehlschlagen kann, Zeit braucht und auf ein Budget pro Minute angerechnet wird. Zuverlässige Speichersysteme lesen deshalb einmal beim Beitreten, halten die Daten während des Spielens in einer Server-Tabelle und schreiben sie ab und zu zurück.

GetAsync, SetAsync oder UpdateAsync: was du nimmst

Die wichtigsten DataStore-Methoden
MethodeWas sie machtNutze sie für
GetAsync(key)Liest den Wert. Das Ergebnis wird auf diesem Server 4 Sekunden zwischengespeichert.Die Daten eines Spielers laden
SetAsync(key, value)Überschreibt den Wert, ohne ihn zu lesen. Ein Schreibzugriff.Einen neuen Schlüssel oder einen Wert, der nicht vom alten abhängt
UpdateAsync(key, callback)Liest den neuesten Wert, übergibt ihn an deinen Callback und schreibt, was er zurückgibt. Ein Lese- und ein Schreibzugriff.Spielerdaten speichern, und jeden Schlüssel, den mehr als ein Server schreiben kann
IncrementAsync(key, delta)Addiert eine ganze Zahl zu einer gespeicherten ganzen Zahl.Zähler
RemoveAsync(key)Löscht den Schlüssel und gibt den alten Wert zurück. Frühere Versionen lassen sich weiterhin auflisten und lesen.Die Daten eines Spielers löschen

SetAsync schreibt blind: Speichern zwei Server fast im selben Moment denselben Schlüssel, gewinnt der spätere Schreibzugriff, egal was er enthält. UpdateAsync liest zuerst den aktuellen Wert, und schreibt dazwischen ein anderer Server, führt Roblox deinen Callback mit dem neuen Wert noch einmal aus. Roblox empfiehlt es, wann immer ein Schreibzugriff vom aktuellen Wert abhängt oder mehrere Server den Schlüssel schreiben können, und genau das trifft auf Spielerdaten zu. Für den Callback gelten drei Regeln:

  • Er darf nicht yielden: kein task.wait() und keine anderen DataStore-Aufrufe darin.
  • Er kann mehr als einmal laufen, also sollte er nur den neuen Wert berechnen, nie Items vergeben oder Events feuern.
  • Gibt er nil zurück, wird der Schreibzugriff abgebrochen. Das Modul nutzt das, um keine Daten zu überschreiben, die eine neuere Version des Spiels gespeichert hat.

Schritt 1: Das Modul PlayerData erstellen

Dieses ModuleScript ist der einzige Code, der mit dem DataStore spricht. Es lädt die Daten jedes Spielers beim Beitreten, hält sie im Speicher, speichert sie alle 180 Sekunden, beim Verlassen und beim Herunterfahren des Servers und weigert sich, jemanden zu speichern, dessen Daten nicht geladen werden konnten.

  1. Fahr im Explorer mit der Maus über ServerScriptService, klick auf + und füge ein ModuleScript ein. Nenn es PlayerData und ersetz seinen Inhalt durch den Code unten.
  2. Ein ModuleScript läuft nur, wenn ein Skript es per require lädt. Füge in ServerScriptService ein Script namens Main mit dieser Zeile ein: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Andere Server-Skripte laden es auf dieselbe Weise.
  3. Pass DEFAULTS und den Typ Data an dein Spiel an, wobei jedes Feld eine Zahl, ein String, ein Boolean oder eine Tabelle bleibt.
Der Explorer nach den Schritten 1 bis 3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript in ServerScriptService namens PlayerData
-- PlayerData: lädt die Daten jedes Spielers beim Beitreten, hält sie im Speicher
-- und speichert sie per Timer, beim Verlassen und beim Herunterfahren des Servers.
-- Andere Server-Skripte nutzen PlayerData.Get(player), um sie zu lesen und zu ändern.

local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- erhöhen, wenn sich die Form der Daten ändert, und einen Schritt in migrate() hinzufügen
local AUTOSAVE_SECONDS = 180
-- In Studio gibt ein fehlgeschlagener Aufruf sofort auf, also geht Testen ohne DataStore-Zugriff schnell
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- verdoppelt sich nach jedem Fehlschlag: 1, 2, 4

export type Data = {
	SchemaVersion: number,
	Coins: number,
	Level: number,
	Inventory: { string },
}

-- Womit ein ganz neuer Spieler startet
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false, wenn das Laden fehlschlug: Standarddaten dürfen nie echten Fortschritt ersetzen
}

-- Wird in jedem pcall unten aufgerufen, damit ein noch nicht veröffentlichtes Spiel
-- (ohne DataStore-Zugriff) Spieler trotzdem mit Standarddaten lädt
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- noch laufende Speichervorgänge, pro Schlüssel
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Feuert mit dem Spieler, sobald seine Daten bereit sind. Ruf PlayerData.Get(player) für die Tabelle auf:
-- Eine Tabelle, die durch ein BindableEvent geschickt wird, kommt als Kopie an, also würde ihre Änderung nichts ändern.
PlayerData.Loaded = loadedEvent.Event

local function deepCopy(value: any): any
	if type(value) ~= "table" then
		return value
	end
	local copy = {}
	for key, item in value do
		copy[key] = deepCopy(item)
	end
	return copy
end

local function defaultData(): Data
	local data = deepCopy(DEFAULTS) -- eine frische Kopie, damit sich Spieler nie eine Inventory-Tabelle teilen
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Bringt gespeicherte Daten auf das aktuelle Schema. Gibt nil zurück, wenn sie nicht sicher nutzbar sind.
local function migrate(saved: any): Data?
	if type(saved) ~= "table" then
		return nil
	end
	local version = tonumber(saved.SchemaVersion) or 1
	if version > SCHEMA_VERSION then
		return nil -- von einer neueren Version des Spiels gespeichert: hier nie laden oder überschreiben
	end

	-- Ein Schritt pro Schema-Änderung, älteste zuerst
	if version < 2 then
		-- Beispiel: Version 1 nannte die Währung Gold. Nur kopieren, wenn Coins fehlt,
		-- damit ältere Daten, die schon Coins, aber keine SchemaVersion haben, ihren Wert behalten.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Felder hinzufügen, die seit dem letzten Speichern dieses Spielers dazugekommen sind, und Werte mit falschem Typ ersetzen
	for field, default in DEFAULTS do
		if type(saved[field]) ~= type(default) then
			saved[field] = deepCopy(default)
		end
	end
	saved.SchemaVersion = SCHEMA_VERSION
	return saved
end

-- Führt einen DataStore-Aufruf in pcall aus. Bei einem Fehlschlag wartet es und versucht es erneut, verdoppelt
-- die Wartezeit jedes Mal und fügt etwas Zufall hinzu, damit nicht alle Server gleichzeitig wiederholen.
local function withRetries(label: string, call: () -> any): (boolean, any)
	for attempt = 1, MAX_ATTEMPTS do
		local ok, result = pcall(call)
		if ok then
			return true, result
		end
		warn(`{label} failed (attempt {attempt} of {MAX_ATTEMPTS}): {result}`)
		if attempt < MAX_ATTEMPTS then
			local waitTime = FIRST_RETRY_SECONDS * 2 ^ (attempt - 1)
			task.wait(waitTime + math.random() * waitTime / 2)
		end
	end
	return false, nil
end

local function save(session: Session): boolean
	if not session.canSave then
		return false
	end
	local key = session.key
	pendingSaves[key] = (pendingSaves[key] or 0) + 1

	local newerSchema = false
	local ok = withRetries(`Save {key}`, function()
		return store():UpdateAsync(key, function(current: any)
			if type(current) == "table" and (tonumber(current.SchemaVersion) or 1) > SCHEMA_VERSION then
				newerSchema = true
				return nil -- nil zurückgeben bricht den Schreibzugriff ab
			end
			-- Die ganze aktuelle Tabelle schreiben, mit der UserId des Spielers markiert
			return session.data, { session.userId }
		end)
	end)

	local left = (pendingSaves[key] or 1) - 1
	if left > 0 then
		pendingSaves[key] = left
	else
		pendingSaves[key] = nil
	end
	if newerSchema then
		session.canSave = false
		warn(`{key} was saved by a newer version of the game, so this server stopped saving it`)
	end
	return ok and not newerSchema
end

local function startAutosave(player: Player, session: Session)
	task.spawn(function()
		-- An einem zufälligen Punkt im Intervall starten, damit nicht alle Server gleichzeitig speichern
		task.wait(math.random() * AUTOSAVE_SECONDS)
		while sessions[player] == session do
			save(session)
			task.wait(AUTOSAVE_SECONDS)
		end
	end)
end

local function load(player: Player)
	local key = "User_" .. player.UserId

	-- Hat dieser Spieler den Server gerade verlassen und ist zurückgekommen, erst das letzte Speichern fertig werden lassen
	while pendingSaves[key] do
		task.wait()
	end

	local ok, saved = withRetries(`Load {key}`, function()
		return store():GetAsync(key)
	end)
	if player.Parent ~= Players then
		return -- während des Ladens gegangen: Nichts hat sich geändert, also gibt es nichts zu speichern
	end

	local data: Data? = nil
	if ok then
		data = if saved == nil then defaultData() else migrate(saved)
	end

	local session: Session = {
		key = key,
		userId = player.UserId,
		data = data or defaultData(),
		canSave = data ~= nil,
	}
	if not session.canSave then
		warn(`Could not load {key}. {player.Name} is playing on default data that will not be saved.`)
	end

	sessions[player] = session
	player:SetAttribute("DataLoaded", session.canSave) -- eine GUI kann das lesen und den Spieler warnen
	startAutosave(player, session)
	loadedEvent:Fire(player)
end

local function endSession(player: Player)
	local session = sessions[player]
	if not session then
		return
	end
	sessions[player] = nil -- stoppt die Autosave-Schleife und sorgt dafür, dass ein zweiter Aufruf nichts tut
	save(session)
end

-- Die live Datentabelle des Spielers, oder nil, bis sie geladen ist. Nur aus Server-Skripten ändern.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True, wenn die Daten des Spielers geladen wurden und gespeichert werden. Prüf das, bevor du etwas verkaufst.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Speichert sofort, statt auf den Timer zu warten, für wichtige Momente wie einen Kauf.
-- Yieldet und gibt true zurück, sobald das Speichern durch ist.
function PlayerData.SaveNow(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and save(session)
end

Players.PlayerAdded:Connect(load)
Players.PlayerRemoving:Connect(endSession)
for _, player in Players:GetPlayers() do
	task.spawn(load, player) -- Spieler, die beigetreten sind, bevor dieses Modul zum ersten Mal geladen wurde
end

game:BindToClose(function()
	-- Der Server gibt diesen Funktionen 30 Sekunden, also alle gleichzeitig speichern
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Dann auf jedes noch laufende Speichern warten, auch auf die, die PlayerRemoving gestartet hat
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Sobald das Spiel live ist, lass STORE_NAME und das Schlüsselmuster User_ unverändert. Änderst du eins davon, zeigt das Modul auf leere Schlüssel, und jeder Spieler fängt wieder bei den Standardwerten an.

Wie das Modul Daten sicher hält

Standardwerte und eine Schema-Version

Ein neuer Spieler bekommt eine frische Kopie von DEFAULTS. Es muss eine Kopie sein: Würden sich alle Spieler eine Inventory-Tabelle teilen, erschiene ein Item, das für einen hinzugefügt wird, bei allen.

Jede gespeicherte Tabelle trägt eine SchemaVersion. Ein neues Feld braucht keine neue Version, weil migrate fehlende Felder aus den Standardwerten auffüllt. Umbenennen oder Umbauen schon: Erhöhe SCHEMA_VERSION und füge einen Schritt hinzu, wie das Beispiel, das Gold in Coins umbenennt (in einem neuen Spiel lösch es und fang bei 1 an). Daten mit einer höheren Version als der des Servers stammen von einem neueren Release, das noch ausgerollt wird, also lassen ältere Server sie in Ruhe.

Ein fehlgeschlagenes Laden wird nie gespeichert

Diese Regel verhindert komplette Löschungen. Schlägt jeder Ladeversuch fehl, spielt der Spieler mit Standarddaten, aber canSave ist false, also überschreiben diese Standardwerte nie seinen echten Fortschritt. Das Modul setzt außerdem ein Attribut DataLoaded auf false, das Schritt 3 nutzt, um es ihm zu sagen. Das Referenzbeispiel von Roblox behandelt fehlgeschlagenes Laden genauso und empfiehlt das statt eines Kicks; wenn du lieber kickst, ruf an der Stelle, an der das Modul warnt, player:Kick() mit einer Nachricht auf.

Wiederholungen mit Backoff

withRetries packt jeden Aufruf in pcall. Nach einem Fehlschlag wartet es 1, dann 2, dann 4 Sekunden, jeweils plus zufällig bis zur Hälfte davon, und hört nach vier Versuchen auf (einem in Studio, damit ein Spiel ohne DataStore-Zugriff sofort startet). Der Zufall verteilt die Wiederholungen vieler Server nach einem Ausfall, und die Obergrenze hält das Warten bei etwa 10 Sekunden, innerhalb der 30 Sekunden, die ein Server zum Herunterfahren bekommt. Weil jedes Speichern die ganze live Tabelle über UpdateAsync schreibt, kann eine spät fertige Wiederholung keine alten Daten zurückschreiben.

Wann es speichert

WannWarum
Alle 180 Sekunden, solange der Spieler auf dem Server istBegrenzt den Verlust bei einem Absturz. Das erste Speichern kommt an einem zufälligen Punkt im Intervall, damit nicht alle Server gleichzeitig speichern. Das Referenzbeispiel von Roblox nutzt ebenfalls 180 Sekunden.
Wenn der Spieler geht (PlayerRemoving)Das normale letzte Speichern. Die Sitzung wird zuerst entfernt, also stoppt der Autosave.
Wenn der Server herunterfährt (game:BindToClose)Alle, die noch auf dem Server sind, werden gleichzeitig gespeichert, und die Funktion wartet auf jedes laufende Speichern. Roblox gibt ihr 30 Sekunden.
Auf Abruf, mit PlayerData.SaveNow(player)Nach etwas, das nicht verloren gehen darf, zum Beispiel einem Kauf.

Tritt ein Spieler demselben Server wieder bei, während sein letztes Speichern noch läuft, wartet das neue Laden, bis dieses Speichern fertig ist, also kann es nicht den älteren Wert lesen.

Schritt 2: Daten aus anderen Skripten lesen und ändern

Jedes Server-Skript, das das Modul lädt, teilt sich dieselben Tabellen:

AufrufWas er macht
PlayerData.Get(player)Die live Datentabelle des Spielers, oder nil, bis sie geladen ist. Ändere Felder direkt, etwa data.Coins += 10, und das nächste Speichern übernimmt es.
PlayerData.LoadedFeuert mit dem Spieler, sobald seine Daten bereit sind, auch nach einem fehlgeschlagenen Laden. Es übergibt nur den Spieler, weil eine Tabelle, die durch ein BindableEvent geschickt wird, als Kopie ankommt.
PlayerData.CanSave(player)false, wenn das Laden fehlschlug. Prüf das, bevor du etwas verkaufst: Ein Kauf, der nicht gespeichert werden kann, ist weg, wenn der Spieler geht.
PlayerData.SaveNow(player)Speichert sofort und gibt true zurück, wenn es geklappt hat. Es yieldet.

Das Modul ist der einzige Ort, an dem gespeicherte Daten leben, und leaderstats ist nur eine Anzeige: Bau es wie im Leaderboard-Guide, füll es in einem Loaded-Handler aus PlayerData.Get(player) und aktualisiere beides, wenn sich ein Wert ändert. Lies gespeicherte Werte nie aus leaderstats zurück, und lass nie ein zweites Skript denselben Schlüssel speichern.

Ein Skript, das das Modul lädt, nachdem Spieler schon beigetreten sind, verpasst für sie Loaded. Verbinde den Handler und geh dann zusätzlich in einer Schleife durch Players:GetPlayers() und behandle jeden, für den PlayerData.Get(player) schon eine Tabelle zurückgibt.

Du ersetzt ein älteres Speicherskript, zum Beispiel das aus dem Leaderboard-Guide? Seine Werte bleiben in seinem eigenen DataStore und Schlüssel, also startet dieses Modul jeden mit den Standardwerten. Zeig vor dem Launch entweder mit STORE_NAME und dem Präfix User_ auf die alten (migrate behandelt Daten ohne SchemaVersion als Version 1 und füllt fehlende Felder auf), oder kopier die alten Werte hinüber, und entferne dann das alte Skript.

Clients ändern diese Daten nie direkt. Ein Shop-Button feuert ein RemoteEvent; der Server prüft CanSave, vergleicht den Preis mit den Coins des Spielers, ändert die Tabelle und ruft SaveNow auf. Der Shop-GUI-Guide baut diesen Kaufablauf auf dem Server.

Ein ausgearbeitetes Beispiel für neue Felder: Der Clicker-Simulator-Guide fügt DEFAULTS und dem Typ Data die Felder PowerLevel und Rebirths hinzu und ändert sie dann in der Tabelle, die PlayerData.Get zurückgibt. migrate gibt Spielern mit älteren Speicherständen die neuen Felder.

Schritt 3: Dem Spieler sagen, wenn seine Daten nicht geladen wurden

Ein Spieler, dessen Daten nicht geladen werden konnten, sollte wissen, dass diese Sitzung nicht gespeichert wird, damit er neu beitreten kann, statt umsonst zu spielen. Dieses LocalScript beobachtet das Attribut DataLoaded und zeigt ein Banner, wenn es false ist.

LocalScript in StarterPlayerScripts namens DataWarning
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local shown = false

local function showWarning()
	if shown or player:GetAttribute("DataLoaded") ~= false then
		return
	end
	shown = true

	local gui = Instance.new("ScreenGui")
	gui.Name = "DataWarning"
	gui.ResetOnSpawn = false

	local label = Instance.new("TextLabel")
	label.AnchorPoint = Vector2.new(0.5, 0)
	label.Position = UDim2.new(0.5, 0, 0, 12)
	label.Size = UDim2.new(0.8, 0, 0, 48)
	label.BackgroundColor3 = Color3.fromRGB(110, 28, 28)
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextScaled = true
	label.Text = "Your saved progress could not be loaded. Nothing you do in this server will be saved, so rejoin later."
	label.Parent = gui

	gui.Parent = player:WaitForChild("PlayerGui")
end

-- Der Server setzt DataLoaded einmal, nachdem er versucht hat, die Daten dieses Spielers zu laden
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Schritt 4: Speichern in Studio testen

Mach das in der Testkopie, mit eingeschaltetem Studio-Zugriff.

  1. Gib dir etwas zum Speichern. Füge in Main unter der require-Zeile hinzu: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Drück auf Play. Das Output-Fenster (im Menü Window oder im Tab Script) zeigt deinen Namen und 100 (beim ersten Durchlauf), ohne Warnung Could not load.
  3. Drück auf Stop. Das Beenden des Tests schließt den Server, und das Modul speichert dich, bevor er schließt.
  4. Drück wieder auf Play. Der Output sollte 200 zeigen, 100 mehr als beim letzten Mal. Zeigt er wieder dieselbe Zahl, ist das Speichern nicht durchgegangen: Lies die Warnungen darüber.
  5. Teste den Fehlerfall. Schalte den Studio-Zugriff aus und drück auf Play. Nach einigen Sekunden mit Wiederholungen zeigt der Output Could not load User_... und 100, und das Banner aus Schritt 3 erscheint. Stopp, schalte den Zugriff wieder ein und drück auf Play: Der Output zeigt 300, deine gespeicherten 200 plus 100, weil die fehlgeschlagene Sitzung nie über deine Daten gespeichert wurde.
  6. Entferne die Testzeile aus Main.

Warum Spielerdaten verloren gehen

Das sind die üblichen Wege, auf denen ein Speichersystem Fortschritt verliert. Das Modul behandelt die ersten vier Zeilen und die Schema-Zeile im Code; die anderen hängen davon ab, was du speicherst und wie du es nutzt, und die letzte braucht Session Locking.

Was passiertErgebnisVorbeugung
Ein Laden schlägt fehl, und das Skript speichert trotzdemStandardwerte überschreiben echten Fortschritt: eine komplette LöschungNie einen Spieler speichern, dessen Laden fehlschlug
Nur in PlayerRemoving speichernEin Absturz oder Herunterfahren überspringt das SpeichernAutosave, plus BindToClose, das auf seine Speichervorgänge wartet
Kein pcall oder keine WiederholungEine fehlgeschlagene Anfrage stoppt das Skript oder verwirft das Speichernpcall mit ein paar zeitversetzten Wiederholungen
Bei jeder Änderung speichernAnfragen stauen sich; sobald eine Warteschlange 30 hält, werden neue verworfenDaten im Speicher halten und per Timer speichern
Etwas speichern, das ein DataStore nicht halten kannDas Speichern bricht mit einem Fehler ab, oder der Wert kommt als nil zurückZahlen, Strings, Booleans und Tabellen daraus speichern
Die Form der Daten ohne Migration ändernAlte Speicherstände landen in den falschen FeldernEine Schema-Version und ein Migrationsschritt
Zwei Skripte speichern denselben SchlüsselJedes Speichern überschreibt die Felder des anderenEin Modul besitzt den Schlüssel
Zwei Server halten denselben SpielerDer Server mit älteren Daten speichert zuletzt und überschreibt neueren FortschrittSession Locking

Session Locking, „lock lost“ und ProfileStore

Ein Spieler ist immer nur mit einem Server verbunden, aber das letzte Speichern des alten Servers kann noch laufen, wenn er einem neuen beitritt: eine langsame Wiederholung, ein Teleport oder ein schnelles erneutes Beitreten. Lädt der neue Server zuerst, hält er ältere Daten, und der Server, der zuletzt speichert, gewinnt. Die Dokumentation von Roblox merkt an, dass diese Lücke in Spielen mit Handel eine häufige Ursache für duplizierte Items ist.

Session Locking schließt sie. Lädt ein Server den Schlüssel eines Spielers, schreibt er im selben UpdateAsync-Aufruf seine eigene Lock-ID in die Metadaten des Schlüssels. Jeder andere Server, der einen nicht abgelaufenen Lock findet, den er nicht selbst gesetzt hat, lädt und speichert den Schlüssel nicht. Der Besitzer erneuert den Lock bei jedem Autosave und entfernt ihn beim letzten Speichern; hört er auf zu erneuern, läuft der Lock ab, und ein anderer Server darf ihn übernehmen.

Was „lock lost“ bedeutet

In einem System mit Session Locking hat ein Server den Lock verloren, wenn jetzt ein anderer Server den Schlüssel des Spielers besitzt, weil der Lock abgelaufen ist oder übernommen wurde. Seine Kopie ist vielleicht veraltet, also muss er aufhören, diesen Spieler zu speichern; eine übliche Reaktion ist, ihn mit einer Nachricht zu kicken, damit er sich neu verbindet. Hast du „lock lost“ als Spieler gesehen, kommt es vom eigenen Speichersystem dieses Spiels, und nur dessen Entwickler können es erklären.

Brauchst du es?

Das Modul in diesem Guide sperrt keine Sitzungen. Ohne Locking ist der realistische schlimmste Fall, dass ein Spieler bei einer seltenen Überschneidung verliert, was er auf dem alten Server seit dessen letztem erfolgreichen Speichern verdient hat. Füge Locking hinzu, wenn Duplizieren oder Verlust Spieler etwas Echtes kosten würde: Handel, Developer Products, seltene Items oder häufige Teleports.

OptionWas es istGut zu wissen
Das Modul aus diesem GuideLaden, Zwischenspeichern, Wiederholungen, Autosave, Speichern beim Herunterfahren und Schema-Versionen, ohne LockingKurz genug, um es ganz zu lesen und zu ändern
Das Beispiel von Roblox für Spielerdaten und KäufeReferenzcode von Roblox mit Session Locking, Wiederholungen der Reihe nach pro Schlüssel und Verarbeitung von KaufbelegenRoblox sagt, es habe sich noch nicht über längere Zeit in einem beliebten Spiel bewährt und solle ohne umfangreiche Tests nicht unverändert genutzt werden
ProfileStoreEin kostenloses Open-Source-Modul aus der Community, Nachfolger von ProfileService, aufgebaut um Session Locking und AutosaveNicht von Roblox. Ein bestehendes Spiel darauf umzustellen heißt, die schon gespeicherten Daten zu migrieren

Für jedes Modul von Dritten rät Roblox zu prüfen, wem es gehört, ob es gepflegt wird und wie du ohne es an deine Daten kämst. Dieselbe Dokumentation nennt DataStore2 eine Legacy-Bibliothek, die neue Spiele nicht nutzen sollten.

DataStore-Limits

Das sind die Limits aus der Dokumentation von Roblox am 30. September 2026. Roblox überarbeitet sie, also prüf die Seite zu Fehlercodes und Limits (auf Englisch), bevor du etwas um eine genaue Zahl herum entwirfst.

Standardlimits für Anfragen pro Server und Minute
AnfragetypNormale DataStoresOrdered DataStores
Lesen: GetAsync, der Lesezugriff in UpdateAsync60 + 40 × Spieler60 + 40 × Spieler
Schreiben: SetAsync, IncrementAsync, der Schreibzugriff in UpdateAsync60 + 40 × Spieler30 + 5 × Spieler
Auflisten: ListKeysAsync, oder GetSortedAsync bei Ordered DataStores5 + 2 × Spieler5 + 2 × Spieler
Entfernen: RemoveAsync60 + 40 × Spieler30 + 5 × Spieler

Mit 20 Spielern darf ein Server 860 normale Schreibzugriffe pro Minute machen; der Autosave dieses Moduls nutzt davon etwa 7, plus einen pro Spieler, der geht. Bei jedem eingesammelten Coin zu speichern ist das, was ein Budget aufbraucht. Ein zweites Budget gilt für das ganze Spiel und wird mit Open Cloud geteilt: 300 Lesezugriffe pro Minute plus 40 pro Spieler online, und 300 Schreibzugriffe plus 20 pro Spieler.

Limits für Größe und Durchsatz
LimitWert
Name des DataStores, Name des Schlüssels, Scopeje 50 Zeichen
In einem Schlüssel gespeicherter Wert4.194.304 Zeichen, gemessen als JSON
Lesezugriffe auf einen Schlüssel, über alle Server25 MB pro Minute
Schreibzugriffe auf einen Schlüssel, über alle Server4 MB pro Minute, jede Anfrage auf das nächste KB aufgerundet
Wartende Anfragen30 pro Warteschlange; darüber hinaus schlagen Anfragen mit den Fehlern 301 bis 306 fehl
Speicherplatz für das ganze Spiel500 MB plus 1 MB pro Nutzer über die gesamte Lebensdauer

Miss die Daten eines Spielers mit #HttpService:JSONEncode(data), und sieh dir das verbleibende Budget eines laufenden Servers mit DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite) an. GetAsync-Aufrufe, die aus dem 4-Sekunden-Cache beantwortet werden, zählen nicht. Der Run-Modus von Studio hat eigene, möglicherweise niedrigere Limits, also empfiehlt Roblox Team Create, um Anfragelimits zu testen.

Versionen und Backups

Normale DataStores führen für dich eine Historie. Der erste Schreibzugriff auf einen Schlüssel in jeder UTC-Stunde wird als Version behalten, und spätere Schreibzugriffe in dieser Stunde überschreiben einander. Eine alte Version läuft 30 Tage ab, nachdem ein neuerer Schreibzugriff sie ersetzt hat; die neueste läuft nie ab. Ordered DataStores behalten keine Versionen.

Um einen Spieler zurückzusetzen, öffne den Data Stores Manager (Creations, dein Spiel, Configure > Data Stores Manager), wähl seinen Schlüssel, such eine frühere Version aus und klick auf Revert, wofür du die Berechtigung Edit brauchst. Mach das, während der Spieler offline ist, sonst speichert der Server, der seine Sitzung hält, seine Kopie über das Zurücksetzen. Aus einem Server-Skript finden und lesen ListVersionsAsync und GetVersionAsync eine alte Version, die du dann als aktuellen Wert zurückschreibst.

Bevor du ein Update veröffentlichst, das ändert, wie Daten gespeichert werden, empfiehlt Roblox einen Snapshot mit der Open Cloud Snapshot Data Stores API (einer pro Tag und Spiel). Ohne ihn überschreibt ein fehlerhaftes Speichern um 3:30 UTC alles, was seit 3:00 in diesen Schlüssel geschrieben wurde, weil es in dieselbe stündliche Version fällt.

Häufige Fehler und Lösungen

DataStore-Fehler erscheinen im Output-Fenster von Studio, und das Modul gibt bei jedem fehlgeschlagenen Versuch eine Warnung mit dem Fehlertext von Roblox aus. Der Guide zu Skriptfehlern erklärt allgemein, wie man den Output liest.

StudioAccessToApisNotAllowed (Fehler 403)

„Can't write to DataStore from Studio because API access is not enabled.“ Veröffentliche das Spiel und schalte dann in der Testkopie unter File > Experience Settings > Security die Option Enable Studio Access to API Services ein.

DataStore request was added to queue

Der Server schickt Anfragen schneller, als sein Budget erlaubt, oder schreibt denselben Schlüssel zu oft, meist weil er bei jeder Änderung oder in einer Schleife speichert. Sobald eine Warteschlange 30 hält, schlagen neue Anfragen mit den Fehlern 301 bis 306 fehl. Halte Daten im Speicher und speichere per Timer.

CantStoreValue (Fehler 104), oder ein Feld kommt als nil zurück

Die Tabelle enthält etwas, das ein DataStore nicht speichern kann, etwa eine Instance, einen Vector3 oder einen Color3. Speichere stattdessen einen Namen, eine ID oder einfache Zahlen und bau das Objekt beim Laden neu auf.

ValueTooLarge (Fehler 105)

Ein Schlüssel hält mehr als 4.194.304 Zeichen JSON. Miss mit #HttpService:JSONEncode(data), lass weg, was du neu aufbauen kannst, oder teil die Daten auf ein paar feste Schlüssel auf.

Keine Fehler, aber die Daten werden nicht gespeichert

Such nach der Warnung Could not load des Moduls: Nach einem fehlgeschlagenen Laden weigert es sich absichtlich zu speichern. Ansonsten wurde der Wert wahrscheinlich in einem LocalScript geändert, was den Server nie erreicht, oder ein anderes Skript speichert denselben Schlüssel.

Die Daten werden bei jedem erneuten Beitreten zurückgesetzt

Der Schlüssel ändert sich zwischen den Sitzungen (aus player.Name gebildet, oder STORE_NAME wurde geändert), das Laden schlägt fehl und du siehst Standardwerte, oder nichts lädt das Modul per require, also läuft es nie. Prüf den Output und ob Main das Modul PlayerData lädt.

Mit RoCode bauen

Wenn du das nicht von Hand verdrahten willst, kann RoCode es in dem Spiel bauen, das du offen hast. Es ist ein unabhängiger KI-Agent, nicht von Roblox, der über ein Roblox Studio Plugin arbeitet: Es schreibt Luau, das DataStoreService wie jedes Skript nutzt, und erstellt die Skripte in deinem Explorer. Es ruft deine DataStores nie selbst auf, aber mit Plugin 3.9 oder neuer kann es für einen kurzen Playtest auf Play drücken, in dem deine Skripte wie in jedem Test laufen. Prompts kannst du auf Deutsch schreiben.

Du schreibst

Füge meinem Spiel Speichern hinzu: Coins, Level und Inventory in einem PlayerData-Modul mit Autosave und Speichern beim Herunterfahren, und zeig Coins in den leaderstats, die ich schon habe.

RoCode macht
  • Kann mit Search Scripts und Read Script nach vorhandenem leaderstats- und DataStore-Code suchen, um das Bestehende zu erweitern, statt ein zweites Speicherskript hinzuzufügen. In einem großen Spiel nenn das Skript oder den Ordner in deiner Nachricht.
  • Erstellt das ModuleScript und das Script, das es lädt, mit Create Script, oder ändert deine vorhandenen mit Edit Script
  • Führt auf jedem geschriebenen Skript Check Script aus: eine Kompilierprüfung in Studio mit einer kurzen Warnliste, keine Typprüfung und kein Testlauf
  • Schickt seine Änderungen in Runden, und jede Runde ist in Studio ein Undo-Punkt

Studio Access to API Services schaltest du in deiner Testkopie trotzdem selbst ein: RoCode kann diese Einstellung nicht ändern. Mit Plugin 3.9 oder neuer liest sein kurzer Playtest die Fehler, und mit Plugin 3.9.11 oder neuer kann es eine Testfigur steuern, um zu prüfen, ob das Spiel funktioniert, aber es prüft nur, was es selbst zum Testen ausgewählt hat, also spielst du selbst, um zu prüfen, ob Coins, Level und Inventory gespeichert und geladen werden. Schlägt in deinem Test ein Speichern fehl, kann Check Output die Server-Zeilen aus dem Playtest lesen, den du gemacht hast. Speichern kommt meist, sobald die Kernschleife funktioniert; ein Roblox-Spiel mit KI, ein System nach dem anderen geht diese Reihenfolge durch. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Wie aktiviere ich DataStore in Roblox Studio?

Veröffentliche das Spiel, öffne File > Experience Settings > Security, schalte Enable Studio Access to API Services ein und klick auf Save. Mach das in einem separaten Testspiel, denn Studio nutzt dann dieselben DataStores wie die Live-Server dieses Spiels.

Speichert Roblox Spielerdaten automatisch?

Nein. Nichts über einen Spieler überdauert die Sitzung, außer ein Server-Skript speichert es mit DataStoreService, und das gilt auch für leaderstats.

Sollte ich ProfileStore oder DataStoreService direkt nutzen?

ProfileStore baut ebenfalls auf DataStores auf, also ist die Frage, ob du Session Locking für dich geschrieben und gepflegt haben willst. Für Handel, bezahlte Items oder häufige Teleports lohnt sich Locking, aus einer Bibliothek oder dem Referenzbeispiel von Roblox. Für ein kleineres Spiel ist ein Modul wie dieses leichter zu lesen und zu ändern.

Wie setze ich die Daten eines Spielers zurück oder lösche sie?

Such im Data Stores Manager den Schlüssel und wähl Mark for Deletion, was du während einer Wartezeit rückgängig machen kannst, oder ruf aus einem Server-Skript RemoveAsync auf dem Schlüssel auf. Mach das, während der Spieler offline ist, sonst schreibt das nächste Speichern seines Servers die Daten zurück. In der Testkopie lässt eine Änderung von STORE_NAME alle neu anfangen; mach das nie in einem Live-Spiel.

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.