Tutorial · Mga game system

Paano gumawa ng inventory sa Roblox Studio

Mukhang UI na trabaho ang inventory, pero kung puwede itong i-hack at kung nawawalan ito ng items ay nakadepende sa kung saan nakatago ang mga item. Sa guide na ito, nasa table sa server ang mga item ng bawat player, nakakakuha ang bawat player ng kopya at ipinapakita ito bilang grid, nag-e-equip ng Tool at gumagamit ng consumables sa pamamagitan ng mga request na chine-check ng server, at sine-save ang lahat sa data store.

In-update Nobyembre 20, 202618 minutong basaIsinulat ni

Sa madaling salita

Itago ang mga item ng bawat player sa isang table sa server, sa loob ng ModuleScript sa ServerScriptService, at ang code na iyon lang ang puwedeng magdagdag, magtanggal at mag-stack sa kanila. Ilarawan ang mga item nang isang beses sa isang ModuleScript sa ReplicatedStorage (id, pangalan, max stack). Pagkatapos ng bawat pagbabago, nagpapadala ang server sa player na iyon ng RemoteEvent na may kopya ng inventory niya, at ipinapakita ito ng isang LocalScript bilang grid gamit ang ScrollingFrame at UIGridLayout.

  • Hindi kailanman nagdadagdag ng items ang client. Puwede lang itong humiling, halimbawa "i-equip ang espada ko", at chine-check ng server na nasa player ito bago gumawa ng kahit ano.
  • Lumalabas lang ang mga item sa pamamagitan ng server code na kontrolado mo: pickups, mga binili sa shop pagkatapos ng check sa server, rewards.
  • I-save ang mga id ng item at ang bilang nila, hindi ang mga Tool, gamit ang DataStoreService kapag umalis ang player, kapag nag-shutdown ang server at bawat ilang minuto. Huwag kailanman i-save ang player na hindi nag-load ang data.
Sa page na ito
  1. Paano ito binubuo
  2. Bakit nasa server ang items
  3. 1. Ihanda ang Explorer
  4. 2. Catalog ng items
  5. 3. Inventory sa server
  6. 4. Pag-load at pag-save
  7. 5. Pickups
  8. 6. Pag-equip at paggamit
  9. 7. Grid UI
  10. Pag-test
  11. Common errors
  12. Gamit ang RoCode
  13. Mga madalas itanong
  14. Mga source at dagdag na babasahin

Paano binubuo ang inventory

IlustrasyonPindutin ang B, i-hover ang item para basahin ang description, i-click ang Sword para hawakan ito.

Anim na maliliit na bahagi ang bumubuo sa system, at may iisang trabaho ang bawat isa. Nasa iisang server module ang lahat ng patakaran tungkol sa mga item, kaya kapag may nasira, iisang lugar lang ang kailangan mong tingnan.

Ang mga bahagi ng system at kung saan sila tumatakbo
BahagiType at lugarTrabaho
ItemCatalogModuleScript sa ReplicatedStorageAno ang bawat item: pangalan, description, max stack at kung puwede itong i-equip o gamitin. Binabasa ito ng server at ng lahat ng client.
InventoryServiceModuleScript sa ServerScriptServiceNag-iimbak ng slots ng lahat ng player. Ang nag-iisang code na nagdadagdag, nagtatanggal at nag-i-stack ng mga item.
InventoryDataScript sa ServerScriptServiceNilo-load ang mga item ng player pagpasok niya at sine-save sila.
InventoryActionsScript sa ServerScriptServiceChine-check at ginagawa ang mga request para mag-equip at gumamit.
ItemPickupScript sa loob ng PartIbinibigay ang item sa kumuha nito.
InventoryClientLocalScript sa StarterPlayerScriptsIpinapakita ang grid at nagpapadala ng mga request. Wala itong binabago mismo.

Iisang direksyon ang daloy ng data. Binabago ng server ang inventory, saka nagpapadala sa player na iyon ng InventoryUpdated na may buong inventory, at ipinapakita ulit ito ng client. Kapag nag-click ang player sa isang slot, nagpapadala ang client ng EquipItem o UseItem na may id ng item; chine-check ng server ang request, ginagawa ang pagbabago, at dumarating ang bagong kopya sa parehong daan. Mas simple ang pagpapadala ng buong inventory kaysa sa pagpapadala ng mga pagbabago, at para sa ilang dosenang slot, maliit pa rin ang message.

Bakit hindi kailanman nagdadagdag ng items ang client

