บทเรียน · ระบบในเกม

วิธีทำอินเวนทอรีใน Roblox Studio

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

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

สรุปสั้น ๆ

เก็บไอเทมของผู้เล่นแต่ละคนในตารางบนเซิร์ฟเวอร์ ภายใน ModuleScript ใน ServerScriptService และมีแค่โค้ดนี้ที่เพิ่ม ลบ และรวมไอเทมเป็นสแตกได้ อธิบายไอเทมครั้งเดียวใน ModuleScript ใน ReplicatedStorage (id ชื่อ สแตกสูงสุด) หลังทุกการเปลี่ยนแปลง เซิร์ฟเวอร์ส่ง RemoteEvent พร้อมสำเนาอินเวนทอรีให้ผู้เล่นคนนั้น และ LocalScript วาดมันเป็นตารางผ่าน ScrollingFrame และ UIGridLayout

  • ไคลเอนต์ไม่เพิ่มไอเทมเลย มันทำได้แค่ขอ เช่น "สวมดาบของฉัน" และเซิร์ฟเวอร์ตรวจว่าผู้เล่นมีมันก่อนจะทำอะไร
  • ไอเทมปรากฏผ่านโค้ดฝั่งเซิร์ฟเวอร์ที่คุณควบคุมเท่านั้น: การเก็บของ การซื้อในร้านค้าหลังตรวจบนเซิร์ฟเวอร์ รางวัล
  • บันทึก id ไอเทมและจำนวน ไม่ใช่ Tool ผ่าน DataStoreService เมื่อผู้เล่นออก เมื่อเซิร์ฟเวอร์ปิด และทุกไม่กี่นาที อย่าบันทึกผู้เล่นที่ข้อมูลโหลดไม่สำเร็จเด็ดขาด
ในหน้านี้
  1. ทำงานอย่างไร
  2. ทำไมไอเทมอยู่บนเซิร์ฟเวอร์
  3. 1. เตรียม Explorer
  4. 2. แคตตาล็อกไอเทม
  5. 3. อินเวนทอรีบนเซิร์ฟเวอร์
  6. 4. การโหลดและบันทึก
  7. 5. การเก็บไอเทม
  8. 6. การสวมใส่และใช้งาน
  9. 7. UI แบบตาราง
  10. ทดสอบ
  11. Common errors
  12. กับ RoCode
  13. คำถามที่พบบ่อย
  14. แหล่งข้อมูลและบทความแนะนำ

อินเวนทอรีทำงานอย่างไร

ภาพประกอบกด B เอาเมาส์ไปวางที่ไอเทมเพื่ออ่านคำอธิบาย คลิก Sword เพื่อถือไว้ในมือ

ระบบมีหกส่วนเล็ก ๆ แต่ละส่วนมีหน้าที่เดียว กฎเรื่องไอเทมทั้งหมดอยู่ในโมดูลฝั่งเซิร์ฟเวอร์ตัวเดียว เมื่ออะไรพัง จึงต้องหาที่เดียวพอดี

ส่วนของระบบและที่ที่มันทำงาน
ส่วนชนิดและที่อยู่หน้าที่
ItemCatalogModuleScript ใน ReplicatedStorageไอเทมแต่ละชิ้นคืออะไร: ชื่อ คำอธิบาย สแตกสูงสุด และสวมใส่หรือใช้ได้หรือไม่ เซิร์ฟเวอร์และทุกไคลเอนต์อ่านมัน
InventoryServiceModuleScript ใน ServerScriptServiceเก็บช่องของผู้เล่นทุกคน เป็นโค้ดเดียวที่เพิ่ม ลบ และรวมไอเทมเป็นสแตก
InventoryDataScript ใน ServerScriptServiceโหลดไอเทมของผู้เล่นตอนเข้าเกมและบันทึกมัน
InventoryActionsScript ใน ServerScriptServiceตรวจและทำคำขอสวมใส่และใช้งาน
ItemPickupScript ใน Partมอบไอเทมให้คนที่เก็บมัน
InventoryClientLocalScript ใน StarterPlayerScriptsวาดตารางและส่งคำขอ ไม่เปลี่ยนอะไรเอง

ข้อมูลไหลทางเดียว เซิร์ฟเวอร์เปลี่ยนอินเวนทอรี แล้วส่ง InventoryUpdated พร้อมอินเวนทอรีทั้งหมดให้ผู้เล่นคนนั้น และไคลเอนต์วาดใหม่ เมื่อผู้เล่นคลิกช่อง ไคลเอนต์ส่ง EquipItem หรือ UseItem พร้อม id ไอเทม เซิร์ฟเวอร์ตรวจคำขอ ทำการเปลี่ยนแปลง และสำเนาใหม่มาทางเดิม การส่งทั้งอินเวนทอรีง่ายกว่าส่งการเปลี่ยนแปลง และสำหรับไม่กี่สิบช่อง ข้อความยังเล็ก

ทำไมไคลเอนต์ไม่เพิ่มไอเทมเลย

มันน่าเพิ่มไอเทมใน LocalScript ที่แสดงมันโดยตรง: ผู้เล่นคลิก ช่องก็เต็ม วิธีนี้พังได้สองแบบ

  • ไม่มีใครเห็น การเปลี่ยนแปลงใน LocalScript มีอยู่แค่บนอุปกรณ์ของผู้เล่นคนนั้น เซิร์ฟเวอร์ไม่รู้ จึงไม่ถูกบันทึก และไม่มีสคริปต์ฝั่งเซิร์ฟเวอร์ใดใช้มันได้
  • ใครก็ปลอมได้ ถ้าแก้ด้วยรีโมตอย่าง AddItem(itemId, amount) ผู้โกงจะเรียกอีเวนต์นี้เองได้ ด้วยอาร์กิวเมนต์อะไรก็ได้และกี่ครั้งก็ได้ คู่มือความปลอดภัยของ Roblox บอกว่าเซิร์ฟเวอร์ต้องตรวจทุกอย่างที่ไคลเอนต์ส่งมาก่อนใช้

ในคู่มือนี้ ไคลเอนต์จึงทำได้แค่ขอให้ทำอะไรบางอย่างกับไอเทมที่ผู้เล่นมีอยู่แล้ว: "สวมสิ่งนี้" และ "ใช้สิ่งนี้" ในแต่ละคำขอมี id ไอเทมหนึ่งตัวและไม่มีจำนวน และบนเซิร์ฟเวอร์มันผ่านการตรวจชุดเดียว: เป็นสตริง ไอเทมนั้นมีอยู่ ผู้เล่นมีอย่างน้อยหนึ่งชิ้น และผู้เล่นส่งคำขอไม่เกินสี่ครั้งต่อวินาที จากนั้นเซิร์ฟเวอร์หา Tool เองจากแคตตาล็อก มันไม่รับ Tool, path หรือ instance จากไคลเอนต์เลย ตามที่คู่มือเดียวกันเตือนไว้

ไอเทมเข้าอินเวนทอรีผ่านโค้ดฝั่งเซิร์ฟเวอร์เท่านั้น: การเก็บของที่เซิร์ฟเวอร์ตรวจ การซื้อที่เซิร์ฟเวอร์หักเงินแล้ว (สร้างในคู่มือร้านค้า) รางวัลเควสต์หรือของดรอป เรื่องรีโมตโดยรวม พร้อมการตรวจอาร์กิวเมนต์ชนิดอื่น อ่านในคู่มือ RemoteEvent

