Tutorial · Sistem game

Cara membuat sistem inventory di Roblox Studio

Inventory kelihatannya urusan UI, tapi yang menentukan apakah inventory kamu bisa di-exploit, atau kehilangan item, adalah di mana item itu disimpan. Panduan ini menyimpan item setiap pemain di sebuah tabel di server, mengirim salinannya ke setiap pemain untuk digambar sebagai grid, membiarkan pemain meng-equip Tool dan memakai consumable lewat request yang dicek server, lalu menyimpan semuanya dengan data store.

Diperbarui 14 November 202614 menit bacaDitulis oleh

Singkatnya

Simpan item setiap pemain di sebuah tabel di server, di dalam ModuleScript di ServerScriptService yang menjadi satu-satunya kode yang boleh menambah, menghapus atau menumpuk (stack) item. Daftarkan item kamu sekali di ModuleScript di ReplicatedStorage (id, nama, max stack). Setelah setiap perubahan, server mengirim RemoteEvent ke pemain itu berisi salinan inventory-nya, dan sebuah LocalScript menggambarnya sebagai grid dengan ScrollingFrame dan UIGridLayout.

  • Client tidak pernah menambah item. Client hanya bisa meminta, misalnya "equip pedangku", dan server mengecek bahwa pemain memang punya pedang sebelum bertindak.
  • Item hanya masuk lewat kode server yang kamu kontrol: pickup, pembelian di shop yang sudah dicek server, hadiah.
  • Simpan id item dan jumlahnya, bukan Tool, dengan DataStoreService saat pemain keluar, saat server mati dan setiap beberapa menit. Jangan pernah menyimpan pemain yang datanya gagal dimuat.
Di halaman ini
  1. Cara kerjanya
  2. Kenapa server yang pegang item
  3. 1. Siapkan Explorer
  4. 2. Katalog item
  5. 3. Inventory di server
  6. 4. Load dan save
  7. 5. Pickup item
  8. 6. Equip dan pakai
  9. 7. UI grid
  10. Tes
  11. Error umum
  12. Dengan RoCode
  13. Pertanyaan umum
  14. Sumber dan bacaan lanjutan

Cara kerja sistem inventory

IlustrasiTekan B, arahkan mouse ke item untuk membacanya, klik Sword untuk memegangnya.

Sistem ini terdiri dari enam bagian kecil, masing-masing dengan satu tugas. Semua aturan tentang item ada di satu modul di server, jadi kalau ada yang salah, hanya ada satu tempat yang perlu dicek.

Bagian-bagiannya dan di mana mereka berjalan
BagianTipe dan lokasiTugas
ItemCatalogModuleScript di ReplicatedStorageApa itu setiap item: nama, deskripsi, max stack, dan apakah item bisa di-equip atau dipakai. Server dan setiap client membacanya.
InventoryServiceModuleScript di ServerScriptServiceMenyimpan slot setiap pemain. Satu-satunya kode yang menambah, menghapus dan menumpuk item.
InventoryDataScript di ServerScriptServiceMemuat item pemain saat mereka join dan menyimpannya.
InventoryActionsScript di ServerScriptServiceMengecek dan menjalankan request equip dan pakai.
ItemPickupScript di dalam PartMemberi item ke siapa pun yang mengambil pickup itu.
InventoryClientLocalScript di StarterPlayerScriptsMenggambar grid dan mengirim request. Script ini tidak mengubah apa pun sendiri.

Data mengalir satu arah. Server mengubah inventory, lalu mengirim InventoryUpdated ke pemain itu dengan seluruh inventory-nya, dan client menggambar ulang dari data itu. Saat pemain mengklik slot, client mengirim EquipItem atau UseItem dengan id item; server mengecek request-nya, membuat perubahan, dan salinan baru datang dengan cara yang sama. Mengirim seluruh inventory lebih sederhana daripada mengirim perubahannya saja, dan untuk beberapa puluh slot pesannya tetap kecil.

Kenapa client tidak pernah menambah item