Nakakatuksong magdagdag ng item mismo sa LocalScript na nagpapakita nito: nag-click ang player, napuno ang slot. Nasisira ito sa dalawang paraan.

  • Walang ibang nakakakita nito. Ang pagbabago sa LocalScript ay umiiral lang sa device ng player na iyon. Hindi ito nalalaman ng server, kaya hindi ito nase-save, at walang server script na makakagamit nito.
  • Kahit sino ay puwedeng mameke. Kung aayusin ito gamit ang remote gaya ng AddItem(itemId, amount), kayang i-fire ng cheater ang event na iyon mismo, kahit anong argument at kahit ilang beses. Sinasabi ng security guide ng Roblox na dapat i-check ng server ang lahat ng ipinapadala ng client bago ito gamitin.

Kaya sa guide na ito, puwede lang humiling ang client ng gagawin sa mga item na nasa player na: "i-equip ito" at "gamitin ito". Bawat request ay may iisang id ng item at walang bilang, at sa server ay dumadaan ito sa isang check: string ito, umiiral ang item na iyon, may kahit isa ang player, at hindi hihigit sa apat na request kada segundo ang ipinapadala ng player. Saka hinahanap mismo ng server ang Tool sa catalog. Hindi ito kailanman tumatanggap ng Tool, path o instance mula sa client, gaya ng babala ng parehong guide.

Napupunta lang ang mga item sa inventory sa pamamagitan ng server code: pickup na chine-check ng server, pagbili kung saan nagbawas ng pera ang server (binubuo ito ng guide tungkol sa shop), reward sa quest o drop. Para sa mga remote sa pangkalahatan, kasama ang pag-check ng ibang uri ng argument, basahin ang guide tungkol sa RemoteEvent.

Hakbang 1: ihanda ang Explorer

Gawin nang mano-mano ang mga object na ito. Hinahanap sila ayon sa pangalan ng mga script sa mga susunod na hakbang, kaya isulat ang bawat pangalan nang eksakto gaya dito.

  1. Sa ReplicatedStorage, mag-insert ng Folder na pinangalanang InventoryRemotes. Sa loob nito, mag-insert ng tatlong RemoteEvent na pinangalanang InventoryUpdated, EquipItem at UseItem.
  2. Sa ServerStorage, mag-insert ng Folder na pinangalanang ItemTools. Sa loob nito, mag-insert ng Tool na pinangalanang Sword, at sa Tool, isang Part na pinangalanang Handle (puwede na ang 1 by 4 by 1 stud). I-check na naka-uncheck ang Anchored ng Handle: nagbababala ang Roblox na naiipit sa puwesto ang character kapag may hawak itong tool na may naka-anchor na parts. Puwede rin ang Tool na mayroon ka na, basta tugma ang pangalan nito sa catalog sa hakbang 2.
  3. Idagdag ang mga script habang sinusundan mo ang mga hakbang. Ipinapakita ng tree kung saan napupunta ang bawat isa.
Ang Explorer kapag tapos na ang guide
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

Hakbang 2: ilarawan ang mga item sa catalog

Inilalarawan ng catalog nang isang beses ang bawat item na puwedeng umiral. Ang mga inventory ay id ng item at bilang lang ang iniimbak. Kaya nananatiling maliit ang mga save, at mamaya puwede mong palitan ang pangalan ng item o isulat ulit ang description nito nang hindi ginagalaw ang naka-save na data ng kahit sino.

Mag-insert ng ModuleScript sa ReplicatedStorage, pangalanan itong ItemCatalog at palitan ang laman nito ng ganito:

ModuleScript sa ReplicatedStorage na pinangalanang ItemCatalog
-- Lahat ng item na puwedeng umiral sa game. Binabasa ang listahang ito ng server at ng lahat
-- ng client; ang server lang ang nagpapasya kung sino ang may ano.
export type Item = {
	id: string, -- dapat tugma sa key sa ibaba
	name: string,
	description: string,
	maxStack: number, -- ilan sa item na ito ang kasya sa isang slot
	icon: string?, -- optional na larawan: "rbxassetid://" plus ID ng image mo
	toolName: string?, -- Tool sa ServerStorage.ItemTools: puwedeng i-equip ang item
	heal: number?, -- gaano karaming health ang ibinabalik: consumable ang item
}

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 = {}

-- Ibinabalik ang item na may ganitong id, o nil kung walang ganoong item
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Ang mga optional na field ang nagpapasya kung ano ang ginagawa ng item. Ginagawa itong equippable ng toolName, ginagawa itong magagamit ng heal, at ang item na wala ng dalawang field, gaya ng wood, ay nananatili sa inventory hanggang tanggalin ito ng ibang server code (crafting, pagbebenta).