ขั้นตอนที่ 1: เตรียม Explorer

สร้างอ็อบเจกต์เหล่านี้ด้วยมือ สคริปต์ในขั้นตอนถัดไปหามันตามชื่อ จึงต้องเขียนแต่ละชื่อให้ตรงกับที่นี่

  1. ใน ReplicatedStorage ใส่ Folder ชื่อ InventoryRemotes ข้างในใส่ RemoteEvent สามตัวชื่อ InventoryUpdated, EquipItem และ UseItem
  2. ใน ServerStorage ใส่ Folder ชื่อ ItemTools ข้างในใส่ Tool ชื่อ Sword และใน Tool ใส่ Part ชื่อ Handle (1 คูณ 4 คูณ 1 สตัดก็พอ) ตรวจว่าไม่ได้ติ๊ก Anchored ที่ Handle: Roblox เตือนว่าตัวละครจะติดอยู่กับที่ถ้าถือเครื่องมือที่มีพาร์ต anchor Tool ที่คุณมีอยู่แล้วก็ใช้ได้ ถ้าชื่อตรงกับแคตตาล็อกจากขั้นตอนที่ 2
  3. เพิ่มสคริปต์ไปตามขั้นตอน ต้นไม้แสดงว่าแต่ละตัวไปอยู่ที่ไหน
Explorer เมื่อทำคู่มือจบ
ReplicatedStorage
  ItemCatalog ModuleScript new
  InventoryRemotes Folder new
    InventoryUpdated RemoteEvent new
    EquipItem RemoteEvent new
    UseItem RemoteEvent new
ServerScriptService
  InventoryService ModuleScript new
  InventoryData Script new
  InventoryActions Script new
ServerStorage
  ItemTools Folder new
    Sword Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    InventoryClient LocalScript new
Workspace
  Apple Part new
    ItemPickup Script new

ขั้นตอนที่ 2: อธิบายไอเทมในแคตตาล็อก

แคตตาล็อกอธิบายไอเทมทุกชิ้นที่มีได้ครั้งเดียว จากนั้นอินเวนทอรีเก็บแค่ id ไอเทมและจำนวน ข้อมูลบันทึกจึงเล็ก และภายหลังคุณเปลี่ยนชื่อไอเทมหรือเขียนคำอธิบายใหม่ได้โดยไม่แตะข้อมูลบันทึกของใคร

ใส่ ModuleScript ใน ReplicatedStorage ตั้งชื่อว่า ItemCatalog แล้วแทนที่เนื้อหาด้วยโค้ดนี้:

ModuleScript ใน ReplicatedStorage ชื่อ ItemCatalog
-- ไอเทมทั้งหมดที่มีได้ในเกม รายการนี้เซิร์ฟเวอร์และทุก
-- ไคลเอนต์อ่าน มีแค่เซิร์ฟเวอร์ที่ตัดสินว่าใครมีอะไร
export type Item = {
	id: string, -- ต้องตรงกับคีย์ด้านล่าง
	name: string,
	description: string,
	maxStack: number, -- ไอเทมนี้ใส่ได้กี่ชิ้นในหนึ่งช่อง
	icon: string?, -- รูปแบบไม่บังคับ: "rbxassetid://" บวก ID รูปของคุณ
	toolName: string?, -- Tool ใน ServerStorage.ItemTools: ไอเทมสวมใส่ได้
	heal: number?, -- ฟื้นพลังชีวิตเท่าไร: ไอเทมเป็นของสิ้นเปลือง
}

local items: { [string]: Item } = {
	sword = {
		id = "sword",
		name = "Sword",
		description = "Equip it to put it in your hand.",
		maxStack = 1,
		toolName = "Sword",
	},
	apple = {
		id = "apple",
		name = "Apple",
		description = "Use it to restore 25 health.",
		maxStack = 10,
		heal = 25,
	},
	wood = {
		id = "wood",
		name = "Wood",
		description = "A building material.",
		maxStack = 50,
	},
}

local ItemCatalog = {}

-- คืนไอเทมที่มี id นี้ หรือ nil ถ้าไม่มีไอเทมนั้น
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

ฟิลด์ที่ไม่บังคับตัดสินว่าไอเทมทำอะไร toolName ทำให้มันสวมใส่ได้ heal ทำให้มันใช้ได้ และไอเทมที่ไม่มีทั้งสองฟิลด์ เช่นไม้ จะอยู่ในอินเวนทอรีจนกว่าโค้ดฝั่งเซิร์ฟเวอร์อื่นจะเอาออก (การคราฟต์ การขาย)

ถ้าจะเพิ่มไอเทม ให้เพิ่มรายการที่คีย์กับ id ตรงกัน id แยกตัวพิมพ์ใหญ่เล็กและเป็นสิ่งที่ถูกบันทึก จึงอย่าเปลี่ยน id เมื่อผู้เล่นมีไอเทมนั้นแล้วเด็ดขาด: ให้เปลี่ยน name ของมันแทน

ขั้นตอนที่ 3: เก็บอินเวนทอรีบนเซิร์ฟเวอร์

ModuleScript นี้เป็นเจ้าของอินเวนทอรีของผู้เล่นทุกคน อินเวนทอรีแต่ละชุดคือรายการช่อง แต่ละช่องมี id ไอเทมและจำนวน บวกความจุ 20 ช่อง สคริปต์ฝั่งเซิร์ฟเวอร์อื่นเรียกฟังก์ชันของมัน และไม่มีใครอื่นแก้ตาราง

ใส่ ModuleScript ใน ServerScriptService และตั้งชื่อว่า InventoryService:

ModuleScript ใน ServerScriptService ชื่อ InventoryService
-- โค้ดเดียวที่เปลี่ยนอินเวนทอรี มันอยู่ใน ServerScriptService
-- ที่ไคลเอนต์ทั้งมองไม่เห็นและรันมันไม่ได้
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- โหมด strict ไม่เห็นว่า require ผ่าน WaitForChild คืนอะไร จึง
-- อธิบายส่วนของโมดูลที่สคริปต์นี้ใช้
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent

export type Slot = { id: string, count: number }
type Inventory = { slots: { Slot }, capacity: number, equipped: string? }

