บทเรียน · ข้อมูลผู้เล่น

วิธีบันทึกข้อมูลผู้เล่นใน Roblox Studio ด้วย DataStore

Roblox ไม่จำอะไรเกี่ยวกับผู้เล่นข้ามเซสชัน ถ้าสคริปต์ฝั่งเซิร์ฟเวอร์ไม่ได้บันทึกไว้ ในคู่มือนี้คุณจะสร้างโมดูล PlayerData ที่โหลด เก็บในหน่วยความจำ และบันทึกข้อมูลของผู้เล่นแต่ละคนผ่าน DataStoreService แล้วดูเรื่องการทดสอบ ขีดจำกัด และวิธีที่ข้อมูลที่บันทึกไว้หายไป

อัปเดตเมื่อ 20 พฤศจิกายน 2569อ่าน 6 นาทีเขียนโดย

สรุปสั้น ๆ

ใช้ 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 เพื่อให้เซิร์ฟเวอร์สองตัวบันทึกผู้เล่นคนเดียวกันไม่ได้
ในหน้านี้
  1. สิทธิ์ของ Studio
  2. DataStore ทำงานอย่างไร
  3. GetAsync และ UpdateAsync
  4. 1. โมดูล PlayerData
  5. โครงสร้างของโมดูล
  6. 2. ใช้งานข้อมูล
  7. 3. คำเตือน
  8. 4. ทดสอบใน Studio
  9. ทำไมข้อมูลหาย
  10. Session locking
  11. ขีดจำกัด
  12. เวอร์ชันและสำเนา
  13. Common errors
  14. With RoCode
  15. คำถามที่พบบ่อย
  16. แหล่งข้อมูลและบทความแนะนำ

ก่อนเริ่ม: เปิดสิทธิ์ Studio ในสำเนาทดสอบ

เกมที่รันใน Studio เข้าถึงที่เก็บข้อมูลไม่ได้ จนกว่าคุณจะอนุญาต การอนุญาตมีข้อควรระวังที่เอกสารของ Roblox เตือนไว้: จากนั้น Studio จะอ่านและเขียนที่เก็บข้อมูลเดียวกับเกมจริง การทดสอบที่รีเซ็ตเหรียญของคุณใน Studio จึงรีเซ็ตในเกมจริงด้วย และข้อผิดพลาดในโค้ดทดสอบอาจทำให้คีย์ของผู้เล่นจริงเสียหาย

  1. ทำสำเนาทดสอบ บันทึก place เป็นไฟล์ เปิดสำเนา เลือก File > Publish to Roblox As แล้วกด Create new game อย่าเพิ่มมันเป็น place ข้างในเกมจริง: ทุก place ในเกมเดียวกันใช้ที่เก็บข้อมูลร่วมกัน
  2. ในสำเนาทดสอบ เปิด File > Experience Settings แล้วไปที่ Security
  3. เปิด Enable Studio Access to API Services แล้วกด Save

การเรียกที่เก็บข้อมูลทำงานเฉพาะใน Script ฝั่งเซิร์ฟเวอร์ LocalScript ที่ลองจะได้ข้อผิดพลาด ไคลเอนต์จึงเขียนข้อมูลที่บันทึกไม่ได้ เมื่อปุ่มต้องเปลี่ยนข้อมูล ไคลเอนต์จะขอเซิร์ฟเวอร์ผ่าน RemoteEvent และเซิร์ฟเวอร์เป็นผู้ตัดสิน (ดูคู่มือ RemoteEvents ภาษาอังกฤษ)

ที่เก็บข้อมูลเก็บข้อมูลผู้เล่นอย่างไร

ภาพประกอบการทดสอบจากขั้นตอนที่ 4 ของคู่มือแบบเร่งความเร็ว: Play แล้ว Stop บันทึกเซสชันลงในที่เก็บข้อมูล Play อีกครั้งโหลดมัน Output จึงแสดง 200