Para magdagdag ng item, magdagdag ng entry na magkapareho ang key at id. Case-sensitive ang mga id at sila mismo ang sine-save, kaya huwag kailanman palitan ang id kapag nasa mga player na ang item: palitan ang name nito.

Hakbang 3: itago ang mga inventory sa server

Ang ModuleScript na ito ang may-ari ng inventory ng bawat player. Ang bawat inventory ay listahan ng slots, bawat slot ay may id ng item at bilang, plus capacity na 20 slots. Tinatawag ng ibang server script ang mga function nito, at wala nang ibang nag-e-edit sa table.

Mag-insert ng ModuleScript sa ServerScriptService at pangalanan itong InventoryService:

ModuleScript sa ServerScriptService na pinangalanang InventoryService
-- Ang nag-iisang code na nagbabago ng mga inventory. Nasa ServerScriptService ito,
-- kung saan hindi ito makikita o mapapatakbo ng mga client.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Hindi nakikita ng strict mode kung ano ang ibinabalik ng require sa pamamagitan ng WaitForChild, kaya
-- inilalarawan natin ang bahagi ng module na ginagamit ng script na ito
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 -- slots kada player
local STARTER_ITEMS: { Slot } = { -- ano ang panimula ng ganap na bagong player
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Nagpapadala sa may-ari ng kopya ng inventory niya. Tinatawag pagkatapos ng bawat pagbabago.
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

-- Stack rules: punuin muna ang hindi pa punong stacks, saka magsimula ng bagong stacks
-- sa mga walang lamang slot. Ibinabalik kung ilan ang naidagdag, puwedeng mas kaunti sa hiningi.
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

-- Ilan pa sa item ang kasya: puwang sa stacks nito plus mga walang lamang slot
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

-- Nagdadagdag ng hanggang amount na piraso ng item. Ibinabalik kung ilan ang naidagdag (0 kung
-- walang ganoong item, puno ang inventory o hindi pa ito nag-load).
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

-- Nagtatanggal ng eksaktong amount na piraso ng item, simula sa mga huling stack.
-- Kung mas kaunti ang mayroon ang player, walang tinatanggal at nagbabalik ng 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
	-- Mula sa dulo, para hindi malaktawan ng table.remove ang slots
	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

-- Tinatawag kapag nag-load na ang naka-save na data ng player. Ang saved ay ang
-- ibinalik ng data store: nil para sa bagong player. Dumadaan ulit sa
-- stack rules ang bawat entry, kaya walang nasisira ang mga tinanggal na item at lumang stack size.
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

-- Simpleng kopya para i-save, o nil kung hindi talaga nag-load ang data ng player
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

Ang mga linyang type at ang cast na :: pagkatapos ng require ay para lang sa Luau type checker, na hindi nakakakita kung ano ang ibinabalik ng module na nahanap gamit ang WaitForChild. Wala silang binabago habang tumatakbo ang game. Ganito rin ang ginagawa ng ibang script sa guide na ito.

Paano gumagana ang mga stack rule sa catalog sa itaas, kung saan hanggang 10 ang stack ng apples:

  • Kapag nagdagdag ka ng 15 apples sa player na may stack na 7, mapupuno ang stack na iyon hanggang 10, saka magsisimula ang bagong stack na 5.
  • Kapag naubos ang slots, idinadagdag ng add ang kasya at ibinabalik ang bilang na iyon. Tawagin muna ang spaceFor kapag kailangan mo ng lahat o wala, gaya ng ginagawa ng pickup sa hakbang 5.
  • Gumagana ang remove sa prinsipyong lahat o wala. Ang paghingi ng 3 apples sa player na may 2 lang ay walang tinatanggal at nagbabalik ng false, kaya i-check ang resulta bago magbigay ng kahit ano kapalit.
  • Walang butas sa slots: kapag nawalan ng laman ang isang slot, umaakyat ang iba. Kaya mas madaling ipadala at i-save ang listahan. Ang slots na nananatili sa posisyon nila ay ipinaliwanag sa mga tanong sa dulo.
Ano ang puwedeng tawagin ng ibang server script
FunctionIbinabalikPara saan
add(player, itemId, amount)Ilan ang naidagdagPickups, rewards, pagbili
remove(player, itemId, amount)true kung natanggal lahatPaggamit, pagbebenta, crafting
count(player, itemId)Kabuuan ng lahat ng stackI-check kung ano ang mayroon ang player
spaceFor(player, itemId)Ilan pa ang kasyaCheck bago magdagdag sa prinsipyong lahat o wala
getEquipped, setEquippedId ng naka-equip na item o nilPag-equip, sa hakbang 6
load, serialize, unloadKopyang handa nang i-save (serialize)Pag-load at pag-save, sa hakbang 4

Hakbang 4: i-load at i-save ang bawat inventory

Nasa memory ng server ang mga inventory, kaya nawawala sila kapag umalis ang player. Nilo-load ng script na ito ang slots ng player mula sa data store pagpasok niya, at isinusulat ulit sila kapag umalis siya, kapag nag-shutdown ang server at bawat tatlong minuto kung sakaling mag-crash ang server. Id ng item at bilang lang ang sine-save nito: hindi kayang mag-imbak ng Instance ang mga data store, halimbawa ng Tool.

Mag-insert ng Script sa ServerScriptService at pangalanan itong InventoryData:

Script sa ServerScriptService na pinangalanang 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

-- Ang mga player lang na nag-load ang data ang sine-save. Pagkatapos ng palpak na pag-load
-- bawal mag-save, kung hindi ay papalitan ng walang lamang inventory ang totoo.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Hindi dapat mawalan ng items ang kahit sino dahil sa isang palpak na request, kaya ilang beses tayong susubok.
-- Nasa loob din ng pcall ang GetDataStore, kaya ang Studio session na walang access sa data
-- stores ay nakakakuha ng warning, at hindi nito napapahinto ang script na ito.
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 -- umalis ang player habang naglo-load tayo
	end
	if ok then
		InventoryService.load(player, saved) -- nil ang saved para sa bagong player
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Kadalasan, ibig sabihin ay naka-off ang Studio access sa API services. Maglaro gamit ang
		-- starter items para makapag-test, pero huwag kailanman i-save ang mga ito.
		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 -- hindi talaga nag-load ang data, walang ligtas na isusulat
	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)