local CAPACITY = 20 -- ช่องต่อผู้เล่น
local STARTER_ITEMS: { Slot } = { -- ผู้เล่นใหม่เอี่ยมเริ่มด้วยอะไร
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

local inventories: { [Player]: Inventory } = {}

local InventoryService = {}

-- ส่งสำเนาอินเวนทอรีให้เจ้าของ เรียกหลังทุกการเปลี่ยนแปลง
local function sync(player: Player)
	local inventory = inventories[player]
	if inventory then
		inventoryUpdated:FireClient(player, {
			capacity = inventory.capacity,
			slots = inventory.slots,
			equipped = inventory.equipped,
		})
	end
end

-- กฎของสแตก: เติมสแตกที่ไม่เต็มก่อน แล้วเริ่มสแตกใหม่
-- ในช่องว่าง คืนจำนวนที่เพิ่ม ซึ่งอาจน้อยกว่าที่ขอ
local function addToInventory(inventory: Inventory, item: Item, amount: number): number
	local remaining = amount
	for _, slot in inventory.slots do
		if remaining == 0 then
			break
		end
		if slot.id == item.id and slot.count < item.maxStack then
			local moved = math.min(item.maxStack - slot.count, remaining)
			slot.count += moved
			remaining -= moved
		end
	end
	while remaining > 0 and #inventory.slots < inventory.capacity do
		local moved = math.min(item.maxStack, remaining)
		table.insert(inventory.slots, { id = item.id, count = moved })
		remaining -= moved
	end
	return amount - remaining
end

function InventoryService.count(player: Player, itemId: string): number
	local inventory = inventories[player]
	local total = 0
	if inventory then
		for _, slot in inventory.slots do
			if slot.id == itemId then
				total += slot.count
			end
		end
	end
	return total
end

-- ไอเทมใส่ได้อีกเท่าไร: ที่ว่างในสแตกของมันบวกช่องว่าง
function InventoryService.spaceFor(player: Player, itemId: string): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	if not inventory or not item then
		return 0
	end
	local space = (inventory.capacity - #inventory.slots) * item.maxStack
	for _, slot in inventory.slots do
		if slot.id == itemId then
			space += item.maxStack - slot.count
		end
	end
	return space
end

-- เพิ่มไอเทมไม่เกิน amount ชิ้น คืนจำนวนที่เพิ่ม (0 ถ้า
-- ไม่มีไอเทมนั้น อินเวนทอรีเต็ม หรือยังโหลดไม่เสร็จ)
function InventoryService.add(player: Player, itemId: string, amount: number): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	local wanted = math.floor(amount)
	if not inventory or not item or wanted < 1 then
		return 0
	end
	local added = addToInventory(inventory, item, wanted)
	if added > 0 then
		sync(player)
	end
	return added
end

-- ลบไอเทมออก amount ชิ้นพอดี เริ่มจากสแตกท้าย ๆ
-- ถ้าผู้เล่นมีน้อยกว่า จะไม่ลบอะไรและคืน false
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
	local inventory = inventories[player]
	local wanted = math.floor(amount)
	if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
		return false
	end
	local remaining = wanted
	-- ไล่จากท้าย เพื่อไม่ให้ table.remove ข้ามช่อง
	for index = #inventory.slots, 1, -1 do
		local slot = inventory.slots[index]
		if slot.id == itemId then
			local taken = math.min(slot.count, remaining)
			slot.count -= taken
			remaining -= taken
			if slot.count == 0 then
				table.remove(inventory.slots, index)
			end
			if remaining == 0 then
				break
			end
		end
	end
	sync(player)
	return true
end

function InventoryService.getEquipped(player: Player): string?
	local inventory = inventories[player]
	return if inventory then inventory.equipped else nil
end

function InventoryService.setEquipped(player: Player, itemId: string?)
	local inventory = inventories[player]
	if inventory then
		inventory.equipped = itemId
		sync(player)
	end
end

-- เรียกเมื่อข้อมูลบันทึกของผู้เล่นโหลดแล้ว saved คือสิ่งที่
-- ที่เก็บข้อมูลคืน: nil สำหรับผู้เล่นใหม่ ทุกรายการผ่าน
-- กฎของสแตกใหม่ ไอเทมที่ถูกลบและขนาดสแตกเก่าจึงไม่ทำให้อะไรพัง
function InventoryService.load(player: Player, saved: any)
	local inventory: Inventory = { slots = {}, capacity = CAPACITY }
	local entries: { Slot } = STARTER_ITEMS
	if type(saved) == "table" and type(saved.slots) == "table" then
		entries = {}
		for _, entry in saved.slots do
			if type(entry) == "table" and type(entry.id) == "string" and type(entry.count) == "number" then
				table.insert(entries, { id = entry.id, count = math.floor(entry.count) })
			end
		end
	end
	for _, entry in entries do
		local item = ItemCatalog.get(entry.id)
		if item and entry.count > 0 then
			addToInventory(inventory, item, entry.count)
		end
	end
	inventories[player] = inventory
	sync(player)
end

-- สำเนาธรรมดาสำหรับบันทึก หรือ nil ถ้าข้อมูลของผู้เล่นไม่เคยโหลดสำเร็จ
function InventoryService.serialize(player: Player): { version: number, slots: { Slot } }?
	local inventory = inventories[player]
	if not inventory then
		return nil
	end
	local slots: { Slot } = {}
	for index, slot in inventory.slots do
		slots[index] = { id = slot.id, count = slot.count }
	end
	return { version = 1, slots = slots }
end

function InventoryService.unload(player: Player)
	inventories[player] = nil
end

return InventoryService

บรรทัด type และการแปลงชนิด :: หลัง require มีไว้ให้ตัวตรวจชนิดของ Luau เท่านั้น ซึ่งไม่เห็นว่าโมดูลที่หาผ่าน WaitForChild คืนอะไร ระหว่างเล่นมันไม่เปลี่ยนอะไร สคริปต์อื่นในคู่มือนี้ทำแบบเดียวกัน

กฎของสแตกทำงานอย่างไรกับแคตตาล็อกด้านบน ที่แอปเปิลซ้อนได้ถึง 10:

  • ถ้าเพิ่มแอปเปิล 15 ลูกให้ผู้เล่นที่มีสแตก 7 สแตกนั้นจะเต็มเป็น 10 แล้วเริ่มสแตกใหม่ที่มี 5
  • เมื่อช่องหมด add เพิ่มเท่าที่ใส่ได้และคืนตัวเลขนั้น เรียก spaceFor ก่อนเมื่อต้องการแบบทั้งหมดหรือไม่เลย เหมือนการเก็บของในขั้นตอนที่ 5
  • remove ทำงานแบบทั้งหมดหรือไม่เลย การขอแอปเปิล 3 ลูกจากผู้เล่นที่มี 2 ลูกจะไม่ลบอะไรและคืน false จึงต้องตรวจผลก่อนจะให้อะไรเป็นการตอบแทน
  • ช่องไม่มีรู: เมื่อช่องว่างลง ช่องที่เหลือจะเลื่อนขึ้น รายการจึงส่งและบันทึกได้ง่ายกว่า เรื่องช่องที่คงตำแหน่งไว้ อธิบายในคำถามท้ายบท
สคริปต์ฝั่งเซิร์ฟเวอร์อื่นเรียกอะไรได้
ฟังก์ชันคืนค่าใช้ทำอะไร
add(player, itemId, amount)จำนวนที่เพิ่มการเก็บของ รางวัล การซื้อ
remove(player, itemId, amount)true ถ้าลบได้ทั้งหมดการใช้ การขาย การคราฟต์
count(player, itemId)ผลรวมทุกสแตกตรวจว่าผู้เล่นมีอะไร
spaceFor(player, itemId)ใส่ได้อีกเท่าไรตรวจก่อนเพิ่มแบบทั้งหมดหรือไม่เลย
getEquipped, setEquippedid ของไอเทมที่สวมใส่หรือ nilการสวมใส่ ในขั้นตอนที่ 6
load, serialize, unloadสำเนาพร้อมบันทึก (serialize)การโหลดและบันทึก ในขั้นตอนที่ 4

ขั้นตอนที่ 4: โหลดและบันทึกทุกอินเวนทอรี

อินเวนทอรีอยู่ในหน่วยความจำของเซิร์ฟเวอร์ จึงหายไปเมื่อผู้เล่นออก สคริปต์นี้โหลดช่องของผู้เล่นจากที่เก็บข้อมูลเมื่อเขาเข้า และเขียนกลับเมื่อเขาออก เมื่อเซิร์ฟเวอร์ปิด และทุกสามนาทีเผื่อเซิร์ฟเวอร์พัง มันบันทึกแค่ id ไอเทมและจำนวน: ที่เก็บข้อมูลเก็บ Instance อย่าง Tool ไม่ได้

ใส่ Script ใน ServerScriptService และตั้งชื่อว่า InventoryData:

Script ใน ServerScriptService ชื่อ InventoryData
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	load: (player: Player, saved: any) -> (),
	serialize: (player: Player) -> any,
	unload: (player: Player) -> (),
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local STORE_NAME = "PlayerInventory_v1"
local LOAD_ATTEMPTS = 3
local AUTOSAVE_SECONDS = 180

-- บันทึกเฉพาะผู้เล่นที่ข้อมูลโหลดสำเร็จ หลังการโหลดที่ล้มเหลว
-- ห้ามบันทึก ไม่อย่างนั้นอินเวนทอรีว่างจะแทนที่ของจริง
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

local function keyFor(player: Player): string
	return "User_" .. player.UserId
end

-- คำขอที่ล้มเหลวครั้งเดียวไม่ควรทำให้ใครเสียไอเทม จึงลองหลายครั้ง
-- GetDataStore ก็อยู่ใน pcall ด้วย เซสชัน Studio ที่ไม่มีสิทธิ์เข้าถึงที่
-- เก็บข้อมูลจึงได้คำเตือน แทนที่จะหยุดสคริปต์นี้
local function loadSaved(player: Player): (boolean, any)
	for attempt = 1, LOAD_ATTEMPTS do
		local ok, result = pcall(function()
			return DataStoreService:GetDataStore(STORE_NAME):GetAsync(keyFor(player))
		end)
		if ok then
			return true, result
		end
		warn(`Inventory load failed for {player.Name} (attempt {attempt}): {result}`)
		if attempt < LOAD_ATTEMPTS then
			task.wait(attempt * 2)
		end
	end
	return false, nil
end

local function onPlayerAdded(player: Player)
	local ok, saved = loadSaved(player)
	if player.Parent ~= Players then
		return -- ผู้เล่นออกไประหว่างที่เราโหลด
	end
	if ok then
		InventoryService.load(player, saved) -- saved เป็น nil สำหรับผู้เล่นใหม่
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- มักแปลว่าสิทธิ์ของ Studio ในการเข้าถึง API services ปิดอยู่ เล่นด้วย
		-- ไอเทมเริ่มต้นเพื่อให้ทดสอบได้ แต่ไม่บันทึกมันเลย
		warn("Inventory not loaded: playing with starter items that will not be saved")
		InventoryService.load(player, nil)
	else
		player:Kick("Your inventory could not be loaded. Please rejoin in a minute.")
	end
end

local function save(player: Player)
	if not canSave[player] then
		return -- ข้อมูลไม่เคยโหลดสำเร็จ ไม่มีอะไรที่เขียนได้อย่างปลอดภัย
	end
	local data = InventoryService.serialize(player)
	if not data then
		return
	end
	activeSaves += 1
	local ok, err = pcall(function()
		DataStoreService:GetDataStore(STORE_NAME):SetAsync(keyFor(player), data, { player.UserId })
	end)
	activeSaves -= 1
	if not ok then
		warn(`Inventory save failed for {player.Name}: {err}`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	save(player)
	canSave[player] = nil
	InventoryService.unload(player)
end)

-- เมื่อเซิร์ฟเวอร์ปิด บันทึกทุกคนที่ยังอยู่ และรอทุก
-- การบันทึกที่ทำงานอยู่ รวมถึงที่ PlayerRemoving เริ่มไว้
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- บันทึกทุกคนทุกไม่กี่นาที เพื่อให้เซิร์ฟเวอร์พังเสียแค่ไม่กี่นาที ไม่ใช่ทั้งเซสชัน
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

สคริปต์ทำอะไรและทำไม:

  • โหลดพร้อมค่าเริ่มต้น ผู้เล่นใหม่ไม่มีค่าที่บันทึกไว้ GetAsync จึงคืน nil และเขาได้ไอเทมเริ่มต้น ช่องที่บันทึกไว้ผ่านกฎของสแตกใหม่ ไอเทมที่ถูกลบออกจากแคตตาล็อกหรือสแตกสูงสุดที่ลดลงจึงไม่ทำให้การโหลดพัง ทุกอย่างที่ใส่ไม่ได้แล้วหรือ id ไม่อยู่ในแคตตาล็อกแล้วจะถูกทิ้ง และการบันทึกครั้งถัดไปทำให้มันถาวร จึงต้องเก็บทุก id ที่ผู้เล่นอาจมีไว้ในแคตตาล็อก
  • ไม่บันทึกหลังการโหลดที่ล้มเหลวเลย เขียนเฉพาะผู้เล่นที่อยู่ใน canSave บนเซิร์ฟเวอร์จริง ผู้เล่นที่ข้อมูลโหลดไม่สำเร็จแม้หลังลองสามครั้ง จะถูกขอให้เข้าใหม่ ใน Studio เขาได้ไอเทมเริ่มต้นที่ไม่ถูกบันทึกแทน ช้าลงไม่กี่วินาทีเพราะการลองใหม่ จะเป็นแบบนี้จนกว่า place จะเผยแพร่พร้อมเปิดสิทธิ์ API
  • บันทึกตอนออกและตอนปิด BindToClose บันทึกทุกคนที่ยังอยู่บนเซิร์ฟเวอร์ และรอการบันทึกที่ทำงานอยู่ Roblox ให้เวลาฟังก์ชันที่ผูกไว้ไม่เกิน 30 วินาที
  • ไม่เกินขีดจำกัด เขียนหนึ่งครั้งต่อผู้เล่นทุกสามนาที บวกหนึ่งครั้งตอนออก ซึ่งน้อยกว่างบมาตรฐานของเซิร์ฟเวอร์ 60 ครั้งต่อนาทีบวก 40 ต่อผู้เล่นแต่ละคนมาก (ตามเอกสาร ณ 30 กันยายน 2026) รูปแบบคีย์ User_ มาจากคำแนะนำของ Roblox และการส่ง user ID ไปใน SetAsync ผูกข้อมูลกับผู้เล่นคนนี้ ซึ่ง Roblox แนะนำอย่างยิ่งสำหรับการจัดการคำขอลบข้อมูล

สำหรับเกมเล็ก นี่คือฐานที่เชื่อถือได้ session locking ที่กันผู้เล่นที่ย้ายเซิร์ฟเวอร์เร็ว ๆ ไม่ให้โหลดข้อมูลก่อนที่เซิร์ฟเวอร์เก่าจะบันทึก และเมื่อไรควรใช้ UpdateAsync แทน SetAsync อธิบายไว้ในบทเรียน DataStore

ขั้นตอนที่ 5: มอบไอเทมจากในโลก

การเก็บของเป็นวิธีที่ง่ายที่สุดที่ไอเทมเข้าอินเวนทอรี: พาร์ตที่มี ProximityPrompt ซึ่งเพิ่มไอเทมเมื่อผู้เล่นใช้มัน สคริปต์ฟังอีเวนต์ Triggered ของมันบนเซิร์ฟเวอร์ ไอเทมจึงถูกเพิ่มในที่ที่ไคลเอนต์แทรกแซงไม่ได้

  1. เพิ่ม Part ใน Workspace ตั้งชื่อว่า Apple และทาสีแดง เปิด Anchored และปิด CanCollide เพื่อไม่ให้ใครชนมันขณะที่มันล่องหน พรอมต์แสดงชื่อพาร์ต
  2. ขณะเลือกพาร์ต เลื่อนหน้าต่าง Properties ลงไปที่ส่วน Attributes แล้วกด + เพิ่ม ItemId ชนิด string แล้วกด Save จากนั้นตั้งค่าเป็น apple เพิ่ม Amount ชนิด number ค่า 1 แบบเดียวกัน
  3. ใส่ Script ในพาร์ต ตั้งชื่อว่า ItemPickup แล้ววางโค้ดนี้:
Script ใน พาร์ต Apple ใน Workspace ชื่อ ItemPickup
-- ใส่ Script นี้ใน Part และให้ Part มีแอตทริบิวต์สองตัว:
-- ItemId (สตริง เช่น apple) และ Amount (ตัวเลข เช่น 1)
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	add: (player: Player, itemId: string, amount: number) -> number,
	spaceFor: (player: Player, itemId: string) -> number,
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local part = script.Parent :: BasePart
local RESPAWN_SECONDS = 15

local itemId = part:GetAttribute("ItemId")
local amount = part:GetAttribute("Amount")
if typeof(itemId) ~= "string" or typeof(amount) ~= "number" or amount < 1 then
	error(`{part:GetFullName()} needs an ItemId (string) and an Amount (number, 1 or more) attribute`)
end

local prompt = Instance.new("ProximityPrompt")
prompt.ActionText = "Pick up"
prompt.ObjectText = part.Name
prompt.Parent = part

local visibleTransparency = part.Transparency

prompt.Triggered:Connect(function(player: Player)
	if not prompt.Enabled then
		return -- มีคนอื่นเพิ่งเก็บมันไป
	end
	-- ตรวจระยะบนเซิร์ฟเวอร์ ไม่เชื่อคำขอ
	local character = player.Character
	if not character then
		return
	end
	local distance = (character:GetPivot().Position - part.Position).Magnitude
	if distance > prompt.MaxActivationDistance + 5 then
		return
	end
	if InventoryService.spaceFor(player, itemId) < amount then
		return -- ที่ไม่พอ: ปล่อยไอเทมไว้ที่เดิม
	end
	InventoryService.add(player, itemId, amount)

	prompt.Enabled = false
	part.Transparency = 1
	task.wait(RESPAWN_SECONDS)
	part.Transparency = visibleTransparency
	prompt.Enabled = true
end)

ก๊อปพาร์ตเพื่อวางไอเทมเพิ่ม เปลี่ยนแอตทริบิวต์เพื่อมอบไม้ ดาบอีกเล่ม หรือแอปเปิลหนึ่งสแตก

Roblox ตรวจระยะสำหรับ Triggered แต่คู่มือความปลอดภัยของมันยังสั่งให้ตรวจพรอมต์บนเซิร์ฟเวอร์: ผู้โกงเรียกอีเวนต์ของพรอมต์ได้แม้ Enabled เป็น false และดึงพาร์ตที่ไม่ได้ anchor มาหาตัวละครของตัวเองได้ สคริปต์จึงตรวจ Enabled และระยะเอง และนั่นคือเหตุผลที่พาร์ต anchor ไว้

สคริปต์ฝั่งเซิร์ฟเวอร์อื่นใดก็มอบไอเทมแบบเดียวกัน หลังการซื้อ เควสต์ หรือการฆ่า ให้ require InventoryService เหมือนสคริปต์ด้านบน แล้วเรียก InventoryService.add(player, "wood", 5) ตรวจ spaceFor ก่อนเมื่อไอเทมห้ามหาย NPC ก็เป็นอีกแหล่งได้: ในคู่มือบทสนทนา NPC คำตอบเรียกการกระทำบนเซิร์ฟเวอร์ และการกระทำนั้นเรียก InventoryService.add แบบเดียวกันได้

ขั้นตอนที่ 6: การสวมใส่ Tool และการใช้ไอเทม

RemoteEvent สองตัวรับส่งคำขอเดียวที่ไคลเอนต์ทำได้ EquipItem วางสำเนา Tool ของไอเทมจาก ServerStorage ไว้ใน Backpack ของผู้เล่น (ฮอตบาร์ด้านล่างจอ) และในมือ และคำขอซ้ำจะเก็บมัน UseItem ลบไอเทมที่ใช้ได้หนึ่งชิ้นและใช้ผลของมัน ในที่นี้คือการฟื้นพลังชีวิต

ใส่ Script ใน ServerScriptService และตั้งชื่อว่า InventoryActions:

Script ใน ServerScriptService ชื่อ InventoryActions
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local ServerStorage = game:GetService("ServerStorage")

type Item = { id: string, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type InventoryApi = {
	count: (player: Player, itemId: string) -> number,
	remove: (player: Player, itemId: string, amount: number) -> boolean,
	getEquipped: (player: Player) -> string?,
	setEquipped: (player: Player, itemId: string?) -> (),
}
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent
local itemTools = ServerStorage:WaitForChild("ItemTools")

local COOLDOWN_SECONDS = 0.25
local lastRequest: { [Player]: number } = {}

-- ทุกคำขอเริ่มที่นี่ ไคลเอนต์ส่งอะไรก็ได้เมื่อไรก็ได้ จึง
-- ตรวจชนิด ว่าไอเทมมีอยู่ ว่าผู้เล่นมีมัน และความถี่
local function ownedItem(player: Player, itemId: unknown): Item?
	if typeof(itemId) ~= "string" then
		return nil
	end
	local now = os.clock()
	if now - (lastRequest[player] or 0) < COOLDOWN_SECONDS then
		return nil
	end
	lastRequest[player] = now
	local item = ItemCatalog.get(itemId)
	if not item or InventoryService.count(player, itemId) < 1 then
		return nil
	end
	return item
end

-- ทำลาย Tool ของไอเทมนี้ ไม่ว่าสำเนาจะอยู่ที่ไหน: ฮอตบาร์ มือ หรือ StarterGear
local function destroyTools(container: Instance?, itemId: string)
	if not container then
		return
	end
	for _, child in container:GetChildren() do
		if child:IsA("Tool") and child:GetAttribute("InventoryItem") == itemId then
			child:Destroy()
		end
	end
end

local function unequip(player: Player)
	local equippedId = InventoryService.getEquipped(player)
	if equippedId then
		destroyTools(player:FindFirstChildOfClass("Backpack"), equippedId)
		destroyTools(player.Character, equippedId)
		destroyTools(player:FindFirstChildOfClass("StarterGear"), equippedId)
		InventoryService.setEquipped(player, nil)
	end
end

local function equip(player: Player, item: Item, toolName: string)
	local template = itemTools:FindFirstChild(toolName)
	local backpack = player:FindFirstChildOfClass("Backpack")
	if not template or not template:IsA("Tool") or not backpack then
		warn(`Cannot equip {item.id}: no Tool named {toolName} in ServerStorage.ItemTools`)
		return
	end
	unequip(player) -- สวมเครื่องมือได้ทีละชิ้น

	local tool = template:Clone()
	tool.CanBeDropped = false -- สำเนาที่ถูกทิ้งอาจถูกคนอื่นเก็บไป
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- สำเนาที่สองใน StarterGear ถูกก๊อปกลับไปที่ Backpack หลังเกิดใหม่
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		local gearCopy = tool:Clone()
		gearCopy.Parent = starterGear
	end

	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		humanoid:EquipTool(tool) -- เข้ามือทันที
	end
	InventoryService.setEquipped(player, item.id)
end

equipItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.toolName then
		return
	end
	if InventoryService.getEquipped(player) == item.id then
		unequip(player) -- คลิกไอเทมที่สวมอยู่อีกครั้งจะเก็บมัน
	else
		equip(player, item, item.toolName)
	end
end)

useItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.heal then
		return
	end
	local heal = item.heal
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
		return -- ตายแล้วหรือพลังชีวิตเต็มอยู่แล้ว: ไม่เปลืองไอเทม
	end
	-- เอาไอเทมไปก่อน และฟื้นพลังชีวิตเฉพาะเมื่อสำเร็จ
	if InventoryService.remove(player, item.id, 1) then
		humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)
แต่ละคำขอได้รับอนุญาตให้ทำอะไร
คำขอไคลเอนต์ส่งเซิร์ฟเวอร์ตรวจก่อนทำ
EquipItemid ไอเทมเป็นสตริง ไอเทมมีอยู่ ผู้เล่นมีมัน คำขอมาไม่ถี่กว่าสี่ครั้งต่อวินาที ไอเทมมี toolName และ Tool ชื่อนั้นอยู่ใน ServerStorage.ItemTools
UseItemid ไอเทมการตรวจชนิด การเป็นเจ้าของ และความถี่แบบเดียวกัน ไอเทมมีค่า heal ตัวละครยังมีชีวิตและบาดเจ็บ และไอเทมหนึ่งชิ้นถูกลบก่อนเพิ่มพลังชีวิต

รายละเอียดสามอย่างกันไม่ให้ Tool ซ้ำหรือหาย สำเนามี CanBeDropped เป็น false เพราะ Tool ที่ถูกทิ้งตกลงใน Workspace ซึ่งผู้เล่นอื่นเก็บไปได้ ขณะที่ต้นฉบับยังอยู่ในอินเวนทอรี ทุกสำเนามีแอตทริบิวต์ InventoryItem ตอนถอดจึงหาและทำลายทุกสำเนาได้ไม่ว่ามันอยู่ที่ไหน และถ้าผู้เล่นมีคอนเทนเนอร์ StarterGear สำเนาที่สองจะถูกใส่ในนั้น Roblox ก๊อป StarterGear ไปที่ Backpack ทุกครั้งที่ตัวละครปรากฏ ดาบที่สวมอยู่จึงกลับมาหลังเกิดใหม่

สวมใส่ Tool ได้ทีละชิ้น และการสวมใส่ไม่ถูกบันทึก ผู้เล่นที่เข้าใหม่จึงเริ่มด้วยฮอตบาร์ว่าง ถ้าภายหลังคุณเพิ่มการขายหรือการทิ้ง ให้ถอดไอเทมก่อนที่สำเนาสุดท้ายจะออกจากอินเวนทอรี

ดาบตัวแทนเปลี่ยนเป็นดาบที่สู้ได้จริงได้: สร้าง Tool ตามคู่มือดาบ ตั้งชื่อเป็น Sword เหมือนเดิม และใส่ใน ItemTools แทนตัวแทน สคริปต์ฝั่งเซิร์ฟเวอร์จากคู่มือนั้นจะตรวจทุกการฟัน ไม่ว่าผู้เล่นได้ดาบมาอย่างไร

ขั้นตอนที่ 7: วาดตารางอินเวนทอรี

LocalScript สร้างหน้าต่างทั้งหมดในโค้ด จึงไม่ต้องจัดวางอะไรด้วยมือ ScrollingFrame เก็บช่อง UIGridLayout ข้างในจัดเรียงเป็นแถว และ AutomaticCanvasSize ขยายพื้นที่เลื่อนเมื่อมีแถวเพิ่ม

ใน Explorer เปิด StarterPlayer ใส่ LocalScript ใน StarterPlayerScripts และตั้งชื่อว่า InventoryClient:

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

type Item = { name: string, description: string, icon: string?, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type Slot = { id: string, count: number }
type Snapshot = { capacity: number, slots: { Slot }, equipped: string? }

local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent

local player = Players.LocalPlayer
local TOGGLE_KEY = Enum.KeyCode.B

local COLOURS = {
	panel = Color3.fromRGB(24, 20, 36),
	slot = Color3.fromRGB(44, 38, 64),
	empty = Color3.fromRGB(34, 30, 48),
	equipped = Color3.fromRGB(124, 77, 255),
	text = Color3.fromRGB(240, 238, 245),
	muted = Color3.fromRGB(170, 165, 185),
}

local function addCorner(parent: GuiObject, radius: number)
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, radius)
	corner.Parent = parent
end

local function makeLabel(parent: GuiObject, text: string, textSize: number): TextLabel
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Font = Enum.Font.BuilderSansBold
	label.TextColor3 = COLOURS.text
	label.TextSize = textSize
	label.Text = text
	label.Parent = parent
	return label
end

-- 1. สร้างหน้าต่างครั้งเดียว ResetOnSpawn = false เก็บมันไว้หลังเกิดใหม่
local gui = Instance.new("ScreenGui")
gui.Name = "InventoryGui"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local openButton = Instance.new("TextButton")
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(140, 40)
openButton.BackgroundColor3 = COLOURS.panel
openButton.Font = Enum.Font.BuilderSansBold
openButton.TextColor3 = COLOURS.text
openButton.TextSize = 18
openButton.Text = "Inventory (B)"
addCorner(openButton, 8)
openButton.Parent = gui

local panel = Instance.new("Frame")
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.9, 0.8)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
addCorner(panel, 12)
panel.Parent = gui