Menambah item di LocalScript yang menampilkannya memang menggoda: pemain klik, slot terisi. Cara itu rusak dalam dua hal.

  • Tidak ada orang lain yang melihatnya. Perubahan di LocalScript hanya ada di perangkat pemain itu. Server tidak pernah tahu, jadi perubahan itu tidak tersimpan dan tidak ada script server yang bisa memakainya.
  • Siapa pun bisa memalsukannya. Kalau kamu memperbaikinya dengan RemoteEvent seperti AddItem(itemId, amount), exploiter bisa mengirim event itu sendiri, dengan argumen apa pun, sesering yang mereka mau. Panduan keamanan Roblox bilang server harus memvalidasi semua yang dikirim client sebelum memakainya.

Jadi di panduan ini client hanya bisa membuat request tentang item yang sudah dimiliki pemain: "equip ini" dan "pakai ini". Setiap request membawa satu id item tanpa jumlah, dan harus lolos satu pengecekan di server: apakah itu string, apakah itu item yang benar-benar ada, apakah pemain punya minimal satu, dan apakah pemain mengirim tidak lebih dari empat request per detik. Lalu server mencari Tool-nya sendiri dari katalog. Server tidak pernah menerima Tool, path atau instance dari client, hal yang juga diperingatkan panduan yang sama.

Item hanya masuk lewat kode server: pickup yang sudah dicek server, pembelian yang sudah ditagih server (panduan shop GUI membuat satu), hadiah quest atau drop. Untuk pola RemoteEvent secara umum, dengan validasi untuk jenis argumen lain, baca panduan RemoteEvent.

Langkah 1: Siapkan Explorer

Buat objek-objek ini secara manual. Script di langkah berikutnya mencarinya berdasarkan nama, jadi tulis setiap nama persis seperti di bawah.

  1. Di ReplicatedStorage, tambahkan Folder bernama InventoryRemotes. Di dalamnya, tambahkan tiga RemoteEvent bernama InventoryUpdated, EquipItem dan UseItem.
  2. Di ServerStorage, tambahkan Folder bernama ItemTools. Di dalamnya, tambahkan Tool bernama Sword, dan di dalam Tool itu sebuah Part bernama Handle (1 kali 4 kali 1 stud sudah cukup). Pastikan kotak Anchored di Handle mati: Roblox memperingatkan bahwa karakter jadi tidak bisa bergerak saat memegang tool dengan part yang di-anchor. Tool yang sudah kamu punya juga bisa, asalkan namanya cocok dengan katalog di Langkah 2.
  3. Tambahkan script-script-nya saat kamu sampai di setiap langkah. Pohon di bawah menunjukkan di mana setiap script ditaruh.
Explorer setelah mengikuti panduan ini
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

Langkah 2: Daftarkan item kamu di katalog

Katalog menjelaskan setiap item yang bisa ada, satu kali saja. Inventory lalu hanya menyimpan id item dan jumlahnya. Itu membuat data save tetap kecil, dan kamu bisa mengganti nama item atau menulis ulang deskripsinya nanti tanpa menyentuh data tersimpan milik siapa pun.

Tambahkan ModuleScript ke ReplicatedStorage, beri nama ItemCatalog, dan ganti isinya dengan ini:

ModuleScript di ReplicatedStorage bernama ItemCatalog
-- Semua item yang bisa ada di game. Server dan setiap client membaca daftar
-- ini; hanya server yang menentukan siapa memiliki apa.
export type Item = {
	id: string, -- harus sama dengan key di bawah
	name: string,
	description: string,
	maxStack: number, -- jumlah terbanyak item ini yang muat dalam satu slot
	icon: string?, -- gambar opsional, ditulis sebagai "rbxassetid://" ditambah ID gambarmu
	toolName: string?, -- sebuah Tool di ServerStorage.ItemTools: item ini bisa di-equip
	heal: number?, -- health yang pulih saat dipakai: item ini adalah consumable
}

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

-- Mengembalikan item dengan id ini, atau nil kalau item itu tidak ada
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Field opsional menentukan apa yang dilakukan item. toolName membuatnya bisa di-equip, heal membuatnya bisa dipakai, dan item yang tidak punya keduanya, seperti wood, tetap di inventory sampai kode server lain (crafting, menjual) menghapusnya.

