Kort fortalt
Bruk DataStoreService fra et server-Script: last inn spillerens data med GetAsync når han kommer inn, hold dem i en tabell mens han spiller, og lagre med UpdateAsync på en tidtaker, når han går (PlayerRemoving) og når serveren slås av (game:BindToClose). Pakk hvert kall inn i pcall og prøv mislykkede kall på nytt noen ganger.
- For å teste i Studio publiserer du placet og slår på File > Experience Settings > Security > Enable Studio Access to API Services i et eget testspill: Studio bruker de samme dataene som de ekte serverne.
- Hvis spillerens data ikke ble lastet inn, skal du aldri lagre den spilleren. Å lagre standardverdier overskriver den ekte fremgangen hans.
- Lagre én tabell per spiller under én nøkkel, for eksempel
User_12345, og lagre på en tidtaker, ikke ved hver endring. - For bytte av gjenstander eller betalte gjenstander legger du til øktlås, så to servere ikke kan lagre den samme spilleren.
På denne siden
Før du starter: slå på Studio-tilgang i en testkopi
Et spill som kjører i Studio, har ikke tilgang til data stores før du tillater det. Tillatelsen har en felle som dokumentasjonen til Roblox advarer om: Studio leser og skriver da de samme data stores som det ekte spillet, så en test som nullstiller myntene dine i Studio, nullstiller dem også i det ekte spillet, og en feil i testkode kan ødelegge nøklene til ekte spillere.
- Lag en testkopi. Lagre placet til en fil, åpne kopien, velg File > Publish to Roblox As og klikk på Create new game. Ikke legg den til som et place inne i det ekte spillet: alle places i ett spill deler de samme data stores.
- Åpne File > Experience Settings i testkopien og gå til Security.
- Slå på Enable Studio Access to API Services og klikk på Save.
Kall til data stores virker bare i server-Script; et LocalScript som prøver, får en feil, så klienter kan ikke skrive lagrede data. Når en knapp skal endre dem, ber klienten serveren om det via en RemoteEvent, og serveren bestemmer (se guiden til RemoteEvents).
Slik lagrer data stores spillerdata
En data store er en navngitt samling nøkler og verdier på serverne til Roblox, felles for alle servere og alle places i spillet ditt. DataStoreService:GetDataStore("PlayerData") returnerer én slik data store.
Anbefalingene fra Roblox koker ned til regelen én data store for spillerdata, én nøkkel per spiller, én tabell i hver nøkkel. Lag nøkkelen fra spillerens UserId, for eksempel User_12345, og aldri fra navnet, som han kan endre. Et fast mønster User_{UserId} lar også den automatiske behandlingen til Roblox av retten til å bli glemt finne spillerens data, hvis du setter den opp.
| Type | Lagres? | Merknader |
|---|---|---|
| Tall, strenger, boolske verdier, buffere | Ja | Strenger må være gyldig UTF-8. Ikke lagre inf eller nan. |
| Tabeller | Ja | Hvis alt inni også kan lagres. En tabell der tallnøklene ikke starter på 1 (så lengden er 0), kommer tilbake med disse nøklene som strenger. |
Instance, Vector3, CFrame, Color3 | Nei | Lagringen gir en feil eller skriver nil. Lagre navnet på gjenstanden, eller posisjonen som tre tall. |
Hver forespørsel er et nettkall som kan mislykkes, tar tid og bruker av et budsjett per minutt. Derfor leser pålitelige lagringssystemer dataene én gang når spilleren kommer inn, holder dem i en servertabell mens han spiller, og skriver dem tilbake av og til.
GetAsync, SetAsync eller UpdateAsync: hva skal du velge
| Metode | Hva den gjør | Til hva |
|---|---|---|
GetAsync(key) | Leser en verdi. Resultatet caches på denne serveren i 4 sekunder. | Innlasting av spillerdata |
SetAsync(key, value) | Overskriver en verdi uten å lese den. Én skriving. | En ny nøkkel eller en verdi som ikke avhenger av den gamle |
UpdateAsync(key, callback) | Leser den nyeste verdien, sender den til funksjonen din og skriver det den returnerer. Én lesing og én skriving. | Lagring av spillerdata og alle nøkler som flere servere kan skrive |
IncrementAsync(key, delta) | Legger et heltall til et lagret heltall. | Tellere |
RemoveAsync(key) | Sletter en nøkkel og returnerer den gamle verdien. Tidligere versjoner kan fortsatt listes opp og leses. | Sletting av spillerdata |
SetAsync skriver i blinde: hvis to servere lagrer den samme nøkkelen nesten samtidig, vinner den siste skrivingen, uansett hva den inneholder. UpdateAsync leser først den gjeldende verdien, og hvis en annen server skriver i mellomtiden, kjører Roblox funksjonen din på nytt med den nye verdien. Roblox anbefaler den alltid når skrivingen avhenger av den gjeldende verdien eller flere servere kan skrive nøkkelen, og det er akkurat spillerdata. Funksjonen har tre regler:
- Den må ikke gi fra seg kjøringen (yield): ingen
task.wait()og ingen andre kall til data stores inni. - Den kan kjøre mer enn én gang, så den skal bare regne ut den nye verdien og aldri dele ut gjenstander eller utløse hendelser.
- Å returnere
nilavbryter skrivingen. Modulen bruker dette for å ikke overskrive data som en nyere versjon av spillet har lagret.
Steg 1: lag PlayerData-modulen
Dette ModuleScript-et er den eneste koden som snakker med data store. Det laster inn spillerens data når han kommer inn, holder dem i minnet, lagrer hvert 180. sekund, når han går og når serveren slås av, og nekter å lagre dem som ikke fikk dataene sine lastet inn.
- Hold musen over ServerScriptService i Explorer, klikk på + og sett inn et ModuleScript. Gi det nytt navn,
PlayerData, og bytt ut innholdet med koden nedenfor. - Et ModuleScript kjører bare når et skript henter det inn (require). Sett inn et Script med navnet
Maini ServerScriptService med denne linjen:local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Andre serverskript henter det inn på samme måte. - Endre
DEFAULTSog typenDataså de passer spillet ditt, og la hvert felt være et tall, en streng, en boolsk verdi eller en tabell.
ServerScriptService
PlayerData ModuleScript new
Main Script new
StarterPlayer
StarterPlayerScripts
DataWarning LocalScript new
-- PlayerData: laster inn spillerens data når han kommer inn, holder dem i minnet
-- og lagrer på en tidtaker, når han går og når serveren slås av.
-- Andre serverskript leser og endrer dem via PlayerData.Get(player).
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- øk når formen på dataene endres, og legg til et steg i migrate()
local AUTOSAVE_SECONDS = 180
-- I Studio gir et mislykket kall opp med en gang, så en test uten tilgang til data store går raskt
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- dobles etter hver feil: 1, 2, 4
export type Data = {
SchemaVersion: number,
Coins: number,
Level: number,
Inventory: { string },
}
-- Det en helt ny spiller starter med
local DEFAULTS: { [string]: any } = {
Coins = 0,
Level = 1,
Inventory = {},
}
type Session = {
key: string,
userId: number,
data: Data,
canSave: boolean, -- false hvis innlastingen mislyktes: standarddata skal ikke erstatte ekte fremgang
}
-- Kalles inne i hvert pcall nedenfor, så et place som ennå ikke er publisert
-- (uten tilgang til data store) likevel laster inn spillere med standarddata
local function store(): DataStore
return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- lagringer som fortsatt pågår, per nøkkel
local loadedEvent = Instance.new("BindableEvent")
local PlayerData = {}
-- Utløses med spilleren når dataene hans er klare. Hent tabellen med PlayerData.Get(player):
-- en tabell sendt via BindableEvent kommer fram som en kopi, og å endre den endrer ingenting.
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) -- en fersk kopi, så spillere aldri deler én Inventory-tabell
data.SchemaVersion = SCHEMA_VERSION
return data
end
-- Bringer lagrede data opp til gjeldende skjema. Returnerer nil hvis de ikke kan brukes trygt.
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 -- lagret av en nyere versjon av spillet: ikke last inn og ikke overskriv her
end
-- Ett steg per skjemaendring, fra eldst til nyest
if version < 2 then
-- Eksempel: i versjon 1 het valutaen Gold. Vi kopierer den bare hvis Coins mangler,
-- så gamle data som allerede har Coins, men ikke SchemaVersion, beholder verdien.
if saved.Coins == nil then
saved.Coins = saved.Gold
end
saved.Gold = nil
end
-- Legger til felt som kom etter spillerens siste lagring, og bytter ut verdier av feil type
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
-- Kjører et kall til data store i pcall. Ved feil venter den og prøver igjen, og dobler
-- ventetiden hver gang og legger til litt tilfeldighet, så servere ikke prøver på nytt samtidig.
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 -- å returnere nil avbryter skrivingen
end
-- Skriver hele den gjeldende tabellen, merket med spillerens UserId
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()
-- Starter på et tilfeldig tidspunkt i intervallet, så servere ikke lagrer samtidig
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
-- Hvis spilleren nettopp gikk fra denne serveren og kom tilbake, lar vi først den siste lagringen bli ferdig
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 -- gikk under innlastingen: ingenting er endret, ingenting å lagre
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) -- et GUI kan lese dette og advare spilleren
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 -- stopper autolagringsløkken, og et nytt kall gjør ingenting
save(session)
end
-- Den levende datatabellen til spilleren, eller nil til den er lastet inn. Endre den bare fra serverskript.
function PlayerData.Get(player: Player): Data?
local session = sessions[player]
return if session then session.data else nil
end
-- True når spillerens data er lastet inn og vil bli lagret. Sjekk før ethvert salg.
function PlayerData.CanSave(player: Player): boolean
local session = sessions[player]
return session ~= nil and session.canSave
end
-- Lagrer nå, uten å vente på tidtakeren, for viktige øyeblikk som et kjøp.
-- Gir fra seg kjøringen og returnerer true når lagringen gikk gjennom.
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) -- spillere som kom inn før denne modulen ble hentet inn første gang
end
game:BindToClose(function()
-- Serveren gir disse funksjonene 30 sekunder, så vi lagrer alle samtidig
for player in sessions do
task.spawn(endSession, player)
end
-- Så venter vi på alle lagringer som fortsatt pågår, også dem som startet i PlayerRemoving
while next(pendingSaves) do
task.wait()
end
end)
return PlayerData
Når spillet er lansert, ikke endre STORE_NAME eller nøkkelmønsteret User_. Å endre noen av dem sender modulen til tomme nøkler, og hver spiller starter på nytt med standardverdiene.
Slik beskytter modulen dataene
Standardverdier og skjemaversjon
En ny spiller får en fersk kopi av DEFAULTS. Det må være en kopi: hvis alle spillere delte én Inventory-tabell, ville en gjenstand som ble lagt til hos én, dukket opp hos alle.
Hver lagret tabell har en SchemaVersion. Å legge til et felt krever ikke en ny versjon, fordi migrate fyller inn manglende felt fra standardverdiene. Å gi nytt navn eller bygge om krever det: øk SCHEMA_VERSION og legg til et steg, som i eksemplet som gir Gold nytt navn til Coins (i et nytt spill sletter du det og starter på 1). Data med høyere versjon enn serveren sin kommer fra en nyere utgivelse som fortsatt rulles ut, så eldre servere rører dem ikke.
En mislykket innlasting lagres aldri
Denne regelen beskytter mot full sletting. Hvis alle innlastingsforsøk mislyktes, spiller spilleren på standarddata, men canSave er false, så disse verdiene overskriver aldri den ekte fremgangen hans. Modulen setter også attributten DataLoaded til false, og steg 3 bruker den til å si fra til spilleren. Referanseeksemplet til Roblox håndterer mislykkede innlastinger på samme måte og foreslår dette i stedet for å kaste ut spilleren; hvis du heller vil kaste ut, kaller du player:Kick() med en melding der modulen skriver advarselen.
Nye forsøk med økende pause
withRetries pakker hvert kall inn i pcall. Etter en feil venter den 1, så 2, så 4 sekunder, hver gang pluss tilfeldig opptil halvparten av den tiden, og stopper etter fire forsøk (i Studio etter ett, så et place uten tilgang til data store starter med en gang). Tilfeldigheten sprer de nye forsøkene fra mange servere etter et brudd, og grensen holder ventingen innenfor omtrent 10 sekunder, innenfor de 30 sekundene serveren får når den slås av. Fordi hver lagring skriver hele den levende tabellen med UpdateAsync, kan ikke et nytt forsøk som blir ferdig for sent, bringe tilbake gamle data.
Når modulen lagrer
| Når | Hvorfor |
|---|---|
| Hvert 180. sekund mens spilleren er på serveren | Begrenser tapet ved et krasj. Den første lagringen kommer på et tilfeldig tidspunkt i intervallet, så servere ikke lagrer samtidig. Referanseeksemplet til Roblox bruker også 180 sekunder. |
Når spilleren går (PlayerRemoving) | Den vanlige siste lagringen. Økten fjernes først, så autolagringen stopper. |
Når serveren slås av (game:BindToClose) | Alle som fortsatt er på serveren, lagres samtidig, og funksjonen venter på hver lagring som pågår. Roblox gir den 30 sekunder. |
Ved behov, med PlayerData.SaveNow(player) | Etter noe som ikke må gå tapt, for eksempel et kjøp. |
Hvis spilleren kommer inn på samme server igjen mens den siste lagringen hans fortsatt pågår, venter den nye innlastingen til den lagringen er ferdig, så den kan ikke lese en gammel verdi.
Steg 2: les og endre dataene fra andre skript
Alle serverskript som henter inn modulen, jobber med de samme tabellene:
| Kall | Hva det gjør |
|---|---|
PlayerData.Get(player) | Den levende datatabellen til spilleren, eller nil til den er lastet inn. Endre feltene direkte, for eksempel data.Coins += 10, og neste lagring tar det med. |
PlayerData.Loaded | Utløses med spilleren når dataene hans er klare, også etter en mislykket innlasting. Sender bare spilleren, fordi en tabell sendt via BindableEvent kommer fram som en kopi. |
PlayerData.CanSave(player) | false hvis innlastingen mislyktes. Sjekk før ethvert salg: et kjøp som ikke kan lagres, forsvinner når spilleren går. |
PlayerData.SaveNow(player) | Lagrer med en gang og returnerer true hvis det gikk. Gir fra seg kjøringen. |
Modulen er det eneste stedet de lagrede dataene bor, og leaderstats er bare visning: bygg den som i guiden til leaderboard, fyll den fra PlayerData.Get(player) i Loaded-behandleren og oppdater begge når en verdi endres. Les aldri lagrede verdier tilbake fra leaderstats, og la aldri et annet skript lagre den samme nøkkelen.
Et skript som henter inn modulen etter at spillerne kom inn, går glipp av Loaded for dem. Koble til behandleren, og gå så i tillegg gjennom Players:GetPlayers() i en løkke og behandle alle der PlayerData.Get(player) allerede returnerer en tabell.
Erstatter du et gammelt lagringsskript, for eksempel fra guiden til leaderboard? Verdiene i det blir værende i dets egen data store og nøkkel, så denne modulen starter alle med standardverdiene. Før lansering peker du enten STORE_NAME og prefikset User_ mot de gamle (migrate regner data uten SchemaVersion som versjon 1 og fyller inn manglende felt), eller flytter de gamle verdiene over og sletter så det gamle skriptet.
Klienter endrer aldri disse dataene direkte. En butikknapp utløser en RemoteEvent; serveren sjekker CanSave, sammenligner prisen med spillerens Coins, endrer tabellen og kaller SaveNow. Guiden til butikk-GUI bygger et slikt kjøp på serversiden.
Et ferdig eksempel på å legge til felt finner du i guiden til clicker-simulator: den legger til PowerLevel og Rebirths i DEFAULTS og typen Data, og endrer dem så i tabellen som PlayerData.Get returnerer. migrate gir de nye feltene til spillere med gamle lagringer.
Steg 3: si fra til spilleren at dataene ikke ble lastet inn
En spiller der dataene ikke ble lastet inn, må vite at denne økten ikke blir lagret, så han kan komme inn på nytt i stedet for å spille forgjeves. Dette LocalScript-et følger med på attributten DataLoaded og viser et banner når den er false.
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
-- Serveren setter DataLoaded én gang, etter forsøket på å laste inn dataene til denne spilleren
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()
Steg 4: test lagringen i Studio
Gjør dette i testkopien med Studio-tilgang slått på.
- Gi deg selv noe å lagre. Under require-linjen i
Mainlegger du til:PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end) - Trykk på Play. Vinduet Output (i menyen Window eller på fanen Script) viser navnet ditt og 100 (første gang), uten advarselen
Could not load. - Trykk på Stop. Å avslutte testen lukker serveren, og modulen lagrer deg før den lukkes.
- Trykk på Play igjen. Output skal vise 200, 100 mer enn forrige gang. Hvis den viser det samme tallet igjen, gikk ikke lagringen gjennom: les advarslene over det.
- Test feilveien. Slå av Studio-tilgang og trykk på Play. Etter noen sekunder med nye forsøk viser Output
Could not load User_...og 100, og banneret fra steg 3 dukker opp. Stopp testen, slå på tilgangen igjen og trykk på Play: Output viser 300, dine lagrede 200 pluss 100, fordi den mislykkede økten aldri overskrev dataene dine. - Slett testlinjen fra
Main.
Hvorfor spillerdata går tapt
Dette er de vanlige måtene et lagringssystem mister fremgang på. Modulen dekker de fire første radene og raden om skjema i koden; resten avhenger av hva og hvordan du lagrer, og den siste krever øktlås.
| Hva som skjer | Resultat | Slik forhindrer du det |
|---|---|---|
| Innlastingen mislyktes, men skriptet lagrer likevel | Standardverdier overskriver ekte fremgang: full sletting | Aldri lagre en spiller der innlastingen mislyktes |
Lagring bare i PlayerRemoving | Et krasj eller en avslutning av serveren hopper over lagringen | Autolagring pluss BindToClose som venter på sine lagringer |
Ingen pcall eller ingen nye forsøk | Én mislykket forespørsel stopper skriptet eller mister en lagring | pcall med noen nye forsøk spredt i tid |
| Lagring ved hver endring | Forespørsler havner i kø; når køen har 30, forkastes nye | Holde dataene i minnet og lagre på en tidtaker |
| Lagring av noe data store ikke kan lagre | Lagringen gir en feil, eller verdien kommer tilbake som nil | Lagre tall, strenger, boolske verdier og tabeller av dem |
| Endring av formen på dataene uten migrering | Gamle lagringer lastes inn i feil felt | Skjemaversjon og et migreringssteg |
| To skript lagrer den samme nøkkelen | Hver lagring overskriver feltene til det andre | Én modul eier nøkkelen |
| To servere holder den samme spilleren | Serveren med gamle data lagrer sist og overskriver ny fremgang | Øktlås |
Øktlås, «lock lost» og ProfileStore
En spiller er koblet til én server om gangen, men den siste lagringen på den gamle serveren kan fortsatt pågå når han kommer inn på en ny: et tregt nytt forsøk, en teleport eller en rask ny innlogging. Hvis den nye serveren laster inn dataene først, får den gamle data, og serveren som lagrer sist, vinner. Dokumentasjonen til Roblox nevner at dette hullet er en vanlig årsak til duplisering av gjenstander i spill med bytte.
Øktlås tetter dette hullet. Når en server laster inn nøkkelen til en spiller, skriver den sin lås-ID i nøkkelens metadata i samme UpdateAsync-kall. Enhver annen server som finner en lås som ikke har utløpt og som den ikke har satt selv, verken laster inn eller lagrer den nøkkelen. Eieren fornyer låsen ved hver autolagring og fjerner den i den siste lagringen; hvis den slutter å fornye den, utløper låsen, og en annen server kan ta den.
Hva «lock lost» betyr
I et system med øktlås har en server mistet låsen når en annen server nå eier spillerens nøkkel, fordi låsen utløp eller ble tatt over. Kopien dens kan være utdatert, så den må slutte å lagre den spilleren; den vanlige reaksjonen er å kaste ham ut med en melding, så han kobler til på nytt. Hvis du så «lock lost» som spiller, er det en melding fra det spillets eget lagringssystem, og bare utviklerne av spillet kan forklare den.
Trenger du det?
Modulen i denne guiden låser ikke økter. Uten lås er det reelle verste tilfellet slik: i et sjeldent kappløp mister spilleren det han tjente på den gamle serveren etter den siste vellykkede lagringen der. Legg til lås når duplisering eller tap koster spillerne noe ekte: bytte, developer products, sjeldne gjenstander eller hyppige teleporter.
| Alternativ | Hva det er | Verdt å vite |
|---|---|---|
| Modulen i denne guiden | Innlasting, cache i minnet, nye forsøk, autolagring, lagring ved avslutning og skjemaversjoner, uten lås | Kort nok til å lese i sin helhet og endre |
| Roblox sitt eksempel for spillerdata og kjøp | Referansekode fra Roblox med øktlås, nye forsøk i rekkefølge for hver nøkkel og behandling av kjøpskvitteringer | Roblox sier at den ikke er testet over tid i et populært spill og ikke bør brukes som den er uten omfattende testing |
| ProfileStore | En gratis modul fra fellesskapet med åpen kildekode, etterfølgeren til ProfileService, bygd rundt øktlås og autolagring | Ikke fra Roblox. Å flytte et eksisterende spill over til den krever migrering av data som allerede er lagret |
For enhver tredjepartsmodul anbefaler Roblox å sjekke hvem som eier den, om den vedlikeholdes, og hvordan du kommer til dataene dine uten den. Den samme dokumentasjonen kaller DataStore2 et utdatert bibliotek som nye spill ikke bør bruke.
Grenser for data stores
Dette er grensene fra dokumentasjonen til Roblox per 30. september 2026. Roblox endrer dem, så sjekk siden med feilkoder og grenser (på engelsk) før du baserer deg på et nøyaktig tall.
| Type forespørsel | Vanlige data stores | Ordered data stores |
|---|---|---|
Lesing: GetAsync, lesing i UpdateAsync | 60 + 40 × spillere | 60 + 40 × spillere |
Skriving: SetAsync, IncrementAsync, skriving i UpdateAsync | 60 + 40 × spillere | 30 + 5 × spillere |
Liste: ListKeysAsync eller GetSortedAsync for ordered data stores | 5 + 2 × spillere | 5 + 2 × spillere |
Sletting: RemoveAsync | 60 + 40 × spillere | 30 + 5 × spillere |
Med 20 spillere kan en server gjøre 860 vanlige skrivinger i minuttet; autolagringen i denne modulen bruker rundt 7 av dem, pluss én for hver spiller som går. Budsjettet brukes opp av lagring ved hver mynt som plukkes opp. Et annet budsjett gjelder hele spillet og deles med Open Cloud: 300 lesinger i minuttet pluss 40 for hver spiller som er pålogget, og 300 skrivinger pluss 20 per spiller.
| Grense | Verdi |
|---|---|
| Navn på data store, navn på nøkkel, scope | 50 tegn hver |
| Verdien i én nøkkel | 4 194 304 tegn som JSON |
| Lesing av én nøkkel fra alle servere | 25 MB i minuttet |
| Skriving til én nøkkel fra alle servere | 4 MB i minuttet, hver forespørsel rundes opp til neste KB |
| Ventende forespørsler | 30 per kø; utover det feiler forespørsler med feil 301-306 |
| Lagringsplass for hele spillet | 500 MB pluss 1 MB for hver bruker gjennom tidene |
Mål størrelsen på spillerens data med #HttpService:JSONEncode(data), og se det gjenværende budsjettet til en ekte server med DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). GetAsync-kall som ble besvart av cachen på 4 sekunder, telles ikke. Run-modus i Studio har egne, kanskje lavere grenser, så for å teste grenser for forespørsler anbefaler Roblox Team Create.
Versjoner og sikkerhetskopier
Vanlige data stores tar vare på historikken for deg. Den første skrivingen til en nøkkel i hver time etter UTC lagres som en versjon, og senere skrivinger i den timen overskriver hverandre. En gammel versjon utløper 30 dager etter at en nyere skriving erstattet den; den siste utløper aldri. Ordered data stores lagrer ikke versjoner.
For å rulle tilbake én spiller åpner du Data Stores Manager (Creations, spillet ditt, Configure > Data Stores Manager), velger nøkkelen hans, velger en tidligere versjon og klikker på Revert; det krever Edit-rettighet. Gjør det mens spilleren ikke er pålogget, ellers lagrer serveren med økten hans sin kopi over tilbakerullingen. Fra et serverskript finner og leser ListVersionsAsync og GetVersionAsync en gammel versjon, som du så skriver tilbake som gjeldende verdi.
Før du publiserer en oppdatering som endrer hvordan data lagres, anbefaler Roblox å ta et øyeblikksbilde med Open Cloud Snapshot Data Stores API (ett per dag per spill). Uten det vil en feilaktig lagring kl. 3:30 UTC overskrive alt som ble skrevet til den nøkkelen siden 3:00, fordi den havner i den samme timesversjonen.
Vanlige feil og løsninger
Feil fra data stores dukker opp i vinduet Output i Studio, og modulen skriver en advarsel med feilteksten fra Roblox ved hvert mislykket forsøk. Guiden til skriptfeil forklarer hvordan du leser Output generelt.
StudioAccessToApisNotAllowed (feil 403)
«Can't write to DataStore from Studio because API access is not enabled.» Publiser placet, og slå så på Enable Studio Access to API Services i File > Experience Settings > Security, i testkopien.
DataStore request was added to queue
Serveren sender forespørsler raskere enn budsjettet tillater, eller skriver én nøkkel for ofte, som regel på grunn av lagring ved hver endring eller i en løkke. Når køen har 30 forespørsler, feiler nye med feil 301-306. Hold dataene i minnet og lagre på en tidtaker.
CantStoreValue (feil 104), eller et felt kommer tilbake som nil
Tabellen inneholder noe data store ikke kan lagre, for eksempel Instance, Vector3 eller Color3. Lagre i stedet et navn, en ID eller enkle tall, og bygg objektet opp igjen ved innlasting.
ValueTooLarge (feil 105)
Én nøkkel inneholder mer enn 4 194 304 tegn JSON. Mål med #HttpService:JSONEncode(data), fjern det som kan bygges opp igjen, eller del dataene på flere faste nøkler.
Ingen feil, men dataene lagres ikke
Se etter advarselen Could not load fra modulen: etter en mislykket innlasting nekter den med vilje å lagre. Ellers ble verdien mest sannsynlig endret i et LocalScript, og det når aldri serveren, eller et annet skript lagrer den samme nøkkelen.
Dataene nullstilles hver gang jeg kommer inn igjen
Nøkkelen endres mellom økter (bygd fra player.Name, eller du endret STORE_NAME), innlastingen mislykkes og du ser standardverdiene, eller ingen henter inn modulen, så den kjører ikke i det hele tatt. Sjekk Output og at Main henter inn PlayerData.
Bygg det med RoCode
Hvis du ikke har lyst til å bygge dette for hånd, kan RoCode gjøre det rett i placet du har åpent. Det er en uavhengig AI-agent, ikke fra Roblox, som jobber via en plugin for Roblox Studio: den skriver Luau som bruker DataStoreService som ethvert skript, og lager skriptene i Explorer. Selv går den aldri inn i dine data stores, men med plugin 3.9 eller nyere kan den trykke på Play for en kort playtest der skriptene dine kjører som i enhver test.
Legg til lagring i spillet mitt: lagre Coins, Level og Inventory i en PlayerData-modul med autolagring og lagring når serveren slås av, og vis Coins i leaderstats som jeg allerede har.
- Kan søke etter eksisterende leaderstats og DataStore-kode med Search Scripts og Read Script for å utvide det du har, i stedet for å legge til et nytt lagringsskript. I et stort place kan du nevne skriptet eller mappen i meldingen.
- Lager ModuleScript-et og et Script som henter det inn med Create Script, eller endrer eksisterende med Edit Script
- Kjører Check Script for hvert skript den skriver: en kompileringssjekk inne i Studio med en kort liste over advarsler, ikke en typesjekk og ikke en testkjøring
- Sender endringene i runder, og hver runde er et angrepunkt (undo) i Studio
Å slå på Studio Access to API Services i testkopien må du fortsatt gjøre selv: RoCode kan ikke endre den innstillingen. Med plugin 3.9 eller nyere leser den korte playtesten feil, og med plugin 3.9.11 eller nyere kan den styre en testkarakter for å sjekke at spillet virker, men den sjekker bare det den selv har valgt å sjekke, så spill selv og forsikre deg om at Coins, Level og Inventory lagres og lastes inn. Hvis lagringen ikke gikk gjennom i testen din, kan Check Output lese Server-linjene fra playtesten du startet. Lagring legges vanligvis til når den grunnleggende spilløkken allerede virker; lage et Roblox-spill med AI, ett system om gangen viser den rekkefølgen. Slik kobler RoCode seg til Studio.
Ofte stilte spørsmål
Hvordan slår jeg på DataStore i Roblox Studio?
Publiser placet, åpne File > Experience Settings > Security, slå på Enable Studio Access to API Services og klikk på Save. Gjør det i et eget testspill, fordi Studio da bruker de samme data stores som de ekte serverne til det spillet.
Lagrer Roblox spillerdata automatisk?
Nei. Ingenting om en spiller lagres etter økten hvis et serverskript ikke lagrer det med DataStoreService, og det gjelder leaderstats også.
Hva skal jeg velge: ProfileStore eller DataStoreService direkte?
ProfileStore er også bygd på data stores, så spørsmålet er om du vil at øktlåsen skal skrives og vedlikeholdes for deg. For bytte, betalte gjenstander eller hyppige teleporter er låsen verdt det, fra et bibliotek eller fra referanseeksemplet til Roblox. For et mindre spill er en modul som denne enklere å lese og endre.
Hvordan nullstiller eller sletter jeg dataene til en spiller?
Finn nøkkelen i Data Stores Manager og velg Mark for Deletion, som kan angres i løpet av venteperioden, eller kall RemoveAsync for nøkkelen fra et serverskript. Gjør det mens spilleren ikke er pålogget, ellers skriver neste lagring fra serveren hans dataene tilbake. I testkopien starter alle fra null hvis du endrer STORE_NAME; gjør aldri det i det ekte spillet.
Kilder og videre lesing
- Roblox Creator Docs: Data stores (på engelsk). Studio-tilgang, GetAsync, SetAsync, UpdateAsync, set og update
- Roblox Creator Docs: Best practices for data stores (på engelsk). én nøkkel per spiller, data i minnet, nye forsøk med økende pause, tredjepartsmoduler
- Roblox Creator Docs: Data store error codes and limits (på engelsk). feilkoder, grenser for forespørsler per server og spill, grenser for størrelse, gjennomstrømning og lagringsplass
- Roblox Creator Docs: Versioning, listing and caching (på engelsk). versjoner per time, øyeblikksbilder, cache på 4 sekunder, hva som kan lagres
- Roblox Creator Docs: Implement player data and purchasing systems (på engelsk). referanseeksempel, øktlås, mislykkede innlastinger, autolagring hvert 180. sekund
- Roblox Creator Docs: Data Stores Manager (på engelsk). se nøkler, rulle tilbake versjoner, slette data
- Roblox Engine API: DataModel:BindToClose (på engelsk). 30 sekunder ved avslutning
Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.