local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(440, 400)
sizeLimit.Parent = panel

local title = makeLabel(panel, "Inventory", 22)
title.Position = UDim2.fromOffset(16, 8)
title.Size = UDim2.new(1, -32, 0, 32)
title.TextXAlignment = Enum.TextXAlignment.Left

local slotCount = makeLabel(panel, "", 16)
slotCount.Position = UDim2.fromOffset(16, 8)
slotCount.Size = UDim2.new(1, -32, 0, 32)
slotCount.TextColor3 = COLOURS.muted
slotCount.TextXAlignment = Enum.TextXAlignment.Right

local grid = Instance.new("ScrollingFrame")
grid.Position = UDim2.fromOffset(12, 48)
grid.Size = UDim2.new(1, -24, 1, -100)
grid.BackgroundTransparency = 1
grid.BorderSizePixel = 0
grid.CanvasSize = UDim2.new() -- AutomaticCanvasSize ขยายมันตามเซลล์
grid.AutomaticCanvasSize = Enum.AutomaticSize.Y
grid.ScrollingDirection = Enum.ScrollingDirection.Y
grid.ScrollBarThickness = 6
grid.Parent = panel

local layout = Instance.new("UIGridLayout")
layout.CellSize = UDim2.fromOffset(72, 72)
layout.CellPadding = UDim2.fromOffset(8, 8)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = grid