Untuk menambah item, tambahkan entri yang key dan id-nya sama. Id membedakan huruf besar dan kecil, dan id itulah yang disimpan, jadi jangan pernah mengganti id setelah pemain memiliki item itu: ganti name-nya saja.

Langkah 3: Simpan inventory di server

ModuleScript ini memegang inventory setiap pemain. Setiap inventory adalah daftar slot, setiap slot berisi id item dan jumlah, ditambah kapasitas 20 slot. Script server lain memanggil fungsinya, dan tidak ada kode lain yang mengedit tabel itu.

Tambahkan ModuleScript ke ServerScriptService dan beri nama InventoryService:

ModuleScript di ServerScriptService bernama InventoryService
-- Satu-satunya kode yang mengubah inventory. Letaknya di ServerScriptService,
-- tempat client tidak bisa melihat maupun menjalankannya.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict mode tidak bisa mengikuti require lewat WaitForChild, jadi kita tulis
-- bagian modul yang dipakai script ini
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 -- slot per pemain
local STARTER_ITEMS: { Slot } = { -- item awal untuk pemain yang benar-benar baru
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Mengirim salinan inventory ke pemiliknya. Berjalan setelah setiap perubahan.
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

-- Aturan stack: isi dulu stack yang belum penuh, lalu mulai stack baru di
-- slot kosong. Mengembalikan jumlah yang ditambahkan, bisa lebih sedikit dari yang diminta.
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

-- Berapa banyak lagi sebuah item muat: sisa ruang di stack-nya ditambah slot kosong
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

-- Menambahkan sampai `amount` item. Mengembalikan jumlah yang ditambahkan (0 kalau
-- item tidak ada, inventory penuh atau belum selesai dimuat).
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

-- Menghapus tepat `amount` item, mengambil dari stack terakhir dulu.
-- Kalau pemain punya kurang dari itu, tidak ada yang dihapus dan hasilnya 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
	-- Jalan mundur supaya table.remove tidak pernah melewatkan slot
	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

-- Dipanggil setelah data tersimpan pemain selesai dimuat. `saved` adalah apa pun yang
-- dikembalikan data store: nil untuk pemain baru. Setiap entri melewati lagi
-- aturan stack, jadi item yang dihapus dan ukuran stack lama tidak bisa merusak apa pun.
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

-- Salinan biasa untuk disimpan, atau nil kalau data pemain ini tidak pernah dimuat
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

Baris type dan cast :: setelah require hanya membantu type checker Luau, yang tidak bisa melihat apa yang dikembalikan modul yang ditemukan lewat WaitForChild. Baris itu tidak mengubah apa pun saat game berjalan. Script lain di panduan ini melakukan hal yang sama.

Begini aturan stack bekerja dengan katalog di atas, di mana apple bisa ditumpuk sampai 10:

  • Menambah 15 apple ke pemain yang punya stack berisi 7 akan mengisi stack itu sampai 10, lalu memulai stack baru berisi 5.
  • Saat slot habis, add menambahkan yang muat dan mengembalikan angka itu. Panggil spaceFor dulu kalau harus semua atau tidak sama sekali, seperti pickup di Langkah 5.
  • remove itu semua atau tidak sama sekali. Meminta 3 apple dari pemain yang punya 2 tidak menghapus apa pun dan mengembalikan false, jadi cek hasilnya sebelum kamu memberi sesuatu sebagai gantinya.
  • Slot tidak punya celah: saat satu slot kosong, slot lain bergeser naik. Itu membuat daftarnya mudah dikirim dan disimpan. Pertanyaan di akhir membahas slot yang tetap di posisinya.
Apa yang bisa dipanggil script server lain
FungsiMengembalikanDipakai untuk
add(player, itemId, amount)Berapa banyak yang ditambahkanPickup, hadiah, pembelian
remove(player, itemId, amount)true kalau semuanya terhapusMemakai, menjual, crafting
count(player, itemId)Total dari semua stackMengecek apa yang dimiliki pemain
spaceFor(player, itemId)Berapa banyak lagi yang muatMengecek sebelum add yang harus semua atau tidak sama sekali
getEquipped, setEquippedId item yang di-equip, atau nilEquip, di Langkah 6
load, serialize, unloadSalinan yang siap disimpan (serialize)Memuat dan menyimpan, di Langkah 4

Langkah 4: Muat dan simpan setiap inventory

Inventory ada di memori server, jadi hilang saat pemain keluar. Script ini memuat slot pemain dari data store saat mereka join dan menulisnya kembali saat mereka keluar, saat server mati, dan setiap tiga menit untuk jaga-jaga kalau server crash. Yang disimpan hanya id item dan jumlahnya: data store tidak bisa menyimpan Instance seperti Tool.

Tambahkan Script ke ServerScriptService dan beri nama InventoryData:

Script di ServerScriptService bernama 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

-- Hanya pemain yang datanya berhasil dimuat yang akan disimpan. Load yang gagal
-- tidak boleh diikuti save, atau inventory kosong menimpa inventory yang asli.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Satu request gagal tidak boleh membuat siapa pun kehilangan item, jadi coba ulang beberapa kali.
-- GetDataStore juga ada di dalam pcall, jadi sesi Studio yang tidak bisa
-- menjangkau data store mendapat peringatan, bukan menghentikan script ini.
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 -- pemain keluar saat data sedang dimuat
	end
	if ok then
		InventoryService.load(player, saved) -- saved bernilai nil untuk pemain baru
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Biasanya berarti akses Studio ke API services mati. Main dengan
		-- item awal supaya kamu bisa mengetes, tapi jangan pernah menyimpannya.
		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 -- datanya tidak pernah dimuat, jadi tidak ada yang aman untuk ditulis
	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)