-- Kapag nag-shutdown ang server, i-save ang lahat ng nandito pa at hintayin ang bawat
-- save na tumatakbo, kasama ang mga sinimulan ng PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- I-save ang lahat bawat ilang minuto, para ilang minuto lang ang mawala sa crash ng server, hindi ang buong session
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Ano ang ginagawa ng script at bakit:

  • Pag-load na may default value. Walang naka-save na value ang bagong player, kaya nagbabalik ng nil ang GetAsync, at nakakakuha siya ng starter items. Dumadaan ulit sa stack rules ang naka-save na slots, kaya hindi masisira ang pag-load ng item na tinanggal sa catalog o ng pinaliit na max stack. Itinatapon ang lahat ng hindi na kasya o na ang id ay wala na sa catalog, at ginagawa itong permanente ng susunod na save, kaya panatilihin sa catalog ang bawat id na puwedeng nasa mga player.
  • Huwag kailanman mag-save pagkatapos ng palpak na pag-load. Ang mga player lang sa canSave ang isinusulat. Sa live server, ang player na hindi nag-load ang data kahit pagkatapos ng tatlong subok ay hinihilingang mag-rejoin. Sa Studio, sa halip ay nakakakuha siya ng starter items na hindi nase-save, ilang segundo mas huli dahil sa mga ulit na subok. Ganito ito hangga't hindi na-publish ang place na naka-on ang API access.
  • Pag-save sa pag-alis at sa shutdown. Sine-save ng BindToClose ang lahat ng nasa server pa at hinihintay ang mga save na tumatakbo na. Binibigyan ng Roblox ang mga naka-bind na function ng hanggang 30 segundo.
  • Huwag lumampas sa limits. Isang write kada player bawat tatlong minuto plus isa sa pag-alis ay mas kaunti nang husto sa standard na budget ng server na 60 write kada minuto plus 40 kada player (ayon sa docs noong 30 Setyembre 2026). Ang key pattern na User_ ay galing sa mga rekomendasyon ng Roblox, at ang pagpasa ng user ID sa SetAsync ay nag-uugnay sa data sa player na iyon, na mariing inirerekomenda ng Roblox para sa paghawak ng mga request na mag-delete ng data.

Para sa maliit na game, matibay na pundasyon ito. Ang session locking, na pumipigil sa player na mabilis lumipat ng server na mag-load ng data bago ito na-save ng lumang server, at kung kailan gagamitin ang UpdateAsync sa halip na SetAsync, ay ipinaliwanag sa tutorial tungkol sa DataStore.