ที่เก็บข้อมูล (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 วินาที ตอนออก และตอนเซิร์ฟเวอร์ปิด และปฏิเสธการบันทึกคนที่ข้อมูลโหลดไม่สำเร็จ

  1. ใน Explorer เอาเมาส์ไปวางที่ ServerScriptService กด + แล้วใส่ ModuleScript เปลี่ยนชื่อเป็น PlayerData และแทนที่เนื้อหาด้วยโค้ดด้านล่าง
  2. ModuleScript ทำงานเฉพาะเมื่อมีสคริปต์ require มัน ใส่ Script ใน ServerScriptService ชื่อ Main พร้อมบรรทัดนี้: local PlayerData = require(game:GetService("ServerScriptService").PlayerData) สคริปต์ฝั่งเซิร์ฟเวอร์อื่น require มันแบบเดียวกัน
  3. เปลี่ยน DEFAULTS และชนิด Data ให้เข้ากับเกมของคุณ โดยให้ทุกฟิลด์เป็นตัวเลข สตริง บูลีน หรือตาราง
Explorer หลังขั้นตอนที่ 1-3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript ใน ServerScriptService ชื่อ PlayerData
-- 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

LocalScript ใน StarterPlayerScripts ชื่อ DataWarning
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local shown = false

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

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

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

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

-- เซิร์ฟเวอร์ตั้ง DataLoaded ครั้งเดียว หลังพยายามโหลดข้อมูลของผู้เล่นคนนี้
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

ขั้นตอนที่ 4: ทดสอบการบันทึกใน Studio

ทำในสำเนาทดสอบที่เปิดสิทธิ์ Studio ไว้

  1. ให้อะไรบางอย่างกับตัวเองเพื่อบันทึก ใต้บรรทัด 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)
  2. กด Play หน้าต่าง Output (ในเมนู Window หรือแท็บ Script) จะแสดงชื่อคุณและ 100 (ในการรันครั้งแรก) โดยไม่มีคำเตือน Could not load
  3. กด Stop การจบการทดสอบปิดเซิร์ฟเวอร์ และโมดูลบันทึกคุณก่อนปิด
  4. กด Play อีกครั้ง Output ควรแสดง 200 มากกว่าครั้งก่อน 100 ถ้ามันแสดงตัวเลขเดิมอีก แปลว่าการบันทึกไม่สำเร็จ: อ่านคำเตือนเหนือมัน
  5. ทดสอบเส้นทางที่ล้มเหลว ปิดสิทธิ์ Studio แล้วกด Play หลังลองใหม่ไม่กี่วินาที Output จะแสดง Could not load User_... และ 100 และแบนเนอร์จากขั้นตอนที่ 3 จะปรากฏ หยุดการทดสอบ เปิดสิทธิ์อีกครั้ง แล้วกด Play: Output จะแสดง 300 คือ 200 ที่บันทึกไว้บวก 100 เพราะเซสชันที่ล้มเหลวไม่เคยเขียนทับข้อมูลของคุณ
  6. ลบบรรทัดทดสอบออกจาก 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, การอ่านใน UpdateAsync60 + 40 × ผู้เล่น60 + 40 × ผู้เล่น
เขียน: SetAsync, IncrementAsync, การเขียนใน UpdateAsync60 + 40 × ผู้เล่น30 + 5 × ผู้เล่น
แสดงรายการ: ListKeysAsync หรือ GetSortedAsync สำหรับที่เก็บแบบเรียงลำดับ5 + 2 × ผู้เล่น5 + 2 × ผู้เล่น
ลบ: RemoveAsync60 + 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 ที่ฉันมีอยู่แล้ว

RoCode ทำให้
  • ค้นหา 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 ทำให้ทุกคนเริ่มจากศูนย์ อย่าทำแบบนี้ในเกมจริงเด็ดขาด

แหล่งข้อมูลและบทความแนะนำ

วิธีตรวจโค้ด: ทุกสคริปต์ในหน้านี้ผ่านตัวตรวจชนิดข้อมูลแบบ strict ของ Luau พร้อมคำจำกัดความของ Roblox API (luau-lsp, 20 พฤศจิกายน 2569) การตรวจชนิดข้อมูลจับได้เฉพาะชื่อ API ที่พิมพ์ผิดและชนิดข้อมูลที่ไม่ถูกต้อง ไม่ได้ตรวจตรรกะของเกม ดังนั้นควรทดสอบใน Studio ก่อนเผยแพร่

ลองใช้ RoCode กับเกมของคุณเอง

มีเครดิตฟรีทุกวัน ไม่ต้องใช้บัตร ติดตั้งปลั๊กอิน อธิบายฟีเจอร์ที่ต้องการ แล้วดูผลลัพธ์ใน Studio