-- Saat server mati, simpan semua pemain yang masih ada, lalu tunggu setiap
-- save yang sedang berjalan, termasuk yang dimulai oleh PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Simpan semua pemain setiap beberapa menit, jadi server crash hanya menghilangkan beberapa menit, bukan satu sesi
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Apa yang dilakukan script ini, dan kenapa:

  • Load dengan nilai default. Pemain baru belum punya data tersimpan, jadi GetAsync mengembalikan nil dan mereka mendapat item awal. Slot yang tersimpan melewati lagi aturan stack, jadi item yang kamu hapus dari katalog atau max stack yang lebih kecil tidak bisa merusak load. Apa pun yang sudah tidak muat, atau yang id-nya sudah tidak ada di katalog, dibuang, dan save berikutnya membuatnya permanen, jadi simpan terus di katalog setiap id yang mungkin dimiliki pemain.
  • Jangan pernah save setelah load gagal. Hanya pemain di canSave yang pernah ditulis. Di server live, pemain yang datanya tetap tidak bisa dimuat setelah tiga kali percobaan diminta join ulang. Di Studio mereka malah mendapat item awal yang tidak disimpan, beberapa detik terlambat karena percobaan ulang, dan itulah yang kamu lihat sampai place-nya di-publish dengan akses API menyala.
  • Save saat keluar dan saat server mati. BindToClose menyimpan semua pemain yang masih ada di server dan menunggu save yang sedang berjalan. Roblox memberi fungsi yang di-bind waktu sampai 30 detik.
  • Tetap di dalam batas. Satu penulisan per pemain setiap tiga menit, ditambah satu saat mereka keluar, jauh di bawah jatah default per server yaitu 60 penulisan per menit ditambah 40 untuk setiap pemain (sesuai dokumentasi per 30 September 2026). Pola key User_ mengikuti best practice Roblox, dan memberikan user ID ke SetAsync menghubungkan data itu ke pemainnya, yang sangat disarankan Roblox untuk menangani permintaan penghapusan data.

Itu dasar yang kuat untuk game kecil. Session locking, yang mencegah pemain yang cepat pindah server memuat data sebelum server lama selesai menyimpannya, dan kapan memakai UpdateAsync alih-alih SetAsync, dibahas di tutorial DataStore.

Langkah 5: Beri item dari dunia game

