Röviden
Használd a DataStoreService-t egy szerveroldali Scriptből: töltsd be a játékos adatait GetAsync-kel, amikor belép, tartsd egy táblában, amíg játszik, és mentsd UpdateAsync-kel időzítve, kilépéskor (PlayerRemoving) és a szerver leállásakor (game:BindToClose). Minden hívást csomagolj pcall-ba, és a sikerteleneket próbáld újra néhányszor.
- A Studióban való teszteléshez publikáld a place-t, és kapcsold be a File > Experience Settings > Security > Enable Studio Access to API Services beállítást egy külön tesztjátékban: a Studio ugyanazokat az adatokat használja, mint az élő szerverek.
- Ha egy játékos adatai nem töltődtek be, soha ne mentsd azt a játékost. Az alapértékek mentése felülírja a valódi előrehaladását.
- Játékosonként egy táblát tárolj egy kulcs alatt, például
User_12345, és időzítve ments, ne minden változáskor. - Tárgycseréhez vagy fizetős tárgyakhoz adj hozzá munkamenet-zárolást, hogy két szerver ne menthesse ugyanazt a játékost.
Ezen az oldalon
- Studio hozzáférés
- Hogyan működik a DataStore
- GetAsync és UpdateAsync
- 1. PlayerData modul
- Hogyan épül fel a modul
- 2. Munka az adatokkal
- 3. Figyelmeztetés
- 4. Teszt a Studióban
- Miért vesznek el az adatok
- Munkamenet-zárolás
- Korlátok
- Verziók és mentések
- Common errors
- With RoCode
- Gyakori kérdések
- Források és további olvasnivaló
Mielőtt elkezded: kapcsold be a Studio hozzáférést egy tesztmásolatban
A Studióban futó játék nem fér hozzá az adattárakhoz, amíg ezt nem engedélyezed. Az engedélynek van egy csapdája, amelyre a Roblox dokumentációja figyelmeztet: a Studio ekkor ugyanazokat az adattárakat olvassa és írja, mint az élő játék, ezért egy teszt, amely a Studióban lenullázza az érméidet, az élő játékban is lenullázza őket, egy hiba a tesztkódban pedig elronthatja valódi játékosok kulcsait.
- Készíts tesztmásolatot. Mentsd a place-t fájlba, nyisd meg a másolatot, válaszd a File > Publish to Roblox As menüpontot, és kattints a Create new game gombra. Ne add hozzá place-ként az élő játékon belül: egy játék összes place-e ugyanazokon az adattárakon osztozik.
- A tesztmásolatban nyisd meg a File > Experience Settings ablakot, és lépj a Security részre.
- Kapcsold be az Enable Studio Access to API Services beállítást, és kattints a Save gombra.
Az adattár-hívások csak szerveroldali Script-ekben működnek; az a LocalScript, amely megpróbálja, hibát kap, így a kliensek nem írhatnak mentett adatokat. Ha egy gombnak módosítania kell őket, a kliens RemoteEventen keresztül kéri meg a szervert, és a szerver dönt (lásd a RemoteEvents útmutatót, angolul).
Hogyan tárolják az adattárak a játékosadatokat
Az adattár (data store) kulcs-érték párok elnevezett gyűjteménye a Roblox szerverein, amely közös a játékod összes szervere és összes place-e között. A DataStoreService:GetDataStore("PlayerData") egy ilyen tárat ad vissza.
A Roblox ajánlásai egy szabályra futnak ki: egy tár a játékosadatoknak, játékosonként egy kulcs, minden kulcsban egy tábla. A kulcsot a játékos UserId-jéből állítsd össze, például User_12345, és soha ne a nevéből, amelyet megváltoztathat. Az állandó User_{UserId} minta azt is lehetővé teszi, hogy a Roblox automatikus, az elfeledtetéshez való jogot kezelő folyamata megtalálja a játékos adatait, ha beállítod.
| Típus | Menthető? | Megjegyzések |
|---|---|---|
| Számok, stringek, logikai értékek, bufferek | Igen | A stringeknek érvényes UTF-8-nak kell lenniük. Ne tárolj inf vagy nan értéket. |
| Táblák | Igen | Ha minden, ami bennük van, szintén menthető. Az a tábla, amelynek numerikus kulcsai nem 1-gyel kezdődnek (ezért a hossza 0), ezekkel a kulcsokkal stringként tér vissza. |
Instance, Vector3, CFrame, Color3 | Nem | A mentés hibát ad vagy nil-t ír. Mentsd a tárgy nevét, vagy a pozíciót három számként. |
Minden kérés egy webes hívás, amely meghiúsulhat, időbe telik, és a percenkénti keretből fogy. Ezért a megbízható mentőrendszerek egyszer olvassák be az adatokat, amikor a játékos belép, egy szerveroldali táblában tartják őket, amíg játszik, és időnként visszaírják.
GetAsync, SetAsync vagy UpdateAsync: melyiket válaszd
| Metódus | Mit csinál | Mire való |
|---|---|---|
GetAsync(key) | Kiolvassa az értéket. Az eredményt ez a szerver 4 másodpercig gyorsítótárazza. | A játékosadatok betöltése |
SetAsync(key, value) | Felülírja az értéket anélkül, hogy kiolvasná. Egy írás. | Új kulcs, vagy olyan érték, amely nem függ a régitől |
UpdateAsync(key, callback) | Kiolvassa a legutóbbi értéket, átadja a függvényednek, és azt írja vissza, amit a függvény visszaad. Egy olvasás és egy írás. | A játékosadatok mentése, és minden kulcs, amelyet több szerver is írhat |
IncrementAsync(key, delta) | Egy egész számot ad hozzá egy mentett egész számhoz. | Számlálók |
RemoveAsync(key) | Törli a kulcsot, és visszaadja a régi értéket. A korábbi verziók továbbra is listázhatók és olvashatók. | Játékosadatok törlése |
A SetAsync vakon ír: ha két szerver majdnem egyszerre menti ugyanazt a kulcsot, az utolsó írás nyer, bármi is van benne. Az UpdateAsync előbb kiolvassa az aktuális értéket, és ha közben egy másik szerver ír, a Roblox újra lefuttatja a függvényedet az új értékkel. A Roblox mindig ezt ajánlja, ha az írás az aktuális értéktől függ, vagy ha a kulcsot több szerver is írhatja, és a játékosadatok pontosan ilyenek. A függvényre három szabály vonatkozik:
- Nem adhatja át a végrehajtást (yield): semmi
task.wait()és semmilyen más adattár-hívás benne. - Többször is lefuthat, ezért csak az új értéket számolhatja ki, és soha nem adhat ki tárgyakat, és nem indíthat eseményeket.
- A
nilvisszaadása megszakítja az írást. A modul ezt használja, hogy ne írja felül a játék egy újabb verziója által mentett adatokat.
1. lépés: hozd létre a PlayerData modult
Ez a ModuleScript az egyetlen kód, amely az adattárral kommunikál. Belépéskor betölti a játékos adatait, a memóriában tartja őket, 180 másodpercenként, kilépéskor és a szerver leállásakor ment, és nem hajlandó menteni azokat, akiknek az adatai nem töltődtek be.
- Az Explorerben vidd az egeret a ServerScriptService fölé, kattints a + gombra, és szúrj be egy ModuleScript-et. Nevezd át
PlayerData-ra, és cseréld le a tartalmát az alábbi kódra. - A ModuleScript csak akkor fut le, amikor egy másik script betölti (require). Szúrj be a ServerScriptService-be egy
Mainnevű Script-et ezzel a sorral:local PlayerData = require(game:GetService("ServerScriptService").PlayerData). A többi szerverscript ugyanígy tölti be. - Igazítsd a
DEFAULTStáblát és aDatatípust a játékodhoz úgy, hogy minden mező szám, string, logikai érték vagy tábla maradjon.
ServerScriptService
PlayerData ModuleScript new
Main Script new
StarterPlayer
StarterPlayerScripts
DataWarning LocalScript new
-- PlayerData: belépéskor betölti a játékos adatait, a memóriában tartja őket,
-- és időzítve, kilépéskor és a szerver leállásakor elmenti.
-- A többi szerverscript a PlayerData.Get(player) segítségével olvassa és módosítja őket.
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- emeld, amikor az adatok formája változik, és adj hozzá egy lépést a migrate()-hez
local AUTOSAVE_SECONDS = 180
-- A Studióban a sikertelen hívás azonnal feladja, így a tárhozzáférés nélküli teszt gyors
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- minden hiba után duplázódik: 1, 2, 4
export type Data = {
SchemaVersion: number,
Coins: number,
Level: number,
Inventory: { string },
}
-- Ezzel kezd egy teljesen új játékos
local DEFAULTS: { [string]: any } = {
Coins = 0,
Level = 1,
Inventory = {},
}
type Session = {
key: string,
userId: number,
data: Data,
canSave: boolean, -- false, ha a betöltés nem sikerült: az alapadatok nem írhatják felül a valódi előrehaladást
}
-- Minden alábbi pcall-on belül hívódik, így egy még nem publikált place
-- (tárhozzáférés nélkül) is betölti a játékosokat alapadatokkal
local function store(): DataStore
return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- a még folyamatban lévő mentések, kulcsonként
local loadedEvent = Instance.new("BindableEvent")
local PlayerData = {}
-- A játékossal sül el, amikor az adatai készen állnak. A táblát a PlayerData.Get(player)-rel kérd le:
-- a BindableEventen át küldött tábla másolatként érkezik, és a módosítása semmit sem változtat.
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) -- friss másolat, hogy a játékosok soha ne osztozzanak egy Inventory táblán
data.SchemaVersion = SCHEMA_VERSION
return data
end
-- A mentett adatokat az aktuális sémára hozza. nil-t ad vissza, ha nem használhatók biztonságosan.
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 -- a játék egy újabb verziója mentette: itt ne töltsd be és ne írd felül
end
-- Sémaváltozásonként egy lépés, a régiektől az újak felé
if version < 2 then
-- Példa: az 1-es verzióban a pénznem neve Gold volt. Csak akkor másoljuk át, ha nincs Coins,
-- hogy azok a régi adatok, amelyekben már van Coins, de nincs SchemaVersion, megtartsák az értéküket.
if saved.Coins == nil then
saved.Coins = saved.Gold
end
saved.Gold = nil
end
-- Hozzáadjuk a játékos utolsó mentése óta megjelent mezőket, és lecseréljük a rossz típusú értékeket
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
-- pcall-ban futtat egy adattár-hívást. Hiba esetén vár és újra próbálja, a várakozást minden alkalommal
-- megduplázza, és egy kis véletlent ad hozzá, hogy a szerverek ne egyszerre próbálkozzanak újra.
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 -- a nil visszaadása megszakítja az írást
end
-- A teljes aktuális táblát írjuk, a játékos UserId-jével megjelölve
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()
-- Az intervallum egy véletlen pontján kezdünk, hogy a szerverek ne egyszerre mentsenek
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
-- Ha a játékos épp most lépett ki erről a szerverről és visszajött, előbb hagyjuk befejeződni az utolsó mentést
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 -- betöltés közben kilépett: semmi sem változott, nincs mit menteni
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) -- a GUI kiolvashatja ezt, és figyelmeztetheti a játékost
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 -- leállítja az automentés ciklusát, és egy újabb hívás nem csinál semmit
save(session)
end
-- A játékos élő adattáblája, vagy nil, amíg be nem töltődött. Csak szerverscriptekből módosítsd.
function PlayerData.Get(player: Player): Data?
local session = sessions[player]
return if session then session.data else nil
end
-- True, ha a játékos adatai betöltődtek és menteni fogjuk őket. Minden eladás előtt ellenőrizd.
function PlayerData.CanSave(player: Player): boolean
local session = sessions[player]
return session ~= nil and session.canSave
end
-- Most ment, az időzítőt meg nem várva, fontos pillanatokban, például vásárláskor.
-- Átadja a végrehajtást, és true-t ad vissza, ha a mentés sikerült.
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) -- azok a játékosok, akik a modul első betöltése előtt léptek be
end
game:BindToClose(function()
-- A szerver 30 másodpercet ad ezeknek a függvényeknek, ezért mindenkit egyszerre mentünk
for player in sessions do
task.spawn(endSession, player)
end
-- Aztán megvárjuk az összes még futó mentést, a PlayerRemovingban indítottakat is
while next(pendingSaves) do
task.wait()
end
end)
return PlayerData
Ha a játék már megjelent, ne változtasd meg a STORE_NAME értékét és a User_ kulcsmintát. Bármelyik megváltoztatása üres kulcsokra irányítja a modult, és minden játékos elölről kezd az alapértékekkel.
Hogyan vigyáz a modul az adatokra
Alapértékek és sémaverzió
Az új játékos a DEFAULTS egy friss másolatát kapja. Ennek tényleg másolatnak kell lennie: ha minden játékos egy Inventory táblán osztozna, az egyiküknek adott tárgy mindenkinél megjelenne.
Minden mentett tábla tartalmaz egy SchemaVersion mezőt. Egy mező hozzáadásához nem kell új verzió, mert a migrate az alapértékekből tölti ki a hiányzó mezőket. Átnevezéshez vagy átszervezéshez kell: emeld a SCHEMA_VERSION értékét, és adj hozzá egy lépést, mint a példában, amely a Gold mezőt Coins-ra nevezi át (egy új játékban töröld, és kezdj 1-ről). A szerverénél magasabb verziójú adatok egy újabb kiadástól származnak, amely még élesedik, ezért a régi szerverek nem nyúlnak hozzájuk.
A sikertelen betöltést soha nem mentjük
Ez a szabály véd a teljes törléstől. Ha minden betöltési kísérlet meghiúsult, a játékos alapadatokon játszik, de a canSave értéke false, így ezek az értékek soha nem írják felül a valódi előrehaladását. A modul a DataLoaded attribútumot is false-ra állítja, és a 3. lépés ezt használja, hogy szóljon a játékosnak. A Roblox referenciapéldája ugyanígy kezeli a sikertelen betöltéseket, és ezt javasolja a kirúgás helyett; ha inkább kirúgnád, hívd meg a player:Kick()-et egy üzenettel ott, ahol a modul a figyelmeztetést kiírja.
Újrapróbálás növekvő szünettel
A withRetries minden hívást pcall-ba csomagol. Hiba után 1, aztán 2, aztán 4 másodpercet vár, minden alkalommal plusz véletlenszerűen legfeljebb ennek az időnek a felét, és négy kísérlet után megáll (a Studióban egy után, hogy a tárhozzáférés nélküli place azonnal elinduljon). A véletlen széthúzza sok szerver újrapróbálásait egy kiesés után, a korlát pedig nagyjából 10 másodpercen belül tartja a várakozást, azon a 30 másodpercen belül, amelyet a szerver a leállásra kap. Mivel minden mentés a teljes élő táblát írja UpdateAsync-kel, egy késve befejeződő újrapróbálás nem hozhat vissza régi adatokat.
Mikor ment a modul
| Mikor | Miért |
|---|---|
| 180 másodpercenként, amíg a játékos a szerveren van | Korlátozza a veszteséget egy összeomláskor. Az első mentés az intervallum egy véletlen pontjára esik, hogy a szerverek ne egyszerre mentsenek. A Roblox referenciapéldája is 180 másodpercet használ. |
Amikor a játékos kilép (PlayerRemoving) | A szokásos végső mentés. Előbb a munkamenet törlődik, így az automentés leáll. |
Amikor a szerver leáll (game:BindToClose) | Mindenki, aki még a szerveren van, egyszerre mentődik, és a függvény minden folyamatban lévő mentést megvár. A Roblox 30 másodpercet ad neki. |
Kérésre, a PlayerData.SaveNow(player) segítségével | Valami után, amit nem szabad elveszíteni, például vásárlás után. |
Ha a játékos újra belép ugyanarra a szerverre, miközben a végső mentése még folyamatban van, az új betöltés megvárja ennek a mentésnek a végét, így nem olvashat régi értéket.
2. lépés: olvasd és módosítsd az adatokat más scriptekből
Minden szerverscript, amely betölti a modult, ugyanazokkal a táblákkal dolgozik:
| Hívás | Mit csinál |
|---|---|
PlayerData.Get(player) | A játékos élő adattáblája, vagy nil, amíg be nem töltődött. A mezőket közvetlenül módosítsd, például data.Coins += 10, és a következő mentés ezt átveszi. |
PlayerData.Loaded | A játékossal sül el, amikor az adatai készen állnak, sikertelen betöltés után is. Csak a játékost adja át, mert a BindableEventen át küldött tábla másolatként érkezik. |
PlayerData.CanSave(player) | false, ha a betöltés nem sikerült. Minden eladás előtt ellenőrizd: az a vásárlás, amelyet nem lehet menteni, elvész, amikor a játékos kilép. |
PlayerData.SaveNow(player) | Azonnal ment, és true-t ad vissza, ha sikerült. Átadja a végrehajtást. |
A modul az egyetlen hely, ahol a mentett adatok élnek, a leaderstats csak megjelenítés: rakd össze úgy, mint a ranglista útmutatóban, töltsd fel a PlayerData.Get(player) adataival a Loaded kezelőjében, és egy érték változásakor frissítsd mindkettőt. Soha ne olvasd vissza a mentett értékeket a leaderstatsból, és soha ne engedd, hogy egy második script ugyanazt a kulcsot mentse.
Az a script, amely azután tölti be a modult, hogy a játékosok beléptek, lemarad a Loaded eseményükről. Kösd be a kezelőt, aztán menj végig egy ciklussal a Players:GetPlayers() listán is, és kezeld le mindazokat, akiknél a PlayerData.Get(player) már táblát ad vissza.
Egy régi mentőscriptet cserélsz le, például a ranglista útmutatóból valót? Annak értékei a saját tárában és kulcsában maradnak, ezért ez a modul mindenkit az alapértékekkel indít. Indulás előtt vagy irányítsd a STORE_NAME értékét és a User_ előtagot a régiekre (a migrate az SchemaVersion nélküli adatokat 1-es verziónak tekinti, és kitölti a hiányzó mezőket), vagy vidd át a régi értékeket, aztán töröld a régi scriptet.
A kliensek soha nem módosítják közvetlenül ezeket az adatokat. A bolt gombja egy RemoteEventet indít; a szerver ellenőrzi a CanSave-et, összeveti az árat a játékos Coins értékével, módosítja a táblát, és meghívja a SaveNow-t. A bolt GUI útmutató egy ilyen szerveroldali vásárlást épít fel.
Kész példát a mezők hozzáadására a clicker szimulátor útmutatóban találsz: hozzáadja a PowerLevel és a Rebirths mezőt a DEFAULTS táblához és a Data típushoz, aztán módosítja őket abban a táblában, amelyet a PlayerData.Get visszaad. A migrate a régi mentésű játékosoknak is megadja az új mezőket.
3. lépés: szólj a játékosnak, hogy az adatai nem töltődtek be
Annak a játékosnak, akinek az adatai nem töltődtek be, tudnia kell, hogy ez a munkamenet nem mentődik, hogy újra belépjen, és ne játsszon hiába. Ez a LocalScript figyeli a DataLoaded attribútumot, és sávot jelenít meg, ha az értéke 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
-- A szerver egyszer állítja be a DataLoaded értékét, miután megpróbálta betölteni ennek a játékosnak az adatait
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()
4. lépés: teszteld a mentést a Studióban
Ezt a bekapcsolt Studio hozzáférésű tesztmásolatban csináld.
- Adj magadnak valamit, amit menteni lehet. A
Mainrequire sora alá írd be:PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end) - Kattints a Play gombra. Az Output ablak (a Window menüben vagy a Script fülön) a nevedet és 100-at mutat (első futtatáskor),
Could not loadfigyelmeztetés nélkül. - Kattints a Stop gombra. A teszt befejezése bezárja a szervert, és a modul bezárás előtt elment téged.
- Kattints újra a Play gombra. Az Outputnak 200-at kell mutatnia, 100-zal többet, mint legutóbb. Ha megint ugyanazt a számot mutatja, a mentés nem sikerült: olvasd el a fölötte lévő figyelmeztetéseket.
- Teszteld a hibás utat. Kapcsold ki a Studio hozzáférést, és kattints a Play gombra. Néhány másodpercnyi újrapróbálás után az Output a
Could not load User_...szöveget és 100-at mutat, és megjelenik a 3. lépés sávja. Állítsd le a tesztet, kapcsold vissza a hozzáférést, és kattints a Play gombra: az Output 300-at mutat, a mentett 200-at plusz 100-at, mert a sikertelen munkamenet soha nem írta felül az adataidat. - Töröld a tesztsort a
Mainscriptből.
Miért vesznek el a játékosadatok
Ezek a szokásos módok, ahogy egy mentőrendszer elveszíti az előrehaladást. A modul a kódban lezárja az első négy sort és a sémáról szóló sort; a többi attól függ, mit és hogyan tárolsz, az utolsóhoz pedig munkamenet-zárolás kell.
| Mi történik | Eredmény | Hogyan előzd meg |
|---|---|---|
| A betöltés nem sikerült, a script mégis ment | Az alapértékek felülírják a valódi előrehaladást: teljes törlés | Soha ne mentsd azt a játékost, akinek a betöltése nem sikerült |
Mentés csak a PlayerRemoving-ban | Egy összeomlás vagy a szerver leállása kihagyja a mentést | Automentés, plusz BindToClose, amely megvárja a saját mentéseit |
Nincs pcall vagy nincs újrapróbálás | Egyetlen sikertelen kérés leállítja a scriptet, vagy elveszít egy mentést | pcall néhány időben széthúzott újrapróbálással |
| Mentés minden változáskor | A kérések sorba állnak; ha 30 van a sorban, az újakat eldobja | Tartsd az adatokat a memóriában, és időzítve ments |
| Olyasmi mentése, amit a tár nem tud tárolni | A mentés hibát ad, vagy az érték nil-ként tér vissza | Számokat, stringeket, logikai értékeket és ezekből álló táblákat ments |
| Az adatok formájának megváltoztatása migráció nélkül | A régi mentések rossz mezőkbe töltődnek | Sémaverzió és migrációs lépés |
| Két script menti ugyanazt a kulcsot | Mindegyik mentés felülírja a másik mezőit | A kulcs egyetlen modulé |
| Két szerver tartja ugyanazt a játékost | A régi adatokkal rendelkező szerver ment utoljára, és felülírja az új előrehaladást | Munkamenet-zárolás |
Munkamenet-zárolás, „lock lost” és ProfileStore
A játékos egyszerre egy szerverhez kapcsolódik, de a régi szerver végső mentése még folyamatban lehet, amikor belép egy újra: lassú újrapróbálás, teleport vagy gyors újracsatlakozás. Ha az új szerver tölti be először az adatokat, régi adatai lesznek, és az a szerver nyer, amelyik utoljára ment. A Roblox dokumentációja megjegyzi, hogy a cserét tartalmazó játékokban ez a rés gyakori oka a tárgyak megduplázódásának.
A munkamenet-zárolás lezárja ezt a rést. Amikor egy szerver betölti egy játékos kulcsát, ugyanabban az UpdateAsync hívásban beírja a zárolási azonosítóját a kulcs metaadataiba. Minden más szerver, amely olyan le nem járt zárat talál, amelyet nem ő tett rá, nem tölti be és nem menti ezt a kulcsot. A tulajdonos minden automentéskor megújítja a zárat, és a végső mentéskor feloldja; ha abbahagyja a megújítást, a zár lejár, és egy másik szerver átveheti.
Mit jelent a „lock lost”
Egy munkamenet-zárolást használó rendszerben a szerver elvesztette a zárat, ha a játékos kulcsa most egy másik szerveré, mert a zár lejárt vagy átvették. A másolata elavult lehet, ezért abba kell hagynia ennek a játékosnak a mentését; a szokásos reakció: kirúgni egy üzenettel, hogy csatlakozzon újra. Ha játékosként láttad a „lock lost” üzenetet, az az adott játék saját mentőrendszerének üzenete, és csak a játék fejlesztői tudják megmagyarázni.
Szükséged van rá?
Az útmutató modulja nem zárolja a munkameneteket. Zárolás nélkül a valós legrosszabb eset ez: egy ritka versenyhelyzetben a játékos elveszíti, amit a régi szerveren annak utolsó sikeres mentése után szerzett. Akkor adj hozzá zárolást, ha a duplázódás vagy a veszteség valami valódiba kerül a játékosoknak: csere, developer productok, ritka tárgyak vagy gyakori teleportok.
| Lehetőség | Mi ez | Amit érdemes tudni |
|---|---|---|
| Az útmutató modulja | Betöltés, memóriabeli gyorsítótár, újrapróbálás, automentés, mentés leálláskor és sémaverziók, zárolás nélkül | Elég rövid ahhoz, hogy végigolvasd és módosítsd |
| A Roblox példája játékosadatokhoz és vásárlásokhoz | Referenciakód a Robloxtól munkamenet-zárolással, kulcsonként sorrendben végzett újrapróbálással és a vásárlási nyugták kezelésével | A Roblox szerint nincs kipróbálva egy népszerű játékban, és alapos tesztelés nélkül nem szabad változatlanul használni |
| ProfileStore | Ingyenes, nyílt forráskódú közösségi modul, a ProfileService utódja, a munkamenet-zárolás és az automentés köré építve | Nem a Robloxtól. Egy meglévő játék átállítása a már mentett adatok migrálását igényli |
Bármilyen külső modulnál a Roblox azt tanácsolja, hogy nézd meg, ki a tulajdonosa, karbantartják-e, és hogyan férsz hozzá az adataidhoz nélküle. Ugyanez a dokumentáció a DataStore2-t elavult könyvtárnak nevezi, amelyet új játékoknak nem érdemes használniuk.
Az adattárak korlátai
Ezek a Roblox dokumentációjában szereplő korlátok 2026. szeptember 30-i állapot szerint. A Roblox felülvizsgálja őket, ezért nézd meg a hibakódok és korlátok oldalát (angolul), mielőtt egy pontos számra építenél.
| Kéréstípus | Normál tárak | Rendezett tárak |
|---|---|---|
Olvasás: GetAsync, olvasás az UpdateAsync-ben | 60 + 40 × játékos | 60 + 40 × játékos |
Írás: SetAsync, IncrementAsync, írás az UpdateAsync-ben | 60 + 40 × játékos | 30 + 5 × játékos |
Listázás: ListKeysAsync, vagy GetSortedAsync rendezett tárakhoz | 5 + 2 × játékos | 5 + 2 × játékos |
Törlés: RemoveAsync | 60 + 40 × játékos | 30 + 5 × játékos |
20 játékosnál a szerver percenként 860 normál írást végezhet; ennek a modulnak az automentése ebből körülbelül 7-et használ, plusz egyet minden kilépő játékosra. A keretet az meríti ki, ha minden felvett érménél mentesz. Egy második keret az egész játékra vonatkozik, és az Open Clouddal közös: percenként 300 olvasás plusz 40 minden online játékosra, és 300 írás plusz 20 játékosonként.
| Korlát | Érték |
|---|---|
| Tár neve, kulcs neve, scope | Egyenként 50 karakter |
| Érték egy kulcsban | 4 194 304 karakter JSON formában |
| Egy kulcs olvasása az összes szerverről | Percenként 25 MB |
| Írás egy kulcsba az összes szerverről | Percenként 4 MB, minden kérés a következő KB-ra kerekítve felfelé |
| Függő kérések | Soronként 30; ezen felül a kérések 301-306-os hibákkal meghiúsulnak |
| Tárhely az egész játékra | 500 MB plusz 1 MB minden valaha volt felhasználóra |
A játékosadatok méretét a #HttpService:JSONEncode(data) segítségével mérd, az élő szerver hátralévő keretét pedig a DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite) segítségével nézd meg. Azok a GetAsync hívások, amelyekre a 4 másodperces gyorsítótár válaszolt, nem számítanak. A Studio Run módjának saját, esetleg alacsonyabb korlátai vannak, ezért a kéréskorlátok teszteléséhez a Roblox a Team Create-et ajánlja.
Verziók és biztonsági mentések
A normál adattárak megőrzik helyetted az előzményeket. Egy kulcsba UTC szerint minden órában az első írás verzióként mentődik, az abban az órában következő írások pedig egymást írják felül. Egy régi verzió 30 nappal azután jár le, hogy egy újabb írás leváltotta; a legutolsó soha nem jár le. A rendezett tárak nem őriznek verziókat.
Egy játékos visszaállításához nyisd meg a Data Stores Manager felületet (Creations, a játékod, Configure > Data Stores Manager), válaszd ki a kulcsát, válassz egy korábbi verziót, és kattints a Revert gombra; ehhez Edit jogosultság kell. Akkor csináld, amikor a játékos nincs online, különben a munkamenetét tartó szerver a visszaállítás fölé menti a saját másolatát. Szerverscriptből a ListVersionsAsync és a GetVersionAsync megkeresi és kiolvassa a régi verziót, amelyet aztán aktuális értékként visszaírsz.
Mielőtt publikálnál egy frissítést, amely megváltoztatja az adatok mentésének módját, a Roblox azt tanácsolja, hogy készíts pillanatképet az Open Cloud Snapshot Data Stores API-val (játékonként naponta egyet). Enélkül egy hibás mentés 3:30 UTC-kor felülír mindent, amit 3:00 óta abba a kulcsba írtak, mert ugyanabba az órás verzióba kerül.
Gyakori hibák és megoldásaik
Az adattár-hibák a Studio Output ablakában jelennek meg, a modul pedig minden sikertelen kísérletnél kiír egy figyelmeztetést a Roblox hibaszövegével. A scripthibák útmutató elmagyarázza, hogyan kell egyáltalán olvasni az Outputot.
StudioAccessToApisNotAllowed (403-as hiba)
„Can't write to DataStore from Studio because API access is not enabled.” Publikáld a place-t, aztán kapcsold be az Enable Studio Access to API Services beállítást a File > Experience Settings > Security alatt, a tesztmásolatban.
DataStore request was added to queue
A szerver gyorsabban küldi a kéréseket, mint amit a kerete enged, vagy túl gyakran írja ugyanazt a kulcsot, általában azért, mert minden változáskor vagy egy ciklusban ment. Ha 30 kérés van a sorban, az újak 301-306-os hibákkal meghiúsulnak. Tartsd az adatokat a memóriában, és időzítve ments.
CantStoreValue (104-es hiba), vagy egy mező nil-ként tér vissza
A táblában van valami, amit a tár nem tud menteni, például Instance, Vector3 vagy Color3. Helyette nevet, azonosítót vagy egyszerű számokat ments, és betöltéskor állítsd vissza az objektumot.
ValueTooLarge (105-ös hiba)
Egy kulcs több mint 4 194 304 karakternyi JSON-t tárol. Mérd meg a #HttpService:JSONEncode(data) segítségével, vedd ki, amit újra elő lehet állítani, vagy oszd szét az adatokat több állandó kulcs között.
Nincs hiba, mégsem mentődnek az adatok
Keresd a modul Could not load figyelmeztetését: sikertelen betöltés után szándékosan nem hajlandó menteni. Ha nem ez, akkor az értéket valószínűleg egy LocalScriptben módosították, ami soha nem jut el a szerverig, vagy ugyanazt a kulcsot egy másik script menti.
Az adatok minden újracsatlakozáskor lenullázódnak
A kulcs munkamenetenként változik (a player.Name-ből áll össze, vagy megváltoztattad a STORE_NAME értékét), a betöltés nem sikerül, és az alapértékeket látod, vagy senki sem tölti be a modult, így egyáltalán nem fut. Nézd meg az Outputot, és azt, hogy a Main betölti-e a PlayerData-t.
Építsd meg a RoCode-dal
Ha nincs kedved kézzel összerakni, a RoCode megcsinálhatja közvetlenül a nálad nyitott place-ben. Ez egy független AI-ügynök, nem a Robloxtól, amely egy Roblox Studio pluginon keresztül dolgozik: olyan Luau kódot ír, amely bármely scripthez hasonlóan a DataStoreService-t használja, és scripteket hoz létre az Explorerben. Ő maga soha nem fér hozzá az adattáraidhoz, de a 3.9-es vagy újabb pluginnal megnyomhatja a Play gombot egy rövid playtesthez, amelyben a scriptjeid úgy futnak, mint bármely tesztben.
Adj mentést a játékomhoz: tárold a Coins, Level és Inventory értékeket egy PlayerData modulban automentéssel és a szerver leállásakor végzett mentéssel, és mutasd a Coins értéket a már meglévő leaderstatsban.
- A Search Scripts és a Read Script segítségével megkeresheti a meglévő leaderstatsot és DataStore kódot, hogy azt bővítse, ami már megvan, és ne adjon hozzá egy második mentőscriptet. Egy nagy place-ben nevezd meg az üzenetben a scriptet vagy a mappát.
- A Create Script segítségével létrehozza a ModuleScriptet és az azt betöltő Scriptet, vagy az Edit Script segítségével módosítja a meglévőket
- Minden megírt scriptre lefuttatja a Check Scriptet: fordítási ellenőrzés a Studióban, rövid figyelmeztetéslistával, nem típusellenőrzés és nem tesztfuttatás
- A változtatásokat csomagokban küldi, és minden csomag egy visszavonási (undo) pont a Studióban
A Studio Access to API Services bekapcsolását a tesztmásolatban így is neked kell elvégezned: a RoCode nem tudja megváltoztatni ezt a beállítást. A 3.9-es vagy újabb pluginnal a rövid playtestje kiolvassa a hibákat, a 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, hogy ellenőrizze, működik-e a játék, de csak azt ellenőrzi, amit ő maga eldöntött, ezért játssz te is, és győződj meg róla, hogy a Coins, Level és Inventory mentődik és betöltődik. Ha a mentés a te tesztedben nem sikerült, a Check Output kiolvashatja a Server sorokat az általad indított playtestből. A mentést általában akkor adják hozzá, amikor a fő játékciklus már működik; a Roblox játék készítése AI-val, egyszerre egy rendszerrel ezt a sorrendet mutatja be. Hogyan kapcsolódik a RoCode a Studióhoz.
Gyakori kérdések
Hogyan kapcsolom be a DataStore-t a Roblox Studióban?
Publikáld a place-t, nyisd meg a File > Experience Settings > Security részt, kapcsold be az Enable Studio Access to API Services beállítást, és kattints a Save gombra. Ezt egy külön tesztjátékban csináld, mert a Studio ekkor ugyanazokat az adattárakat használja, mint a játék élő szerverei.
Menti a Roblox automatikusan a játékos adatait?
Nem. A játékosról semmi sem marad meg a munkamenet után, ha egy szerverscript nem menti el a DataStoreService segítségével, és ez a leaderstatsra is igaz.
Mit válasszak: ProfileStore vagy közvetlenül DataStoreService?
A ProfileStore is adattárakra épül, így a kérdés az, hogy szeretnéd-e, hogy a munkamenet-zárolást más írja meg és tartsa karban helyetted. Cseréhez, fizetős tárgyakhoz vagy gyakori teleportokhoz megéri a zárolás, egy könyvtárból vagy a Roblox referenciapéldájából. Egy kisebb játékhoz egy ilyen modult könnyebb olvasni és módosítani.
Hogyan nullázom le vagy törlöm egy játékos adatait?
A Data Stores Managerben keresd meg a kulcsot, és válaszd a Mark for Deletion lehetőséget, amelyet a várakozási időn belül vissza lehet vonni, vagy hívd meg a RemoveAsync-et a kulcsra egy szerverscriptből. Akkor csináld, amikor a játékos nincs online, különben a szervere következő mentése visszaírja az adatokat. A tesztmásolatban a STORE_NAME megváltoztatása mindenkit nulláról indít; ezt soha ne csináld az élő játékban.
Források és további olvasnivaló
- Roblox Creator Docs: Data stores (angolul). Studio hozzáférés, GetAsync, SetAsync, UpdateAsync, set és update
- Roblox Creator Docs: Best practices for data stores (angolul). játékosonként egy kulcs, adatok a memóriában, újrapróbálás növekvő szünettel, külső modulok
- Roblox Creator Docs: Data store error codes and limits (angolul). hibakódok, szerver- és játékszintű kéréskorlátok, méret-, áteresztőképesség- és tárhelykorlátok
- Roblox Creator Docs: Versioning, listing and caching (angolul). órás verziók, pillanatképek, 4 másodperces gyorsítótár, mit lehet menteni
- Roblox Creator Docs: Implement player data and purchasing systems (angolul). referenciapélda, munkamenet-zárolás, sikertelen betöltések, automentés 180 másodpercenként
- Roblox Creator Docs: Data Stores Manager (angolul). kulcsok megtekintése, verziók visszaállítása, adatok törlése
- Roblox Engine API: DataModel:BindToClose (angolul). 30 másodperc a leállásra
Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.