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
- Studio-Zugriff einschalten
- So funktionieren DataStores
- GetAsync vs UpdateAsync
- 1. Modul PlayerData
- So funktioniert das Modul
- 2. Daten nutzen
- 3. Spieler warnen
- 4. In Studio testen
- Warum Daten verloren gehen
- Session Locking
- Limits
- Versionen und Backups
- Häufige Fehler
- Mit RoCode
- Häufige Fragen
- 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.
- 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.
- Öffne in der Testkopie File > Experience Settings und geh zu Security.
- 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
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.
| Typ | Speicherbar? | Hinweise |
|---|---|---|
| Zahlen, Strings, Booleans, Buffer | Ja | Strings müssen gültiges UTF-8 sein. Speichere kein inf oder nan. |
| Tabellen | Ja | Wenn 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, Color3 | Nein | Das 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
| Methode | Was sie macht | Nutze 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
nilzurü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.
- Fahr im Explorer mit der Maus über ServerScriptService, klick auf + und füge ein ModuleScript ein. Nenn es
PlayerDataund ersetz seinen Inhalt durch den Code unten. - Ein ModuleScript läuft nur, wenn ein Skript es per require lädt. Füge in ServerScriptService ein Script namens
Mainmit dieser Zeile ein:local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Andere Server-Skripte laden es auf dieselbe Weise. - Pass
DEFAULTSund den TypDataan dein Spiel an, wobei jedes Feld eine Zahl, ein String, ein Boolean oder eine Tabelle bleibt.
ServerScriptService
PlayerData ModuleScript new
Main Script new
StarterPlayer
StarterPlayerScripts
DataWarning LocalScript new
-- 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
| Wann | Warum |
|---|---|
| Alle 180 Sekunden, solange der Spieler auf dem Server ist | Begrenzt 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:
| Aufruf | Was 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.Loaded | Feuert 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.
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.
- Gib dir etwas zum Speichern. Füge in
Mainunter 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) - 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. - Drück auf Stop. Das Beenden des Tests schließt den Server, und das Modul speichert dich, bevor er schließt.
- 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.
- 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. - 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 passiert | Ergebnis | Vorbeugung |
|---|---|---|
| Ein Laden schlägt fehl, und das Skript speichert trotzdem | Standardwerte überschreiben echten Fortschritt: eine komplette Löschung | Nie einen Spieler speichern, dessen Laden fehlschlug |
Nur in PlayerRemoving speichern | Ein Absturz oder Herunterfahren überspringt das Speichern | Autosave, plus BindToClose, das auf seine Speichervorgänge wartet |
Kein pcall oder keine Wiederholung | Eine fehlgeschlagene Anfrage stoppt das Skript oder verwirft das Speichern | pcall mit ein paar zeitversetzten Wiederholungen |
| Bei jeder Änderung speichern | Anfragen stauen sich; sobald eine Warteschlange 30 hält, werden neue verworfen | Daten im Speicher halten und per Timer speichern |
| Etwas speichern, das ein DataStore nicht halten kann | Das Speichern bricht mit einem Fehler ab, oder der Wert kommt als nil zurück | Zahlen, Strings, Booleans und Tabellen daraus speichern |
| Die Form der Daten ohne Migration ändern | Alte Speicherstände landen in den falschen Feldern | Eine Schema-Version und ein Migrationsschritt |
| Zwei Skripte speichern denselben Schlüssel | Jedes Speichern überschreibt die Felder des anderen | Ein Modul besitzt den Schlüssel |
| Zwei Server halten denselben Spieler | Der Server mit älteren Daten speichert zuletzt und überschreibt neueren Fortschritt | Session 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.
| Option | Was es ist | Gut zu wissen |
|---|---|---|
| Das Modul aus diesem Guide | Laden, Zwischenspeichern, Wiederholungen, Autosave, Speichern beim Herunterfahren und Schema-Versionen, ohne Locking | Kurz genug, um es ganz zu lesen und zu ändern |
| Das Beispiel von Roblox für Spielerdaten und Käufe | Referenzcode von Roblox mit Session Locking, Wiederholungen der Reihe nach pro Schlüssel und Verarbeitung von Kaufbelegen | Roblox 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 |
| ProfileStore | Ein kostenloses Open-Source-Modul aus der Community, Nachfolger von ProfileService, aufgebaut um Session Locking und Autosave | Nicht 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.
| Anfragetyp | Normale DataStores | Ordered DataStores |
|---|---|---|
Lesen: GetAsync, der Lesezugriff in UpdateAsync | 60 + 40 × Spieler | 60 + 40 × Spieler |
Schreiben: SetAsync, IncrementAsync, der Schreibzugriff in UpdateAsync | 60 + 40 × Spieler | 30 + 5 × Spieler |
Auflisten: ListKeysAsync, oder GetSortedAsync bei Ordered DataStores | 5 + 2 × Spieler | 5 + 2 × Spieler |
Entfernen: RemoveAsync | 60 + 40 × Spieler | 30 + 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.
| Limit | Wert |
|---|---|
| Name des DataStores, Name des Schlüssels, Scope | je 50 Zeichen |
| In einem Schlüssel gespeicherter Wert | 4.194.304 Zeichen, gemessen als JSON |
| Lesezugriffe auf einen Schlüssel, über alle Server | 25 MB pro Minute |
| Schreibzugriffe auf einen Schlüssel, über alle Server | 4 MB pro Minute, jede Anfrage auf das nächste KB aufgerundet |
| Wartende Anfragen | 30 pro Warteschlange; darüber hinaus schlagen Anfragen mit den Fehlern 301 bis 306 fehl |
| Speicherplatz für das ganze Spiel | 500 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.
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.
- 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
- Roblox Creator Docs: Data stores (auf Englisch). Studio-Zugriff, GetAsync, SetAsync, UpdateAsync, Set vs Update
- Roblox Creator Docs: Best practices for data stores (auf Englisch). ein Schlüssel pro Spieler, Puffern im Speicher, Wiederholungen mit Backoff, Module von Dritten
- Roblox Creator Docs: Data store error codes and limits (auf Englisch). Fehlercodes, Anfragelimits für Server und Spiel, Limits für Größe, Durchsatz und Speicherplatz
- Roblox Creator Docs: Versioning, listing and caching (auf Englisch). stündliche Versionen, Snapshots, der 4-Sekunden-Cache, was gespeichert werden kann
- Roblox Creator Docs: Implement player data and purchasing systems (auf Englisch). das Referenzbeispiel, Session Locking, fehlgeschlagenes Laden, der 180-Sekunden-Autosave
- Roblox Creator Docs: Data Stores Manager (auf Englisch). Schlüssel ansehen, Versionen zurücksetzen, Daten löschen
- Roblox Engine API: DataModel:BindToClose (auf Englisch). das 30-Sekunden-Fenster beim Herunterfahren
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.