Pickup adalah cara paling sederhana item masuk ke inventory: sebuah part dengan ProximityPrompt yang menambahkan item saat pemain memakainya. Script ini mendengarkan event Triggered-nya di server, jadi item ditambahkan di tempat yang tidak bisa diganggu client.

  1. Tambahkan Part ke Workspace, beri nama Apple dan warnai merah. Nyalakan Anchored dan matikan CanCollide, supaya tidak ada yang menabraknya saat part itu tidak terlihat. Prompt-nya menampilkan nama part.
  2. Dengan part terpilih, scroll ke bagian Attributes di jendela Properties dan klik +. Tambahkan ItemId dengan tipe string dan klik Save, lalu isi nilainya dengan apple. Tambahkan Amount dengan cara yang sama sebagai number bernilai 1.
  3. Tambahkan Script ke dalam part, beri nama ItemPickup dan tempel kode ini:
Script di part Apple di Workspace bernama ItemPickup
-- Taruh Script ini di dalam Part dan beri Part itu dua atribut:
-- ItemId (string, misalnya apple) dan Amount (number, misalnya 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 -- pemain lain baru saja mengambilnya
	end
	-- Cek jaraknya di server, jangan percaya begitu saja pada 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 -- tidak cukup ruang: biarkan pickup tetap di tempatnya
	end
	InventoryService.add(player, itemId, amount)

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

Salin part-nya untuk menaruh lebih banyak pickup. Ganti atributnya untuk membagikan wood, sword lain atau satu stack apple.

Roblox mengecek jarak untuk Triggered, tapi panduan keamanannya tetap menyuruh kamu memvalidasi prompt di server: exploiter bisa memicu event prompt bahkan saat Enabled bernilai false, dan bisa menarik part yang tidak di-anchor ke dekat karakternya. Karena itulah script ini mengecek Enabled dan jaraknya sendiri, dan karena itu juga part-nya di-anchor.

Script server lain memberi item dengan cara yang sama. Setelah pembelian, quest atau kill, require InventoryService seperti script di atas dan panggil InventoryService.add(player, "wood", 5). Cek spaceFor dulu setiap kali item tidak boleh hilang. NPC juga bisa jadi sumber: di panduan dialog NPC, sebuah jawaban menjalankan action di server, dan action itu bisa memanggil InventoryService.add dengan cara yang sama.

Langkah 6: Equip Tool dan pakai item

Dua RemoteEvent membawa satu-satunya request yang bisa dibuat client. EquipItem menaruh salinan Tool item itu dari ServerStorage ke Backpack pemain (hotbar di bagian bawah layar) dan ke tangannya, dan meminta lagi akan melepasnya. UseItem menghapus satu item yang bisa dipakai dan menerapkan efeknya, yang di sini adalah heal.

Tambahkan Script ke ServerScriptService dan beri nama InventoryActions:

Script di ServerScriptService bernama 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 } = {}

-- Setiap request mulai di sini. Client bisa mengirim apa saja kapan saja, jadi cek
-- tipenya, apakah item itu ada, apakah pemain punya satu, dan kecepatan request-nya.
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

-- Menghancurkan Tool item ini di mana pun salinannya berada: hotbar, tangan atau 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) -- hanya satu tool yang di-equip pada satu waktu

	local tool = template:Clone()
	tool.CanBeDropped = false -- salinan yang dijatuhkan bisa diambil pemain lain
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Salinan kedua di StarterGear disalin kembali ke Backpack setelah 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) -- langsung taruh di tangannya
	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) -- mengklik lagi item yang sedang di-equip akan melepasnya
	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 -- sudah mati atau health sudah penuh: jangan buang item-nya
	end
	-- Ambil item-nya dulu, dan hanya heal kalau itu berhasil
	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)
Apa yang boleh dilakukan setiap request
RequestYang dikirim clientYang dicek server sebelum bertindak
EquipItemId itemItu string, item-nya ada, pemain punya satu, request tidak datang lebih cepat dari empat per detik, item punya toolName, dan Tool dengan nama itu ada di ServerStorage.ItemTools
UseItemId itemPengecekan tipe, kepemilikan dan kecepatan yang sama, item punya nilai heal, karakternya hidup dan terluka, dan satu item sudah dihapus sebelum health diberikan