Hakbang 5: magbigay ng items mula sa mundo

Ang pickup ang pinakasimpleng paraan para mapunta ang mga item sa inventory: isang part na may ProximityPrompt na nagdadagdag ng item kapag ginamit ito ng player. Nakikinig ang script sa Triggered event nito sa server, kaya idinadagdag ang item kung saan hindi makakapakialam ang client.

  1. Magdagdag ng Part sa Workspace, pangalanan itong Apple at kulayan ng pula. I-on ang Anchored at i-off ang CanCollide, para walang bumangga dito habang invisible ito. Ipinapakita ng prompt ang pangalan ng part.
  2. Habang naka-select ang part, i-scroll ang Properties window hanggang sa section na Attributes at pindutin ang +. Idagdag ang ItemId na type string at pindutin ang Save, saka itakda ang value sa apple. Sa parehong paraan, idagdag ang Amount na type number na may value na 1.
  3. Mag-insert ng Script sa part, pangalanan itong ItemPickup at i-paste ang code na ito:
Script sa part na Apple sa Workspace na pinangalanang ItemPickup
-- Ilagay ang Script na ito sa loob ng Part at bigyan ang Part ng dalawang attribute:
-- ItemId (string, halimbawa apple) at Amount (number, halimbawa 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 -- may ibang nakapulot nito ngayon lang
	end
	-- I-check ang distansya sa server, sa halip na magtiwala sa request
	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 -- kulang ang puwang: iwan ang item sa puwesto nito
	end
	InventoryService.add(player, itemId, amount)

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

Kopyahin ang part para maglagay ng mas maraming item. Baguhin ang mga attribute para magbigay ng wood, isa pang espada o isang stack ng apples.

Chine-check ng Roblox ang distansya para sa Triggered, pero sinasabi pa rin ng security guide nito na i-check ang mga prompt sa server: kayang i-fire ng cheater ang mga event ng prompt kahit Enabled ay false, at kayang hilahin ang hindi naka-anchor na part papunta sa character niya. Kaya chine-check mismo ng script ang Enabled at ang distansya, at kaya naka-anchor ang part.

Ganito rin nagbibigay ng items ang kahit anong ibang server script. Pagkatapos ng pagbili, quest o kill, i-require ang InventoryService, gaya ng mga script sa itaas, at tawagin ang InventoryService.add(player, "wood", 5). I-check muna ang spaceFor kapag hindi puwedeng mawala ang item. Puwede ring maging source ang isang NPC: sa guide tungkol sa NPC dialogue, nagpapatakbo ng action sa server ang isang sagot, at puwede ring tawagin ng action na iyon ang InventoryService.add.

Hakbang 6: pag-equip ng Tool at paggamit ng items

Dalawang RemoteEvent ang nagdadala ng mga tanging request na kayang gawin ng client. Inilalagay ng EquipItem ang kopya ng Tool ng item mula sa ServerStorage sa Backpack ng player (ang hotbar sa ibaba ng screen) at sa kamay niya, at tinatanggal ito ng pangalawang request. Nagtatanggal ang UseItem ng isa sa magagamit na item at ina-apply ang effect nito, dito ay pag-heal.

Mag-insert ng Script sa ServerScriptService at pangalanan itong InventoryActions:

Script sa ServerScriptService na pinangalanang 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 } = {}

-- Dito nagsisimula ang bawat request. Kayang magpadala ng client ng kahit ano kahit kailan, kaya
-- chine-check natin ang type, na umiiral ang item, na nasa player ito, at ang dalas.
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

-- Dine-destroy ang Tool ng item na ito nasaan man ang kopya: hotbar, kamay o 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) -- isang naka-equip na tool sa bawat pagkakataon

	local tool = template:Clone()
	tool.CanBeDropped = false -- puwedeng pulutin ng iba ang inihulog na kopya
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Kinokopya pabalik sa Backpack ang pangalawang kopya sa StarterGear pagkatapos ng respawn
	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) -- diretso sa kamay
	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) -- ang pangalawang click sa naka-equip na item ay nagtatanggal dito
	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 -- patay o puno na ang health: huwag sayangin ang item
	end
	-- Kunin muna ang item, at mag-heal lang kung nagtagumpay iyon
	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)
Ano ang pinapayagan sa bawat request
RequestIpinapadala ng clientChine-check ng server bago kumilos
EquipItemId ng itemString ito, umiiral ang item, nasa player ito, hindi hihigit sa apat kada segundo ang dating ng mga request, may toolName ang item, at may Tool na ganoon ang pangalan sa ServerStorage.ItemTools
UseItemId ng itemParehong check sa type, pagmamay-ari at dalas, may value na heal ang item, buhay at sugatan ang character, at natanggal ang isang item bago idinagdag ang health

