สรุปสั้น ๆ
ใช้ DataStoreService จาก Script ฝั่งเซิร์ฟเวอร์: โหลดข้อมูลผู้เล่นด้วย GetAsync เมื่อเขาเข้าเกม เก็บไว้ในตารางขณะที่เขาเล่น และบันทึกด้วย UpdateAsync ตามตัวจับเวลา เมื่อเขาออก (PlayerRemoving) และเมื่อเซิร์ฟเวอร์ปิด (game:BindToClose) ห่อทุกการเรียกด้วย pcall และลองใหม่หลายครั้งเมื่อล้มเหลว
- ถ้าจะทดสอบใน Studio ให้เผยแพร่ place และเปิด File > Experience Settings > Security > Enable Studio Access to API Services ในเกมทดสอบแยกต่างหาก: Studio ใช้ข้อมูลเดียวกับเซิร์ฟเวอร์จริง
- ถ้าข้อมูลของผู้เล่นโหลดไม่สำเร็จ อย่าบันทึกผู้เล่นคนนั้นเด็ดขาด การบันทึกค่าเริ่มต้นจะเขียนทับความคืบหน้าจริงของเขา
- เก็บตารางเดียวต่อผู้เล่นภายใต้คีย์เดียว เช่น
User_12345และบันทึกตามตัวจับเวลา ไม่ใช่ทุกครั้งที่มีการเปลี่ยนแปลง - สำหรับการแลกเปลี่ยนไอเทมหรือไอเทมที่เสียเงิน ให้เพิ่ม session locking เพื่อให้เซิร์ฟเวอร์สองตัวบันทึกผู้เล่นคนเดียวกันไม่ได้
ในหน้านี้
ก่อนเริ่ม: เปิดสิทธิ์ Studio ในสำเนาทดสอบ
เกมที่รันใน Studio เข้าถึงที่เก็บข้อมูลไม่ได้ จนกว่าคุณจะอนุญาต การอนุญาตมีข้อควรระวังที่เอกสารของ Roblox เตือนไว้: จากนั้น Studio จะอ่านและเขียนที่เก็บข้อมูลเดียวกับเกมจริง การทดสอบที่รีเซ็ตเหรียญของคุณใน Studio จึงรีเซ็ตในเกมจริงด้วย และข้อผิดพลาดในโค้ดทดสอบอาจทำให้คีย์ของผู้เล่นจริงเสียหาย
- ทำสำเนาทดสอบ บันทึก place เป็นไฟล์ เปิดสำเนา เลือก File > Publish to Roblox As แล้วกด Create new game อย่าเพิ่มมันเป็น place ข้างในเกมจริง: ทุก place ในเกมเดียวกันใช้ที่เก็บข้อมูลร่วมกัน
- ในสำเนาทดสอบ เปิด File > Experience Settings แล้วไปที่ Security
- เปิด Enable Studio Access to API Services แล้วกด Save
การเรียกที่เก็บข้อมูลทำงานเฉพาะใน Script ฝั่งเซิร์ฟเวอร์ LocalScript ที่ลองจะได้ข้อผิดพลาด ไคลเอนต์จึงเขียนข้อมูลที่บันทึกไม่ได้ เมื่อปุ่มต้องเปลี่ยนข้อมูล ไคลเอนต์จะขอเซิร์ฟเวอร์ผ่าน RemoteEvent และเซิร์ฟเวอร์เป็นผู้ตัดสิน (ดูคู่มือ RemoteEvents ภาษาอังกฤษ)
ที่เก็บข้อมูลเก็บข้อมูลผู้เล่นอย่างไร
ที่เก็บข้อมูล (data store) คือชุดคีย์และค่าที่มีชื่อบนเซิร์ฟเวอร์ของ Roblox ใช้ร่วมกันในทุกเซิร์ฟเวอร์และทุก place ของเกมคุณ DataStoreService:GetDataStore("PlayerData") คืนที่เก็บหนึ่งชุดแบบนี้
คำแนะนำของ Roblox สรุปได้เป็นกฎ ที่เก็บเดียวสำหรับข้อมูลผู้เล่น หนึ่งคีย์ต่อผู้เล่น หนึ่งตารางในแต่ละคีย์ สร้างคีย์จาก UserId ของผู้เล่น เช่น User_12345 และไม่ใช้ชื่อที่เขาเปลี่ยนได้เด็ดขาด รูปแบบ User_{UserId} ที่คงที่ยังทำให้การจัดการสิทธิ์ที่จะถูกลืมแบบอัตโนมัติของ Roblox หาข้อมูลของผู้เล่นเจอได้ ถ้าคุณตั้งค่ามันไว้
| ชนิด | บันทึกได้ไหม? | หมายเหตุ |
|---|---|---|
| ตัวเลข สตริง บูลีน บัฟเฟอร์ | ได้ | สตริงต้องเป็น UTF-8 ที่ถูกต้อง อย่าเก็บ inf หรือ nan |
| ตาราง | ได้ | ถ้าทุกอย่างข้างในบันทึกได้ด้วย ตารางที่คีย์ตัวเลขไม่ได้เริ่มที่ 1 (ความยาวจึงเป็น 0) จะกลับมาพร้อมคีย์เหล่านั้นเป็นสตริง |
Instance, Vector3, CFrame, Color3 | ไม่ได้ | การบันทึกเกิดข้อผิดพลาดหรือเขียน nil ให้บันทึกชื่อไอเทม หรือตำแหน่งเป็นตัวเลขสามตัว |
ทุกคำขอเป็นการเรียกผ่านเว็บที่อาจล้มเหลว ใช้เวลา และใช้งบรายนาที ระบบบันทึกที่เชื่อถือได้จึงอ่านข้อมูลครั้งเดียวตอนผู้เล่นเข้าเกม เก็บไว้ในตารางฝั่งเซิร์ฟเวอร์ขณะที่เขาเล่น และเขียนกลับเป็นครั้งคราว
GetAsync, SetAsync หรือ UpdateAsync: เลือกอะไร
| เมธอด | หน้าที่ | ใช้ทำอะไร |
|---|---|---|
GetAsync(key) | อ่านค่า ผลลัพธ์ถูกแคชบนเซิร์ฟเวอร์นี้ 4 วินาที | โหลดข้อมูลผู้เล่น |
SetAsync(key, value) | เขียนทับค่าโดยไม่อ่าน เขียนหนึ่งครั้ง | คีย์ใหม่หรือค่าที่ไม่ขึ้นกับค่าเดิม |
UpdateAsync(key, callback) | อ่านค่าล่าสุด ส่งให้ฟังก์ชันของคุณ และเขียนสิ่งที่มันคืน อ่านหนึ่งครั้งและเขียนหนึ่งครั้ง | บันทึกข้อมูลผู้เล่น และคีย์ใดก็ตามที่หลายเซิร์ฟเวอร์อาจเขียน |
IncrementAsync(key, delta) | บวกจำนวนเต็มเข้ากับจำนวนเต็มที่บันทึกไว้ | ตัวนับ |
RemoveAsync(key) | ลบคีย์และคืนค่าเดิม เวอร์ชันก่อนหน้ายังแสดงรายการและอ่านได้ | ลบข้อมูลผู้เล่น |
SetAsync เขียนโดยไม่ดู: ถ้าสองเซิร์ฟเวอร์บันทึกคีย์เดียวกันเกือบพร้อมกัน การเขียนครั้งสุดท้ายชนะ ไม่ว่ามันจะมีอะไร UpdateAsync อ่านค่าปัจจุบันก่อน และถ้ามีเซิร์ฟเวอร์อื่นเขียนในระหว่างนั้น Roblox จะรันฟังก์ชันของคุณใหม่ด้วยค่าใหม่ Roblox แนะนำมันทุกครั้งที่การเขียนขึ้นกับค่าปัจจุบัน หรือคีย์อาจถูกเขียนจากหลายเซิร์ฟเวอร์ ซึ่งก็คือข้อมูลผู้เล่นพอดี ฟังก์ชันมีกฎสามข้อ:
- มันต้องไม่หยุดรอ (yield): ไม่มี
task.wait()และการเรียกที่เก็บข้อมูลอื่นข้างใน - มันอาจทำงานมากกว่าหนึ่งครั้ง จึงต้องแค่คำนวณค่าใหม่ ไม่ให้ไอเทมหรือเรียกอีเวนต์เด็ดขาด
- การคืนค่า
nilยกเลิกการเขียน โมดูลใช้สิ่งนี้เพื่อไม่ให้เขียนทับข้อมูลที่บันทึกโดยเกมเวอร์ชันใหม่กว่า
ขั้นตอนที่ 1: สร้างโมดูล PlayerData
ModuleScript นี้เป็นโค้ดเดียวที่คุยกับที่เก็บข้อมูล มันโหลดข้อมูลผู้เล่นตอนเข้าเกม เก็บไว้ในหน่วยความจำ บันทึกทุก 180 วินาที ตอนออก และตอนเซิร์ฟเวอร์ปิด และปฏิเสธการบันทึกคนที่ข้อมูลโหลดไม่สำเร็จ
- ใน Explorer เอาเมาส์ไปวางที่ ServerScriptService กด + แล้วใส่ ModuleScript เปลี่ยนชื่อเป็น
PlayerDataและแทนที่เนื้อหาด้วยโค้ดด้านล่าง - ModuleScript ทำงานเฉพาะเมื่อมีสคริปต์ require มัน ใส่ Script ใน ServerScriptService ชื่อ
Mainพร้อมบรรทัดนี้:local PlayerData = require(game:GetService("ServerScriptService").PlayerData)สคริปต์ฝั่งเซิร์ฟเวอร์อื่น require มันแบบเดียวกัน - เปลี่ยน
DEFAULTSและชนิดDataให้เข้ากับเกมของคุณ โดยให้ทุกฟิลด์เป็นตัวเลข สตริง บูลีน หรือตาราง
ServerScriptService
PlayerData ModuleScript new
Main Script new
StarterPlayer
StarterPlayerScripts
DataWarning LocalScript new
-- PlayerData: โหลดข้อมูลผู้เล่นตอนเข้าเกม เก็บไว้ในหน่วยความจำ
-- และบันทึกตามตัวจับเวลา ตอนออก และตอนเซิร์ฟเวอร์ปิด
-- สคริปต์ฝั่งเซิร์ฟเวอร์อื่นอ่านและเปลี่ยนมันผ่าน 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 -- เพิ่มเมื่อรูปแบบข้อมูลเปลี่ยน และเพิ่มขั้นตอนใน migrate()
local AUTOSAVE_SECONDS = 180
-- ใน Studio การเรียกที่ล้มเหลวยอมแพ้ทันที การทดสอบที่ไม่มีสิทธิ์เข้าถึงที่เก็บจึงรันเร็ว
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- เพิ่มเป็นสองเท่าหลังแต่ละความล้มเหลว: 1, 2, 4
export type Data = {
SchemaVersion: number,
Coins: number,
Level: number,
Inventory: { string },
}
-- ผู้เล่นใหม่เอี่ยมเริ่มด้วยอะไร
local DEFAULTS: { [string]: any } = {
Coins = 0,
Level = 1,
Inventory = {},
}
type Session = {
key: string,
userId: number,
data: Data,
canSave: boolean, -- false ถ้าโหลดไม่สำเร็จ: ข้อมูลค่าเริ่มต้นต้องไม่แทนความคืบหน้าจริง
}
-- เรียกข้างในทุก pcall ด้านล่าง place ที่ยังไม่เผยแพร่
-- (ไม่มีสิทธิ์เข้าถึงที่เก็บ) จึงยังโหลดผู้เล่นด้วยข้อมูลค่าเริ่มต้นได้
local function store(): DataStore
return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- การบันทึกที่ยังทำงานอยู่ แยกตามคีย์
local loadedEvent = Instance.new("BindableEvent")
local PlayerData = {}
-- ทำงานพร้อมผู้เล่นเมื่อข้อมูลของเขาพร้อม ให้เอาตารางผ่าน PlayerData.Get(player):
-- ตารางที่ส่งผ่าน BindableEvent จะมาถึงเป็นสำเนา การแก้มันจึงไม่เปลี่ยนอะไร
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) -- สำเนาใหม่ เพื่อไม่ให้ผู้เล่นใช้ตาราง Inventory ร่วมกันเลย
data.SchemaVersion = SCHEMA_VERSION
return data
end
-- แปลงข้อมูลที่บันทึกไว้ให้เป็นรูปแบบปัจจุบัน คืนค่า nil ถ้าใช้อย่างปลอดภัยไม่ได้
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 -- บันทึกโดยเกมเวอร์ชันใหม่กว่า: ที่นี่ไม่โหลดและไม่เขียนทับ
end
-- หนึ่งขั้นตอนต่อการเปลี่ยนรูปแบบ จากเก่าไปใหม่
if version < 2 then
-- ตัวอย่าง: ในเวอร์ชัน 1 สกุลเงินชื่อ Gold ก๊อปมันเฉพาะเมื่อไม่มี Coins
-- เพื่อให้ข้อมูลเก่าที่มี Coins อยู่แล้วแต่ไม่มี SchemaVersion ยังคงค่าไว้
if saved.Coins == nil then
saved.Coins = saved.Gold
end
saved.Gold = nil
end
-- เพิ่มฟิลด์ที่มีขึ้นหลังการบันทึกครั้งล่าสุดของผู้เล่น และแทนค่าที่ผิดชนิด
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 เมื่อล้มเหลว รอแล้วลองใหม่ โดยเพิ่มเวลารอ
-- เป็นสองเท่าทุกครั้งและเพิ่มความสุ่มเล็กน้อย เพื่อไม่ให้เซิร์ฟเวอร์ลองใหม่พร้อมกันหมด
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 ยกเลิกการเขียน
end
-- เขียนทั้งตารางปัจจุบัน พร้อมกำกับด้วย 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()
-- เริ่มที่จุดสุ่มในช่วงเวลา เพื่อไม่ให้เซิร์ฟเวอร์บันทึกพร้อมกันหมด
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
-- ถ้าผู้เล่นเพิ่งออกจากเซิร์ฟเวอร์นี้แล้วกลับมา ให้การบันทึกครั้งล่าสุดเสร็จก่อน
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 -- ออกไประหว่างโหลด: ไม่มีอะไรเปลี่ยน ไม่มีอะไรต้องบันทึก
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) -- GUI อ่านค่านี้แล้วเตือนผู้เล่นได้
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 -- หยุดลูปบันทึกอัตโนมัติ และการเรียกซ้ำจะไม่ทำอะไร
save(session)
end
-- ตารางข้อมูลสดของผู้เล่น หรือ nil จนกว่าจะโหลดเสร็จ เปลี่ยนมันจากสคริปต์ฝั่งเซิร์ฟเวอร์เท่านั้น
function PlayerData.Get(player: Player): Data?
local session = sessions[player]
return if session then session.data else nil
end
-- true เมื่อข้อมูลของผู้เล่นโหลดแล้วและจะถูกบันทึก ตรวจก่อนการขายทุกครั้ง
function PlayerData.CanSave(player: Player): boolean
local session = sessions[player]
return session ~= nil and session.canSave
end
-- บันทึกตอนนี้โดยไม่รอตัวจับเวลา สำหรับช่วงเวลาสำคัญอย่างการซื้อ
-- หยุดรอและคืนค่า true เมื่อบันทึกสำเร็จ
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) -- ผู้เล่นที่เข้ามาก่อนที่โมดูลนี้จะถูก require ครั้งแรก
end
game:BindToClose(function()
-- เซิร์ฟเวอร์ให้เวลาฟังก์ชันเหล่านี้ 30 วินาที จึงบันทึกทุกคนพร้อมกัน
for player in sessions do
task.spawn(endSession, player)
end
-- แล้วรอทุกการบันทึกที่ยังทำงานอยู่ รวมถึงที่เริ่มใน PlayerRemoving
while next(pendingSaves) do
task.wait()
end
end)
return PlayerData
เมื่อเกมออกแล้ว อย่าเปลี่ยน STORE_NAME และรูปแบบคีย์ User_ การเปลี่ยนอย่างใดอย่างหนึ่งจะชี้โมดูลไปยังคีย์ว่าง และผู้เล่นทุกคนจะเริ่มใหม่ด้วยค่าเริ่มต้น
โมดูลปกป้องข้อมูลอย่างไร
ค่าเริ่มต้นและเวอร์ชันของรูปแบบข้อมูล
ผู้เล่นใหม่ได้สำเนาใหม่ของ DEFAULTS ต้องเป็นสำเนาจริง ๆ: ถ้าผู้เล่นทุกคนใช้ตาราง Inventory ร่วมกัน ไอเทมที่เพิ่มให้คนหนึ่งจะปรากฏในของทุกคน
ทุกตารางที่บันทึกมี SchemaVersion การเพิ่มฟิลด์ไม่ต้องใช้เวอร์ชันใหม่ เพราะ migrate เติมฟิลด์ที่ขาดจากค่าเริ่มต้น การเปลี่ยนชื่อหรือจัดโครงสร้างใหม่ต้องใช้: เพิ่ม SCHEMA_VERSION และเพิ่มขั้นตอน เหมือนตัวอย่างที่เปลี่ยนชื่อ Gold เป็น Coins (ในเกมใหม่ให้ลบมันและเริ่มที่ 1) ข้อมูลที่มีเวอร์ชันสูงกว่าของเซิร์ฟเวอร์มาจากรีลีสที่ใหม่กว่าซึ่งยังทยอยปล่อยอยู่ เซิร์ฟเวอร์เก่าจึงไม่แตะมัน
การโหลดที่ล้มเหลวไม่ถูกบันทึกเลย
กฎนี้ป้องกันการลบข้อมูลทั้งหมด ถ้าทุกความพยายามโหลดล้มเหลว ผู้เล่นจะเล่นด้วยข้อมูลค่าเริ่มต้น แต่ canSave เป็น false ค่าเหล่านี้จึงไม่มีวันเขียนทับความคืบหน้าจริงของเขา โมดูลยังตั้งแอตทริบิวต์ DataLoaded เป็น false และขั้นตอนที่ 3 ใช้มันแจ้งผู้เล่น ตัวอย่างอ้างอิงของ Roblox จัดการการโหลดที่ล้มเหลวแบบเดียวกัน และแนะนำวิธีนี้แทนการเตะ ถ้าคุณอยากเตะ ให้เรียก player:Kick() พร้อมข้อความตรงที่โมดูลแสดงคำเตือน
ลองใหม่โดยเพิ่มเวลารอ
withRetries ห่อทุกการเรียกด้วย pcall หลังความล้มเหลว มันรอ 1 แล้ว 2 แล้ว 4 วินาที ทุกครั้งบวกเวลาสุ่มไม่เกินครึ่งหนึ่ง และหยุดหลังสี่ครั้ง (ใน Studio หลังหนึ่งครั้ง เพื่อให้ place ที่ไม่มีสิทธิ์เข้าถึงที่เก็บเริ่มได้ทันที) ความสุ่มกระจายการลองใหม่ของเซิร์ฟเวอร์จำนวนมากหลังเกิดปัญหา และการจำกัดทำให้การรออยู่ในราว 10 วินาที ภายใน 30 วินาทีที่เซิร์ฟเวอร์ได้ตอนปิด เพราะทุกการบันทึกเขียนทั้งตารางสดผ่าน UpdateAsync การลองใหม่ที่เสร็จช้าจึงคืนข้อมูลเก่ากลับมาไม่ได้
โมดูลบันทึกเมื่อไร
| เมื่อไร | ทำไม |
|---|---|
| ทุก 180 วินาที ขณะที่ผู้เล่นอยู่บนเซิร์ฟเวอร์ | จำกัดความเสียหายเมื่อเซิร์ฟเวอร์พัง การบันทึกครั้งแรกเกิดที่จุดสุ่มในช่วงเวลา เพื่อไม่ให้เซิร์ฟเวอร์บันทึกพร้อมกันหมด ตัวอย่างอ้างอิงของ Roblox ก็ใช้ 180 วินาที |
เมื่อผู้เล่นออก (PlayerRemoving) | การบันทึกครั้งสุดท้ายตามปกติ เซสชันถูกลบก่อน การบันทึกอัตโนมัติจึงหยุด |
เมื่อเซิร์ฟเวอร์ปิด (game:BindToClose) | ทุกคนที่ยังอยู่บนเซิร์ฟเวอร์ถูกบันทึกพร้อมกัน และฟังก์ชันรอทุกการบันทึกที่ทำงานอยู่ Roblox ให้เวลามัน 30 วินาที |
ตามคำขอ ผ่าน PlayerData.SaveNow(player) | หลังสิ่งที่ห้ามหาย เช่นการซื้อ |
ถ้าผู้เล่นเข้าเซิร์ฟเวอร์เดิมอีกครั้งขณะที่การบันทึกครั้งสุดท้ายยังทำงานอยู่ การโหลดใหม่จะรอให้การบันทึกนั้นเสร็จ จึงอ่านค่าเก่าไม่ได้
ขั้นตอนที่ 2: อ่านและเปลี่ยนข้อมูลจากสคริปต์อื่น
สคริปต์ฝั่งเซิร์ฟเวอร์ทุกตัวที่ require โมดูล ทำงานกับตารางชุดเดียวกัน:
| การเรียก | หน้าที่ |
|---|---|
PlayerData.Get(player) | ตารางข้อมูลสดของผู้เล่น หรือ nil จนกว่าจะโหลดเสร็จ เปลี่ยนฟิลด์โดยตรง เช่น data.Coins += 10 แล้วการบันทึกครั้งถัดไปจะเก็บไปด้วย |
PlayerData.Loaded | ทำงานพร้อมผู้เล่นเมื่อข้อมูลของเขาพร้อม รวมถึงหลังการโหลดที่ล้มเหลว ส่งแค่ผู้เล่น เพราะตารางที่ส่งผ่าน BindableEvent มาถึงเป็นสำเนา |
PlayerData.CanSave(player) | false ถ้าโหลดไม่สำเร็จ ตรวจก่อนการขายทุกครั้ง: การซื้อที่บันทึกไม่ได้จะหายไปเมื่อผู้เล่นออก |
PlayerData.SaveNow(player) | บันทึกทันทีและคืน true ถ้าสำเร็จ หยุดรอระหว่างทำงาน |
โมดูลเป็นที่เดียวที่ข้อมูลที่บันทึกอยู่ ส่วน leaderstats เป็นแค่การแสดงผล: สร้างมันเหมือนในคู่มือลีดเดอร์บอร์ด เติมจาก PlayerData.Get(player) ในตัวจัดการ Loaded และอัปเดตทั้งสองเมื่อค่าเปลี่ยน อย่าอ่านค่าที่บันทึกกลับจาก leaderstats และอย่าให้สคริปต์ที่สองบันทึกคีย์เดียวกันเด็ดขาด
สคริปต์ที่ require โมดูลหลังผู้เล่นเข้ามาแล้ว จะพลาด Loaded ของพวกเขา ให้เชื่อมตัวจัดการ แล้ววนลูป Players:GetPlayers() อีกรอบ และจัดการทุกคนที่ PlayerData.Get(player) คืนตารางมาแล้ว
กำลังแทนสคริปต์บันทึกเก่า เช่นจากคู่มือลีดเดอร์บอร์ดอยู่ไหม? ค่าของมันยังอยู่ในที่เก็บและคีย์ของมันเอง โมดูลนี้จึงจะเริ่มทุกคนด้วยค่าเริ่มต้น ก่อนเปิดใช้ ให้ชี้ STORE_NAME และ prefix User_ ไปที่ของเก่า (migrate ถือว่าข้อมูลที่ไม่มี SchemaVersion เป็นเวอร์ชัน 1 และเติมฟิลด์ที่ขาด) หรือย้ายค่าเก่ามา แล้วลบสคริปต์เก่า
ไคลเอนต์ไม่เปลี่ยนข้อมูลนี้โดยตรงเลย ปุ่มร้านค้าเรียก RemoteEvent เซิร์ฟเวอร์ตรวจ CanSave เทียบราคากับ Coins ของผู้เล่น เปลี่ยนตาราง และเรียก SaveNow คู่มือ GUI ร้านค้าสร้างการซื้อแบบนี้ฝั่งเซิร์ฟเวอร์
ตัวอย่างการเพิ่มฟิลด์ที่เสร็จแล้วอยู่ในคู่มือเกมซิมูเลเตอร์แบบคลิก: มันเพิ่ม PowerLevel และ Rebirths ใน DEFAULTS และชนิด Data แล้วเปลี่ยนมันในตารางที่ PlayerData.Get คืน migrate ให้ฟิลด์ใหม่กับผู้เล่นที่มีข้อมูลบันทึกเก่า
ขั้นตอนที่ 3: แจ้งผู้เล่นว่าข้อมูลของเขาโหลดไม่สำเร็จ
ผู้เล่นที่ข้อมูลโหลดไม่สำเร็จควรรู้ว่าเซสชันนี้จะไม่ถูกบันทึก เพื่อจะได้เข้าใหม่แทนที่จะเล่นเปล่า ๆ LocalScript นี้คอยดูแอตทริบิวต์ DataLoaded และแสดงแบนเนอร์เมื่อมันเป็น 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
-- เซิร์ฟเวอร์ตั้ง DataLoaded ครั้งเดียว หลังพยายามโหลดข้อมูลของผู้เล่นคนนี้
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()
ขั้นตอนที่ 4: ทดสอบการบันทึกใน Studio
ทำในสำเนาทดสอบที่เปิดสิทธิ์ Studio ไว้
- ให้อะไรบางอย่างกับตัวเองเพื่อบันทึก ใต้บรรทัด require ใน
Mainให้เพิ่ม:PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end) - กด Play หน้าต่าง Output (ในเมนู Window หรือแท็บ Script) จะแสดงชื่อคุณและ 100 (ในการรันครั้งแรก) โดยไม่มีคำเตือน
Could not load - กด Stop การจบการทดสอบปิดเซิร์ฟเวอร์ และโมดูลบันทึกคุณก่อนปิด
- กด Play อีกครั้ง Output ควรแสดง 200 มากกว่าครั้งก่อน 100 ถ้ามันแสดงตัวเลขเดิมอีก แปลว่าการบันทึกไม่สำเร็จ: อ่านคำเตือนเหนือมัน
- ทดสอบเส้นทางที่ล้มเหลว ปิดสิทธิ์ Studio แล้วกด Play หลังลองใหม่ไม่กี่วินาที Output จะแสดง
Could not load User_...และ 100 และแบนเนอร์จากขั้นตอนที่ 3 จะปรากฏ หยุดการทดสอบ เปิดสิทธิ์อีกครั้ง แล้วกด Play: Output จะแสดง 300 คือ 200 ที่บันทึกไว้บวก 100 เพราะเซสชันที่ล้มเหลวไม่เคยเขียนทับข้อมูลของคุณ - ลบบรรทัดทดสอบออกจาก
Main
ทำไมข้อมูลผู้เล่นถึงหาย
นี่คือวิธีปกติที่ระบบบันทึกทำความคืบหน้าหาย โมดูลปิดสี่แถวแรกและแถวเรื่องรูปแบบข้อมูลไว้ในโค้ดแล้ว ส่วนที่เหลือขึ้นกับว่าคุณเก็บอะไรและเก็บอย่างไร และแถวสุดท้ายต้องใช้ session locking
| สิ่งที่เกิดขึ้น | ผลลัพธ์ | ป้องกันอย่างไร |
|---|---|---|
| โหลดไม่สำเร็จ แต่สคริปต์ยังบันทึก | ค่าเริ่มต้นเขียนทับความคืบหน้าจริง: ลบหมด | ไม่บันทึกผู้เล่นที่โหลดไม่สำเร็จเลย |
บันทึกเฉพาะใน PlayerRemoving | เซิร์ฟเวอร์พังหรือปิดแล้วพลาดการบันทึก | บันทึกอัตโนมัติ บวก BindToClose ที่รอการบันทึกของมัน |
ไม่มี pcall หรือไม่มีการลองใหม่ | คำขอที่ล้มเหลวครั้งเดียวทำให้สคริปต์หยุดหรือการบันทึกหาย | pcall พร้อมการลองใหม่หลายครั้งที่เว้นระยะห่าง |
| บันทึกทุกครั้งที่มีการเปลี่ยนแปลง | คำขอเข้าคิว เมื่อคิวมี 30 คำขอใหม่จะถูกทิ้ง | เก็บข้อมูลในหน่วยความจำและบันทึกตามตัวจับเวลา |
| บันทึกสิ่งที่ที่เก็บเก็บไม่ได้ | การบันทึกเกิดข้อผิดพลาด หรือค่ากลับมาเป็น nil | บันทึกตัวเลข สตริง บูลีน และตารางของสิ่งเหล่านี้ |
| เปลี่ยนรูปแบบข้อมูลโดยไม่ migrate | ข้อมูลบันทึกเก่าโหลดเข้าฟิลด์ผิด | เวอร์ชันของรูปแบบข้อมูลและขั้นตอน migrate |
| สองสคริปต์บันทึกคีย์เดียวกัน | การบันทึกแต่ละครั้งเขียนทับฟิลด์ของอีกฝ่าย | โมดูลเดียวเป็นเจ้าของคีย์ |
| สองเซิร์ฟเวอร์ถือผู้เล่นคนเดียวกัน | เซิร์ฟเวอร์ที่มีข้อมูลเก่าบันทึกเป็นตัวสุดท้ายและเขียนทับความคืบหน้าใหม่ | Session locking |
Session locking, "lock lost" และ ProfileStore
ผู้เล่นเชื่อมต่อกับเซิร์ฟเวอร์ได้ทีละตัว แต่การบันทึกครั้งสุดท้ายของเซิร์ฟเวอร์เก่าอาจยังทำงานอยู่ตอนที่เขาเข้าเซิร์ฟเวอร์ใหม่: การลองใหม่ที่ช้า การเทเลพอร์ต หรือการเข้าใหม่อย่างรวดเร็ว ถ้าเซิร์ฟเวอร์ใหม่โหลดข้อมูลก่อน มันจะได้ข้อมูลเก่า และเซิร์ฟเวอร์ที่บันทึกเป็นตัวสุดท้ายจะชนะ เอกสารของ Roblox ระบุว่าในเกมที่มีการแลกเปลี่ยน ช่องว่างนี้เป็นสาเหตุที่พบบ่อยของการปั๊มไอเทม
Session locking ปิดช่องว่างนี้ เมื่อเซิร์ฟเวอร์โหลดคีย์ของผู้เล่น มันเขียน ID การล็อกของตัวเองลงใน metadata ของคีย์ในการเรียก UpdateAsync ครั้งเดียวกัน เซิร์ฟเวอร์อื่นที่เจอการล็อกที่ยังไม่หมดอายุซึ่งไม่ใช่ของตัวเอง จะไม่โหลดและไม่บันทึกคีย์นั้น เจ้าของต่ออายุการล็อกในทุกการบันทึกอัตโนมัติ และปลดในการบันทึกครั้งสุดท้าย ถ้ามันหยุดต่ออายุ การล็อกจะหมดอายุ และเซิร์ฟเวอร์อื่นเอาไปได้
"lock lost" หมายความว่าอะไร
ในระบบที่มี session locking เซิร์ฟเวอร์เสียการล็อกเมื่อเซิร์ฟเวอร์อื่นเป็นเจ้าของคีย์ของผู้เล่นแล้ว เพราะการล็อกหมดอายุหรือถูกแย่งไป สำเนาของมันอาจล้าสมัย มันจึงต้องหยุดบันทึกผู้เล่นคนนี้ การตอบสนองปกติคือเตะเขาพร้อมข้อความให้เชื่อมต่อใหม่ ถ้าคุณเห็น "lock lost" ในฐานะผู้เล่น นี่คือข้อความของระบบบันทึกของเกมนั้นเอง และมีแค่ผู้พัฒนาเกมนั้นที่อธิบายได้
คุณต้องใช้มันไหม?
โมดูลในคู่มือนี้ไม่ล็อกเซสชัน ถ้าไม่มีการล็อก กรณีที่แย่ที่สุดจริง ๆ คือ: ในการแข่งกันที่เกิดน้อยครั้ง ผู้เล่นเสียสิ่งที่ได้บนเซิร์ฟเวอร์เก่าหลังการบันทึกที่สำเร็จครั้งล่าสุด เพิ่มการล็อกเมื่อการปั๊มหรือการหายมีราคาจริงกับผู้เล่น: การแลกเปลี่ยน developer products ไอเทมหายาก หรือการเทเลพอร์ตบ่อย ๆ
| ตัวเลือก | คืออะไร | ควรรู้ |
|---|---|---|
| โมดูลในคู่มือนี้ | โหลด แคชในหน่วยความจำ ลองใหม่ บันทึกอัตโนมัติ บันทึกตอนปิด และเวอร์ชันของรูปแบบข้อมูล ไม่มีการล็อก | สั้นพอที่จะอ่านทั้งหมดและแก้ได้ |
| ตัวอย่างของ Roblox สำหรับข้อมูลผู้เล่นและการซื้อ | โค้ดอ้างอิงจาก Roblox ที่มี session locking การลองใหม่ตามลำดับสำหรับแต่ละคีย์ และการจัดการใบเสร็จการซื้อ | Roblox บอกว่ามันยังไม่ผ่านการพิสูจน์ในเกมยอดนิยม และไม่ควรใช้ตามที่เป็นโดยไม่ทดสอบอย่างละเอียด |
| ProfileStore | โมดูลโอเพนซอร์สฟรีจากชุมชน ผู้สืบทอด ProfileService สร้างขึ้นรอบ session locking และการบันทึกอัตโนมัติ | ไม่ได้มาจาก Roblox การย้ายเกมที่มีอยู่ไปใช้ต้อง migrate ข้อมูลที่บันทึกไว้แล้ว |
สำหรับโมดูลของบุคคลที่สามใดก็ตาม Roblox แนะนำให้ตรวจว่าใครเป็นเจ้าของ ยังได้รับการดูแลไหม และคุณจะเข้าถึงข้อมูลของตัวเองโดยไม่มีมันได้อย่างไร เอกสารเดียวกันเรียก DataStore2 ว่าไลบรารีที่ล้าสมัย ซึ่งเกมใหม่ไม่ควรใช้
ขีดจำกัดของที่เก็บข้อมูล
นี่คือขีดจำกัดจากเอกสารของ Roblox ณ 30 กันยายน 2026 Roblox ทบทวนมันเป็นระยะ จึงควรตรวจหน้ารหัสข้อผิดพลาดและขีดจำกัด (ภาษาอังกฤษ) ก่อนจะพึ่งตัวเลขที่แน่นอน
| ชนิดคำขอ | ที่เก็บปกติ | ที่เก็บแบบเรียงลำดับ |
|---|---|---|
อ่าน: GetAsync, การอ่านใน UpdateAsync | 60 + 40 × ผู้เล่น | 60 + 40 × ผู้เล่น |
เขียน: SetAsync, IncrementAsync, การเขียนใน UpdateAsync | 60 + 40 × ผู้เล่น | 30 + 5 × ผู้เล่น |
แสดงรายการ: ListKeysAsync หรือ GetSortedAsync สำหรับที่เก็บแบบเรียงลำดับ | 5 + 2 × ผู้เล่น | 5 + 2 × ผู้เล่น |
ลบ: RemoveAsync | 60 + 40 × ผู้เล่น | 30 + 5 × ผู้เล่น |
เมื่อมีผู้เล่น 20 คน เซิร์ฟเวอร์เขียนแบบปกติได้ 860 ครั้งต่อนาที การบันทึกอัตโนมัติของโมดูลนี้ใช้ประมาณ 7 ครั้ง บวกหนึ่งครั้งต่อผู้เล่นที่ออก สิ่งที่ทำให้งบหมดคือการบันทึกทุกครั้งที่เก็บเหรียญได้ งบที่สองมีผลกับทั้งเกมและใช้ร่วมกับ Open Cloud: อ่าน 300 ครั้งต่อนาทีบวก 40 ต่อผู้เล่นออนไลน์แต่ละคน และเขียน 300 ครั้งบวก 20 ต่อผู้เล่น
| ขีดจำกัด | ค่า |
|---|---|
| ชื่อที่เก็บ ชื่อคีย์ scope | อย่างละ 50 ตัวอักษร |
| ค่าในคีย์เดียว | 4,194,304 ตัวอักษรในรูป JSON |
| การอ่านคีย์เดียวจากทุกเซิร์ฟเวอร์ | 25 MB ต่อนาที |
| การเขียนลงคีย์เดียวจากทุกเซิร์ฟเวอร์ | 4 MB ต่อนาที แต่ละคำขอปัดขึ้นเป็น KB ถัดไป |
| คำขอที่รออยู่ | 30 ต่อคิว เกินนั้นคำขอจะล้มเหลวด้วยข้อผิดพลาด 301-306 |
| พื้นที่เก็บสำหรับทั้งเกม | 500 MB บวก 1 MB ต่อผู้ใช้แต่ละคนตลอดเวลา |
วัดขนาดข้อมูลผู้เล่นด้วย #HttpService:JSONEncode(data) และดูงบที่เหลือของเซิร์ฟเวอร์จริงด้วย DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite) การเรียก GetAsync ที่ได้คำตอบจากแคช 4 วินาทีไม่นับ โหมด Run ใน Studio มีขีดจำกัดของตัวเองซึ่งอาจต่ำกว่า สำหรับการทดสอบขีดจำกัดคำขอ Roblox จึงแนะนำ Team Create
เวอร์ชันและการสำรองข้อมูล
ที่เก็บปกติเก็บประวัติให้คุณ การเขียนครั้งแรกลงคีย์ในแต่ละชั่วโมงตาม UTC จะถูกเก็บเป็นเวอร์ชัน และการเขียนครั้งถัดไปในชั่วโมงนั้นจะเขียนทับกันเอง เวอร์ชันเก่าหมดอายุ 30 วันหลังจากที่การเขียนที่ใหม่กว่าแทนมัน เวอร์ชันล่าสุดไม่มีวันหมดอายุ ที่เก็บแบบเรียงลำดับไม่เก็บเวอร์ชัน
ถ้าจะย้อนผู้เล่นคนหนึ่ง ให้เปิด Data Stores Manager (Creations เกมของคุณ Configure > Data Stores Manager) เลือกคีย์ของเขา เลือกเวอร์ชันก่อนหน้า แล้วกด Revert ต้องมีสิทธิ์ Edit ทำขณะที่ผู้เล่นออฟไลน์ ไม่อย่างนั้นเซิร์ฟเวอร์ที่ถือเซสชันของเขาจะบันทึกสำเนาของตัวเองทับการย้อน จาก Script ฝั่งเซิร์ฟเวอร์ ListVersionsAsync และ GetVersionAsync หาและอ่านเวอร์ชันเก่าได้ แล้วคุณเขียนมันกลับเป็นค่าปัจจุบัน
ก่อนเผยแพร่อัปเดตที่เปลี่ยนวิธีบันทึกข้อมูล Roblox แนะนำให้ทำสแนปช็อตผ่าน Open Cloud Snapshot Data Stores API (วันละครั้งต่อเกม) ถ้าไม่มี การบันทึกที่ผิดพลาดตอน 3:30 UTC จะเขียนทับทุกอย่างที่เขียนลงคีย์นั้นตั้งแต่ 3:00 เพราะอยู่ในเวอร์ชันรายชั่วโมงเดียวกัน
ข้อผิดพลาดที่พบบ่อยและวิธีแก้
ข้อผิดพลาดของที่เก็บข้อมูลแสดงในหน้าต่าง Output ของ Studio และโมดูลแสดงคำเตือนพร้อมข้อความข้อผิดพลาดของ Roblox ทุกครั้งที่พยายามแล้วล้มเหลว คู่มือข้อผิดพลาดของสคริปต์อธิบายวิธีอ่าน Output โดยทั่วไป
StudioAccessToApisNotAllowed (ข้อผิดพลาด 403)
"Can't write to DataStore from Studio because API access is not enabled." เผยแพร่ place แล้วเปิด Enable Studio Access to API Services ใน File > Experience Settings > Security ในสำเนาทดสอบ
DataStore request was added to queue
เซิร์ฟเวอร์ส่งคำขอเร็วกว่าที่งบอนุญาต หรือเขียนคีย์เดียวบ่อยเกินไป มักเพราะบันทึกทุกครั้งที่มีการเปลี่ยนแปลงหรือในลูป เมื่อคิวมี 30 คำขอ คำขอใหม่จะล้มเหลวด้วยข้อผิดพลาด 301-306 เก็บข้อมูลในหน่วยความจำและบันทึกตามตัวจับเวลา
CantStoreValue (ข้อผิดพลาด 104) หรือฟิลด์กลับมาเป็น nil
ในตารางมีสิ่งที่ที่เก็บบันทึกไม่ได้ เช่น Instance, Vector3 หรือ Color3 ให้บันทึกชื่อ ID หรือตัวเลขธรรมดาแทน และสร้างอ็อบเจกต์ขึ้นใหม่ตอนโหลด
ValueTooLarge (ข้อผิดพลาด 105)
คีย์เดียวเก็บ JSON เกิน 4,194,304 ตัวอักษร วัดด้วย #HttpService:JSONEncode(data) ตัดสิ่งที่สร้างใหม่ได้ออก หรือแบ่งข้อมูลเป็นหลายคีย์ที่คงที่
ไม่มีข้อผิดพลาด แต่ข้อมูลไม่ถูกบันทึก
หาคำเตือน Could not load ของโมดูล: หลังการโหลดที่ล้มเหลว มันตั้งใจปฏิเสธการบันทึก ไม่อย่างนั้นค่าน่าจะถูกเปลี่ยนใน LocalScript ซึ่งไม่เคยไปถึงเซิร์ฟเวอร์ หรือสคริปต์อื่นบันทึกคีย์เดียวกัน
ข้อมูลรีเซ็ตทุกครั้งที่เข้าเกมใหม่
คีย์เปลี่ยนระหว่างเซสชัน (สร้างจาก player.Name หรือคุณเปลี่ยน STORE_NAME) การโหลดล้มเหลวและคุณเห็นค่าเริ่มต้น หรือไม่มีใคร require โมดูล มันจึงไม่ทำงานเลย ตรวจ Output และตรวจว่า Main require PlayerData
สร้างด้วย RoCode
ถ้าไม่อยากประกอบเอง RoCode ทำให้ใน place ที่คุณเปิดอยู่ได้โดยตรง มันคือเอเจนต์ AI อิสระ ไม่ได้มาจาก Roblox ที่ทำงานผ่านปลั๊กอินสำหรับ Roblox Studio: มันเขียน Luau ที่ใช้ DataStoreService เหมือนสคริปต์ทั่วไป และสร้างสคริปต์ใน Explorer ของคุณ ตัวมันเองไม่เคยเข้าถึงที่เก็บข้อมูลของคุณ แต่กับปลั๊กอิน 3.9 ขึ้นไป มันกด Play เพื่อเพลย์เทสต์สั้น ๆ ได้ ซึ่งสคริปต์ของคุณทำงานเหมือนในการทดสอบทั่วไป
เพิ่มการบันทึกให้เกมของฉัน: เก็บ Coins, Level และ Inventory ในโมดูล PlayerData พร้อมบันทึกอัตโนมัติและบันทึกตอนเซิร์ฟเวอร์ปิด และแสดง Coins ใน leaderstats ที่ฉันมีอยู่แล้ว
- ค้นหา leaderstats และโค้ด DataStore ที่มีอยู่ด้วย Search Scripts และ Read Script ได้ เพื่อต่อยอดสิ่งที่คุณมี แทนที่จะเพิ่มสคริปต์บันทึกตัวที่สอง ใน place ใหญ่ ให้บอกชื่อสคริปต์หรือโฟลเดอร์ในข้อความ
- สร้าง ModuleScript และ Script ที่ require มันด้วย Create Script หรือแก้ตัวที่มีอยู่ด้วย Edit Script
- รัน Check Script กับทุกสคริปต์ที่เขียน: การตรวจการคอมไพล์ภายใน Studio พร้อมรายการคำเตือนสั้น ๆ ไม่ใช่การตรวจชนิดข้อมูลและไม่ใช่การทดสอบรัน
- ส่งการเปลี่ยนแปลงเป็นชุด และแต่ละชุดเป็นจุดย้อนกลับ (undo) ใน Studio
คุณยังต้องเปิด Studio Access to API Services ในสำเนาทดสอบเอง: RoCode เปลี่ยนการตั้งค่านี้ไม่ได้ กับปลั๊กอิน 3.9 ขึ้นไป เพลย์เทสต์สั้น ๆ ของมันอ่านข้อผิดพลาดได้ และกับปลั๊กอิน 3.9.11 ขึ้นไปจะควบคุมตัวละครทดสอบเพื่อตรวจว่าเกมทำงานได้ แต่มันตรวจเฉพาะสิ่งที่เลือกตรวจเอง ดังนั้นให้เล่นเองและยืนยันว่า Coins, Level และ Inventory ถูกบันทึกและโหลด ถ้าการบันทึกไม่สำเร็จในการทดสอบของคุณ Check Output อ่านบรรทัด Server จากเพลย์เทสต์ที่คุณรันได้ การบันทึกมักถูกเพิ่มเมื่อลูปเกมหลักทำงานแล้ว การสร้างเกม Roblox ด้วย AI ทีละระบบแสดงลำดับนี้ RoCode เชื่อมกับ Studio อย่างไร
คำถามที่พบบ่อย
จะเปิด DataStore ใน Roblox Studio ได้อย่างไร?
เผยแพร่ place เปิด File > Experience Settings > Security เปิด Enable Studio Access to API Services แล้วกด Save ทำในเกมทดสอบแยกต่างหาก เพราะจากนั้น Studio จะใช้ที่เก็บข้อมูลเดียวกับเซิร์ฟเวอร์จริงของเกมนั้น
Roblox บันทึกข้อมูลผู้เล่นอัตโนมัติไหม?
ไม่ ไม่มีอะไรเกี่ยวกับผู้เล่นถูกบันทึกหลังจบเซสชัน ถ้าสคริปต์ฝั่งเซิร์ฟเวอร์ไม่ได้บันทึกผ่าน DataStoreService และ leaderstats ก็เช่นกัน
ควรเลือก ProfileStore หรือ DataStoreService โดยตรง?
ProfileStore ก็สร้างบนที่เก็บข้อมูลเช่นกัน คำถามจึงอยู่ที่ว่าคุณอยากให้คนอื่นเขียนและดูแล session locking ให้หรือไม่ สำหรับการแลกเปลี่ยน ไอเทมที่เสียเงิน หรือการเทเลพอร์ตบ่อย ๆ การล็อกคุ้มค่า ไม่ว่าจากไลบรารีหรือตัวอย่างอ้างอิงของ Roblox สำหรับเกมที่เล็กกว่า โมดูลแบบนี้อ่านและแก้ได้ง่ายกว่า
จะรีเซ็ตหรือลบข้อมูลผู้เล่นได้อย่างไร?
ใน Data Stores Manager หาคีย์แล้วเลือก Mark for Deletion ซึ่งยกเลิกได้ในช่วงเวลารอ หรือเรียก RemoveAsync กับคีย์จากสคริปต์ฝั่งเซิร์ฟเวอร์ ทำขณะที่ผู้เล่นออฟไลน์ ไม่อย่างนั้นการบันทึกครั้งถัดไปของเซิร์ฟเวอร์เขาจะเขียนข้อมูลกลับมา ในสำเนาทดสอบ การเปลี่ยน STORE_NAME ทำให้ทุกคนเริ่มจากศูนย์ อย่าทำแบบนี้ในเกมจริงเด็ดขาด
แหล่งข้อมูลและบทความแนะนำ
- Roblox Creator Docs: Data stores (ภาษาอังกฤษ). สิทธิ์ของ Studio, GetAsync, SetAsync, UpdateAsync, set และ update
- Roblox Creator Docs: Best practices for data stores (ภาษาอังกฤษ). หนึ่งคีย์ต่อผู้เล่น ข้อมูลในหน่วยความจำ การลองใหม่โดยเพิ่มเวลารอ โมดูลของบุคคลที่สาม
- Roblox Creator Docs: Data store error codes and limits (ภาษาอังกฤษ). รหัสข้อผิดพลาด ขีดจำกัดคำขอของเซิร์ฟเวอร์และเกม ขีดจำกัดขนาด ปริมาณการรับส่ง และพื้นที่เก็บ
- Roblox Creator Docs: Versioning, listing and caching (ภาษาอังกฤษ). เวอร์ชันรายชั่วโมง สแนปช็อต แคช 4 วินาที อะไรบันทึกได้
- Roblox Creator Docs: Implement player data and purchasing systems (ภาษาอังกฤษ). ตัวอย่างอ้างอิง session locking การโหลดที่ล้มเหลว การบันทึกอัตโนมัติทุก 180 วินาที
- Roblox Creator Docs: Data Stores Manager (ภาษาอังกฤษ). การดูคีย์ การย้อนเวอร์ชัน การลบข้อมูล
- Roblox Engine API: DataModel:BindToClose (ภาษาอังกฤษ). 30 วินาทีสำหรับการปิด
วิธีตรวจโค้ด: ทุกสคริปต์ในหน้านี้ผ่านตัวตรวจชนิดข้อมูลแบบ strict ของ Luau พร้อมคำจำกัดความของ Roblox API (luau-lsp, 20 พฤศจิกายน 2569) การตรวจชนิดข้อมูลจับได้เฉพาะชื่อ API ที่พิมพ์ผิดและชนิดข้อมูลที่ไม่ถูกต้อง ไม่ได้ตรวจตรรกะของเกม ดังนั้นควรทดสอบใน Studio ก่อนเผยแพร่