Tiga detail mencegah Tool terduplikasi atau hilang. Salinannya punya CanBeDropped yang diset false, karena Tool yang dijatuhkan mendarat di Workspace, tempat pemain lain bisa mengambilnya sementara aslinya tetap di inventory. Setiap salinan membawa atribut InventoryItem, jadi saat unequip semua salinan bisa ditemukan dan dihancurkan di mana pun berada. Dan kalau pemain punya container StarterGear, salinan kedua masuk ke sana. Roblox menyalin StarterGear ke Backpack setiap kali karakter spawn, jadi pedang yang di-equip kembali lagi setelah respawn.

Hanya satu Tool yang di-equip pada satu waktu, dan apa yang di-equip tidak disimpan, jadi pemain yang join ulang mulai dengan hotbar kosong. Kalau nanti kamu menambah fitur menjual atau menjatuhkan item, unequip item itu sebelum salinan terakhirnya keluar dari inventory.

Sword placeholder bisa jadi pedang yang benar-benar bertarung: buat Tool-nya dari panduan pedang, biarkan namanya Sword, dan taruh di ItemTools menggantikan placeholder. Script server dari panduan itu lalu mengecek setiap ayunan, dari mana pun pemain mendapatkan pedangnya.

Langkah 7: Gambar grid inventory

LocalScript ini membangun seluruh jendela lewat kode, jadi tidak ada UI yang perlu diatur manual. ScrollingFrame menampung slot, UIGridLayout di dalamnya menyusunnya per baris, dan AutomaticCanvasSize memperbesar area scroll saat baris bertambah.

Di Explorer, buka StarterPlayer, tambahkan LocalScript ke StarterPlayerScripts dan beri nama InventoryClient:

LocalScript di StarterPlayerScripts bernama 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. Bangun jendelanya sekali. ResetOnSpawn = false menjaganya tetap ada setelah 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() -- AutomaticCanvasSize memperbesarnya agar semua sel muat
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. Satu sel per slot. Ini hanya menggambar apa yang dikirim server; ini tidak pernah
-- mengubah inventory sendiri.
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 -- slot kosong
	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()
		-- Minta, jangan perintah: server mengecek request dan mengirim balik hasilnya
		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

-- Server mengirim ini setelah load dan setelah setiap perubahan
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Buka dan tutup dengan button atau tombol 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 di StarterPlayerScripts berjalan sekali per sesi, dan ResetOnSpawn = false menjaga ScreenGui tetap ada saat karakter respawn, jadi grid tetap menampilkan salinan terakhir yang dikirim server.

Client menggambar satu sel untuk setiap slot, termasuk yang kosong, jadi inventory 20 slot selalu terlihat seperti 20 slot. Setiap update menghancurkan sel lama dan membangun sel baru, yang sederhana dan cukup untuk beberapa puluh slot. Kalau server mengirim InventoryUpdated sebelum script ini tersambung ke event itu, Roblox mengantrekan pesannya dan mengirimkannya begitu handler tersambung, jadi inventory pertama tidak hilang.

Lebih suka mendesain jendelanya di Studio? Buat ScreenGui dengan satu slot template dan Clone slot itu di makeCell. Untuk ikon, isi icon item di katalog dengan gambar yang sudah kamu upload, dan sel-nya akan menampilkan gambar itu, bukan namanya.

Tes inventory-nya

  1. Tekan Play. Buka inventory dengan tombol di kiri atau B: pemain baru punya Sword dan 3 Apple, dan penghitungnya menunjukkan 2 / 20 slots. Selama Studio belum bisa menjangkau data store, item muncul beberapa detik kemudian, setelah peringatan load di Output, dan tidak disimpan.
  2. Klik Sword. Pedangnya muncul di tanganmu dan di hotbar, dan slot-nya mendapat garis ungu. Klik lagi untuk menyimpannya.
  3. Jalan ke part Apple dan pakai prompt-nya. Stack apple naik jadi 4, dan part-nya menghilang selama 15 detik.
  4. Untuk mencoba heal, turunkan health-mu dulu. Ganti toggle Client/Server ke Server, pilih Humanoid karaktermu di Explorer, isi Health dengan 50, ganti kembali ke Client dan klik sebuah Apple.
  5. Dengan akses Studio ke API services menyala, stop lalu play lagi. Apple yang kamu ambil masih ada. Kalau load atau save gagal, Output akan memberitahumu.