local info = makeLabel(panel, "Click an item to equip or use it.", 16)
info.AnchorPoint = Vector2.new(0, 1)
info.Position = UDim2.new(0, 16, 1, -8)
info.Size = UDim2.new(1, -32, 0, 40)
info.Font = Enum.Font.BuilderSans
info.TextColor3 = COLOURS.muted
info.TextWrapped = true
info.TextXAlignment = Enum.TextXAlignment.Left

-- 2. หนึ่งเซลล์ต่อหนึ่งช่อง นี่แค่วาดสิ่งที่เซิร์ฟเวอร์ส่งมา ตัว
-- อินเวนทอรีเองไม่เคยถูกเปลี่ยนจากที่นี่
local function makeCell(index: number, slot: Slot?, equippedId: string?)
	local cell = Instance.new("TextButton")
	cell.LayoutOrder = index
	cell.Text = ""
	cell.AutoButtonColor = slot ~= nil
	cell.BackgroundColor3 = if slot then COLOURS.slot else COLOURS.empty
	addCorner(cell, 8)
	cell.Parent = grid
	if not slot then
		return -- ช่องว่าง
	end

	local itemId = slot.id
	local item = ItemCatalog.get(itemId)
	local name = if item then item.name else itemId

	if item and item.icon then
		local image = Instance.new("ImageLabel")
		image.BackgroundTransparency = 1
		image.Size = UDim2.fromScale(1, 1)
		image.Image = item.icon
		image.Parent = cell
	else
		local nameLabel = makeLabel(cell, name, 14)
		nameLabel.Size = UDim2.fromScale(1, 1)
		nameLabel.TextWrapped = true
	end

	if slot.count > 1 then
		local countLabel = makeLabel(cell, `x{slot.count}`, 14)
		countLabel.AnchorPoint = Vector2.new(1, 1)
		countLabel.Position = UDim2.new(1, -6, 1, -4)
		countLabel.Size = UDim2.fromOffset(40, 16)
		countLabel.TextXAlignment = Enum.TextXAlignment.Right
	end

	if itemId == equippedId then
		local outline = Instance.new("UIStroke")
		outline.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
		outline.Color = COLOURS.equipped
		outline.Thickness = 3
		outline.Parent = cell
	end

	cell.MouseEnter:Connect(function()
		info.Text = if item then `{item.name}: {item.description}` else name
	end)
	cell.Activated:Connect(function()
		-- ขอ ไม่ใช่สั่ง: เซิร์ฟเวอร์ตรวจคำขอและส่งผลกลับมา
		if item and item.toolName then
			equipItem:FireServer(itemId)
		elseif item and item.heal then
			useItem:FireServer(itemId)
		end
	end)