Tatlong detalye ang pumipigil sa Tool na dumoble o mawala. Ang CanBeDropped ng kopya ay false, dahil ang inihulog na Tool ay bumabagsak sa Workspace kung saan puwede itong kunin ng ibang player, habang nananatili sa inventory ang original. Bawat kopya ay may attribute na InventoryItem, kaya sa pag-unequip, mahahanap at made-destroy ang bawat kopya nasaan man ito. At kung may container na StarterGear ang player, nilalagyan ito ng pangalawang kopya. Kinokopya ng Roblox ang StarterGear sa Backpack tuwing lilitaw ang character, kaya bumabalik ang naka-equip na espada pagkatapos ng respawn.

Isang Tool lang ang naka-equip sa bawat pagkakataon, at hindi sine-save ang pag-equip, kaya nagsisimula ang player na walang laman ang hotbar pagkatapos mag-rejoin. Kung magdadagdag ka mamaya ng pagbebenta o pagtapon, i-unequip ang item bago umalis sa inventory ang huling kopya nito.

Puwedeng gawing espadang talagang nakikipaglaban ang placeholder sword: buuin ang Tool ayon sa guide tungkol sa espada, panatilihin ang pangalan nitong Sword at ilagay ito sa ItemTools kapalit ng placeholder. Chine-check ng server script mula sa guide na iyon ang bawat tama, paano man nakuha ng player ang espada.

Hakbang 7: iguhit ang inventory grid

Binubuo ng LocalScript ang buong window sa code, kaya wala kang kailangang ilagay nang mano-mano. Hinahawakan ng ScrollingFrame ang slots, inaayos sila ng UIGridLayout sa loob nito nang pa-row, at pinalalaki ng AutomaticCanvasSize ang scrollable na area habang nadadagdagan ang mga row.

Sa Explorer, buksan ang StarterPlayer, mag-insert ng LocalScript sa StarterPlayerScripts at pangalanan itong InventoryClient:

LocalScript sa StarterPlayerScripts na pinangalanang 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. Buuin ang window nang isang beses. Pinapanatili ito ng ResetOnSpawn = false pagkatapos ng mga respawn.
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() -- pinalalaki ito ng AutomaticCanvasSize para sa mga cell
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. Isang cell kada slot. Ipinapakita lang nito ang ipinadala ng server; ang
-- inventory mismo ay hindi kailanman nagbabago mula dito.
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 -- walang lamang slot
	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()
		-- Humihiling, hindi nag-uutos: chine-check ng server ang request at ipinapadala ang resulta
		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

-- Ipinapadala ito ng server pagkatapos mag-load at pagkatapos ng bawat pagbabago
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Buksan at isara gamit ang button o ang key na 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)

Isang beses kada session tumatakbo ang LocalScript sa StarterPlayerScripts, at pinapanatili ng ResetOnSpawn = false ang ScreenGui kapag nag-respawn ang character, kaya patuloy na ipinapakita ng grid ang huling kopyang ipinadala ng server.

Gumuguhit ang client ng isang cell kada slot, kasama ang mga walang laman, kaya laging mukhang 20 slots ang inventory na 20 slots. Bawat update ay dine-destroy ang mga lumang cell at gumagawa ng mga bago, simple ito at bagay para sa ilang dosenang slot. Kapag ipinadala ng server ang InventoryUpdated bago kumonekta dito ang script na ito, ilalagay ng Roblox ang message sa queue at ihahatid ito pagkakonekta ng handler, kaya hindi mawawala ang unang inventory.

Gusto mo bang iguhit ang window sa Studio? Bumuo ng ScreenGui na may isang template slot at i-Clone ito sa makeCell. Para sa mga icon, bigyan ang item sa catalog ng icon na may image na in-upload mo, at ipapakita ng cell nito ang larawan sa halip na ang pangalan.