Untuk melihatnya dengan lebih dari satu pemain, pilih Server & Clients di opsi tes dengan 2 client. Setiap pemain hanya melihat inventory-nya sendiri, sementara keduanya bisa melihat pedang di tangan pemain lain.

Error umum dan cara memperbaikinya

Sebagian besar masalah muncul di jendela Output sebagai peringatan atau baris error merah. Baca yang pertama: error berikutnya sering kali akibat dari error itu.

Infinite yield possible pada panggilan WaitForChild

Sebuah script menunggu objek yang tidak ada dengan nama persis itu. Bandingkan Explorer kamu dengan pohon di Langkah 1: InventoryRemotes dengan tiga RemoteEvent-nya di ReplicatedStorage, ItemTools di ServerStorage, dan dua modulnya. Nama membedakan huruf besar dan kecil. Panduan error script menjelaskan peringatan ini lebih dalam.

Grid terbuka tapi tetap kosong

Client hanya menggambar apa yang dikirim server. Cek Output untuk peringatan Inventory load failed, dan cek bahwa InventoryData adalah Script, bukan LocalScript, di ServerScriptService, dengan ModuleScript InventoryService di sebelahnya. Kalau Output menunjukkan error Remote event invocation, tidak ada apa pun di client yang mendengarkan InventoryUpdated: cari error sebelumnya dari InventoryClient.

Item ter-reset setiap kali aku play di Studio

Kalau Output bilang Inventory not loaded: playing with starter items that will not be saved, place-nya belum di-publish atau akses Studio ke API services mati. Nyalakan seperti dijelaskan di Langkah 4, di salinan tes game kamu.

Mengklik sword tidak terjadi apa-apa

Cari Cannot equip sword di Output: Tool di ServerStorage.ItemTools harus bernama persis seperti toolName di katalog. Tool juga butuh part bernama Handle supaya bisa dipegang, kecuali kamu mengatur RequiresHandle-nya ke false.

Prompt pickup muncul, tapi tidak ada yang ditambahkan

Atribut ItemId harus cocok persis dengan id di katalog, termasuk huruf besar kecilnya: apple, bukan Apple. Tidak ada yang ditambahkan selama inventory pemain masih dimuat, atau saat tidak ada ruang untuk seluruh jumlahnya.

Save gagal setelah aku mengubah apa yang disimpan

Data store menerima data biasa: string, number, boolean dan tabel berisi itu. Menyimpan Tool, Part atau Instance lain akan gagal, atau nilainya tersimpan sebagai nil. Simpan id item dan jumlahnya, lalu bangun ulang sisanya dari katalog, seperti yang dilakukan serialize.

Buat dengan RoCode

Kalau kamu lebih suka menjelaskan sistemnya daripada merangkainya sendiri, RoCode bisa membuatnya di place yang sedang kamu buka. RoCode adalah agen AI untuk Roblox Studio: kamu menjelaskan fiturnya di web chat, dan plugin Studio-nya membuat script dan objek di Explorer kamu, bukan memberimu kode untuk ditempel.

Kamu ketik

Tambahkan inventory 20 slot yang menumpuk item, UI grid yang terbuka dengan B, pedang dari ServerStorage yang bisa di-equip pemain, apple yang memulihkan health, dan save dengan DataStoreService.