end

local function render(snapshot: Snapshot)
	for _, child in grid:GetChildren() do
		if child:IsA("GuiButton") then
			child:Destroy()
		end
	end
	for index = 1, snapshot.capacity do
		makeCell(index, snapshot.slots[index], snapshot.equipped)
	end
	slotCount.Text = `{#snapshot.slots} / {snapshot.capacity} slots`
end

-- เซิร์ฟเวอร์ส่งสิ่งนี้หลังโหลดและหลังทุกการเปลี่ยนแปลง
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. เปิดและปิดด้วยปุ่มหรือปุ่ม B
local function toggle()
	panel.Visible = not panel.Visible
end

openButton.Activated:Connect(toggle)
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessedEvent: boolean)
	if not gameProcessedEvent and input.KeyCode == TOGGLE_KEY then
		toggle()
	end
end)

LocalScript ใน StarterPlayerScripts รันครั้งเดียวต่อเซสชัน และ ResetOnSpawn = false เก็บ ScreenGui ไว้เมื่อตัวละครเกิดใหม่ ตารางจึงยังแสดงสำเนาล่าสุดที่เซิร์ฟเวอร์ส่งมา

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

อยากวาดหน้าต่างใน Studio ไหม? สร้าง ScreenGui ที่มีช่องแม่แบบหนึ่งช่อง และ Clone มันใน makeCell สำหรับไอคอน ให้ตั้ง icon ของไอเทมในแคตตาล็อกเป็นรูปที่คุณอัปโหลด แล้วเซลล์ของมันจะแสดงรูปแทนชื่อ