I-test ang inventory

  1. Pindutin ang Play. Buksan ang inventory gamit ang button sa kaliwa o ang key na B: may Sword at 3 Apple ang bagong player, at 2 / 20 slots ang ipinapakita ng counter. Habang hindi makaka-access ang Studio sa mga data store, lumalabas ang mga item pagkalipas ng ilang segundo, pagkatapos ng mga warning tungkol sa pag-load sa Output, at hindi sila nase-save.
  2. I-click ang Sword. Lalabas ang espada sa kamay mo at sa hotbar, at magkakaroon ng purple na border ang slot nito. I-click ulit para tanggalin ito.
  3. Lumapit sa part na Apple at gamitin ang prompt nito. Magiging 4 ang stack ng apples, at mawawala ang part nang 15 segundo.
  4. Para i-test ang pag-heal, bawasan muna ang health. Ilipat ang Client/Server sa Server, piliin ang Humanoid ng character mo sa Explorer, itakda ang Health sa 50, bumalik sa Client at i-click ang Apple.
  5. Habang naka-on ang Studio access sa API services, ihinto ang game at patakbuhin ulit. Nandoon pa rin ang napulot na apple. Kung pumalya ang pag-load o pag-save, sasabihin ito ng Output.

Para mag-test na may ilang player, piliin sa test settings ang Server & Clients na may 2 client. Sariling inventory lang ang nakikita ng bawat player, at pareho nilang nakikita ang espada sa kamay ng isa.

Mga karaniwang error at solusyon

Karamihan ng problema ay makikita sa Output window bilang warning o pulang error line. Basahin ang una: madalas na nanggagaling dito ang mga sumunod na error.

Infinite yield possible sa tawag sa WaitForChild

Naghihintay ang script ng object na wala sa eksaktong pangalang iyon. Ikumpara ang Explorer mo sa tree sa hakbang 1: InventoryRemotes na may tatlong RemoteEvent sa ReplicatedStorage, ItemTools sa ServerStorage at ang dalawang module. Case-sensitive ang mga pangalan. Mas detalyadong ipinaliwanag ang warning na ito sa guide tungkol sa mga script error.

Bumubukas ang grid pero walang laman

Ang ipinapadala lang ng server ang iginuguhit ng client. Hanapin sa Output ang mga warning na Inventory load failed at i-check na Script ang InventoryData, hindi LocalScript, sa ServerScriptService, at katabi nito ang ModuleScript na InventoryService. Kung may error na Remote event invocation sa Output, walang nakikinig sa InventoryUpdated sa client: hanapin ang mas naunang error mula sa InventoryClient.

Nare-reset ang mga item tuwing naglalaro ako sa Studio

Kung nakasulat sa Output ang Inventory not loaded: playing with starter items that will not be saved, hindi pa na-publish ang place o naka-off ang Studio access sa API services. I-on ito gaya ng inilarawan sa hakbang 4, sa test copy ng game mo.

Walang ginagawa ang pag-click sa espada

Hanapin sa Output ang Cannot equip sword: ang Tool sa ServerStorage.ItemTools ay dapat may eksaktong pangalan gaya ng toolName sa catalog. Kailangan din ng Tool ng part na pinangalanang Handle para mahawakan ito, maliban kung itinakda mo ang RequiresHandle nito sa false.

Lumalabas ang pickup prompt pero walang naidadagdag

Dapat eksaktong tugma ang attribute na ItemId sa id sa catalog, kasama ang case: apple, hindi Apple. Walang naidadagdag habang naglo-load pa ang inventory ng player o kapag walang puwang para sa buong bilang.

Nasisira ang pag-save pagkatapos kong baguhin kung ano ang sine-save

Simpleng data lang ang tinatanggap ng mga data store: strings, numbers, booleans at mga table ng mga ito. Pumapalya ang pag-save ng Tool, Part o kahit anong ibang Instance, o nase-save ang value bilang nil. I-save ang id ng item at ang bilang, at buuin ulit ang lahat ng iba mula sa catalog, gaya ng ginagawa ng serialize.

Gawin gamit ang RoCode

Kung mas madali sa iyo na ilarawan ang system kaysa buuin ito nang mano-mano, kayang buuin ito ng RoCode sa place na bukas mo. Isa itong AI agent para sa Roblox Studio: ilalarawan mo ang feature sa web chat, at ang plugin nito para sa Studio ang gagawa ng mga script at object sa Explorer mo, sa halip na magbigay ng code na ipe-paste.

Ang tina-type mo

Magdagdag ng inventory na may 20 slots na may stacks ng items, grid UI na bumubukas sa B, espada mula sa ServerStorage na puwedeng i-equip ng mga player, apples na nagpapagaling, at pag-save gamit ang DataStoreService.