RoCode mengerjakan
  • Bisa memeriksa place kamu saat sebuah langkah membutuhkannya, dengan Search Game dan Search Scripts, jadi RoCode bisa melanjutkan item, remote atau kode save yang sudah kamu punya, bukan menambah sistem kedua
  • Membuat folder dan RemoteEvent dengan Create Instance, dan ModuleScript, Script serta LocalScript dengan Create Script
  • Bisa menyiapkan kerangka jendelanya dengan Build UI, yang punya layout inventory dengan slot placeholder; kode yang mengisi slot dari server ditulis sebagai script terpisah
  • Mengecek compile setiap script di dalam Studio dengan Check Script, yang menangkap error compile dan beberapa pola berisiko tapi tidak melakukan type-check, lint atau menjalankan kode kamu

Setiap batch perubahan adalah satu titik undo di Studio. RoCode tidak bisa menyalakan akses Studio ke API services, jadi kamu yang melakukannya. Dengan plugin 3.9 atau lebih baru RoCode bisa menjalankan playtest singkat dan membaca error-nya, dan dengan plugin 3.9.15 atau lebih baru karakter tesnya bisa menekan tombol dan meng-equip item, tapi yang dicek hanya apa yang dipilihnya untuk dites, jadi tes sendiri bagian save-nya. Inventory berdiri di atas sistem lain seperti save dan tool, dan AI game maker yang membangun di place Studio milikmu sendiri menambahkannya satu prompt demi satu prompt. Cara RoCode terhubung ke Studio.

Pertanyaan umum

Apakah sebaiknya aku pakai Backpack Roblox saja daripada inventory custom?

Backpack adalah inventory bawaan Roblox: setiap Tool di dalamnya muncul sebagai tombol di hotbar. Kalau semua item di game kamu adalah Tool dan kamu tidak butuh stack, jumlah atau batas slot, Backpack mungkin cukup, walaupun kamu tetap harus menyimpan Tool apa saja yang dimiliki setiap pemain. Inventory custom dibuat untuk item yang bukan Tool, seperti material dan consumable. Panduan ini memakai keduanya: inventory menyimpan semuanya, dan Backpack memegang Tool mana pun yang sedang di-equip.

Bisakah aku menyembunyikan hotbar default?

Bisa. Dari LocalScript, panggil StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Dengan hotbar tersembunyi, pemain butuh cara lain untuk memegang dan menyimpan Tool yang di-equip, misalnya tombol yang meminta server memanggil Humanoid:EquipTool atau Humanoid:UnequipTools.

Bagaimana cara membuat slot tetap di posisinya untuk drag and drop?

Simpan daftar dengan panjang tetap, satu entri per slot, dan tandai slot kosong dengan nilai seperti id kosong, bukan nil, karena Roblox menyarankan untuk tidak memakai nilai nil di tabel yang dikirim lewat RemoteEvent. Lalu tambahkan RemoteEvent MoveItem yang mengirim dua nomor slot, dan biarkan server mengecek bahwa keduanya bilangan bulat antara 1 dan kapasitas sebelum menukarnya.

Seberapa besar inventory yang tersimpan bisa jadi?

Satu nilai data store bisa sampai 4.194.304 karakter setelah diserialisasi (sesuai dokumentasi per 30 September 2026). Daftar id dan jumlah hanya memakai sebagian sangat kecil dari itu. Teks per item, seperti nama custom atau deskripsi panjang yang disimpan untuk setiap item, adalah yang membuat data save membesar.

Bagaimana cara membeli atau menjual item dengan koin?

Lakukan semuanya di server. Untuk menjual, panggil InventoryService.remove dan bayar hanya kalau hasilnya true. Untuk membeli, cek harganya dan spaceFor, ambil koinnya, lalu panggil add. Panduan shop GUI membuat bagian pembeliannya.

Sumber dan bacaan lanjutan

Cara kode ini dicek: setiap skrip di halaman ini lolos pemeriksa tipe strict Luau dengan definisi API Roblox (luau-lsp, 14 November 2026). Pemeriksaan tipe menangkap nama API yang salah ketik dan tipe yang keliru, bukan logika game, jadi uji dulu di Studio sebelum dipublikasikan.

Coba RoCode di game kamu sendiri.

Kredit gratis setiap hari, tanpa kartu. Pasang plugin-nya, jelaskan fiturnya, lalu cek hasilnya di Studio.