ทดสอบอินเวนทอรี

  1. กด Play เปิดอินเวนทอรีด้วยปุ่มทางซ้ายหรือปุ่ม B: ผู้เล่นใหม่มี Sword และ Apple 3 ลูก และตัวนับแสดง 2 / 20 slots ขณะที่ Studio เข้าถึงที่เก็บข้อมูลไม่ได้ ไอเทมปรากฏหลังไม่กี่วินาที หลังคำเตือนเรื่องการโหลดใน Output และไม่ถูกบันทึก
  2. คลิก Sword ดาบจะปรากฏในมือคุณและในฮอตบาร์ และช่องของมันได้กรอบสีม่วง คลิกอีกครั้งเพื่อเก็บ
  3. เดินไปที่พาร์ต Apple แล้วใช้พรอมต์ของมัน สแตกแอปเปิลจะเพิ่มเป็น 4 และพาร์ตหายไป 15 วินาที
  4. ถ้าจะทดสอบการฟื้นพลังชีวิต ให้ลดพลังชีวิตก่อน สลับ Client/Server เป็น Server เลือก Humanoid ของตัวละครคุณใน Explorer ตั้ง Health เป็น 50 สลับกลับเป็น Client แล้วคลิก Apple
  5. เมื่อเปิดสิทธิ์ Studio ในการเข้าถึง API services แล้ว ให้หยุดเกมและรันใหม่ แอปเปิลที่เก็บมายังอยู่ ถ้าการโหลดหรือบันทึกไม่สำเร็จ Output จะบอก

ถ้าจะทดสอบกับผู้เล่นหลายคน ให้เลือก Server & Clients พร้อม 2 ไคลเอนต์ในการตั้งค่าทดสอบ ผู้เล่นแต่ละคนเห็นแค่อินเวนทอรีของตัวเอง และทั้งสองเห็นดาบในมือของอีกคน

ข้อผิดพลาดที่พบบ่อยและวิธีแก้

ปัญหาส่วนใหญ่เห็นได้ในหน้าต่าง Output เป็นคำเตือนหรือบรรทัดข้อผิดพลาดสีแดง อ่านบรรทัดแรก: ข้อผิดพลาดถัดไปมักเกิดจากมัน

Infinite yield possible ที่การเรียก WaitForChild

สคริปต์กำลังรออ็อบเจกต์ที่ไม่มีชื่อตรงแบบนั้น เทียบ Explorer ของคุณกับต้นไม้จากขั้นตอนที่ 1: InventoryRemotes ที่มี RemoteEvent สามตัวใน ReplicatedStorage, ItemTools ใน ServerStorage และโมดูลสองตัว ชื่อแยกตัวพิมพ์ใหญ่เล็ก คู่มือข้อผิดพลาดของสคริปต์อธิบายคำเตือนนี้ละเอียดขึ้น

ตารางเปิดได้ แต่ว่างเปล่า