Ang ginagawa ng RoCode
  • Kayang tingnan ang place mo kapag kailangan ito ng hakbang, gamit ang Search Game at Search Scripts, para gamitin ang mga item, remote o save code na nandiyan na, sa halip na magdagdag ng pangalawang system
  • Gumagawa ng mga folder at RemoteEvent gamit ang Create Instance, at ng ModuleScript, Script at LocalScript gamit ang Create Script
  • Kayang buuin ang base ng window gamit ang Build UI, kung saan may inventory layout na may placeholder slots; ang code na pumupuno sa slots mula sa server ay isinusulat sa hiwalay na mga script
  • Chine-check ang compile ng bawat script sa Studio gamit ang Check Script, na nakakahuli ng compile errors at ilang delikadong pattern, pero hindi nagche-check ng types, hindi nagla-lint at hindi pinapatakbo ang code mo

Bawat batch ng pagbabago ay isang undo point sa Studio. Hindi kayang i-on ng RoCode ang Studio access sa API services, ikaw mismo ang gagawa niyon. Sa plugin 3.9 o mas bago, kaya nitong magpatakbo ng maikling playtest at basahin ang mga error, at sa plugin 3.9.15 o mas bago, kayang pumindot ng mga key at mag-equip ng items ng test character nito, pero ang mga napagpasyahan lang nitong i-test ang chine-check nito, kaya ikaw mismo ang mag-check ng pag-save gamit ang playtest. Nakapatong ang inventory sa ibang system, gaya ng pag-save at mga tool, at ang AI game builder na bumubuo sa sarili mong place sa Studio ay idinadagdag sila nang isang prompt kada beses. Paano kumokonekta ang RoCode sa Studio.

Mga madalas itanong

Gamitin ko na lang ba ang Backpack ng Roblox sa halip na sariling inventory?

Ang Backpack ay ang built-in na inventory ng Roblox: bawat Tool dito ay ipinapakita bilang button sa hotbar. Kung Tool ang lahat ng item sa game mo at hindi mo kailangan ng stacks, bilang at limit sa slots, puwede na itong sapat, bagaman kailangan mo pa ring i-save kung aling mga Tool ang mayroon ang bawat player. Kailangan ng sariling inventory para sa mga item na hindi Tool, halimbawa materials at consumables. Ginagamit ng guide na ito ang dalawa: iniimbak ng inventory ang lahat, at hawak ng Backpack ang naka-equip na Tool.

Paano itago ang default na hotbar sa Roblox?

Mula sa LocalScript, tawagin ang StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Kapag nakatago ang hotbar, kailangan ng mga player ng ibang paraan para kunin at tanggalin ang naka-equip na Tool, halimbawa isang button na humihiling sa server na tawagin ang Humanoid:EquipTool o Humanoid:UnequipTools.

Paano gawing nananatili sa posisyon ang slots para sa drag and drop?

Mag-imbak ng listahang fixed ang haba na may isang entry kada slot, at markahan ang mga walang lamang slot ng value gaya ng empty id, hindi nil, dahil hindi pinapayo ng Roblox ang pagpapadala ng mga table na may nil sa RemoteEvent. Saka magdagdag ng RemoteEvent na MoveItem na nagpapadala ng dalawang slot number, at hayaang i-check ng server na parehong integer sila mula 1 hanggang sa capacity bago sila pagpalitin.

Gaano kalaki puwede ang naka-save na inventory?

Ang isang value sa data store ay puwedeng umabot ng 4,194,304 na character pagkatapos ng serialization (ayon sa docs noong 30 Setyembre 2026). Napakaliit na bahagi nito ang listahan ng mga id at bilang. Ang nagpapalaki sa save ay ang text kada item, halimbawa sariling pangalan o mahahabang description na sine-save para sa bawat item.

Paano bumili at magbenta ng items gamit ang coins?

Gawin ang lahat sa server. Para magbenta, tawagin ang InventoryService.remove at magbayad lang kung nagbalik ito ng true. Para bumili, i-check ang presyo at ang spaceFor, kunin ang coins, saka tawagin ang add. Binubuo ng guide tungkol sa shop ang bahagi ng pagbili.

Mga source at dagdag na babasahin

Paano sinuri ang code: bawat script sa page na ito ay dumaan sa strict Luau type check gamit ang mga definition ng Roblox API (luau-lsp, Nobyembre 20, 2026). Nahuhuli ng type check ang maling pangalan ng API at maling type, pero hindi ang mga mali sa game logic, kaya i-test muna ang lahat sa Studio bago mag-publish.

Subukan ang RoCode sa sarili mong game.

Libreng credits araw-araw, walang card. I-install ang plugin, ilarawan ang feature, at tingnan kung ano ang lumabas sa Studio.