ไคลเอนต์วาดแค่สิ่งที่เซิร์ฟเวอร์ส่งมา หาคำเตือน Inventory load failed ใน Output และตรวจว่า InventoryData เป็น Script ไม่ใช่ LocalScript ใน ServerScriptService และมี ModuleScript InventoryService อยู่ข้าง ๆ ถ้า Output แสดงข้อผิดพลาด Remote event invocation แปลว่าไม่มีใครบนไคลเอนต์ฟัง InventoryUpdated: หาข้อผิดพลาดก่อนหน้าจาก InventoryClient

ไอเทมรีเซ็ตทุกครั้งที่ฉันเล่นใน Studio

ถ้า Output เขียนว่า Inventory not loaded: playing with starter items that will not be saved แปลว่า place ยังไม่เผยแพร่ หรือสิทธิ์ Studio ในการเข้าถึง API services ปิดอยู่ เปิดมันตามที่อธิบายในขั้นตอนที่ 4 ในสำเนาทดสอบของเกมคุณ

คลิกดาบแล้วไม่มีอะไรเกิดขึ้น

หา Cannot equip sword ใน Output: Tool ใน ServerStorage.ItemTools ต้องมีชื่อตรงกับ toolName ในแคตตาล็อก Tool ยังต้องมีพาร์ตชื่อ Handle เพื่อให้ถือได้ เว้นแต่คุณตั้ง RequiresHandle เป็น false

พรอมต์เก็บของปรากฏ แต่ไม่มีอะไรถูกเพิ่ม

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

การบันทึกพังหลังจากฉันเปลี่ยนสิ่งที่บันทึก

ที่เก็บข้อมูลรับข้อมูลธรรมดา: สตริง ตัวเลข บูลีน และตารางของสิ่งเหล่านี้ การบันทึก Tool, Part หรือ Instance อื่นใดจะล้มเหลว หรือค่าถูกบันทึกเป็น nil ให้บันทึก id ไอเทมและจำนวน และสร้างที่เหลือจากแคตตาล็อก เหมือนที่ serialize ทำ

ทำด้วย RoCode

ถ้าคุณอธิบายระบบได้ง่ายกว่าประกอบเอง RoCode สร้างมันใน place ที่คุณเปิดอยู่ได้ มันคือเอเจนต์ AI สำหรับ Roblox Studio: คุณอธิบายฟีเจอร์ในแชตบนเว็บ แล้วปลั๊กอินสำหรับ Studio ของมันจะสร้างสคริปต์และอ็อบเจกต์ใน Explorer ของคุณ ไม่ใช่ให้โค้ดมาวางเอง

คุณพิมพ์

เพิ่มอินเวนทอรี 20 ช่องที่มีสแตกไอเทม UI แบบตารางที่เปิดด้วย B ดาบจาก ServerStorage ที่ผู้เล่นสวมได้ แอปเปิลที่ฟื้นพลังชีวิต และการบันทึกผ่าน DataStoreService

RoCode ทำให้
  • ดู place ของคุณได้เมื่อขั้นตอนต้องการ ผ่าน Search Game และ Search Scripts เพื่อต่อยอดไอเทม รีโมต หรือโค้ดบันทึกที่มีอยู่ แทนที่จะเพิ่มระบบที่สอง
  • สร้างโฟลเดอร์และ RemoteEvent ผ่าน Create Instance และ ModuleScript, Script และ LocalScript ผ่าน Create Script
  • สร้างโครงหน้าต่างผ่าน Build UI ได้ ซึ่งมีเลย์เอาต์อินเวนทอรีพร้อมช่องตัวแทน โค้ดที่เติมช่องจากเซิร์ฟเวอร์เขียนเป็นสคริปต์แยก
  • ตรวจการคอมไพล์ของทุกสคริปต์ใน Studio ผ่าน Check Script ซึ่งจับข้อผิดพลาดการคอมไพล์และรูปแบบเสี่ยงบางอย่าง แต่ไม่ตรวจชนิดข้อมูล ไม่ lint และไม่รันโค้ดของคุณ

การเปลี่ยนแปลงแต่ละชุดเป็นจุดย้อนกลับใน Studio RoCode เปิดสิทธิ์ Studio ในการเข้าถึง API services ไม่ได้ คุณต้องทำเอง กับปลั๊กอิน 3.9 ขึ้นไป มันรันเพลย์เทสต์สั้น ๆ และอ่านข้อผิดพลาดได้ และกับปลั๊กอิน 3.9.15 ขึ้นไป ตัวละครทดสอบของมันกดปุ่มและสวมไอเทมได้ แต่มันตรวจเฉพาะสิ่งที่เลือกทดสอบเอง ดังนั้นให้ตรวจการบันทึกด้วยเพลย์เทสต์ของคุณเอง อินเวนทอรีอยู่บนระบบอื่นอย่างการบันทึกและเครื่องมือ และตัวสร้างเกมด้วย AI ที่สร้างใน place ของคุณเองใน Studioเพิ่มระบบเหล่านั้นทีละพรอมต์ RoCode เชื่อมกับ Studio อย่างไร

คำถามที่พบบ่อย

ควรใช้ Backpack ของ Roblox แทนอินเวนทอรีของตัวเองไหม?

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

จะซ่อนฮอตบาร์มาตรฐานใน Roblox ได้อย่างไร?

จาก LocalScript เรียก StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) เมื่อฮอตบาร์ถูกซ่อน ผู้เล่นต้องมีวิธีอื่นในการหยิบและเก็บ Tool ที่สวม เช่นปุ่มที่ขอให้เซิร์ฟเวอร์เรียก Humanoid:EquipTool หรือ Humanoid:UnequipTools

จะทำให้ช่องคงตำแหน่งไว้สำหรับ drag and drop ได้อย่างไร?

เก็บรายการความยาวคงที่ หนึ่งรายการต่อหนึ่งช่อง และระบุช่องว่างด้วยค่าอย่าง id ว่าง ไม่ใช่ nil เพราะ Roblox ไม่แนะนำให้ส่งตารางที่มี nil ผ่าน RemoteEvent จากนั้นเพิ่ม RemoteEvent MoveItem ที่ส่งหมายเลขช่องสองตัว และให้เซิร์ฟเวอร์ตรวจว่าทั้งสองเป็นจำนวนเต็มตั้งแต่ 1 ถึงความจุ ก่อนสลับตำแหน่ง

อินเวนทอรีที่บันทึกใหญ่ได้แค่ไหน?

ค่าหนึ่งค่าในที่เก็บข้อมูลยาวได้ถึง 4,194,304 ตัวอักษรหลังแปลงเป็นข้อความ (ตามเอกสาร ณ 30 กันยายน 2026) รายการ id และจำนวนใช้แค่ส่วนเล็กจิ๋วของนั้น สิ่งที่ทำให้ขนาดข้อมูลบันทึกโตคือข้อความต่อไอเทม เช่นชื่อที่ตั้งเองหรือคำอธิบายยาว ๆ ที่บันทึกสำหรับแต่ละไอเทม

จะซื้อขายไอเทมด้วยเหรียญได้อย่างไร?

ทำทุกอย่างบนเซิร์ฟเวอร์ ถ้าจะขาย ให้เรียก InventoryService.remove และจ่ายเงินเฉพาะเมื่อมันคืน true ถ้าจะซื้อ ให้ตรวจราคาและ spaceFor หักเหรียญ แล้วเรียก add คู่มือร้านค้าสร้างฝั่งการซื้อ

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

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

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

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